Refactored the application structure to better separate concerns between files and packages

.woodpecker/build-image.yml

@@ -0,0 +1,25 @@
+when:
+  # Allow both normal runs (push) and UI-triggered runs (manual)
+  - event: [push, manual]
+
+steps:
+  - name: build-and-push-image
+    image: harbor.maximumdirect.net/proxy-dockerhub/woodpeckerci/plugin-kaniko
+    environment:
+      GITEA_USER:
+        from_secret: GITEA_USER
+      GITEA_TOKEN:
+        from_secret: GITEA_TOKEN
+    settings:
+      registry: harbor.maximumdirect.net
+      repo: build/weatherapi
+      auto_tag: true 
+      build_args_from_env:
+        - GITEA_USER
+        - GITEA_TOKEN
+      username:
+        from_secret: HARBOR_ROBOT_USER
+      password:
+        from_secret: HARBOR_ROBOT_TOKEN
+      cache: true
+      cache_repo: build-cache/weatherapi

Dockerfile

@@ -0,0 +1,87 @@
+# syntax=docker/dockerfile:1.6
+
+ARG GO_VERSION=1.25
+ARG GITEA_USER
+ARG GITEA_TOKEN
+
+############################
+# Build stage
+############################
+FROM harbor.maximumdirect.net/proxy-dockerhub/golang:${GO_VERSION}-bookworm AS build
+
+WORKDIR /src
+ARG GITEA_USER
+ARG GITEA_TOKEN
+ENV GOPRIVATE=gitea.maximumdirect.net/ejr/* \
+    GONOSUMDB=gitea.maximumdirect.net/ejr/*
+
+# Install baseline packages
+RUN apt-get update && apt-get install -y --no-install-recommends \
+      ca-certificates tzdata git build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Cache dependencies first
+COPY go.mod go.sum ./
+RUN --mount=type=cache,target=/go/pkg/mod \
+    git config --global url."https://${GITEA_USER}:${GITEA_TOKEN}@gitea.maximumdirect.net/".insteadOf "https://gitea.maximumdirect.net/" && \
+    go mod download && go mod verify && \
+    rm -f /root/.gitconfig
+
+# Copy the rest of the source
+COPY . .
+
+# Default to a static build (no CGO)
+# If errors, can build with: --build-arg CGO_ENABLED=1
+ARG CGO_ENABLED=0
+ARG TARGETOS=linux
+ARG TARGETARCH=amd64
+ENV CGO_ENABLED=${CGO_ENABLED} \
+    GOOS=${TARGETOS} \
+    GOARCH=${TARGETARCH}
+
+# Run tests before building the final binary
+RUN --mount=type=cache,target=/go/pkg/mod \
+    --mount=type=cache,target=/root/.cache/go-build \
+    git config --global url."https://${GITEA_USER}:${GITEA_TOKEN}@gitea.maximumdirect.net/".insteadOf "https://gitea.maximumdirect.net/" && \
+    go test ./...
+
+# Build the cmd entrypoint
+RUN --mount=type=cache,target=/go/pkg/mod \
+    --mount=type=cache,target=/root/.cache/go-build \
+    git config --global url."https://${GITEA_USER}:${GITEA_TOKEN}@gitea.maximumdirect.net/".insteadOf "https://gitea.maximumdirect.net/" && \
+    go build \
+      -trimpath \
+      -ldflags="-s -w" \
+      -o /out/weatherapi \
+      ./cmd/weatherapi
+
+
+############################
+# Runtime stage
+############################
+FROM harbor.maximumdirect.net/proxy-dockerhub/debian:bookworm-slim AS runtime
+
+# Install runtime necessities
+RUN apt-get update && apt-get install -y --no-install-recommends \
+      ca-certificates tzdata curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Define /weatherapi as the working directory
+WORKDIR /weatherapi
+
+# Create an unprivileged user
+RUN useradd \
+      --uid 10001 \
+      --no-create-home \
+      --shell /usr/sbin/nologin \
+      weatherapi
+
+# Copy the binary
+COPY --chown=weatherapi:weatherapi --from=build /out/weatherapi /weatherapi/weatherapi
+COPY --chown=weatherapi:weatherapi config.yml /weatherapi/config.yml
+COPY --chown=weatherapi:weatherapi templates /weatherapi/templates
+
+USER weatherapi
+
+# The application expects config.yml in the same directory as the binary
+ENTRYPOINT ["/weatherapi/weatherapi"]

cmd/weatherapi/main.go

@@ -1,3 +1,5 @@
+// main.go wires configuration, dependencies, and HTTP runtime startup.
+// Layer: cmd/weatherapi executable composition root.
 package main
 
 import (
@@ -15,7 +17,7 @@ import (
 	"gitea.maximumdirect.net/ejr/feedapi/db"
 	httpapi "gitea.maximumdirect.net/ejr/weatherapi/internal/adapters/inbound/httpapi"
 	wfpq "gitea.maximumdirect.net/ejr/weatherapi/internal/adapters/outbound/postgres"
-	"gitea.maximumdirect.net/ejr/weatherapi/internal/core"
+	"gitea.maximumdirect.net/ejr/weatherapi/internal/app"
 
 	_ "github.com/lib/pq"
 )
@@ -60,7 +62,7 @@ func run(ctx context.Context, cfgPath string) error {
 	}
 
 	repo := wfpq.NewRepository(primary)
-	svc := core.NewService(repo)
+	svc := app.NewService(repo)
 	defs := httpapi.Definitions(svc)
 
 	a, err := feedapp.New(cfg,

go.mod

@@ -3,13 +3,9 @@ module gitea.maximumdirect.net/ejr/weatherapi
 go 1.25.5
 
 require (
-	gitea.maximumdirect.net/ejr/feedapi v0.0.0
-	gitea.maximumdirect.net/ejr/weatherfeeder v0.0.0
+	gitea.maximumdirect.net/ejr/feedapi v0.1.0
+	gitea.maximumdirect.net/ejr/weatherfeeder v0.7.2
 	github.com/lib/pq v1.10.9
 )
 
 require gopkg.in/yaml.v3 v3.0.1 // indirect
-
-replace gitea.maximumdirect.net/ejr/feedapi => ../feedapi
-
-replace gitea.maximumdirect.net/ejr/weatherfeeder => ../weatherfeeder

go.sum

@@ -1,3 +1,7 @@
+gitea.maximumdirect.net/ejr/feedapi v0.1.0 h1:ZB5QWKD5DPFV3P7vyeJqXPMcSWN9qHkDUHw1LgN9hwY=
+gitea.maximumdirect.net/ejr/feedapi v0.1.0/go.mod h1:3fIaFFx4ywt0TWbN8DIIBAHJn7ZQUm6PNcceqRgy3bw=
+gitea.maximumdirect.net/ejr/weatherfeeder v0.7.2 h1:GJdZ9x54HLTPidPGhD/dmq7efvGjBltK1ywCIRU1w6c=
+gitea.maximumdirect.net/ejr/weatherfeeder v0.7.2/go.mod h1:P7rP7XftJjBFzNEIkAiX+z2YqXOtnZjy3BaF6kX+sO4=
 github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
 github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=

internal/adapters/inbound/httpapi/alerts_endpoint.go

@@ -0,0 +1,28 @@
+// alerts_endpoint.go defines the /alerts/active endpoint behavior.
+// Layer: adapters/inbound/httpapi alerts route.
+package httpapi
+
+import (
+	"context"
+
+	"gitea.maximumdirect.net/ejr/feedapi/endpoint"
+	"gitea.maximumdirect.net/ejr/feedapi/render"
+	"gitea.maximumdirect.net/ejr/feedapi/response"
+	"gitea.maximumdirect.net/ejr/weatherapi/internal/adapters/inbound/httpapi/presenter"
+)
+
+func alertsDefinition(svc Service) endpoint.Definition {
+	return endpoint.GET(
+		"/alerts/active",
+		bindQuery,
+		func(ctx context.Context, req queryRequest) (any, error) {
+			run, err := svc.LatestAlertRun(ctx)
+			if err != nil {
+				return nil, err
+			}
+			return response.Envelope{Data: presenter.AlertsPayload(run, req.Units)}, nil
+		},
+		endpoint.WithProduces(render.FormatJSON, render.FormatXML, render.FormatText),
+		endpoint.WithTemplate("alerts_active.txt.tmpl"),
+	)
+}

internal/adapters/inbound/httpapi/conditions_endpoint.go

@@ -0,0 +1,28 @@
+// conditions_endpoint.go defines the /conditions/current endpoint behavior.
+// Layer: adapters/inbound/httpapi current-conditions route.
+package httpapi
+
+import (
+	"context"
+
+	"gitea.maximumdirect.net/ejr/feedapi/endpoint"
+	"gitea.maximumdirect.net/ejr/feedapi/render"
+	"gitea.maximumdirect.net/ejr/feedapi/response"
+	"gitea.maximumdirect.net/ejr/weatherapi/internal/adapters/inbound/httpapi/presenter"
+)
+
+func conditionsDefinition(svc Service) endpoint.Definition {
+	return endpoint.GET(
+		"/conditions/current",
+		bindQuery,
+		func(ctx context.Context, req queryRequest) (any, error) {
+			conditions, err := svc.CurrentConditions(ctx)
+			if err != nil {
+				return nil, err
+			}
+			return response.Envelope{Data: presenter.CurrentConditionsPayload(conditions, req.Units)}, nil
+		},
+		endpoint.WithProduces(render.FormatJSON, render.FormatXML, render.FormatText),
+		endpoint.WithTemplate("conditions_current.txt.tmpl"),
+	)
+}

internal/adapters/inbound/httpapi/endpoints.go

@@ -1,76 +1,14 @@
+// endpoints.go registers all HTTP endpoint definitions for weatherapi.
+// Layer: adapters/inbound/httpapi endpoint registry only.
 package httpapi
 
-import (
-	"context"
-	"net/http"
-
-	"gitea.maximumdirect.net/ejr/feedapi/bind"
-	"gitea.maximumdirect.net/ejr/feedapi/endpoint"
-	"gitea.maximumdirect.net/ejr/feedapi/render"
-	"gitea.maximumdirect.net/ejr/feedapi/response"
-	"gitea.maximumdirect.net/ejr/weatherfeeder/model"
-)
-
-// Service describes the weather use-cases needed by the HTTP adapter.
-type Service interface {
-	LatestObservation(ctx context.Context) (*model.WeatherObservation, error)
-	LatestHourlyForecast(ctx context.Context) (*model.WeatherForecastRun, error)
-	LatestActiveAlerts(ctx context.Context) (*model.WeatherAlertRun, error)
-}
-
-type emptyRequest struct{}
+import "gitea.maximumdirect.net/ejr/feedapi/endpoint"
 
 func Definitions(svc Service) []endpoint.Definition {
 	return []endpoint.Definition{
-		endpoint.GET(
-			"/observations",
-			bindFormatOnly,
-			func(ctx context.Context, _ emptyRequest) (any, error) {
-				obs, err := svc.LatestObservation(ctx)
-				if err != nil {
-					return nil, err
-				}
-				return response.Envelope{Data: obs}, nil
-			},
-			endpoint.WithProduces(render.FormatJSON, render.FormatXML, render.FormatText),
-			endpoint.WithTemplate("observations.txt.tmpl"),
-		),
-		endpoint.GET(
-			"/forecast/hourly",
-			bindFormatOnly,
-			func(ctx context.Context, _ emptyRequest) (any, error) {
-				run, err := svc.LatestHourlyForecast(ctx)
-				if err != nil {
-					return nil, err
-				}
-				return response.Envelope{Data: run}, nil
-			},
-			endpoint.WithProduces(render.FormatJSON, render.FormatXML, render.FormatText),
-			endpoint.WithTemplate("forecast_hourly.txt.tmpl"),
-		),
-		endpoint.GET(
-			"/alerts/active",
-			bindFormatOnly,
-			func(ctx context.Context, _ emptyRequest) (any, error) {
-				run, err := svc.LatestActiveAlerts(ctx)
-				if err != nil {
-					return nil, err
-				}
-				return response.Envelope{Data: run}, nil
-			},
-			endpoint.WithProduces(render.FormatJSON, render.FormatXML, render.FormatText),
-			endpoint.WithTemplate("alerts_active.txt.tmpl"),
-		),
+		observationDefinition(svc),
+		forecastDefinition(svc),
+		alertsDefinition(svc),
+		conditionsDefinition(svc),
 	}
 }
-
-func bindFormatOnly(r *http.Request) (emptyRequest, error) {
-	_, err := bind.CommonQueryParams(r, bind.QueryPolicy{
-		AllowFormat:   true,
-		RejectUnknown: true,
-	})
-	if err != nil {
-		return emptyRequest{}, err
-	}
-	return emptyRequest{}, nil
-}

internal/adapters/inbound/httpapi/endpoints_test.go

@@ -1,8 +1,11 @@
+// endpoints_test.go validates HTTP endpoint behavior and format negotiation.
+// Layer: adapters/inbound/httpapi endpoint regression tests.
 package httpapi
 
 import (
 	"context"
 	"encoding/json"
+	"math"
 	"net/http"
 	"net/http/httptest"
 	"strings"
@@ -15,6 +18,7 @@ import (
 	"gitea.maximumdirect.net/ejr/feedapi/render"
 	"gitea.maximumdirect.net/ejr/feedapi/templates"
 	"gitea.maximumdirect.net/ejr/feedapi/transport/httpx"
+	"gitea.maximumdirect.net/ejr/weatherapi/internal/app"
 	"gitea.maximumdirect.net/ejr/weatherfeeder/model"
 )
 
@@ -22,6 +26,7 @@ type fakeService struct {
 	observation *model.WeatherObservation
 	forecast    *model.WeatherForecastRun
 	alerts      *model.WeatherAlertRun
+	conditions  *app.CurrentConditions
 	err         error
 }
 
@@ -33,10 +38,14 @@ func (s *fakeService) LatestHourlyForecast(context.Context) (*model.WeatherForec
 	return s.forecast, s.err
 }
 
-func (s *fakeService) LatestActiveAlerts(context.Context) (*model.WeatherAlertRun, error) {
+func (s *fakeService) LatestAlertRun(context.Context) (*model.WeatherAlertRun, error) {
 	return s.alerts, s.err
 }
 
+func (s *fakeService) CurrentConditions(context.Context) (*app.CurrentConditions, error) {
+	return s.conditions, s.err
+}
+
 func TestObservationsRejectUnknownQueryParameter(t *testing.T) {
 	h := newHandler(t, &fakeService{}, "/observations")
 
@@ -110,12 +119,11 @@ func TestObservationsPopulatedJSONEnvelope(t *testing.T) {
 	}
 }
 
-func TestFormatNegotiationXMLAndText(t *testing.T) {
+func TestFormatNegotiationCaseInsensitive(t *testing.T) {
 	hXML := newHandler(t, &fakeService{alerts: &model.WeatherAlertRun{AsOf: time.Now().UTC()}}, "/alerts/active")
 
 	w := httptest.NewRecorder()
-	req := httptest.NewRequest(http.MethodGet, "/alerts/active", nil)
-	req.Header.Set("Accept", "application/xml")
+	req := httptest.NewRequest(http.MethodGet, "/alerts/active?format=XML", nil)
 	hXML.ServeHTTP(w, req)
 
 	if w.Code != http.StatusOK {
@@ -127,7 +135,7 @@ func TestFormatNegotiationXMLAndText(t *testing.T) {
 
 	hText := newHandler(t, &fakeService{forecast: &model.WeatherForecastRun{Product: model.ForecastProductHourly}}, "/forecast/hourly")
 	w = httptest.NewRecorder()
-	req = httptest.NewRequest(http.MethodGet, "/forecast/hourly?format=text", nil)
+	req = httptest.NewRequest(http.MethodGet, "/forecast/hourly?format=TEXT", nil)
 	hText.ServeHTTP(w, req)
 
 	if w.Code != http.StatusOK {
@@ -141,6 +149,293 @@ func TestFormatNegotiationXMLAndText(t *testing.T) {
 	}
 }
 
+func TestObservationUSUnitsChangesFieldNames(t *testing.T) {
+	h := newHandler(t, &fakeService{
+		observation: &model.WeatherObservation{
+			StationID:     "KSTL",
+			Timestamp:     time.Now().UTC(),
+			ConditionCode: 1,
+			TemperatureC:  float64Ptr(20),
+		},
+	}, "/observations")
+
+	w := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodGet, "/observations?units=US", nil)
+	h.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+
+	var payload struct {
+		Data map[string]any `json:"data"`
+	}
+	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("decode envelope: %v", err)
+	}
+
+	if _, ok := payload.Data["temperatureC"]; ok {
+		t.Fatalf("expected temperatureC to be omitted in US payload")
+	}
+	v, ok := payload.Data["temperatureF"].(float64)
+	if !ok {
+		t.Fatalf("expected temperatureF in US payload, got %#v", payload.Data["temperatureF"])
+	}
+	if math.Abs(v-68.0) > 0.0001 {
+		t.Fatalf("expected temperatureF ~= 68, got %f", v)
+	}
+}
+
+func TestAlertsUSUnitsKeepSchema(t *testing.T) {
+	h := newHandler(t, &fakeService{
+		alerts: &model.WeatherAlertRun{
+			AsOf: time.Now().UTC(),
+			Alerts: []model.WeatherAlert{{
+				ID:       "abc",
+				Headline: "A headline",
+			}},
+		},
+	}, "/alerts/active")
+
+	w := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodGet, "/alerts/active?units=us", nil)
+	h.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+
+	var payload struct {
+		Data map[string]any `json:"data"`
+	}
+	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("decode envelope: %v", err)
+	}
+	alerts, ok := payload.Data["alerts"].([]any)
+	if !ok || len(alerts) != 1 {
+		t.Fatalf("expected one alert in response, got %#v", payload.Data["alerts"])
+	}
+	first, ok := alerts[0].(map[string]any)
+	if !ok {
+		t.Fatalf("expected first alert object, got %#v", alerts[0])
+	}
+	if first["id"] != "abc" {
+		t.Fatalf("expected alert id abc, got %#v", first["id"])
+	}
+}
+
+func TestObservationUSUnitsWithXMLFormat(t *testing.T) {
+	h := newHandler(t, &fakeService{
+		observation: &model.WeatherObservation{
+			StationID:     "KSTL",
+			Timestamp:     time.Now().UTC(),
+			ConditionCode: 1,
+			TemperatureC:  float64Ptr(20),
+		},
+	}, "/observations")
+
+	w := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodGet, "/observations?format=xml&units=us", nil)
+	h.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+	if !strings.Contains(w.Header().Get("Content-Type"), "application/xml") {
+		t.Fatalf("expected xml content type, got %q", w.Header().Get("Content-Type"))
+	}
+	if strings.Contains(w.Body.String(), "temperatureC") {
+		t.Fatalf("expected metric field temperatureC to be omitted in XML payload: %s", w.Body.String())
+	}
+	if !strings.Contains(w.Body.String(), "temperatureF") {
+		t.Fatalf("expected US field temperatureF in XML payload: %s", w.Body.String())
+	}
+}
+
+func TestForecastUSUnitsWithXMLFormatUppercaseQuery(t *testing.T) {
+	h := newHandler(t, &fakeService{
+		forecast: &model.WeatherForecastRun{
+			Product:  model.ForecastProductHourly,
+			IssuedAt: time.Now().UTC(),
+			Periods: []model.WeatherForecastPeriod{{
+				StartTime:     time.Now().UTC(),
+				EndTime:       time.Now().UTC().Add(time.Hour),
+				ConditionCode: 1,
+				TemperatureC:  float64Ptr(10),
+			}},
+		},
+	}, "/forecast/hourly")
+
+	w := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodGet, "/forecast/hourly?format=XML&units=US", nil)
+	h.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+	if !strings.Contains(w.Header().Get("Content-Type"), "application/xml") {
+		t.Fatalf("expected xml content type, got %q", w.Header().Get("Content-Type"))
+	}
+	body := w.Body.String()
+	if strings.Contains(body, "temperatureC") {
+		t.Fatalf("expected metric field temperatureC to be omitted in XML payload: %s", body)
+	}
+	if !strings.Contains(body, "temperatureF") {
+		t.Fatalf("expected US field temperatureF in XML payload: %s", body)
+	}
+}
+
+func TestCurrentConditionsNoDataReturnsNullEnvelopeData(t *testing.T) {
+	h := newHandler(t, &fakeService{}, "/conditions/current")
+
+	w := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodGet, "/conditions/current", nil)
+	h.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+
+	var payload struct {
+		Data *json.RawMessage `json:"data"`
+	}
+	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("decode envelope: %v", err)
+	}
+	if payload.Data != nil {
+		t.Fatalf("expected data null, got %s", string(*payload.Data))
+	}
+}
+
+func TestCurrentConditionsMetricDefaultJSON(t *testing.T) {
+	h := newHandler(t, &fakeService{
+		conditions: &app.CurrentConditions{
+			TemperatureC:            float64Ptr(10),
+			ApparentTemperatureC:    float64Ptr(9),
+			DewpointC:               float64Ptr(5),
+			RelativeHumidityPercent: float64Ptr(75),
+			WindSpeedKmh:            float64Ptr(18),
+			WindDirectionDegrees:    float64Ptr(135),
+			ConditionCode:           63,
+		},
+	}, "/conditions/current")
+
+	w := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodGet, "/conditions/current", nil)
+	h.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+
+	var payload struct {
+		Data map[string]any `json:"data"`
+	}
+	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("decode envelope: %v", err)
+	}
+	if _, ok := payload.Data["temperatureC"]; !ok {
+		t.Fatalf("expected temperatureC in metric payload")
+	}
+	if _, ok := payload.Data["temperatureF"]; ok {
+		t.Fatalf("expected temperatureF omitted in metric payload")
+	}
+	if payload.Data["conditionText"] != "Rain" {
+		t.Fatalf("expected conditionText Rain, got %#v", payload.Data["conditionText"])
+	}
+}
+
+func TestCurrentConditionsUSJSON(t *testing.T) {
+	h := newHandler(t, &fakeService{
+		conditions: &app.CurrentConditions{
+			TemperatureC:            float64Ptr(10),
+			ApparentTemperatureC:    float64Ptr(9),
+			DewpointC:               float64Ptr(5),
+			RelativeHumidityPercent: float64Ptr(75),
+			WindSpeedKmh:            float64Ptr(18),
+			WindDirectionDegrees:    float64Ptr(135),
+			ConditionCode:           63,
+		},
+	}, "/conditions/current")
+
+	w := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodGet, "/conditions/current?units=us", nil)
+	h.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+
+	var payload struct {
+		Data map[string]any `json:"data"`
+	}
+	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("decode envelope: %v", err)
+	}
+	if _, ok := payload.Data["temperatureF"]; !ok {
+		t.Fatalf("expected temperatureF in us payload")
+	}
+	if _, ok := payload.Data["temperatureC"]; ok {
+		t.Fatalf("expected temperatureC omitted in us payload")
+	}
+	if _, ok := payload.Data["windSpeedMph"]; !ok {
+		t.Fatalf("expected windSpeedMph in us payload")
+	}
+	if _, ok := payload.Data["windSpeedKmh"]; ok {
+		t.Fatalf("expected windSpeedKmh omitted in us payload")
+	}
+}
+
+func TestCurrentConditionsXMLAndTextFormats(t *testing.T) {
+	h := newHandler(t, &fakeService{
+		conditions: &app.CurrentConditions{
+			TemperatureC:  float64Ptr(10),
+			WindSpeedKmh:  float64Ptr(18),
+			ConditionCode: 2,
+		},
+	}, "/conditions/current")
+
+	w := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodGet, "/conditions/current?format=xml&units=us", nil)
+	h.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+	if !strings.Contains(w.Header().Get("Content-Type"), "application/xml") {
+		t.Fatalf("expected xml content type, got %q", w.Header().Get("Content-Type"))
+	}
+	if !strings.Contains(w.Body.String(), "temperatureF") {
+		t.Fatalf("expected US field temperatureF in XML payload: %s", w.Body.String())
+	}
+
+	w = httptest.NewRecorder()
+	req = httptest.NewRequest(http.MethodGet, "/conditions/current?format=TEXT", nil)
+	h.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200 for text request, got %d", w.Code)
+	}
+	if !strings.Contains(w.Header().Get("Content-Type"), "text/plain") {
+		t.Fatalf("expected text/plain content type, got %q", w.Header().Get("Content-Type"))
+	}
+	if !strings.Contains(w.Body.String(), "Conditions text") {
+		t.Fatalf("expected rendered text template body, got %q", w.Body.String())
+	}
+}
+
+func TestCurrentConditionsRejectUnknownQueryParameter(t *testing.T) {
+	h := newHandler(t, &fakeService{}, "/conditions/current")
+
+	w := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodGet, "/conditions/current?bogus=1", nil)
+	h.ServeHTTP(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400, got %d", w.Code)
+	}
+}
+
 func newHandler(t *testing.T, svc Service, path string) http.Handler {
 	t.Helper()
 
@@ -175,9 +470,10 @@ func testRenderers(t *testing.T) *render.Registry {
 
 	tmplReg := templates.NewRegistry()
 	for name, body := range map[string]string{
-		"observations.txt.tmpl":    "Observation text",
-		"forecast_hourly.txt.tmpl": "Forecast text",
-		"alerts_active.txt.tmpl":   "Alerts text",
+		"observations.txt.tmpl":       "Observation text",
+		"forecast_hourly.txt.tmpl":    "Forecast text",
+		"alerts_active.txt.tmpl":      "Alerts text",
+		"conditions_current.txt.tmpl": "Conditions text",
 	} {
 		tmpl, err := template.New(name).Parse(body)
 		if err != nil {
@@ -193,3 +489,7 @@ func testRenderers(t *testing.T) *render.Registry {
 
 	return reg
 }
+
+func float64Ptr(v float64) *float64 {
+	return &v
+}

internal/adapters/inbound/httpapi/forecast_endpoint.go

@@ -0,0 +1,28 @@
+// forecast_endpoint.go defines the /forecast/hourly endpoint behavior.
+// Layer: adapters/inbound/httpapi forecast route.
+package httpapi
+
+import (
+	"context"
+
+	"gitea.maximumdirect.net/ejr/feedapi/endpoint"
+	"gitea.maximumdirect.net/ejr/feedapi/render"
+	"gitea.maximumdirect.net/ejr/feedapi/response"
+	"gitea.maximumdirect.net/ejr/weatherapi/internal/adapters/inbound/httpapi/presenter"
+)
+
+func forecastDefinition(svc Service) endpoint.Definition {
+	return endpoint.GET(
+		"/forecast/hourly",
+		bindQuery,
+		func(ctx context.Context, req queryRequest) (any, error) {
+			run, err := svc.LatestHourlyForecast(ctx)
+			if err != nil {
+				return nil, err
+			}
+			return response.Envelope{Data: presenter.ForecastPayload(run, req.Units)}, nil
+		},
+		endpoint.WithProduces(render.FormatJSON, render.FormatXML, render.FormatText),
+		endpoint.WithTemplate("forecast_hourly.txt.tmpl"),
+	)
+}

internal/adapters/inbound/httpapi/observations_endpoint.go

@@ -0,0 +1,28 @@
+// observations_endpoint.go defines the /observations endpoint behavior.
+// Layer: adapters/inbound/httpapi observation route.
+package httpapi
+
+import (
+	"context"
+
+	"gitea.maximumdirect.net/ejr/feedapi/endpoint"
+	"gitea.maximumdirect.net/ejr/feedapi/render"
+	"gitea.maximumdirect.net/ejr/feedapi/response"
+	"gitea.maximumdirect.net/ejr/weatherapi/internal/adapters/inbound/httpapi/presenter"
+)
+
+func observationDefinition(svc Service) endpoint.Definition {
+	return endpoint.GET(
+		"/observations",
+		bindQuery,
+		func(ctx context.Context, req queryRequest) (any, error) {
+			obs, err := svc.LatestObservation(ctx)
+			if err != nil {
+				return nil, err
+			}
+			return response.Envelope{Data: presenter.ObservationPayload(obs, req.Units)}, nil
+		},
+		endpoint.WithProduces(render.FormatJSON, render.FormatXML, render.FormatText),
+		endpoint.WithTemplate("observations.txt.tmpl"),
+	)
+}

internal/adapters/inbound/httpapi/presenter/alerts.go

@@ -0,0 +1,12 @@
+// alerts.go presents alert-run payloads.
+// Layer: adapters/inbound/httpapi/presenter alerts payload mapping.
+package presenter
+
+import "gitea.maximumdirect.net/ejr/weatherfeeder/model"
+
+func AlertsPayload(run *model.WeatherAlertRun, _ Units) any {
+	if run == nil {
+		return nil
+	}
+	return run
+}

internal/adapters/inbound/httpapi/presenter/conditions.go

@@ -0,0 +1,54 @@
+// conditions.go presents current-conditions payloads in metric and US shapes.
+// Layer: adapters/inbound/httpapi/presenter current-conditions payload mapping.
+package presenter
+
+import (
+	"gitea.maximumdirect.net/ejr/weatherapi/internal/app"
+	"gitea.maximumdirect.net/ejr/weatherfeeder/standards"
+)
+
+// CurrentConditionsResponse is the response shape for /conditions/current.
+// Unit-bearing fields are populated according to the requested unit mode.
+type CurrentConditionsResponse struct {
+	TemperatureC            *float64 `json:"temperatureC,omitempty" xml:"temperatureC,omitempty"`
+	ApparentTemperatureC    *float64 `json:"apparentTemperatureC,omitempty" xml:"apparentTemperatureC,omitempty"`
+	DewpointC               *float64 `json:"dewpointC,omitempty" xml:"dewpointC,omitempty"`
+	WindSpeedKmh            *float64 `json:"windSpeedKmh,omitempty" xml:"windSpeedKmh,omitempty"`
+	TemperatureF            *float64 `json:"temperatureF,omitempty" xml:"temperatureF,omitempty"`
+	ApparentTemperatureF    *float64 `json:"apparentTemperatureF,omitempty" xml:"apparentTemperatureF,omitempty"`
+	DewpointF               *float64 `json:"dewpointF,omitempty" xml:"dewpointF,omitempty"`
+	WindSpeedMph            *float64 `json:"windSpeedMph,omitempty" xml:"windSpeedMph,omitempty"`
+	RelativeHumidityPercent *float64 `json:"relativeHumidityPercent,omitempty" xml:"relativeHumidityPercent,omitempty"`
+	WindDirectionDegrees    *float64 `json:"windDirectionDegrees,omitempty" xml:"windDirectionDegrees,omitempty"`
+	ConditionText           string   `json:"conditionText,omitempty" xml:"conditionText,omitempty"`
+	IsDay                   *bool    `json:"isDay,omitempty" xml:"isDay,omitempty"`
+	IsDayText               string   `json:"-" xml:"-"`
+}
+
+func CurrentConditionsPayload(conditions *app.CurrentConditions, units Units) any {
+	if conditions == nil {
+		return nil
+	}
+
+	out := CurrentConditionsResponse{
+		RelativeHumidityPercent: copyFloat64Ptr(conditions.RelativeHumidityPercent),
+		WindDirectionDegrees:    copyFloat64Ptr(conditions.WindDirectionDegrees),
+		ConditionText:           standards.WMOText(conditions.ConditionCode, conditions.IsDay),
+		IsDay:                   copyBoolPtr(conditions.IsDay),
+		IsDayText:               boolText(conditions.IsDay),
+	}
+
+	if units == UnitsUS {
+		out.TemperatureF = celsiusToFahrenheitPtr(conditions.TemperatureC)
+		out.ApparentTemperatureF = celsiusToFahrenheitPtr(conditions.ApparentTemperatureC)
+		out.DewpointF = celsiusToFahrenheitPtr(conditions.DewpointC)
+		out.WindSpeedMph = scalePtr(conditions.WindSpeedKmh, kmhToMphFactor)
+		return out
+	}
+
+	out.TemperatureC = copyFloat64Ptr(conditions.TemperatureC)
+	out.ApparentTemperatureC = copyFloat64Ptr(conditions.ApparentTemperatureC)
+	out.DewpointC = copyFloat64Ptr(conditions.DewpointC)
+	out.WindSpeedKmh = copyFloat64Ptr(conditions.WindSpeedKmh)
+	return out
+}

internal/adapters/inbound/httpapi/presenter/constants.go

@@ -0,0 +1,13 @@
+// constants.go defines unit conversion constants for payload presentation.
+// Layer: adapters/inbound/httpapi/presenter conversion constants.
+package presenter
+
+const (
+	celsiusToFahrenheitScale  = 9.0 / 5.0
+	celsiusToFahrenheitOffset = 32.0
+	kmhToMphFactor            = 0.621371192237334
+	metersToMilesFactor       = 0.000621371192237334
+	metersToFeetFactor        = 3.280839895013123
+	paToInHgFactor            = 0.000295299830714045
+	mmToInchesFactor          = 0.03937007874015748
+)

internal/adapters/inbound/httpapi/presenter/forecast.go

@@ -0,0 +1,103 @@
+// forecast.go presents hourly forecast payloads in metric and US shapes.
+// Layer: adapters/inbound/httpapi/presenter forecast payload mapping.
+package presenter
+
+import (
+	"time"
+
+	"gitea.maximumdirect.net/ejr/weatherfeeder/model"
+)
+
+// WeatherForecastRunUS is the US-customary response shape for hourly forecasts.
+type WeatherForecastRunUS struct {
+	LocationID    string                    `json:"locationId,omitempty" xml:"locationId,omitempty"`
+	LocationName  string                    `json:"locationName,omitempty" xml:"locationName,omitempty"`
+	IssuedAt      time.Time                 `json:"issuedAt" xml:"issuedAt"`
+	UpdatedAt     *time.Time                `json:"updatedAt,omitempty" xml:"updatedAt,omitempty"`
+	Product       model.ForecastProduct     `json:"product" xml:"product"`
+	Latitude      *float64                  `json:"latitude,omitempty" xml:"latitude,omitempty"`
+	Longitude     *float64                  `json:"longitude,omitempty" xml:"longitude,omitempty"`
+	ElevationFeet *float64                  `json:"elevationFeet,omitempty" xml:"elevationFeet,omitempty"`
+	Periods       []WeatherForecastPeriodUS `json:"periods" xml:"periods"`
+}
+
+// WeatherForecastPeriodUS is the US-customary response shape for forecast periods.
+type WeatherForecastPeriodUS struct {
+	StartTime                         time.Time     `json:"startTime" xml:"startTime"`
+	EndTime                           time.Time     `json:"endTime" xml:"endTime"`
+	Name                              string        `json:"name,omitempty" xml:"name,omitempty"`
+	IsDay                             *bool         `json:"isDay,omitempty" xml:"isDay,omitempty"`
+	ConditionCode                     model.WMOCode `json:"conditionCode" xml:"conditionCode"`
+	ConditionText                     string        `json:"conditionText,omitempty" xml:"conditionText,omitempty"`
+	ProviderRawDescription            string        `json:"providerRawDescription,omitempty" xml:"providerRawDescription,omitempty"`
+	TextDescription                   string        `json:"textDescription,omitempty" xml:"textDescription,omitempty"`
+	DetailedText                      string        `json:"detailedText,omitempty" xml:"detailedText,omitempty"`
+	IconURL                           string        `json:"iconUrl,omitempty" xml:"iconUrl,omitempty"`
+	TemperatureF                      *float64      `json:"temperatureF,omitempty" xml:"temperatureF,omitempty"`
+	TemperatureFMin                   *float64      `json:"temperatureFMin,omitempty" xml:"temperatureFMin,omitempty"`
+	TemperatureFMax                   *float64      `json:"temperatureFMax,omitempty" xml:"temperatureFMax,omitempty"`
+	DewpointF                         *float64      `json:"dewpointF,omitempty" xml:"dewpointF,omitempty"`
+	RelativeHumidityPercent           *float64      `json:"relativeHumidityPercent,omitempty" xml:"relativeHumidityPercent,omitempty"`
+	WindDirectionDegrees              *float64      `json:"windDirectionDegrees,omitempty" xml:"windDirectionDegrees,omitempty"`
+	WindSpeedMph                      *float64      `json:"windSpeedMph,omitempty" xml:"windSpeedMph,omitempty"`
+	WindGustMph                       *float64      `json:"windGustMph,omitempty" xml:"windGustMph,omitempty"`
+	BarometricPressureInHg            *float64      `json:"barometricPressureInHg,omitempty" xml:"barometricPressureInHg,omitempty"`
+	VisibilityMiles                   *float64      `json:"visibilityMiles,omitempty" xml:"visibilityMiles,omitempty"`
+	ApparentTemperatureF              *float64      `json:"apparentTemperatureF,omitempty" xml:"apparentTemperatureF,omitempty"`
+	CloudCoverPercent                 *float64      `json:"cloudCoverPercent,omitempty" xml:"cloudCoverPercent,omitempty"`
+	ProbabilityOfPrecipitationPercent *float64      `json:"probabilityOfPrecipitationPercent,omitempty" xml:"probabilityOfPrecipitationPercent,omitempty"`
+	PrecipitationAmountIn             *float64      `json:"precipitationAmountIn,omitempty" xml:"precipitationAmountIn,omitempty"`
+	SnowfallDepthIn                   *float64      `json:"snowfallDepthIn,omitempty" xml:"snowfallDepthIn,omitempty"`
+	UVIndex                           *float64      `json:"uvIndex,omitempty" xml:"uvIndex,omitempty"`
+}
+
+func ForecastPayload(run *model.WeatherForecastRun, units Units) any {
+	if run == nil {
+		return nil
+	}
+	if units == UnitsUS {
+		out := WeatherForecastRunUS{
+			LocationID:    run.LocationID,
+			LocationName:  run.LocationName,
+			IssuedAt:      run.IssuedAt,
+			UpdatedAt:     copyTimePtr(run.UpdatedAt),
+			Product:       run.Product,
+			Latitude:      copyFloat64Ptr(run.Latitude),
+			Longitude:     copyFloat64Ptr(run.Longitude),
+			ElevationFeet: scalePtr(run.ElevationMeters, metersToFeetFactor),
+			Periods:       make([]WeatherForecastPeriodUS, 0, len(run.Periods)),
+		}
+		for _, p := range run.Periods {
+			out.Periods = append(out.Periods, WeatherForecastPeriodUS{
+				StartTime:                         p.StartTime,
+				EndTime:                           p.EndTime,
+				Name:                              p.Name,
+				IsDay:                             copyBoolPtr(p.IsDay),
+				ConditionCode:                     p.ConditionCode,
+				ConditionText:                     p.ConditionText,
+				ProviderRawDescription:            p.ProviderRawDescription,
+				TextDescription:                   p.TextDescription,
+				DetailedText:                      p.DetailedText,
+				IconURL:                           p.IconURL,
+				TemperatureF:                      celsiusToFahrenheitPtr(p.TemperatureC),
+				TemperatureFMin:                   celsiusToFahrenheitPtr(p.TemperatureCMin),
+				TemperatureFMax:                   celsiusToFahrenheitPtr(p.TemperatureCMax),
+				DewpointF:                         celsiusToFahrenheitPtr(p.DewpointC),
+				RelativeHumidityPercent:           copyFloat64Ptr(p.RelativeHumidityPercent),
+				WindDirectionDegrees:              copyFloat64Ptr(p.WindDirectionDegrees),
+				WindSpeedMph:                      scalePtr(p.WindSpeedKmh, kmhToMphFactor),
+				WindGustMph:                       scalePtr(p.WindGustKmh, kmhToMphFactor),
+				BarometricPressureInHg:            scalePtr(p.BarometricPressurePa, paToInHgFactor),
+				VisibilityMiles:                   scalePtr(p.VisibilityMeters, metersToMilesFactor),
+				ApparentTemperatureF:              celsiusToFahrenheitPtr(p.ApparentTemperatureC),
+				CloudCoverPercent:                 copyFloat64Ptr(p.CloudCoverPercent),
+				ProbabilityOfPrecipitationPercent: copyFloat64Ptr(p.ProbabilityOfPrecipitationPercent),
+				PrecipitationAmountIn:             scalePtr(p.PrecipitationAmountMm, mmToInchesFactor),
+				SnowfallDepthIn:                   scalePtr(p.SnowfallDepthMM, mmToInchesFactor),
+				UVIndex:                           copyFloat64Ptr(p.UVIndex),
+			})
+		}
+		return out
+	}
+	return run
+}

internal/adapters/inbound/httpapi/presenter/helpers.go

@@ -0,0 +1,55 @@
+// helpers.go contains shared pointer and scalar conversion helpers.
+// Layer: adapters/inbound/httpapi/presenter helper functions.
+package presenter
+
+import "time"
+
+func celsiusToFahrenheitPtr(v *float64) *float64 {
+	if v == nil {
+		return nil
+	}
+	out := (*v * celsiusToFahrenheitScale) + celsiusToFahrenheitOffset
+	return &out
+}
+
+func scalePtr(v *float64, factor float64) *float64 {
+	if v == nil {
+		return nil
+	}
+	out := *v * factor
+	return &out
+}
+
+func copyFloat64Ptr(v *float64) *float64 {
+	if v == nil {
+		return nil
+	}
+	out := *v
+	return &out
+}
+
+func copyBoolPtr(v *bool) *bool {
+	if v == nil {
+		return nil
+	}
+	out := *v
+	return &out
+}
+
+func copyTimePtr(v *time.Time) *time.Time {
+	if v == nil {
+		return nil
+	}
+	out := *v
+	return &out
+}
+
+func boolText(v *bool) string {
+	if v == nil {
+		return ""
+	}
+	if *v {
+		return "true"
+	}
+	return "false"
+}

internal/adapters/inbound/httpapi/presenter/observation.go

@@ -0,0 +1,57 @@
+// observation.go presents observation payloads in metric and US shapes.
+// Layer: adapters/inbound/httpapi/presenter observation payload mapping.
+package presenter
+
+import (
+	"time"
+
+	"gitea.maximumdirect.net/ejr/weatherfeeder/model"
+)
+
+// WeatherObservationUS is the US-customary response shape for observations.
+type WeatherObservationUS struct {
+	StationID               string                 `json:"stationId,omitempty" xml:"stationId,omitempty"`
+	StationName             string                 `json:"stationName,omitempty" xml:"stationName,omitempty"`
+	Timestamp               time.Time              `json:"timestamp" xml:"timestamp"`
+	ConditionCode           model.WMOCode          `json:"conditionCode" xml:"conditionCode"`
+	IsDay                   *bool                  `json:"isDay,omitempty" xml:"isDay,omitempty"`
+	TextDescription         string                 `json:"textDescription,omitempty" xml:"textDescription,omitempty"`
+	TemperatureF            *float64               `json:"temperatureF,omitempty" xml:"temperatureF,omitempty"`
+	DewpointF               *float64               `json:"dewpointF,omitempty" xml:"dewpointF,omitempty"`
+	WindDirectionDegrees    *float64               `json:"windDirectionDegrees,omitempty" xml:"windDirectionDegrees,omitempty"`
+	WindSpeedMph            *float64               `json:"windSpeedMph,omitempty" xml:"windSpeedMph,omitempty"`
+	WindGustMph             *float64               `json:"windGustMph,omitempty" xml:"windGustMph,omitempty"`
+	BarometricPressureInHg  *float64               `json:"barometricPressureInHg,omitempty" xml:"barometricPressureInHg,omitempty"`
+	VisibilityMiles         *float64               `json:"visibilityMiles,omitempty" xml:"visibilityMiles,omitempty"`
+	RelativeHumidityPercent *float64               `json:"relativeHumidityPercent,omitempty" xml:"relativeHumidityPercent,omitempty"`
+	ApparentTemperatureF    *float64               `json:"apparentTemperatureF,omitempty" xml:"apparentTemperatureF,omitempty"`
+	PresentWeather          []model.PresentWeather `json:"presentWeather,omitempty" xml:"presentWeather,omitempty"`
+}
+
+func ObservationPayload(obs *model.WeatherObservation, units Units) any {
+	if obs == nil {
+		return nil
+	}
+	if units == UnitsUS {
+		converted := WeatherObservationUS{
+			StationID:               obs.StationID,
+			StationName:             obs.StationName,
+			Timestamp:               obs.Timestamp,
+			ConditionCode:           obs.ConditionCode,
+			IsDay:                   copyBoolPtr(obs.IsDay),
+			TextDescription:         obs.TextDescription,
+			TemperatureF:            celsiusToFahrenheitPtr(obs.TemperatureC),
+			DewpointF:               celsiusToFahrenheitPtr(obs.DewpointC),
+			WindDirectionDegrees:    copyFloat64Ptr(obs.WindDirectionDegrees),
+			WindSpeedMph:            scalePtr(obs.WindSpeedKmh, kmhToMphFactor),
+			WindGustMph:             scalePtr(obs.WindGustKmh, kmhToMphFactor),
+			BarometricPressureInHg:  scalePtr(obs.BarometricPressurePa, paToInHgFactor),
+			VisibilityMiles:         scalePtr(obs.VisibilityMeters, metersToMilesFactor),
+			RelativeHumidityPercent: copyFloat64Ptr(obs.RelativeHumidityPercent),
+			ApparentTemperatureF:    celsiusToFahrenheitPtr(obs.ApparentTemperatureC),
+			PresentWeather:          append([]model.PresentWeather(nil), obs.PresentWeather...),
+		}
+		return converted
+	}
+	return obs
+}

internal/adapters/inbound/httpapi/presenter/payload_test.go

@@ -0,0 +1,181 @@
+// payload_test.go validates presenter conversion and payload shaping behavior.
+// Layer: adapters/inbound/httpapi/presenter unit and schema tests.
+package presenter
+
+import (
+	"math"
+	"testing"
+	"time"
+
+	"gitea.maximumdirect.net/ejr/weatherapi/internal/app"
+	"gitea.maximumdirect.net/ejr/weatherfeeder/model"
+)
+
+func TestObservationPayloadUS(t *testing.T) {
+	obs := &model.WeatherObservation{
+		StationID:               "KSTL",
+		Timestamp:               time.Date(2026, 3, 20, 0, 0, 0, 0, time.UTC),
+		ConditionCode:           2,
+		TemperatureC:            float64Ptr(20),
+		DewpointC:               float64Ptr(10),
+		WindSpeedKmh:            float64Ptr(100),
+		WindGustKmh:             float64Ptr(80),
+		BarometricPressurePa:    float64Ptr(101325),
+		VisibilityMeters:        float64Ptr(1609.344),
+		ApparentTemperatureC:    float64Ptr(25),
+		RelativeHumidityPercent: float64Ptr(50),
+	}
+
+	payload := ObservationPayload(obs, UnitsUS)
+	converted, ok := payload.(WeatherObservationUS)
+	if !ok {
+		t.Fatalf("expected WeatherObservationUS payload, got %T", payload)
+	}
+
+	assertApprox(t, converted.TemperatureF, 68.0, 0.0001)
+	assertApprox(t, converted.WindSpeedMph, 62.1371192237, 0.0001)
+	assertApprox(t, converted.BarometricPressureInHg, 29.9212524019, 0.0001)
+	assertApprox(t, converted.VisibilityMiles, 1.0, 0.0001)
+
+	if converted.TemperatureF == nil || converted.DewpointF == nil || converted.ApparentTemperatureF == nil {
+		t.Fatalf("expected converted Fahrenheit fields to be populated")
+	}
+}
+
+func TestForecastPayloadUS(t *testing.T) {
+	issuedAt := time.Date(2026, 3, 20, 12, 0, 0, 0, time.UTC)
+	updatedAt := issuedAt.Add(1 * time.Hour)
+	run := &model.WeatherForecastRun{
+		LocationID:      "stl",
+		IssuedAt:        issuedAt,
+		UpdatedAt:       &updatedAt,
+		Product:         model.ForecastProductHourly,
+		ElevationMeters: float64Ptr(1000),
+		Periods: []model.WeatherForecastPeriod{{
+			StartTime:             issuedAt,
+			EndTime:               issuedAt.Add(1 * time.Hour),
+			ConditionCode:         63,
+			TemperatureC:          float64Ptr(0),
+			TemperatureCMin:       float64Ptr(-5),
+			TemperatureCMax:       float64Ptr(5),
+			WindSpeedKmh:          float64Ptr(64.37376),
+			PrecipitationAmountMm: float64Ptr(25.4),
+			SnowfallDepthMM:       float64Ptr(50.8),
+		}},
+	}
+
+	payload := ForecastPayload(run, UnitsUS)
+	converted, ok := payload.(WeatherForecastRunUS)
+	if !ok {
+		t.Fatalf("expected WeatherForecastRunUS payload, got %T", payload)
+	}
+
+	assertApprox(t, converted.ElevationFeet, 3280.839895, 0.0001)
+	if len(converted.Periods) != 1 {
+		t.Fatalf("expected 1 period, got %d", len(converted.Periods))
+	}
+	period := converted.Periods[0]
+	assertApprox(t, period.TemperatureF, 32.0, 0.0001)
+	assertApprox(t, period.TemperatureFMin, 23.0, 0.0001)
+	assertApprox(t, period.TemperatureFMax, 41.0, 0.0001)
+	assertApprox(t, period.WindSpeedMph, 40.0, 0.0001)
+	assertApprox(t, period.PrecipitationAmountIn, 1.0, 0.0001)
+	assertApprox(t, period.SnowfallDepthIn, 2.0, 0.0001)
+}
+
+func TestMetricPassthroughAndNilHandling(t *testing.T) {
+	obs := &model.WeatherObservation{}
+	metric := ObservationPayload(obs, UnitsMetric)
+	metricObs, ok := metric.(*model.WeatherObservation)
+	if !ok {
+		t.Fatalf("expected metric payload to remain model type, got %T", metric)
+	}
+	if metricObs != obs {
+		t.Fatalf("expected metric payload to be original pointer")
+	}
+
+	if ObservationPayload(nil, UnitsUS) != nil {
+		t.Fatalf("expected nil observation input to return nil payload")
+	}
+	if ForecastPayload(nil, UnitsUS) != nil {
+		t.Fatalf("expected nil forecast input to return nil payload")
+	}
+	if AlertsPayload(nil, UnitsUS) != nil {
+		t.Fatalf("expected nil alerts input to return nil payload")
+	}
+	if CurrentConditionsPayload(nil, UnitsUS) != nil {
+		t.Fatalf("expected nil current conditions input to return nil payload")
+	}
+}
+
+func TestCurrentConditionsPayloadMetricAndUS(t *testing.T) {
+	conditions := &app.CurrentConditions{
+		TemperatureC:            float64Ptr(20),
+		ApparentTemperatureC:    float64Ptr(18),
+		DewpointC:               float64Ptr(10),
+		RelativeHumidityPercent: float64Ptr(55),
+		WindSpeedKmh:            float64Ptr(100),
+		WindDirectionDegrees:    float64Ptr(225),
+		ConditionCode:           0,
+		IsDay:                   boolPtr(true),
+	}
+
+	metricPayload := CurrentConditionsPayload(conditions, UnitsMetric)
+	metric, ok := metricPayload.(CurrentConditionsResponse)
+	if !ok {
+		t.Fatalf("expected CurrentConditionsResponse metric payload, got %T", metricPayload)
+	}
+	assertApprox(t, metric.TemperatureC, 20, 0.0001)
+	assertApprox(t, metric.WindSpeedKmh, 100, 0.0001)
+	if metric.TemperatureF != nil || metric.WindSpeedMph != nil {
+		t.Fatalf("expected US fields omitted for metric payload")
+	}
+	if metric.ConditionText != "Sunny" {
+		t.Fatalf("expected condition text Sunny, got %q", metric.ConditionText)
+	}
+
+	usPayload := CurrentConditionsPayload(conditions, UnitsUS)
+	us, ok := usPayload.(CurrentConditionsResponse)
+	if !ok {
+		t.Fatalf("expected CurrentConditionsResponse US payload, got %T", usPayload)
+	}
+	assertApprox(t, us.TemperatureF, 68, 0.0001)
+	assertApprox(t, us.WindSpeedMph, 62.1371192237, 0.0001)
+	if us.TemperatureC != nil || us.WindSpeedKmh != nil {
+		t.Fatalf("expected metric fields omitted for US payload")
+	}
+}
+
+func TestCurrentConditionsPayloadUsesNightConditionText(t *testing.T) {
+	night := false
+	payload := CurrentConditionsPayload(&app.CurrentConditions{
+		ConditionCode: 0,
+		IsDay:         &night,
+	}, UnitsMetric)
+
+	metric, ok := payload.(CurrentConditionsResponse)
+	if !ok {
+		t.Fatalf("expected CurrentConditionsResponse payload, got %T", payload)
+	}
+	if metric.ConditionText != "Clear" {
+		t.Fatalf("expected condition text Clear, got %q", metric.ConditionText)
+	}
+}
+
+func float64Ptr(v float64) *float64 {
+	return &v
+}
+
+func boolPtr(v bool) *bool {
+	return &v
+}
+
+func assertApprox(t *testing.T, got *float64, want, eps float64) {
+	t.Helper()
+	if got == nil {
+		t.Fatalf("expected value near %f, got nil", want)
+	}
+	if math.Abs(*got-want) > eps {
+		t.Fatalf("expected %f +/- %f, got %f", want, eps, *got)
+	}
+}

internal/adapters/inbound/httpapi/presenter/units.go

@@ -0,0 +1,11 @@
+// units.go defines response unit modes for HTTP presentation.
+// Layer: adapters/inbound/httpapi/presenter unit selection.
+package presenter
+
+// Units controls response-unit output formatting.
+type Units string
+
+const (
+	UnitsMetric Units = "metric"
+	UnitsUS     Units = "us"
+)

internal/adapters/inbound/httpapi/query_bind.go

@@ -0,0 +1,36 @@
+// query_bind.go binds endpoint query parameters into typed request config.
+// Layer: adapters/inbound/httpapi request binding.
+package httpapi
+
+import (
+	"net/http"
+	"strings"
+
+	"gitea.maximumdirect.net/ejr/feedapi/bind"
+	"gitea.maximumdirect.net/ejr/weatherapi/internal/adapters/inbound/httpapi/presenter"
+)
+
+type queryRequest struct {
+	Units presenter.Units
+}
+
+func bindQuery(r *http.Request) (queryRequest, error) {
+	normalizeCommonQueryValue(r, "units")
+	normalizeCommonQueryValue(r, "format")
+
+	common, err := bind.CommonQueryParams(r, bind.QueryPolicy{
+		AllowUnits:    true,
+		AllowFormat:   true,
+		DefaultUnits:  string(presenter.UnitsMetric),
+		RejectUnknown: true,
+	})
+	if err != nil {
+		return queryRequest{}, err
+	}
+
+	units := presenter.Units(strings.ToLower(strings.TrimSpace(common.Units)))
+	if units == "" {
+		units = presenter.UnitsMetric
+	}
+	return queryRequest{Units: units}, nil
+}

internal/adapters/inbound/httpapi/query_normalize.go

@@ -0,0 +1,23 @@
+// query_normalize.go normalizes common query values before binding.
+// Layer: adapters/inbound/httpapi request pre-processing.
+package httpapi
+
+import (
+	"net/http"
+	"strings"
+)
+
+func normalizeCommonQueryValue(r *http.Request, key string) {
+	q := r.URL.Query()
+	values, ok := q[key]
+	if !ok || len(values) == 0 {
+		return
+	}
+
+	normalized := strings.ToLower(strings.TrimSpace(values[0]))
+	if normalized == values[0] {
+		return
+	}
+	q.Set(key, normalized)
+	r.URL.RawQuery = q.Encode()
+}

internal/adapters/inbound/httpapi/service.go

@@ -0,0 +1,18 @@
+// service.go defines the inbound service contract consumed by HTTP handlers.
+// Layer: adapters/inbound/httpapi boundary to application service.
+package httpapi
+
+import (
+	"context"
+
+	"gitea.maximumdirect.net/ejr/weatherapi/internal/app"
+	"gitea.maximumdirect.net/ejr/weatherfeeder/model"
+)
+
+// Service describes weather resource queries needed by the HTTP adapter.
+type Service interface {
+	LatestObservation(ctx context.Context) (*model.WeatherObservation, error)
+	LatestHourlyForecast(ctx context.Context) (*model.WeatherForecastRun, error)
+	LatestAlertRun(ctx context.Context) (*model.WeatherAlertRun, error)
+	CurrentConditions(ctx context.Context) (*app.CurrentConditions, error)
+}

internal/adapters/outbound/postgres/alerts_mapper.go

@@ -0,0 +1,70 @@
+// alerts_mapper.go maps alert rows into weather model payloads.
+// Layer: adapters/outbound/postgres alerts feature.
+package postgres
+
+import "gitea.maximumdirect.net/ejr/weatherfeeder/model"
+
+func mapAlertRunParentRow(row alertRunParentRow) model.WeatherAlertRun {
+	return model.WeatherAlertRun{
+		LocationID:   stringValue(row.LocationID),
+		LocationName: stringValue(row.LocationName),
+		AsOf:         row.AsOf.UTC(),
+		Latitude:     float64Ptr(row.Latitude),
+		Longitude:    float64Ptr(row.Longitude),
+	}
+}
+
+func mapAlertRow(row alertRow) indexedAlert {
+	return indexedAlert{
+		Index: row.AlertIndex,
+		Alert: model.WeatherAlert{
+			ID:              row.AlertID,
+			Event:           stringValue(row.Event),
+			Headline:        stringValue(row.Headline),
+			Severity:        stringValue(row.Severity),
+			Urgency:         stringValue(row.Urgency),
+			Certainty:       stringValue(row.Certainty),
+			Status:          stringValue(row.Status),
+			MessageType:     stringValue(row.MessageType),
+			Category:        stringValue(row.Category),
+			Response:        stringValue(row.Response),
+			Description:     stringValue(row.Description),
+			Instruction:     stringValue(row.Instruction),
+			Sent:            timePtr(row.Sent),
+			Effective:       timePtr(row.Effective),
+			Onset:           timePtr(row.Onset),
+			Expires:         timePtr(row.Expires),
+			AreaDescription: stringValue(row.AreaDescription),
+			SenderName:      stringValue(row.SenderName),
+		},
+	}
+}
+
+func mapAlertReferenceRow(row alertReferenceRow) indexedAlertReference {
+	return indexedAlertReference{
+		AlertIndex: row.AlertIndex,
+		Reference: model.AlertReference{
+			ID:         stringValue(row.ID),
+			Identifier: stringValue(row.Identifier),
+			Sender:     stringValue(row.Sender),
+			Sent:       timePtr(row.Sent),
+		},
+	}
+}
+
+func attachAlertReferences(alerts []indexedAlert, references []indexedAlertReference) []model.WeatherAlert {
+	refsByAlertIndex := make(map[int][]model.AlertReference, len(alerts))
+	for _, ref := range references {
+		refsByAlertIndex[ref.AlertIndex] = append(refsByAlertIndex[ref.AlertIndex], ref.Reference)
+	}
+
+	out := make([]model.WeatherAlert, 0, len(alerts))
+	for _, alert := range alerts {
+		mapped := alert.Alert
+		if refs := refsByAlertIndex[alert.Index]; len(refs) > 0 {
+			mapped.References = refs
+		}
+		out = append(out, mapped)
+	}
+	return out
+}

internal/adapters/outbound/postgres/alerts_queries.go

@@ -0,0 +1,53 @@
+// alerts_queries.go contains SQL text for alert-run reads.
+// Layer: adapters/outbound/postgres alerts feature.
+package postgres
+
+const (
+	queryLatestAlertRun = `
+SELECT
+  event_id,
+  location_id,
+  location_name,
+  as_of,
+  latitude,
+  longitude
+FROM alert_runs
+ORDER BY as_of DESC, event_emitted_at DESC
+LIMIT 1`
+
+	queryAlerts = `
+SELECT
+  alert_index,
+  alert_id,
+  event,
+  headline,
+  severity,
+  urgency,
+  certainty,
+  status,
+  message_type,
+  category,
+  response,
+  description,
+  instruction,
+  sent,
+  effective,
+  onset,
+  expires,
+  area_description,
+  sender_name
+FROM alerts
+WHERE run_event_id = $1
+ORDER BY alert_index ASC`
+
+	queryAlertReferences = `
+SELECT
+  alert_index,
+  id,
+  identifier,
+  sender,
+  sent
+FROM alert_references
+WHERE run_event_id = $1
+ORDER BY alert_index ASC, reference_index ASC`
+)

internal/adapters/outbound/postgres/alerts_read.go

@@ -0,0 +1,110 @@
+// alerts_read.go executes alert-run, alerts, and reference queries.
+// Layer: adapters/outbound/postgres alerts feature.
+package postgres
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+
+	"gitea.maximumdirect.net/ejr/weatherfeeder/model"
+)
+
+func (r *Repository) LatestAlertRun(ctx context.Context) (*model.WeatherAlertRun, error) {
+	if r == nil || r.db == nil {
+		return nil, fmt.Errorf("postgres repository is not configured")
+	}
+
+	var row alertRunParentRow
+	err := r.db.QueryRowContext(ctx, queryLatestAlertRun).Scan(
+		&row.EventID,
+		&row.LocationID,
+		&row.LocationName,
+		&row.AsOf,
+		&row.Latitude,
+		&row.Longitude,
+	)
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("query latest alert run: %w", err)
+	}
+
+	run := mapAlertRunParentRow(row)
+
+	alerts, err := r.loadAlerts(ctx, row.EventID)
+	if err != nil {
+		return nil, err
+	}
+	run.Alerts = alerts
+
+	return &run, nil
+}
+
+func (r *Repository) loadAlerts(ctx context.Context, eventID string) ([]model.WeatherAlert, error) {
+	alertsRows, err := r.db.QueryContext(ctx, queryAlerts, eventID)
+	if err != nil {
+		return nil, fmt.Errorf("query alerts: %w", err)
+	}
+	defer alertsRows.Close()
+
+	indexedAlerts := make([]indexedAlert, 0)
+	for alertsRows.Next() {
+		var row alertRow
+		if err := alertsRows.Scan(
+			&row.AlertIndex,
+			&row.AlertID,
+			&row.Event,
+			&row.Headline,
+			&row.Severity,
+			&row.Urgency,
+			&row.Certainty,
+			&row.Status,
+			&row.MessageType,
+			&row.Category,
+			&row.Response,
+			&row.Description,
+			&row.Instruction,
+			&row.Sent,
+			&row.Effective,
+			&row.Onset,
+			&row.Expires,
+			&row.AreaDescription,
+			&row.SenderName,
+		); err != nil {
+			return nil, fmt.Errorf("scan alerts row: %w", err)
+		}
+		indexedAlerts = append(indexedAlerts, mapAlertRow(row))
+	}
+	if err := alertsRows.Err(); err != nil {
+		return nil, fmt.Errorf("iterate alerts rows: %w", err)
+	}
+
+	referenceRows, err := r.db.QueryContext(ctx, queryAlertReferences, eventID)
+	if err != nil {
+		return nil, fmt.Errorf("query alert references: %w", err)
+	}
+	defer referenceRows.Close()
+
+	indexedReferences := make([]indexedAlertReference, 0)
+	for referenceRows.Next() {
+		var row alertReferenceRow
+		if err := referenceRows.Scan(
+			&row.AlertIndex,
+			&row.ID,
+			&row.Identifier,
+			&row.Sender,
+			&row.Sent,
+		); err != nil {
+			return nil, fmt.Errorf("scan alert reference row: %w", err)
+		}
+		indexedReferences = append(indexedReferences, mapAlertReferenceRow(row))
+	}
+	if err := referenceRows.Err(); err != nil {
+		return nil, fmt.Errorf("iterate alert reference rows: %w", err)
+	}
+
+	return attachAlertReferences(indexedAlerts, indexedReferences), nil
+}

internal/adapters/outbound/postgres/alerts_rows.go

@@ -0,0 +1,59 @@
+// alerts_rows.go defines row DTOs for alert-run, alert, and reference reads.
+// Layer: adapters/outbound/postgres alerts feature.
+package postgres
+
+import (
+	"database/sql"
+	"time"
+
+	"gitea.maximumdirect.net/ejr/weatherfeeder/model"
+)
+
+type alertRunParentRow struct {
+	EventID      string
+	LocationID   sql.NullString
+	LocationName sql.NullString
+	AsOf         time.Time
+	Latitude     sql.NullFloat64
+	Longitude    sql.NullFloat64
+}
+
+type alertRow struct {
+	AlertIndex      int
+	AlertID         string
+	Event           sql.NullString
+	Headline        sql.NullString
+	Severity        sql.NullString
+	Urgency         sql.NullString
+	Certainty       sql.NullString
+	Status          sql.NullString
+	MessageType     sql.NullString
+	Category        sql.NullString
+	Response        sql.NullString
+	Description     sql.NullString
+	Instruction     sql.NullString
+	Sent            sql.NullTime
+	Effective       sql.NullTime
+	Onset           sql.NullTime
+	Expires         sql.NullTime
+	AreaDescription sql.NullString
+	SenderName      sql.NullString
+}
+
+type indexedAlert struct {
+	Index int
+	Alert model.WeatherAlert
+}
+
+type alertReferenceRow struct {
+	AlertIndex int
+	ID         sql.NullString
+	Identifier sql.NullString
+	Sender     sql.NullString
+	Sent       sql.NullTime
+}
+
+type indexedAlertReference struct {
+	AlertIndex int
+	Reference  model.AlertReference
+}

internal/adapters/outbound/postgres/conditions_mapper.go

@@ -0,0 +1,30 @@
+// conditions_mapper.go maps current-conditions DB rows into app models.
+// Layer: adapters/outbound/postgres conditions feature.
+package postgres
+
+import (
+	"gitea.maximumdirect.net/ejr/weatherapi/internal/app"
+	"gitea.maximumdirect.net/ejr/weatherfeeder/model"
+)
+
+func mapCurrentConditionsRow(row currentConditionsRow) *app.CurrentConditions {
+	if row.SampleCount == 0 {
+		return nil
+	}
+
+	conditionCode := model.WMOUnknown
+	if row.ConditionCode.Valid {
+		conditionCode = model.WMOCode(row.ConditionCode.Int64)
+	}
+
+	return &app.CurrentConditions{
+		TemperatureC:            float64Ptr(row.TemperatureC),
+		ApparentTemperatureC:    float64Ptr(row.ApparentTemperatureC),
+		DewpointC:               float64Ptr(row.DewpointC),
+		RelativeHumidityPercent: float64Ptr(row.RelativeHumidityPercent),
+		WindSpeedKmh:            float64Ptr(row.WindSpeedKmh),
+		WindDirectionDegrees:    float64Ptr(row.WindDirectionDegrees),
+		ConditionCode:           conditionCode,
+		IsDay:                   boolPtr(row.IsDay),
+	}
+}

internal/adapters/outbound/postgres/conditions_queries.go

@@ -0,0 +1,50 @@
+// conditions_queries.go contains SQL text for current-conditions reads.
+// Layer: adapters/outbound/postgres conditions feature.
+package postgres
+
+const (
+	queryCurrentConditions = `
+WITH windowed AS (
+  SELECT
+    temperature_c,
+    apparent_temperature_c,
+    dewpoint_c,
+    relative_humidity_percent,
+    wind_speed_kmh,
+    wind_direction_degrees,
+    condition_code,
+    is_day,
+    observed_at
+  FROM observations
+  WHERE observed_at > CURRENT_TIMESTAMP - make_interval(mins => $1)
+)
+SELECT
+  COUNT(*) AS sample_count,
+  AVG(temperature_c) AS temperature_c,
+  AVG(apparent_temperature_c) AS apparent_temperature_c,
+  AVG(dewpoint_c) AS dewpoint_c,
+  AVG(relative_humidity_percent) AS relative_humidity_percent,
+  AVG(wind_speed_kmh) AS wind_speed_kmh,
+  CASE
+    WHEN atan2d(
+      AVG(sind(wind_direction_degrees)),
+      AVG(cosd(wind_direction_degrees))
+    ) < 0
+    THEN atan2d(
+      AVG(sind(wind_direction_degrees)),
+      AVG(cosd(wind_direction_degrees))
+    ) + 360.0
+    ELSE atan2d(
+      AVG(sind(wind_direction_degrees)),
+      AVG(cosd(wind_direction_degrees))
+    )
+  END AS wind_direction_degrees,
+  MAX(condition_code) AS condition_code,
+  (
+    SELECT is_day
+    FROM windowed
+    ORDER BY observed_at DESC
+    LIMIT 1
+  ) AS is_day
+FROM windowed`
+)

internal/adapters/outbound/postgres/conditions_read.go

@@ -0,0 +1,39 @@
+// conditions_read.go executes current-conditions queries.
+// Layer: adapters/outbound/postgres conditions feature.
+package postgres
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+
+	"gitea.maximumdirect.net/ejr/weatherapi/internal/app"
+)
+
+func (r *Repository) CurrentConditions(ctx context.Context, observationWindowMinutes int) (*app.CurrentConditions, error) {
+	if r == nil || r.db == nil {
+		return nil, fmt.Errorf("postgres repository is not configured")
+	}
+
+	var row currentConditionsRow
+	err := r.db.QueryRowContext(ctx, queryCurrentConditions, observationWindowMinutes).Scan(
+		&row.SampleCount,
+		&row.TemperatureC,
+		&row.ApparentTemperatureC,
+		&row.DewpointC,
+		&row.RelativeHumidityPercent,
+		&row.WindSpeedKmh,
+		&row.WindDirectionDegrees,
+		&row.ConditionCode,
+		&row.IsDay,
+	)
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("query current conditions: %w", err)
+	}
+
+	return mapCurrentConditionsRow(row), nil
+}

internal/adapters/outbound/postgres/conditions_rows.go

@@ -0,0 +1,17 @@
+// conditions_rows.go defines row DTOs for current-conditions reads.
+// Layer: adapters/outbound/postgres conditions feature.
+package postgres
+
+import "database/sql"
+
+type currentConditionsRow struct {
+	SampleCount             int64
+	TemperatureC            sql.NullFloat64
+	ApparentTemperatureC    sql.NullFloat64
+	DewpointC               sql.NullFloat64
+	RelativeHumidityPercent sql.NullFloat64
+	WindSpeedKmh            sql.NullFloat64
+	WindDirectionDegrees    sql.NullFloat64
+	ConditionCode           sql.NullInt64
+	IsDay                   sql.NullBool
+}

internal/adapters/outbound/postgres/forecast_mapper.go

@@ -0,0 +1,49 @@
+// forecast_mapper.go maps forecast rows into weather model payloads.
+// Layer: adapters/outbound/postgres forecast feature.
+package postgres
+
+import "gitea.maximumdirect.net/ejr/weatherfeeder/model"
+
+func mapForecastParentRow(row forecastParentRow) model.WeatherForecastRun {
+	return model.WeatherForecastRun{
+		LocationID:      stringValue(row.LocationID),
+		LocationName:    stringValue(row.LocationName),
+		IssuedAt:        row.IssuedAt.UTC(),
+		UpdatedAt:       timePtr(row.UpdatedAt),
+		Product:         model.ForecastProduct(row.Product),
+		Latitude:        float64Ptr(row.Latitude),
+		Longitude:       float64Ptr(row.Longitude),
+		ElevationMeters: float64Ptr(row.ElevationMeters),
+	}
+}
+
+func mapForecastPeriodRow(row forecastPeriodRow) model.WeatherForecastPeriod {
+	return model.WeatherForecastPeriod{
+		StartTime:                         row.StartTime.UTC(),
+		EndTime:                           row.EndTime.UTC(),
+		Name:                              stringValue(row.Name),
+		IsDay:                             boolPtr(row.IsDay),
+		ConditionCode:                     model.WMOCode(row.ConditionCode),
+		ConditionText:                     stringValue(row.ConditionText),
+		ProviderRawDescription:            stringValue(row.ProviderRawDescription),
+		TextDescription:                   stringValue(row.TextDescription),
+		DetailedText:                      stringValue(row.DetailedText),
+		IconURL:                           stringValue(row.IconURL),
+		TemperatureC:                      float64Ptr(row.TemperatureC),
+		TemperatureCMin:                   float64Ptr(row.TemperatureCMin),
+		TemperatureCMax:                   float64Ptr(row.TemperatureCMax),
+		DewpointC:                         float64Ptr(row.DewpointC),
+		RelativeHumidityPercent:           float64Ptr(row.RelativeHumidityPercent),
+		WindDirectionDegrees:              float64Ptr(row.WindDirectionDegrees),
+		WindSpeedKmh:                      float64Ptr(row.WindSpeedKmh),
+		WindGustKmh:                       float64Ptr(row.WindGustKmh),
+		BarometricPressurePa:              float64Ptr(row.BarometricPressurePa),
+		VisibilityMeters:                  float64Ptr(row.VisibilityMeters),
+		ApparentTemperatureC:              float64Ptr(row.ApparentTemperatureC),
+		CloudCoverPercent:                 float64Ptr(row.CloudCoverPercent),
+		ProbabilityOfPrecipitationPercent: float64Ptr(row.ProbabilityOfPrecipitationPercent),
+		PrecipitationAmountMm:             float64Ptr(row.PrecipitationAmountMM),
+		SnowfallDepthMM:                   float64Ptr(row.SnowfallDepthMM),
+		UVIndex:                           float64Ptr(row.UVIndex),
+	}
+}

internal/adapters/outbound/postgres/forecast_queries.go

@@ -0,0 +1,54 @@
+// forecast_queries.go contains SQL text for hourly forecast reads.
+// Layer: adapters/outbound/postgres forecast feature.
+package postgres
+
+const (
+	queryLatestHourlyForecast = `
+SELECT
+  event_id,
+  location_id,
+  location_name,
+  issued_at,
+  updated_at,
+  product,
+  latitude,
+  longitude,
+  elevation_meters
+FROM forecasts
+WHERE product = 'hourly'
+ORDER BY issued_at DESC, event_emitted_at DESC
+LIMIT 1`
+
+	queryForecastPeriods = `
+SELECT
+  period_index,
+  start_time,
+  end_time,
+  name,
+  is_day,
+  condition_code,
+  condition_text,
+  provider_raw_description,
+  text_description,
+  detailed_text,
+  icon_url,
+  temperature_c,
+  temperature_c_min,
+  temperature_c_max,
+  dewpoint_c,
+  relative_humidity_percent,
+  wind_direction_degrees,
+  wind_speed_kmh,
+  wind_gust_kmh,
+  barometric_pressure_pa,
+  visibility_meters,
+  apparent_temperature_c,
+  cloud_cover_percent,
+  probability_of_precipitation_percent,
+  precipitation_amount_mm,
+  snowfall_depth_mm,
+  uv_index
+FROM forecast_periods
+WHERE run_event_id = $1
+ORDER BY period_index ASC`
+)

internal/adapters/outbound/postgres/forecast_read.go

@@ -0,0 +1,96 @@
+// forecast_read.go executes hourly forecast and period queries.
+// Layer: adapters/outbound/postgres forecast feature.
+package postgres
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+
+	"gitea.maximumdirect.net/ejr/weatherfeeder/model"
+)
+
+func (r *Repository) LatestHourlyForecast(ctx context.Context) (*model.WeatherForecastRun, error) {
+	if r == nil || r.db == nil {
+		return nil, fmt.Errorf("postgres repository is not configured")
+	}
+
+	var row forecastParentRow
+	err := r.db.QueryRowContext(ctx, queryLatestHourlyForecast).Scan(
+		&row.EventID,
+		&row.LocationID,
+		&row.LocationName,
+		&row.IssuedAt,
+		&row.UpdatedAt,
+		&row.Product,
+		&row.Latitude,
+		&row.Longitude,
+		&row.ElevationMeters,
+	)
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("query latest hourly forecast: %w", err)
+	}
+
+	run := mapForecastParentRow(row)
+
+	periods, err := r.loadForecastPeriods(ctx, row.EventID)
+	if err != nil {
+		return nil, err
+	}
+	run.Periods = periods
+
+	return &run, nil
+}
+
+func (r *Repository) loadForecastPeriods(ctx context.Context, eventID string) ([]model.WeatherForecastPeriod, error) {
+	rows, err := r.db.QueryContext(ctx, queryForecastPeriods, eventID)
+	if err != nil {
+		return nil, fmt.Errorf("query forecast periods: %w", err)
+	}
+	defer rows.Close()
+
+	out := make([]model.WeatherForecastPeriod, 0)
+	for rows.Next() {
+		var row forecastPeriodRow
+		if err := rows.Scan(
+			&row.PeriodIndex,
+			&row.StartTime,
+			&row.EndTime,
+			&row.Name,
+			&row.IsDay,
+			&row.ConditionCode,
+			&row.ConditionText,
+			&row.ProviderRawDescription,
+			&row.TextDescription,
+			&row.DetailedText,
+			&row.IconURL,
+			&row.TemperatureC,
+			&row.TemperatureCMin,
+			&row.TemperatureCMax,
+			&row.DewpointC,
+			&row.RelativeHumidityPercent,
+			&row.WindDirectionDegrees,
+			&row.WindSpeedKmh,
+			&row.WindGustKmh,
+			&row.BarometricPressurePa,
+			&row.VisibilityMeters,
+			&row.ApparentTemperatureC,
+			&row.CloudCoverPercent,
+			&row.ProbabilityOfPrecipitationPercent,
+			&row.PrecipitationAmountMM,
+			&row.SnowfallDepthMM,
+			&row.UVIndex,
+		); err != nil {
+			return nil, fmt.Errorf("scan forecast period row: %w", err)
+		}
+		out = append(out, mapForecastPeriodRow(row))
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("iterate forecast period rows: %w", err)
+	}
+	return out, nil
+}

internal/adapters/outbound/postgres/forecast_rows.go

@@ -0,0 +1,50 @@
+// forecast_rows.go defines row DTOs for forecast reads.
+// Layer: adapters/outbound/postgres forecast feature.
+package postgres
+
+import (
+	"database/sql"
+	"time"
+)
+
+type forecastParentRow struct {
+	EventID         string
+	LocationID      sql.NullString
+	LocationName    sql.NullString
+	IssuedAt        time.Time
+	UpdatedAt       sql.NullTime
+	Product         string
+	Latitude        sql.NullFloat64
+	Longitude       sql.NullFloat64
+	ElevationMeters sql.NullFloat64
+}
+
+type forecastPeriodRow struct {
+	PeriodIndex                       int
+	StartTime                         time.Time
+	EndTime                           time.Time
+	Name                              sql.NullString
+	IsDay                             sql.NullBool
+	ConditionCode                     int
+	ConditionText                     sql.NullString
+	ProviderRawDescription            sql.NullString
+	TextDescription                   sql.NullString
+	DetailedText                      sql.NullString
+	IconURL                           sql.NullString
+	TemperatureC                      sql.NullFloat64
+	TemperatureCMin                   sql.NullFloat64
+	TemperatureCMax                   sql.NullFloat64
+	DewpointC                         sql.NullFloat64
+	RelativeHumidityPercent           sql.NullFloat64
+	WindDirectionDegrees              sql.NullFloat64
+	WindSpeedKmh                      sql.NullFloat64
+	WindGustKmh                       sql.NullFloat64
+	BarometricPressurePa              sql.NullFloat64
+	VisibilityMeters                  sql.NullFloat64
+	ApparentTemperatureC              sql.NullFloat64
+	CloudCoverPercent                 sql.NullFloat64
+	ProbabilityOfPrecipitationPercent sql.NullFloat64
+	PrecipitationAmountMM             sql.NullFloat64
+	SnowfallDepthMM                   sql.NullFloat64
+	UVIndex                           sql.NullFloat64
+}

internal/adapters/outbound/postgres/observations_mapper.go

@@ -0,0 +1,42 @@
+// observations_mapper.go maps observation rows into weather model payloads.
+// Layer: adapters/outbound/postgres observations feature.
+package postgres
+
+import (
+	"encoding/json"
+	"strings"
+
+	"gitea.maximumdirect.net/ejr/weatherfeeder/model"
+)
+
+func mapObservationParentRow(row observationParentRow) model.WeatherObservation {
+	return model.WeatherObservation{
+		StationID:               stringValue(row.StationID),
+		StationName:             stringValue(row.StationName),
+		Timestamp:               row.ObservedAt.UTC(),
+		ConditionCode:           model.WMOCode(row.ConditionCode),
+		IsDay:                   boolPtr(row.IsDay),
+		TextDescription:         stringValue(row.TextDescription),
+		TemperatureC:            float64Ptr(row.TemperatureC),
+		DewpointC:               float64Ptr(row.DewpointC),
+		WindDirectionDegrees:    float64Ptr(row.WindDirectionDegrees),
+		WindSpeedKmh:            float64Ptr(row.WindSpeedKmh),
+		WindGustKmh:             float64Ptr(row.WindGustKmh),
+		BarometricPressurePa:    float64Ptr(row.BarometricPressurePa),
+		VisibilityMeters:        float64Ptr(row.VisibilityMeters),
+		RelativeHumidityPercent: float64Ptr(row.RelativeHumidityPercent),
+		ApparentTemperatureC:    float64Ptr(row.ApparentTemperatureC),
+	}
+}
+
+func mapObservationPresentWeatherRow(row observationPresentWeatherRow) (model.PresentWeather, error) {
+	if !row.RawText.Valid || strings.TrimSpace(row.RawText.String) == "" {
+		return model.PresentWeather{}, nil
+	}
+
+	var raw map[string]any
+	if err := json.Unmarshal([]byte(row.RawText.String), &raw); err != nil {
+		return model.PresentWeather{}, err
+	}
+	return model.PresentWeather{Raw: raw}, nil
+}

internal/adapters/outbound/postgres/observations_queries.go

@@ -0,0 +1,33 @@
+// observations_queries.go contains SQL text for observation reads.
+// Layer: adapters/outbound/postgres observations feature.
+package postgres
+
+const (
+	queryLatestObservation = `
+SELECT
+  event_id,
+  station_id,
+  station_name,
+  observed_at,
+  condition_code,
+  is_day,
+  text_description,
+  temperature_c,
+  dewpoint_c,
+  wind_direction_degrees,
+  wind_speed_kmh,
+  wind_gust_kmh,
+  barometric_pressure_pa,
+  visibility_meters,
+  relative_humidity_percent,
+  apparent_temperature_c
+FROM observations
+ORDER BY observed_at DESC, event_emitted_at DESC
+LIMIT 1`
+
+	queryObservationPresentWeather = `
+SELECT weather_index, raw_text
+FROM observation_present_weather
+WHERE event_id = $1
+ORDER BY weather_index ASC`
+)

internal/adapters/outbound/postgres/observations_read.go

@@ -0,0 +1,79 @@
+// observations_read.go executes observation and present-weather queries.
+// Layer: adapters/outbound/postgres observations feature.
+package postgres
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+
+	"gitea.maximumdirect.net/ejr/weatherfeeder/model"
+)
+
+func (r *Repository) LatestObservation(ctx context.Context) (*model.WeatherObservation, error) {
+	if r == nil || r.db == nil {
+		return nil, fmt.Errorf("postgres repository is not configured")
+	}
+
+	var row observationParentRow
+	err := r.db.QueryRowContext(ctx, queryLatestObservation).Scan(
+		&row.EventID,
+		&row.StationID,
+		&row.StationName,
+		&row.ObservedAt,
+		&row.ConditionCode,
+		&row.IsDay,
+		&row.TextDescription,
+		&row.TemperatureC,
+		&row.DewpointC,
+		&row.WindDirectionDegrees,
+		&row.WindSpeedKmh,
+		&row.WindGustKmh,
+		&row.BarometricPressurePa,
+		&row.VisibilityMeters,
+		&row.RelativeHumidityPercent,
+		&row.ApparentTemperatureC,
+	)
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("query latest observation: %w", err)
+	}
+
+	obs := mapObservationParentRow(row)
+
+	presentWeather, err := r.loadObservationPresentWeather(ctx, row.EventID)
+	if err != nil {
+		return nil, err
+	}
+	obs.PresentWeather = presentWeather
+
+	return &obs, nil
+}
+
+func (r *Repository) loadObservationPresentWeather(ctx context.Context, eventID string) ([]model.PresentWeather, error) {
+	rows, err := r.db.QueryContext(ctx, queryObservationPresentWeather, eventID)
+	if err != nil {
+		return nil, fmt.Errorf("query observation present weather: %w", err)
+	}
+	defer rows.Close()
+
+	out := make([]model.PresentWeather, 0)
+	for rows.Next() {
+		var row observationPresentWeatherRow
+		if err := rows.Scan(&row.WeatherIndex, &row.RawText); err != nil {
+			return nil, fmt.Errorf("scan observation present weather row: %w", err)
+		}
+		pw, err := mapObservationPresentWeatherRow(row)
+		if err != nil {
+			return nil, fmt.Errorf("decode observation present weather row (index=%d): %w", row.WeatherIndex, err)
+		}
+		out = append(out, pw)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("iterate observation present weather rows: %w", err)
+	}
+	return out, nil
+}

internal/adapters/outbound/postgres/observations_rows.go

@@ -0,0 +1,32 @@
+// observations_rows.go defines row DTOs for observation reads.
+// Layer: adapters/outbound/postgres observations feature.
+package postgres
+
+import (
+	"database/sql"
+	"time"
+)
+
+type observationParentRow struct {
+	EventID                 string
+	StationID               sql.NullString
+	StationName             sql.NullString
+	ObservedAt              time.Time
+	ConditionCode           int
+	IsDay                   sql.NullBool
+	TextDescription         sql.NullString
+	TemperatureC            sql.NullFloat64
+	DewpointC               sql.NullFloat64
+	WindDirectionDegrees    sql.NullFloat64
+	WindSpeedKmh            sql.NullFloat64
+	WindGustKmh             sql.NullFloat64
+	BarometricPressurePa    sql.NullFloat64
+	VisibilityMeters        sql.NullFloat64
+	RelativeHumidityPercent sql.NullFloat64
+	ApparentTemperatureC    sql.NullFloat64
+}
+
+type observationPresentWeatherRow struct {
+	WeatherIndex int
+	RawText      sql.NullString
+}

internal/adapters/outbound/postgres/repository.go

@@ -1,143 +1,11 @@
+// repository.go defines the Postgres repository shell and constructor.
+// Layer: adapters/outbound/postgres repository root.
 package postgres
 
 import (
-	"context"
 	"database/sql"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"strings"
-	"time"
 
-	"gitea.maximumdirect.net/ejr/weatherapi/internal/core"
-	"gitea.maximumdirect.net/ejr/weatherfeeder/model"
-)
-
-const (
-	queryLatestObservation = `
-SELECT
-  event_id,
-  station_id,
-  station_name,
-  observed_at,
-  condition_code,
-  is_day,
-  text_description,
-  temperature_c,
-  dewpoint_c,
-  wind_direction_degrees,
-  wind_speed_kmh,
-  wind_gust_kmh,
-  barometric_pressure_pa,
-  visibility_meters,
-  relative_humidity_percent,
-  apparent_temperature_c
-FROM observations
-ORDER BY observed_at DESC, event_emitted_at DESC
-LIMIT 1`
-
-	queryObservationPresentWeather = `
-SELECT weather_index, raw_text
-FROM observation_present_weather
-WHERE event_id = $1
-ORDER BY weather_index ASC`
-
-	queryLatestHourlyForecast = `
-SELECT
-  event_id,
-  location_id,
-  location_name,
-  issued_at,
-  updated_at,
-  product,
-  latitude,
-  longitude,
-  elevation_meters
-FROM forecasts
-WHERE product = 'hourly'
-ORDER BY issued_at DESC, event_emitted_at DESC
-LIMIT 1`
-
-	queryForecastPeriods = `
-SELECT
-  period_index,
-  start_time,
-  end_time,
-  name,
-  is_day,
-  condition_code,
-  condition_text,
-  provider_raw_description,
-  text_description,
-  detailed_text,
-  icon_url,
-  temperature_c,
-  temperature_c_min,
-  temperature_c_max,
-  dewpoint_c,
-  relative_humidity_percent,
-  wind_direction_degrees,
-  wind_speed_kmh,
-  wind_gust_kmh,
-  barometric_pressure_pa,
-  visibility_meters,
-  apparent_temperature_c,
-  cloud_cover_percent,
-  probability_of_precipitation_percent,
-  precipitation_amount_mm,
-  snowfall_depth_mm,
-  uv_index
-FROM forecast_periods
-WHERE run_event_id = $1
-ORDER BY period_index ASC`
-
-	queryLatestAlertRun = `
-SELECT
-  event_id,
-  location_id,
-  location_name,
-  as_of,
-  latitude,
-  longitude
-FROM alert_runs
-ORDER BY as_of DESC, event_emitted_at DESC
-LIMIT 1`
-
-	queryAlerts = `
-SELECT
-  alert_index,
-  alert_id,
-  event,
-  headline,
-  severity,
-  urgency,
-  certainty,
-  status,
-  message_type,
-  category,
-  response,
-  description,
-  instruction,
-  sent,
-  effective,
-  onset,
-  expires,
-  area_description,
-  sender_name
-FROM alerts
-WHERE run_event_id = $1
-ORDER BY alert_index ASC`
-
-	queryAlertReferences = `
-SELECT
-  alert_index,
-  id,
-  identifier,
-  sender,
-  sent
-FROM alert_references
-WHERE run_event_id = $1
-ORDER BY alert_index ASC, reference_index ASC`
+	"gitea.maximumdirect.net/ejr/weatherapi/internal/app"
 )
 
 // Repository is a Postgres-backed implementation of weatherapi read ports.
@@ -145,544 +13,8 @@ type Repository struct {
 	db *sql.DB
 }
 
-var _ core.Repository = (*Repository)(nil)
+var _ app.Repository = (*Repository)(nil)
 
 func NewRepository(db *sql.DB) *Repository {
 	return &Repository{db: db}
 }
-
-func (r *Repository) LatestObservation(ctx context.Context) (*model.WeatherObservation, error) {
-	if r == nil || r.db == nil {
-		return nil, fmt.Errorf("postgres repository is not configured")
-	}
-
-	var row observationParentRow
-	err := r.db.QueryRowContext(ctx, queryLatestObservation).Scan(
-		&row.EventID,
-		&row.StationID,
-		&row.StationName,
-		&row.ObservedAt,
-		&row.ConditionCode,
-		&row.IsDay,
-		&row.TextDescription,
-		&row.TemperatureC,
-		&row.DewpointC,
-		&row.WindDirectionDegrees,
-		&row.WindSpeedKmh,
-		&row.WindGustKmh,
-		&row.BarometricPressurePa,
-		&row.VisibilityMeters,
-		&row.RelativeHumidityPercent,
-		&row.ApparentTemperatureC,
-	)
-	if errors.Is(err, sql.ErrNoRows) {
-		return nil, nil
-	}
-	if err != nil {
-		return nil, fmt.Errorf("query latest observation: %w", err)
-	}
-
-	obs := mapObservationParentRow(row)
-
-	presentWeather, err := r.loadObservationPresentWeather(ctx, row.EventID)
-	if err != nil {
-		return nil, err
-	}
-	obs.PresentWeather = presentWeather
-
-	return &obs, nil
-}
-
-func (r *Repository) LatestHourlyForecast(ctx context.Context) (*model.WeatherForecastRun, error) {
-	if r == nil || r.db == nil {
-		return nil, fmt.Errorf("postgres repository is not configured")
-	}
-
-	var row forecastParentRow
-	err := r.db.QueryRowContext(ctx, queryLatestHourlyForecast).Scan(
-		&row.EventID,
-		&row.LocationID,
-		&row.LocationName,
-		&row.IssuedAt,
-		&row.UpdatedAt,
-		&row.Product,
-		&row.Latitude,
-		&row.Longitude,
-		&row.ElevationMeters,
-	)
-	if errors.Is(err, sql.ErrNoRows) {
-		return nil, nil
-	}
-	if err != nil {
-		return nil, fmt.Errorf("query latest hourly forecast: %w", err)
-	}
-
-	run := mapForecastParentRow(row)
-
-	periods, err := r.loadForecastPeriods(ctx, row.EventID)
-	if err != nil {
-		return nil, err
-	}
-	run.Periods = periods
-
-	return &run, nil
-}
-
-func (r *Repository) LatestActiveAlerts(ctx context.Context) (*model.WeatherAlertRun, error) {
-	if r == nil || r.db == nil {
-		return nil, fmt.Errorf("postgres repository is not configured")
-	}
-
-	var row alertRunParentRow
-	err := r.db.QueryRowContext(ctx, queryLatestAlertRun).Scan(
-		&row.EventID,
-		&row.LocationID,
-		&row.LocationName,
-		&row.AsOf,
-		&row.Latitude,
-		&row.Longitude,
-	)
-	if errors.Is(err, sql.ErrNoRows) {
-		return nil, nil
-	}
-	if err != nil {
-		return nil, fmt.Errorf("query latest alert run: %w", err)
-	}
-
-	run := mapAlertRunParentRow(row)
-
-	alerts, err := r.loadAlerts(ctx, row.EventID)
-	if err != nil {
-		return nil, err
-	}
-	run.Alerts = alerts
-
-	return &run, nil
-}
-
-func (r *Repository) loadObservationPresentWeather(ctx context.Context, eventID string) ([]model.PresentWeather, error) {
-	rows, err := r.db.QueryContext(ctx, queryObservationPresentWeather, eventID)
-	if err != nil {
-		return nil, fmt.Errorf("query observation present weather: %w", err)
-	}
-	defer rows.Close()
-
-	out := make([]model.PresentWeather, 0)
-	for rows.Next() {
-		var row observationPresentWeatherRow
-		if err := rows.Scan(&row.WeatherIndex, &row.RawText); err != nil {
-			return nil, fmt.Errorf("scan observation present weather row: %w", err)
-		}
-		pw, err := mapObservationPresentWeatherRow(row)
-		if err != nil {
-			return nil, fmt.Errorf("decode observation present weather row (index=%d): %w", row.WeatherIndex, err)
-		}
-		out = append(out, pw)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, fmt.Errorf("iterate observation present weather rows: %w", err)
-	}
-	return out, nil
-}
-
-func (r *Repository) loadForecastPeriods(ctx context.Context, eventID string) ([]model.WeatherForecastPeriod, error) {
-	rows, err := r.db.QueryContext(ctx, queryForecastPeriods, eventID)
-	if err != nil {
-		return nil, fmt.Errorf("query forecast periods: %w", err)
-	}
-	defer rows.Close()
-
-	out := make([]model.WeatherForecastPeriod, 0)
-	for rows.Next() {
-		var row forecastPeriodRow
-		if err := rows.Scan(
-			&row.PeriodIndex,
-			&row.StartTime,
-			&row.EndTime,
-			&row.Name,
-			&row.IsDay,
-			&row.ConditionCode,
-			&row.ConditionText,
-			&row.ProviderRawDescription,
-			&row.TextDescription,
-			&row.DetailedText,
-			&row.IconURL,
-			&row.TemperatureC,
-			&row.TemperatureCMin,
-			&row.TemperatureCMax,
-			&row.DewpointC,
-			&row.RelativeHumidityPercent,
-			&row.WindDirectionDegrees,
-			&row.WindSpeedKmh,
-			&row.WindGustKmh,
-			&row.BarometricPressurePa,
-			&row.VisibilityMeters,
-			&row.ApparentTemperatureC,
-			&row.CloudCoverPercent,
-			&row.ProbabilityOfPrecipitationPercent,
-			&row.PrecipitationAmountMM,
-			&row.SnowfallDepthMM,
-			&row.UVIndex,
-		); err != nil {
-			return nil, fmt.Errorf("scan forecast period row: %w", err)
-		}
-		out = append(out, mapForecastPeriodRow(row))
-	}
-	if err := rows.Err(); err != nil {
-		return nil, fmt.Errorf("iterate forecast period rows: %w", err)
-	}
-	return out, nil
-}
-
-func (r *Repository) loadAlerts(ctx context.Context, eventID string) ([]model.WeatherAlert, error) {
-	alertsRows, err := r.db.QueryContext(ctx, queryAlerts, eventID)
-	if err != nil {
-		return nil, fmt.Errorf("query alerts: %w", err)
-	}
-	defer alertsRows.Close()
-
-	indexedAlerts := make([]indexedAlert, 0)
-	for alertsRows.Next() {
-		var row alertRow
-		if err := alertsRows.Scan(
-			&row.AlertIndex,
-			&row.AlertID,
-			&row.Event,
-			&row.Headline,
-			&row.Severity,
-			&row.Urgency,
-			&row.Certainty,
-			&row.Status,
-			&row.MessageType,
-			&row.Category,
-			&row.Response,
-			&row.Description,
-			&row.Instruction,
-			&row.Sent,
-			&row.Effective,
-			&row.Onset,
-			&row.Expires,
-			&row.AreaDescription,
-			&row.SenderName,
-		); err != nil {
-			return nil, fmt.Errorf("scan alerts row: %w", err)
-		}
-		indexedAlerts = append(indexedAlerts, mapAlertRow(row))
-	}
-	if err := alertsRows.Err(); err != nil {
-		return nil, fmt.Errorf("iterate alerts rows: %w", err)
-	}
-
-	referenceRows, err := r.db.QueryContext(ctx, queryAlertReferences, eventID)
-	if err != nil {
-		return nil, fmt.Errorf("query alert references: %w", err)
-	}
-	defer referenceRows.Close()
-
-	indexedReferences := make([]indexedAlertReference, 0)
-	for referenceRows.Next() {
-		var row alertReferenceRow
-		if err := referenceRows.Scan(
-			&row.AlertIndex,
-			&row.ID,
-			&row.Identifier,
-			&row.Sender,
-			&row.Sent,
-		); err != nil {
-			return nil, fmt.Errorf("scan alert reference row: %w", err)
-		}
-		indexedReferences = append(indexedReferences, mapAlertReferenceRow(row))
-	}
-	if err := referenceRows.Err(); err != nil {
-		return nil, fmt.Errorf("iterate alert reference rows: %w", err)
-	}
-
-	return attachAlertReferences(indexedAlerts, indexedReferences), nil
-}
-
-type observationParentRow struct {
-	EventID                 string
-	StationID               sql.NullString
-	StationName             sql.NullString
-	ObservedAt              time.Time
-	ConditionCode           int
-	IsDay                   sql.NullBool
-	TextDescription         sql.NullString
-	TemperatureC            sql.NullFloat64
-	DewpointC               sql.NullFloat64
-	WindDirectionDegrees    sql.NullFloat64
-	WindSpeedKmh            sql.NullFloat64
-	WindGustKmh             sql.NullFloat64
-	BarometricPressurePa    sql.NullFloat64
-	VisibilityMeters        sql.NullFloat64
-	RelativeHumidityPercent sql.NullFloat64
-	ApparentTemperatureC    sql.NullFloat64
-}
-
-func mapObservationParentRow(row observationParentRow) model.WeatherObservation {
-	return model.WeatherObservation{
-		StationID:               stringValue(row.StationID),
-		StationName:             stringValue(row.StationName),
-		Timestamp:               row.ObservedAt.UTC(),
-		ConditionCode:           model.WMOCode(row.ConditionCode),
-		IsDay:                   boolPtr(row.IsDay),
-		TextDescription:         stringValue(row.TextDescription),
-		TemperatureC:            float64Ptr(row.TemperatureC),
-		DewpointC:               float64Ptr(row.DewpointC),
-		WindDirectionDegrees:    float64Ptr(row.WindDirectionDegrees),
-		WindSpeedKmh:            float64Ptr(row.WindSpeedKmh),
-		WindGustKmh:             float64Ptr(row.WindGustKmh),
-		BarometricPressurePa:    float64Ptr(row.BarometricPressurePa),
-		VisibilityMeters:        float64Ptr(row.VisibilityMeters),
-		RelativeHumidityPercent: float64Ptr(row.RelativeHumidityPercent),
-		ApparentTemperatureC:    float64Ptr(row.ApparentTemperatureC),
-	}
-}
-
-type observationPresentWeatherRow struct {
-	WeatherIndex int
-	RawText      sql.NullString
-}
-
-func mapObservationPresentWeatherRow(row observationPresentWeatherRow) (model.PresentWeather, error) {
-	if !row.RawText.Valid || strings.TrimSpace(row.RawText.String) == "" {
-		return model.PresentWeather{}, nil
-	}
-
-	var raw map[string]any
-	if err := json.Unmarshal([]byte(row.RawText.String), &raw); err != nil {
-		return model.PresentWeather{}, err
-	}
-	return model.PresentWeather{Raw: raw}, nil
-}
-
-type forecastParentRow struct {
-	EventID         string
-	LocationID      sql.NullString
-	LocationName    sql.NullString
-	IssuedAt        time.Time
-	UpdatedAt       sql.NullTime
-	Product         string
-	Latitude        sql.NullFloat64
-	Longitude       sql.NullFloat64
-	ElevationMeters sql.NullFloat64
-}
-
-func mapForecastParentRow(row forecastParentRow) model.WeatherForecastRun {
-	return model.WeatherForecastRun{
-		LocationID:      stringValue(row.LocationID),
-		LocationName:    stringValue(row.LocationName),
-		IssuedAt:        row.IssuedAt.UTC(),
-		UpdatedAt:       timePtr(row.UpdatedAt),
-		Product:         model.ForecastProduct(row.Product),
-		Latitude:        float64Ptr(row.Latitude),
-		Longitude:       float64Ptr(row.Longitude),
-		ElevationMeters: float64Ptr(row.ElevationMeters),
-	}
-}
-
-type forecastPeriodRow struct {
-	PeriodIndex                       int
-	StartTime                         time.Time
-	EndTime                           time.Time
-	Name                              sql.NullString
-	IsDay                             sql.NullBool
-	ConditionCode                     int
-	ConditionText                     sql.NullString
-	ProviderRawDescription            sql.NullString
-	TextDescription                   sql.NullString
-	DetailedText                      sql.NullString
-	IconURL                           sql.NullString
-	TemperatureC                      sql.NullFloat64
-	TemperatureCMin                   sql.NullFloat64
-	TemperatureCMax                   sql.NullFloat64
-	DewpointC                         sql.NullFloat64
-	RelativeHumidityPercent           sql.NullFloat64
-	WindDirectionDegrees              sql.NullFloat64
-	WindSpeedKmh                      sql.NullFloat64
-	WindGustKmh                       sql.NullFloat64
-	BarometricPressurePa              sql.NullFloat64
-	VisibilityMeters                  sql.NullFloat64
-	ApparentTemperatureC              sql.NullFloat64
-	CloudCoverPercent                 sql.NullFloat64
-	ProbabilityOfPrecipitationPercent sql.NullFloat64
-	PrecipitationAmountMM             sql.NullFloat64
-	SnowfallDepthMM                   sql.NullFloat64
-	UVIndex                           sql.NullFloat64
-}
-
-func mapForecastPeriodRow(row forecastPeriodRow) model.WeatherForecastPeriod {
-	return model.WeatherForecastPeriod{
-		StartTime:                         row.StartTime.UTC(),
-		EndTime:                           row.EndTime.UTC(),
-		Name:                              stringValue(row.Name),
-		IsDay:                             boolPtr(row.IsDay),
-		ConditionCode:                     model.WMOCode(row.ConditionCode),
-		ConditionText:                     stringValue(row.ConditionText),
-		ProviderRawDescription:            stringValue(row.ProviderRawDescription),
-		TextDescription:                   stringValue(row.TextDescription),
-		DetailedText:                      stringValue(row.DetailedText),
-		IconURL:                           stringValue(row.IconURL),
-		TemperatureC:                      float64Ptr(row.TemperatureC),
-		TemperatureCMin:                   float64Ptr(row.TemperatureCMin),
-		TemperatureCMax:                   float64Ptr(row.TemperatureCMax),
-		DewpointC:                         float64Ptr(row.DewpointC),
-		RelativeHumidityPercent:           float64Ptr(row.RelativeHumidityPercent),
-		WindDirectionDegrees:              float64Ptr(row.WindDirectionDegrees),
-		WindSpeedKmh:                      float64Ptr(row.WindSpeedKmh),
-		WindGustKmh:                       float64Ptr(row.WindGustKmh),
-		BarometricPressurePa:              float64Ptr(row.BarometricPressurePa),
-		VisibilityMeters:                  float64Ptr(row.VisibilityMeters),
-		ApparentTemperatureC:              float64Ptr(row.ApparentTemperatureC),
-		CloudCoverPercent:                 float64Ptr(row.CloudCoverPercent),
-		ProbabilityOfPrecipitationPercent: float64Ptr(row.ProbabilityOfPrecipitationPercent),
-		PrecipitationAmountMm:             float64Ptr(row.PrecipitationAmountMM),
-		SnowfallDepthMM:                   float64Ptr(row.SnowfallDepthMM),
-		UVIndex:                           float64Ptr(row.UVIndex),
-	}
-}
-
-type alertRunParentRow struct {
-	EventID      string
-	LocationID   sql.NullString
-	LocationName sql.NullString
-	AsOf         time.Time
-	Latitude     sql.NullFloat64
-	Longitude    sql.NullFloat64
-}
-
-func mapAlertRunParentRow(row alertRunParentRow) model.WeatherAlertRun {
-	return model.WeatherAlertRun{
-		LocationID:   stringValue(row.LocationID),
-		LocationName: stringValue(row.LocationName),
-		AsOf:         row.AsOf.UTC(),
-		Latitude:     float64Ptr(row.Latitude),
-		Longitude:    float64Ptr(row.Longitude),
-	}
-}
-
-type alertRow struct {
-	AlertIndex      int
-	AlertID         string
-	Event           sql.NullString
-	Headline        sql.NullString
-	Severity        sql.NullString
-	Urgency         sql.NullString
-	Certainty       sql.NullString
-	Status          sql.NullString
-	MessageType     sql.NullString
-	Category        sql.NullString
-	Response        sql.NullString
-	Description     sql.NullString
-	Instruction     sql.NullString
-	Sent            sql.NullTime
-	Effective       sql.NullTime
-	Onset           sql.NullTime
-	Expires         sql.NullTime
-	AreaDescription sql.NullString
-	SenderName      sql.NullString
-}
-
-type indexedAlert struct {
-	Index int
-	Alert model.WeatherAlert
-}
-
-func mapAlertRow(row alertRow) indexedAlert {
-	return indexedAlert{
-		Index: row.AlertIndex,
-		Alert: model.WeatherAlert{
-			ID:              row.AlertID,
-			Event:           stringValue(row.Event),
-			Headline:        stringValue(row.Headline),
-			Severity:        stringValue(row.Severity),
-			Urgency:         stringValue(row.Urgency),
-			Certainty:       stringValue(row.Certainty),
-			Status:          stringValue(row.Status),
-			MessageType:     stringValue(row.MessageType),
-			Category:        stringValue(row.Category),
-			Response:        stringValue(row.Response),
-			Description:     stringValue(row.Description),
-			Instruction:     stringValue(row.Instruction),
-			Sent:            timePtr(row.Sent),
-			Effective:       timePtr(row.Effective),
-			Onset:           timePtr(row.Onset),
-			Expires:         timePtr(row.Expires),
-			AreaDescription: stringValue(row.AreaDescription),
-			SenderName:      stringValue(row.SenderName),
-		},
-	}
-}
-
-type alertReferenceRow struct {
-	AlertIndex int
-	ID         sql.NullString
-	Identifier sql.NullString
-	Sender     sql.NullString
-	Sent       sql.NullTime
-}
-
-type indexedAlertReference struct {
-	AlertIndex int
-	Reference  model.AlertReference
-}
-
-func mapAlertReferenceRow(row alertReferenceRow) indexedAlertReference {
-	return indexedAlertReference{
-		AlertIndex: row.AlertIndex,
-		Reference: model.AlertReference{
-			ID:         stringValue(row.ID),
-			Identifier: stringValue(row.Identifier),
-			Sender:     stringValue(row.Sender),
-			Sent:       timePtr(row.Sent),
-		},
-	}
-}
-
-func attachAlertReferences(alerts []indexedAlert, references []indexedAlertReference) []model.WeatherAlert {
-	refsByAlertIndex := make(map[int][]model.AlertReference, len(alerts))
-	for _, ref := range references {
-		refsByAlertIndex[ref.AlertIndex] = append(refsByAlertIndex[ref.AlertIndex], ref.Reference)
-	}
-
-	out := make([]model.WeatherAlert, 0, len(alerts))
-	for _, alert := range alerts {
-		mapped := alert.Alert
-		if refs := refsByAlertIndex[alert.Index]; len(refs) > 0 {
-			mapped.References = refs
-		}
-		out = append(out, mapped)
-	}
-	return out
-}
-
-func stringValue(v sql.NullString) string {
-	if !v.Valid {
-		return ""
-	}
-	return v.String
-}
-
-func boolPtr(v sql.NullBool) *bool {
-	if !v.Valid {
-		return nil
-	}
-	b := v.Bool
-	return &b
-}
-
-func float64Ptr(v sql.NullFloat64) *float64 {
-	if !v.Valid {
-		return nil
-	}
-	f := v.Float64
-	return &f
-}
-
-func timePtr(v sql.NullTime) *time.Time {
-	if !v.Valid {
-		return nil
-	}
-	t := v.Time.UTC()
-	return &t
-}

internal/adapters/outbound/postgres/repository_test.go

@@ -1,3 +1,5 @@
+// repository_test.go validates Postgres row mapping and attachment helpers.
+// Layer: adapters/outbound/postgres mapper regression tests.
 package postgres
 
 import (
@@ -110,3 +112,54 @@ func TestAttachAlertReferencesPreservesOrder(t *testing.T) {
 		t.Fatalf("unexpected second alert references: %+v", out[1].References)
 	}
 }
+
+func TestMapCurrentConditionsRowNoSamplesReturnsNil(t *testing.T) {
+	got := mapCurrentConditionsRow(currentConditionsRow{
+		SampleCount: 0,
+	})
+	if got != nil {
+		t.Fatalf("expected nil for empty sample window, got %+v", got)
+	}
+}
+
+func TestMapCurrentConditionsRowMapsFields(t *testing.T) {
+	isDay := true
+	got := mapCurrentConditionsRow(currentConditionsRow{
+		SampleCount:             12,
+		TemperatureC:            sql.NullFloat64{Float64: 15.5, Valid: true},
+		ApparentTemperatureC:    sql.NullFloat64{Float64: 14.2, Valid: true},
+		DewpointC:               sql.NullFloat64{Float64: 10.1, Valid: true},
+		RelativeHumidityPercent: sql.NullFloat64{Float64: 72, Valid: true},
+		WindSpeedKmh:            sql.NullFloat64{Float64: 24.8, Valid: true},
+		WindDirectionDegrees:    sql.NullFloat64{Float64: 182.5, Valid: true},
+		ConditionCode:           sql.NullInt64{Int64: 65, Valid: true},
+		IsDay:                   sql.NullBool{Bool: isDay, Valid: true},
+	})
+	if got == nil {
+		t.Fatalf("expected mapped current conditions")
+	}
+	if got.TemperatureC == nil || *got.TemperatureC != 15.5 {
+		t.Fatalf("expected temperature pointer 15.5, got %v", got.TemperatureC)
+	}
+	if got.ApparentTemperatureC == nil || *got.ApparentTemperatureC != 14.2 {
+		t.Fatalf("expected apparent temp pointer 14.2, got %v", got.ApparentTemperatureC)
+	}
+	if got.DewpointC == nil || *got.DewpointC != 10.1 {
+		t.Fatalf("expected dewpoint pointer 10.1, got %v", got.DewpointC)
+	}
+	if got.RelativeHumidityPercent == nil || *got.RelativeHumidityPercent != 72 {
+		t.Fatalf("expected rh pointer 72, got %v", got.RelativeHumidityPercent)
+	}
+	if got.WindSpeedKmh == nil || *got.WindSpeedKmh != 24.8 {
+		t.Fatalf("expected wind speed pointer 24.8, got %v", got.WindSpeedKmh)
+	}
+	if got.WindDirectionDegrees == nil || *got.WindDirectionDegrees != 182.5 {
+		t.Fatalf("expected wind direction pointer 182.5, got %v", got.WindDirectionDegrees)
+	}
+	if got.ConditionCode != 65 {
+		t.Fatalf("expected condition code 65, got %d", got.ConditionCode)
+	}
+	if got.IsDay == nil || !*got.IsDay {
+		t.Fatalf("expected isDay pointer true, got %v", got.IsDay)
+	}
+}

internal/adapters/outbound/postgres/scan_helpers.go

@@ -0,0 +1,39 @@
+// scan_helpers.go provides shared sql.Null* conversion helpers.
+// Layer: adapters/outbound/postgres helper utilities.
+package postgres
+
+import (
+	"database/sql"
+	"time"
+)
+
+func stringValue(v sql.NullString) string {
+	if !v.Valid {
+		return ""
+	}
+	return v.String
+}
+
+func boolPtr(v sql.NullBool) *bool {
+	if !v.Valid {
+		return nil
+	}
+	b := v.Bool
+	return &b
+}
+
+func float64Ptr(v sql.NullFloat64) *float64 {
+	if !v.Valid {
+		return nil
+	}
+	f := v.Float64
+	return &f
+}
+
+func timePtr(v sql.NullTime) *time.Time {
+	if !v.Valid {
+		return nil
+	}
+	t := v.Time.UTC()
+	return &t
+}

internal/app/constants.go

@@ -0,0 +1,7 @@
+// constants.go defines shared application-level constants.
+// Layer: internal/app service behavior defaults.
+package app
+
+const (
+	ObservationWindowMinutesDefault = 30
+)

internal/app/current_conditions.go

@@ -0,0 +1,17 @@
+// current_conditions.go defines the current-conditions aggregate model.
+// Layer: internal/app domain-adjacent read model.
+package app
+
+import "gitea.maximumdirect.net/ejr/weatherfeeder/model"
+
+// CurrentConditions is an averaged current-conditions aggregate over a recent window.
+type CurrentConditions struct {
+	TemperatureC            *float64
+	ApparentTemperatureC    *float64
+	DewpointC               *float64
+	RelativeHumidityPercent *float64
+	WindSpeedKmh            *float64
+	WindDirectionDegrees    *float64
+	ConditionCode           model.WMOCode
+	IsDay                   *bool
+}

internal/app/service.go

@@ -1,4 +1,6 @@
-package core
+// service.go defines application read ports and use-case orchestration.
+// Layer: internal/app core business-facing API.
+package app
 
 import (
 	"context"
@@ -10,7 +12,8 @@ import (
 type Repository interface {
 	LatestObservation(ctx context.Context) (*model.WeatherObservation, error)
 	LatestHourlyForecast(ctx context.Context) (*model.WeatherForecastRun, error)
-	LatestActiveAlerts(ctx context.Context) (*model.WeatherAlertRun, error)
+	LatestAlertRun(ctx context.Context) (*model.WeatherAlertRun, error)
+	CurrentConditions(ctx context.Context, observationWindowMinutes int) (*CurrentConditions, error)
 }
 
 // Service provides weather read use-cases.
@@ -30,6 +33,10 @@ func (s *Service) LatestHourlyForecast(ctx context.Context) (*model.WeatherForec
 	return s.repo.LatestHourlyForecast(ctx)
 }
 
-func (s *Service) LatestActiveAlerts(ctx context.Context) (*model.WeatherAlertRun, error) {
-	return s.repo.LatestActiveAlerts(ctx)
+func (s *Service) LatestAlertRun(ctx context.Context) (*model.WeatherAlertRun, error) {
+	return s.repo.LatestAlertRun(ctx)
+}
+
+func (s *Service) CurrentConditions(ctx context.Context) (*CurrentConditions, error) {
+	return s.repo.CurrentConditions(ctx, ObservationWindowMinutesDefault)
 }

internal/app/service_test.go

@@ -0,0 +1,100 @@
+// service_test.go validates application service delegation behavior.
+// Layer: internal/app tests for read use-case orchestration.
+package app
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"gitea.maximumdirect.net/ejr/weatherfeeder/model"
+)
+
+type fakeRepository struct {
+	observation *model.WeatherObservation
+	forecast    *model.WeatherForecastRun
+	alerts      *model.WeatherAlertRun
+	conditions  *CurrentConditions
+	err         error
+
+	currentConditionsWindow int
+}
+
+func (r *fakeRepository) LatestObservation(context.Context) (*model.WeatherObservation, error) {
+	return r.observation, r.err
+}
+
+func (r *fakeRepository) LatestHourlyForecast(context.Context) (*model.WeatherForecastRun, error) {
+	return r.forecast, r.err
+}
+
+func (r *fakeRepository) LatestAlertRun(context.Context) (*model.WeatherAlertRun, error) {
+	return r.alerts, r.err
+}
+
+func (r *fakeRepository) CurrentConditions(_ context.Context, observationWindowMinutes int) (*CurrentConditions, error) {
+	r.currentConditionsWindow = observationWindowMinutes
+	return r.conditions, r.err
+}
+
+func TestServiceDelegatesObservation(t *testing.T) {
+	repo := &fakeRepository{observation: &model.WeatherObservation{StationID: "KSTL"}}
+	svc := NewService(repo)
+
+	obs, err := svc.LatestObservation(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if obs == nil || obs.StationID != "KSTL" {
+		t.Fatalf("unexpected observation: %+v", obs)
+	}
+}
+
+func TestServiceDelegatesForecast(t *testing.T) {
+	repo := &fakeRepository{forecast: &model.WeatherForecastRun{LocationID: "stl"}}
+	svc := NewService(repo)
+
+	run, err := svc.LatestHourlyForecast(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if run == nil || run.LocationID != "stl" {
+		t.Fatalf("unexpected forecast: %+v", run)
+	}
+}
+
+func TestServiceDelegatesAlerts(t *testing.T) {
+	repo := &fakeRepository{alerts: &model.WeatherAlertRun{LocationID: "stl"}}
+	svc := NewService(repo)
+
+	run, err := svc.LatestAlertRun(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if run == nil || run.LocationID != "stl" {
+		t.Fatalf("unexpected alert run: %+v", run)
+	}
+}
+
+func TestServiceUsesDefaultCurrentConditionsWindow(t *testing.T) {
+	repo := &fakeRepository{conditions: &CurrentConditions{ConditionCode: model.WMOUnknown}}
+	svc := NewService(repo)
+
+	_, err := svc.CurrentConditions(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if repo.currentConditionsWindow != ObservationWindowMinutesDefault {
+		t.Fatalf("expected observation window %d, got %d", ObservationWindowMinutesDefault, repo.currentConditionsWindow)
+	}
+}
+
+func TestServicePropagatesErrors(t *testing.T) {
+	want := errors.New("boom")
+	repo := &fakeRepository{err: want}
+	svc := NewService(repo)
+
+	if _, err := svc.LatestObservation(context.Background()); !errors.Is(err, want) {
+		t.Fatalf("expected error %v, got %v", want, err)
+	}
+}

templates/conditions_current.txt.tmpl

@@ -0,0 +1,41 @@
+{{- if .Data -}}
+Current Conditions
+{{- if .Data.ConditionText}}
+Condition: {{.Data.ConditionText}}
+{{- end}}
+{{- if .Data.IsDayText}}
+Is Day: {{.Data.IsDayText}}
+{{- end}}
+{{- if .Data.TemperatureC}}
+Temperature (C): {{.Data.TemperatureC}}
+{{- end}}
+{{- if .Data.ApparentTemperatureC}}
+Apparent Temperature (C): {{.Data.ApparentTemperatureC}}
+{{- end}}
+{{- if .Data.DewpointC}}
+Dewpoint (C): {{.Data.DewpointC}}
+{{- end}}
+{{- if .Data.WindSpeedKmh}}
+Wind Speed (km/h): {{.Data.WindSpeedKmh}}
+{{- end}}
+{{- if .Data.TemperatureF}}
+Temperature (F): {{.Data.TemperatureF}}
+{{- end}}
+{{- if .Data.ApparentTemperatureF}}
+Apparent Temperature (F): {{.Data.ApparentTemperatureF}}
+{{- end}}
+{{- if .Data.DewpointF}}
+Dewpoint (F): {{.Data.DewpointF}}
+{{- end}}
+{{- if .Data.WindSpeedMph}}
+Wind Speed (mph): {{.Data.WindSpeedMph}}
+{{- end}}
+{{- if .Data.RelativeHumidityPercent}}
+Relative Humidity (%): {{.Data.RelativeHumidityPercent}}
+{{- end}}
+{{- if .Data.WindDirectionDegrees}}
+Wind Direction (deg): {{.Data.WindDirectionDegrees}}
+{{- end}}
+{{- else -}}
+No current conditions data available.
+{{- end}}