feat: auto-login to tailscale in devcontainer

.devcontainer/devcontainer.json

@@ -10,8 +10,8 @@
 		"context": ".",
 		"dockerfile": "Dockerfile"
 	},
-	"postCreateCommand": "bun install",
-	"postStartCommand": "./scripts/setup-git.sh && ./scripts/setup-nvim.sh && ./scripts/setup-tailscale.sh",
+	"postCreateCommand": "bun install && ./scripts/setup-tailscale.sh",
+	"postStartCommand": "./scripts/setup-git.sh && ./scripts/setup-nvim.sh",
 	// Features add additional features to your environment. See https://containers.dev/features
 	// Beware: features are not supported on all platforms and may have unintended side-effects.
 	"features": {

.ona/automations.yaml

@@ -25,13 +25,7 @@ services:
       - manual
     commands:
       start: |
-        gitpod --context environment environment port open 3000 --name "Aelis Backend" --protocol http
-        TS_IP=$(tailscale ip -4)
-        echo ""
-        echo "------------------ Bun Debugger ------------------"
-        echo "https://debug.bun.sh/#${TS_IP}:6499"
-        echo "------------------ Bun Debugger ------------------"
-        echo ""
+        gitpod --context environment environment port open 3000 --name "Aelis Backend" --protocol https
         cd apps/aelis-backend && bun run dev
 
   admin-dashboard:
@@ -41,5 +35,5 @@ services:
       - manual
     commands:
       start: |
-        gitpod --context environment environment port open 5174 --name "Admin Dashboard" --protocol http
-        cd apps/admin-dashboard && bun run dev --host
+        gitpod --context environment environment port open 5174 --name "Admin Dashboard" --protocol https
+        cd apps/admin-dashboard && bun run dev

apps/admin-dashboard/src/components/source-config-panel.tsx

@@ -408,40 +408,6 @@ function FieldInput({
     )
   }
 
-  if (field.type === "multiselect" && field.options) {
-    const selected = Array.isArray(value) ? (value as string[]) : []
-
-    function toggle(optValue: string) {
-      const next = selected.includes(optValue)
-        ? selected.filter((v) => v !== optValue)
-        : [...selected, optValue]
-      onChange(next)
-    }
-
-    return (
-      <div className="space-y-2">
-        <Label className="text-xs font-medium">
-          {labelContent}
-        </Label>
-        <div className="flex flex-wrap gap-1.5">
-          {field.options!.map((opt) => {
-            const isSelected = selected.includes(opt.value)
-            return (
-              <Badge
-                key={opt.value}
-                variant={isSelected ? "default" : "outline"}
-                className={`cursor-pointer select-none ${isSelected ? "" : "opacity-60 hover:opacity-100"}`}
-                onClick={() => !disabled && toggle(opt.value)}
-              >
-                {opt.label}
-              </Badge>
-            )
-          })}
-        </div>
-      </div>
-    )
-  }
-
   if (field.type === "number") {
     return (
       <div className="space-y-2">
@@ -490,8 +456,6 @@ function buildInitialValues(
       values[name] = saved[name]
     } else if (field.defaultValue !== undefined) {
       values[name] = field.defaultValue
-    } else if (field.type === "multiselect") {
-      values[name] = []
     } else {
       values[name] = field.type === "number" ? undefined : ""
     }

apps/admin-dashboard/src/lib/api.ts

@@ -9,12 +9,12 @@ function serverBase() {
 }
 
 export interface ConfigFieldDef {
-  type: "string" | "number" | "select" | "multiselect"
+  type: "string" | "number" | "select"
   label: string
   required?: boolean
   description?: string
   secret?: boolean
-  defaultValue?: string | number | string[]
+  defaultValue?: string | number
   options?: { label: string; value: string }[]
 }
 
@@ -54,39 +54,6 @@ const sourceDefinitions: SourceDefinition[] = [
       dailyLimit: { type: "number", label: "Daily Forecast Limit", defaultValue: 7, description: "Number of daily forecasts to include" },
     },
   },
-  {
-    id: "aelis.tfl",
-    name: "TfL",
-    description: "Transport for London tube line status alerts.",
-    fields: {
-      lines: {
-        type: "multiselect",
-        label: "Lines",
-        description: "Lines to monitor. Leave empty for all lines.",
-        defaultValue: [],
-        options: [
-          { label: "Bakerloo", value: "bakerloo" },
-          { label: "Central", value: "central" },
-          { label: "Circle", value: "circle" },
-          { label: "District", value: "district" },
-          { label: "Hammersmith & City", value: "hammersmith-city" },
-          { label: "Jubilee", value: "jubilee" },
-          { label: "Metropolitan", value: "metropolitan" },
-          { label: "Northern", value: "northern" },
-          { label: "Piccadilly", value: "piccadilly" },
-          { label: "Victoria", value: "victoria" },
-          { label: "Waterloo & City", value: "waterloo-city" },
-          { label: "Lioness", value: "lioness" },
-          { label: "Mildmay", value: "mildmay" },
-          { label: "Windrush", value: "windrush" },
-          { label: "Weaver", value: "weaver" },
-          { label: "Suffragette", value: "suffragette" },
-          { label: "Liberty", value: "liberty" },
-          { label: "Elizabeth", value: "elizabeth" },
-        ],
-      },
-    },
-  },
 ]
 
 export function fetchSources(): Promise<SourceDefinition[]> {

apps/admin-dashboard/src/routes/_dashboard.tsx

@@ -6,7 +6,6 @@ import {
   CircleDot,
   CloudSun,
   Loader2,
-  TrainFront,
   LogOut,
   MapPin,
   Rss,
@@ -42,7 +41,6 @@ const SOURCE_ICONS: Record<string, React.ComponentType<{ className?: string }>>
   "aelis.weather": CloudSun,
   "aelis.caldav": CalendarDays,
   "aelis.google-calendar": Calendar,
-  "aelis.tfl": TrainFront,
 }
 
 export const Route = createRoute({

apps/aelis-backend/package.json

@@ -4,7 +4,7 @@
 	"type": "module",
 	"main": "src/server.ts",
 	"scripts": {
-		"dev": "bun run --watch --inspect=0.0.0.0:6499 src/server.ts",
+		"dev": "bun run --watch src/server.ts",
 		"start": "bun run src/server.ts",
 		"test": "bun test src/",
 		"db:generate": "bunx drizzle-kit generate",

apps/aelis-backend/src/enhancement/llm-client.ts

@@ -4,7 +4,7 @@ import type { EnhancementResult } from "./schema.ts"
 
 import { enhancementResultJsonSchema, parseEnhancementResult } from "./schema.ts"
 
-const DEFAULT_MODEL = "z-ai/glm-4.7-flash"
+const DEFAULT_MODEL = "openai/gpt-4.1-mini"
 const DEFAULT_TIMEOUT_MS = 30_000
 
 export interface LlmClientConfig {
@@ -46,7 +46,7 @@ export function createLlmClient(config: LlmClientConfig): LlmClient {
 						type: "json_schema" as const,
 						jsonSchema: {
 							name: "enhancement_result",
-							strict: false,
+							strict: true,
 							schema: enhancementResultJsonSchema,
 						},
 					},

apps/aelis-backend/src/enhancement/schema.test.ts

@@ -166,12 +166,11 @@ describe("schema sync", () => {
 		expect(parseEnhancementResult(JSON.stringify(bad))).toBeNull()
 
 		// JSON Schema only allows string or null for slot values
-		const slotValueSchema =
+		const slotValueTypes =
 			enhancementResultJsonSchema.properties.slotFills.additionalProperties
-				.additionalProperties
-		expect(slotValueSchema.anyOf).toEqual([
-			{ type: "string" },
-			{ type: "null" },
-		])
+				.additionalProperties.type
+		expect(slotValueTypes).toContain("string")
+		expect(slotValueTypes).toContain("null")
+		expect(slotValueTypes).not.toContain("number")
 	})
 })

apps/aelis-backend/src/enhancement/schema.ts

@@ -31,7 +31,7 @@ export const enhancementResultJsonSchema = {
 			additionalProperties: {
 				type: "object",
 				additionalProperties: {
-					anyOf: [{ type: "string" }, { type: "null" }],
+					type: ["string", "null"],
 				},
 			},
 		},

apps/aelis-backend/src/server.ts

@@ -14,7 +14,6 @@ import { registerLocationHttpHandlers } from "./location/http.ts"
 import { LocationSourceProvider } from "./location/provider.ts"
 import { UserSessionManager } from "./session/index.ts"
 import { registerSourcesHttpHandlers } from "./sources/http.ts"
-import { TflSourceProvider } from "./tfl/provider.ts"
 import { WeatherSourceProvider } from "./weather/provider.ts"
 
 function main() {
@@ -46,7 +45,6 @@ function main() {
 					serviceId: process.env.WEATHERKIT_SERVICE_ID!,
 				},
 			}),
-			new TflSourceProvider({ apiKey: process.env.TFL_API_KEY! }),
 		],
 		feedEnhancer,
 	})

bun.lock

@@ -170,6 +170,14 @@
         "@nym.sh/jrx": "*",
       },
     },
+    "packages/aelis-data-source-weatherkit": {
+      "name": "@aelis/data-source-weatherkit",
+      "version": "0.0.0",
+      "dependencies": {
+        "@aelis/core": "workspace:*",
+        "arktype": "^2.1.0",
+      },
+    },
     "packages/aelis-feed-enhancers": {
       "name": "@aelis/feed-enhancers",
       "version": "0.0.0",
@@ -240,6 +248,8 @@
 
     "@aelis/core": ["@aelis/core@workspace:packages/aelis-core"],
 
+    "@aelis/data-source-weatherkit": ["@aelis/data-source-weatherkit@workspace:packages/aelis-data-source-weatherkit"],
+
     "@aelis/feed-enhancers": ["@aelis/feed-enhancers@workspace:packages/aelis-feed-enhancers"],
 
     "@aelis/source-caldav": ["@aelis/source-caldav@workspace:packages/aelis-source-caldav"],

packages/aelis-data-source-weatherkit/.env.example

@@ -0,0 +1,4 @@
+WEATHERKIT_PRIVATE_KEY="-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----"
+WEATHERKIT_KEY_ID=ABC123DEFG
+WEATHERKIT_TEAM_ID=TEAM123456
+WEATHERKIT_SERVICE_ID=com.example.weatherkit.test

packages/aelis-data-source-weatherkit/README.md

@@ -0,0 +1,58 @@
+# @aelis/data-source-weatherkit
+
+Weather data source using Apple WeatherKit REST API.
+
+## Usage
+
+```typescript
+import { WeatherKitDataSource, Units } from "@aelis/data-source-weatherkit"
+
+const dataSource = new WeatherKitDataSource({
+	credentials: {
+		privateKey: "-----BEGIN PRIVATE KEY-----\n...",
+		keyId: "ABC123",
+		teamId: "DEF456",
+		serviceId: "com.example.weatherkit",
+	},
+	hourlyLimit: 12, // optional, default: 12
+	dailyLimit: 7, // optional, default: 7
+})
+
+const items = await dataSource.query(context, {
+	units: Units.metric, // or Units.imperial
+})
+```
+
+## Feed Items
+
+The data source returns four types of feed items:
+
+| Type              | Description                |
+| ----------------- | -------------------------- |
+| `weather-current` | Current weather conditions |
+| `weather-hourly`  | Hourly forecast            |
+| `weather-daily`   | Daily forecast             |
+| `weather-alert`   | Weather alerts             |
+
+## Priority
+
+Base priorities are adjusted based on weather conditions:
+
+- Severe conditions (tornado, hurricane, blizzard, etc.): +0.3
+- Moderate conditions (thunderstorm, heavy rain, etc.): +0.15
+- Alert severity: extreme=1.0, severe=0.9, moderate=0.75, minor=0.7
+
+## Authentication
+
+WeatherKit requires Apple Developer credentials. Generate a private key in the Apple Developer portal under Certificates, Identifiers & Profiles > Keys.
+
+## Validation
+
+API responses are validated using [arktype](https://arktype.io) schemas.
+
+## Generating Test Fixtures
+
+To regenerate fixture data from the real API:
+
+1. Create a `.env` file with your credentials (see `.env.example`)
+2. Run `bun run scripts/generate-fixtures.ts`

packages/aelis-data-source-weatherkit/package.json

@@ -0,0 +1,14 @@
+{
+	"name": "@aelis/data-source-weatherkit",
+	"version": "0.0.0",
+	"type": "module",
+	"main": "src/index.ts",
+	"types": "src/index.ts",
+	"scripts": {
+		"test": "bun test ."
+	},
+	"dependencies": {
+		"@aelis/core": "workspace:*",
+		"arktype": "^2.1.0"
+	}
+}

packages/aelis-data-source-weatherkit/scripts/generate-fixtures.ts

@@ -0,0 +1,60 @@
+import { DefaultWeatherKitClient } from "../src/weatherkit"
+
+function loadEnv(): Record<string, string> {
+	const content = require("fs").readFileSync(".env", "utf-8")
+	const env: Record<string, string> = {}
+
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim()
+		if (!trimmed || trimmed.startsWith("#")) continue
+
+		const eqIndex = trimmed.indexOf("=")
+		if (eqIndex === -1) continue
+
+		const key = trimmed.slice(0, eqIndex)
+		let value = trimmed.slice(eqIndex + 1)
+
+		if (value.startsWith('"') && value.endsWith('"')) {
+			value = value.slice(1, -1)
+		}
+
+		env[key] = value.replace(/\\n/g, "\n")
+	}
+
+	return env
+}
+
+const env = loadEnv()
+
+const client = new DefaultWeatherKitClient({
+	privateKey: env.WEATHERKIT_PRIVATE_KEY!,
+	keyId: env.WEATHERKIT_KEY_ID!,
+	teamId: env.WEATHERKIT_TEAM_ID!,
+	serviceId: env.WEATHERKIT_SERVICE_ID!,
+})
+
+const locations = {
+	sanFrancisco: { lat: 37.7749, lng: -122.4194 },
+}
+
+async function main() {
+	console.log("Fetching weather data for San Francisco...")
+
+	const response = await client.fetch({
+		lat: locations.sanFrancisco.lat,
+		lng: locations.sanFrancisco.lng,
+	})
+
+	const fixture = {
+		generatedAt: new Date().toISOString(),
+		location: locations.sanFrancisco,
+		response,
+	}
+
+	const output = JSON.stringify(fixture)
+	await Bun.write("fixtures/san-francisco.json", output)
+
+	console.log("Fixture written to fixtures/san-francisco.json")
+}
+
+main().catch(console.error)

packages/aelis-data-source-weatherkit/src/data-source.test.ts

@@ -0,0 +1,233 @@
+import type { ContextKey } from "@aelis/core"
+
+import { Context, contextKey } from "@aelis/core"
+import { describe, expect, test } from "bun:test"
+
+import type { WeatherKitClient, WeatherKitResponse } from "./weatherkit"
+
+import fixture from "../fixtures/san-francisco.json"
+import { WeatherKitDataSource, Units } from "./data-source"
+import { WeatherFeedItemType } from "./feed-items"
+
+const mockCredentials = {
+	privateKey: "mock",
+	keyId: "mock",
+	teamId: "mock",
+	serviceId: "mock",
+}
+
+interface LocationData {
+	lat: number
+	lng: number
+	accuracy: number
+}
+
+const LocationKey: ContextKey<LocationData> = contextKey("aelis.location", "location")
+
+const createMockClient = (response: WeatherKitResponse): WeatherKitClient => ({
+	fetch: async () => response,
+})
+
+function createMockContext(location?: { lat: number; lng: number }): Context {
+	const ctx = new Context(new Date("2026-01-17T00:00:00Z"))
+	if (location) {
+		ctx.set([[LocationKey, { ...location, accuracy: 10 }]])
+	}
+	return ctx
+}
+
+describe("WeatherKitDataSource", () => {
+	test("returns empty array when location is missing", async () => {
+		const dataSource = new WeatherKitDataSource({
+			credentials: mockCredentials,
+		})
+		const items = await dataSource.query(createMockContext())
+
+		expect(items).toEqual([])
+	})
+
+	test("type is weather-current", () => {
+		const dataSource = new WeatherKitDataSource({
+			credentials: mockCredentials,
+		})
+
+		expect(dataSource.type).toBe(WeatherFeedItemType.Current)
+	})
+
+	test("throws error if neither client nor credentials provided", () => {
+		expect(() => new WeatherKitDataSource({})).toThrow(
+			"Either client or credentials must be provided",
+		)
+	})
+})
+
+describe("WeatherKitDataSource with fixture", () => {
+	const response = fixture.response
+
+	test("parses current weather from fixture", () => {
+		const current = response.currentWeather
+
+		expect(typeof current.conditionCode).toBe("string")
+		expect(typeof current.temperature).toBe("number")
+		expect(typeof current.humidity).toBe("number")
+		expect(current.pressureTrend).toMatch(/^(rising|falling|steady)$/)
+	})
+
+	test("parses hourly forecast from fixture", () => {
+		const hours = response.forecastHourly.hours
+
+		expect(hours.length).toBeGreaterThan(0)
+
+		const firstHour = hours[0]!
+		expect(firstHour.forecastStart).toBeDefined()
+		expect(typeof firstHour.temperature).toBe("number")
+		expect(typeof firstHour.precipitationChance).toBe("number")
+	})
+
+	test("parses daily forecast from fixture", () => {
+		const days = response.forecastDaily.days
+
+		expect(days.length).toBeGreaterThan(0)
+
+		const firstDay = days[0]!
+		expect(firstDay.forecastStart).toBeDefined()
+		expect(typeof firstDay.temperatureMax).toBe("number")
+		expect(typeof firstDay.temperatureMin).toBe("number")
+		expect(firstDay.sunrise).toBeDefined()
+		expect(firstDay.sunset).toBeDefined()
+	})
+
+	test("hourly limit is respected", () => {
+		const dataSource = new WeatherKitDataSource({
+			credentials: mockCredentials,
+			hourlyLimit: 6,
+		})
+
+		expect(dataSource["hourlyLimit"]).toBe(6)
+	})
+
+	test("daily limit is respected", () => {
+		const dataSource = new WeatherKitDataSource({
+			credentials: mockCredentials,
+			dailyLimit: 3,
+		})
+
+		expect(dataSource["dailyLimit"]).toBe(3)
+	})
+
+	test("default limits are applied", () => {
+		const dataSource = new WeatherKitDataSource({
+			credentials: mockCredentials,
+		})
+
+		expect(dataSource["hourlyLimit"]).toBe(12)
+		expect(dataSource["dailyLimit"]).toBe(7)
+	})
+})
+
+describe("unit conversion", () => {
+	test("Units enum has metric and imperial", () => {
+		expect(Units.metric).toBe("metric")
+		expect(Units.imperial).toBe("imperial")
+	})
+})
+
+describe("query() with mocked client", () => {
+	const mockClient = createMockClient(fixture.response as WeatherKitResponse)
+
+	test("transforms API response into feed items", async () => {
+		const dataSource = new WeatherKitDataSource({ client: mockClient })
+		const context = createMockContext({ lat: 37.7749, lng: -122.4194 })
+
+		const items = await dataSource.query(context)
+
+		expect(items.length).toBeGreaterThan(0)
+		expect(items.some((i) => i.type === WeatherFeedItemType.Current)).toBe(true)
+		expect(items.some((i) => i.type === WeatherFeedItemType.Hourly)).toBe(true)
+		expect(items.some((i) => i.type === WeatherFeedItemType.Daily)).toBe(true)
+	})
+
+	test("applies hourly and daily limits", async () => {
+		const dataSource = new WeatherKitDataSource({
+			client: mockClient,
+			hourlyLimit: 3,
+			dailyLimit: 2,
+		})
+		const context = createMockContext({ lat: 37.7749, lng: -122.4194 })
+
+		const items = await dataSource.query(context)
+
+		const hourlyItems = items.filter((i) => i.type === WeatherFeedItemType.Hourly)
+		const dailyItems = items.filter((i) => i.type === WeatherFeedItemType.Daily)
+
+		expect(hourlyItems.length).toBe(3)
+		expect(dailyItems.length).toBe(2)
+	})
+
+	test("sets timestamp from context.time", async () => {
+		const dataSource = new WeatherKitDataSource({ client: mockClient })
+		const queryTime = new Date("2026-01-17T12:00:00Z")
+		const context = createMockContext({ lat: 37.7749, lng: -122.4194 })
+		context.time = queryTime
+
+		const items = await dataSource.query(context)
+
+		for (const item of items) {
+			expect(item.timestamp).toEqual(queryTime)
+		}
+	})
+
+	test("converts temperatures to imperial", async () => {
+		const dataSource = new WeatherKitDataSource({ client: mockClient })
+		const context = createMockContext({ lat: 37.7749, lng: -122.4194 })
+
+		const metricItems = await dataSource.query(context, {
+			units: Units.metric,
+		})
+		const imperialItems = await dataSource.query(context, {
+			units: Units.imperial,
+		})
+
+		const metricCurrent = metricItems.find((i) => i.type === WeatherFeedItemType.Current)
+		const imperialCurrent = imperialItems.find((i) => i.type === WeatherFeedItemType.Current)
+
+		expect(metricCurrent).toBeDefined()
+		expect(imperialCurrent).toBeDefined()
+
+		const metricTemp = (metricCurrent!.data as { temperature: number }).temperature
+		const imperialTemp = (imperialCurrent!.data as { temperature: number }).temperature
+
+		// Verify conversion: F = C * 9/5 + 32
+		const expectedImperial = (metricTemp * 9) / 5 + 32
+		expect(imperialTemp).toBeCloseTo(expectedImperial, 2)
+	})
+
+	test("assigns signals based on weather conditions", async () => {
+		const dataSource = new WeatherKitDataSource({ client: mockClient })
+		const context = createMockContext({ lat: 37.7749, lng: -122.4194 })
+
+		const items = await dataSource.query(context)
+
+		for (const item of items) {
+			expect(item.signals).toBeDefined()
+			expect(item.signals!.urgency).toBeGreaterThanOrEqual(0)
+			expect(item.signals!.urgency).toBeLessThanOrEqual(1)
+			expect(item.signals!.timeRelevance).toBeDefined()
+		}
+
+		const currentItem = items.find((i) => i.type === WeatherFeedItemType.Current)
+		expect(currentItem).toBeDefined()
+		expect(currentItem!.signals!.urgency).toBeGreaterThanOrEqual(0.5)
+	})
+
+	test("generates unique IDs for each item", async () => {
+		const dataSource = new WeatherKitDataSource({ client: mockClient })
+		const context = createMockContext({ lat: 37.7749, lng: -122.4194 })
+
+		const items = await dataSource.query(context)
+		const ids = items.map((i) => i.id)
+		const uniqueIds = new Set(ids)
+
+		expect(uniqueIds.size).toBe(ids.length)
+	})
+})

packages/aelis-data-source-weatherkit/src/data-source.ts

@@ -0,0 +1,356 @@
+import type { Context, ContextKey, DataSource, FeedItemSignals } from "@aelis/core"
+
+import { TimeRelevance, contextKey } from "@aelis/core"
+
+import {
+	WeatherFeedItemType,
+	type CurrentWeatherFeedItem,
+	type DailyWeatherFeedItem,
+	type HourlyWeatherFeedItem,
+	type WeatherAlertFeedItem,
+	type WeatherFeedItem,
+} from "./feed-items"
+import {
+	ConditionCode,
+	DefaultWeatherKitClient,
+	Severity,
+	type CurrentWeather,
+	type DailyForecast,
+	type HourlyForecast,
+	type WeatherAlert,
+	type WeatherKitClient,
+	type WeatherKitCredentials,
+} from "./weatherkit"
+
+export const Units = {
+	metric: "metric",
+	imperial: "imperial",
+} as const
+
+export type Units = (typeof Units)[keyof typeof Units]
+
+export interface WeatherKitDataSourceOptions {
+	credentials?: WeatherKitCredentials
+	client?: WeatherKitClient
+	hourlyLimit?: number
+	dailyLimit?: number
+}
+
+export interface WeatherKitQueryConfig {
+	units?: Units
+}
+
+interface LocationData {
+	lat: number
+	lng: number
+}
+
+const LocationKey: ContextKey<LocationData> = contextKey("aelis.location", "location")
+
+const SOURCE_ID = "aelis.weather"
+
+export class WeatherKitDataSource implements DataSource<WeatherFeedItem, WeatherKitQueryConfig> {
+	private readonly DEFAULT_HOURLY_LIMIT = 12
+	private readonly DEFAULT_DAILY_LIMIT = 7
+
+	readonly type = WeatherFeedItemType.Current
+	private readonly client: WeatherKitClient
+	private readonly hourlyLimit: number
+	private readonly dailyLimit: number
+
+	constructor(options: WeatherKitDataSourceOptions) {
+		if (!options.client && !options.credentials) {
+			throw new Error("Either client or credentials must be provided")
+		}
+		this.client = options.client ?? new DefaultWeatherKitClient(options.credentials!)
+		this.hourlyLimit = options.hourlyLimit ?? this.DEFAULT_HOURLY_LIMIT
+		this.dailyLimit = options.dailyLimit ?? this.DEFAULT_DAILY_LIMIT
+	}
+
+	async query(context: Context, config: WeatherKitQueryConfig = {}): Promise<WeatherFeedItem[]> {
+		const location = context.get(LocationKey)
+		if (!location) {
+			return []
+		}
+
+		const units = config.units ?? Units.metric
+		const timestamp = context.time
+
+		const response = await this.client.fetch({
+			lat: location.lat,
+			lng: location.lng,
+		})
+
+		const items: WeatherFeedItem[] = []
+
+		if (response.currentWeather) {
+			items.push(createCurrentWeatherFeedItem(response.currentWeather, timestamp, units))
+		}
+
+		if (response.forecastHourly?.hours) {
+			const hours = response.forecastHourly.hours.slice(0, this.hourlyLimit)
+			for (let i = 0; i < hours.length; i++) {
+				const hour = hours[i]
+				if (hour) {
+					items.push(createHourlyWeatherFeedItem(hour, i, timestamp, units))
+				}
+			}
+		}
+
+		if (response.forecastDaily?.days) {
+			const days = response.forecastDaily.days.slice(0, this.dailyLimit)
+			for (let i = 0; i < days.length; i++) {
+				const day = days[i]
+				if (day) {
+					items.push(createDailyWeatherFeedItem(day, i, timestamp, units))
+				}
+			}
+		}
+
+		if (response.weatherAlerts?.alerts) {
+			for (const alert of response.weatherAlerts.alerts) {
+				items.push(createWeatherAlertFeedItem(alert, timestamp))
+			}
+		}
+
+		return items
+	}
+}
+
+const BASE_URGENCY = {
+	current: 0.5,
+	hourly: 0.3,
+	daily: 0.2,
+	alert: 0.7,
+} as const
+
+const SEVERE_CONDITIONS = new Set<ConditionCode>([
+	ConditionCode.SevereThunderstorm,
+	ConditionCode.Hurricane,
+	ConditionCode.Tornado,
+	ConditionCode.TropicalStorm,
+	ConditionCode.Blizzard,
+	ConditionCode.FreezingRain,
+	ConditionCode.Hail,
+	ConditionCode.Frigid,
+	ConditionCode.Hot,
+])
+
+const MODERATE_CONDITIONS = new Set<ConditionCode>([
+	ConditionCode.Thunderstorm,
+	ConditionCode.IsolatedThunderstorms,
+	ConditionCode.ScatteredThunderstorms,
+	ConditionCode.HeavyRain,
+	ConditionCode.HeavySnow,
+	ConditionCode.FreezingDrizzle,
+	ConditionCode.BlowingSnow,
+])
+
+function adjustUrgencyForCondition(baseUrgency: number, conditionCode: ConditionCode): number {
+	if (SEVERE_CONDITIONS.has(conditionCode)) {
+		return Math.min(1, baseUrgency + 0.3)
+	}
+	if (MODERATE_CONDITIONS.has(conditionCode)) {
+		return Math.min(1, baseUrgency + 0.15)
+	}
+	return baseUrgency
+}
+
+function adjustUrgencyForAlertSeverity(severity: Severity): number {
+	switch (severity) {
+		case Severity.Extreme:
+			return 1
+		case Severity.Severe:
+			return 0.9
+		case Severity.Moderate:
+			return 0.75
+		case Severity.Minor:
+			return BASE_URGENCY.alert
+	}
+}
+
+function timeRelevanceForCondition(conditionCode: ConditionCode): TimeRelevance {
+	if (SEVERE_CONDITIONS.has(conditionCode)) {
+		return TimeRelevance.Imminent
+	}
+	if (MODERATE_CONDITIONS.has(conditionCode)) {
+		return TimeRelevance.Upcoming
+	}
+	return TimeRelevance.Ambient
+}
+
+function timeRelevanceForAlertSeverity(severity: Severity): TimeRelevance {
+	switch (severity) {
+		case Severity.Extreme:
+		case Severity.Severe:
+			return TimeRelevance.Imminent
+		case Severity.Moderate:
+			return TimeRelevance.Upcoming
+		case Severity.Minor:
+			return TimeRelevance.Ambient
+	}
+}
+
+function convertTemperature(celsius: number, units: Units): number {
+	if (units === Units.imperial) {
+		return (celsius * 9) / 5 + 32
+	}
+	return celsius
+}
+
+function convertSpeed(kmh: number, units: Units): number {
+	if (units === Units.imperial) {
+		return kmh * 0.621371
+	}
+	return kmh
+}
+
+function convertDistance(km: number, units: Units): number {
+	if (units === Units.imperial) {
+		return km * 0.621371
+	}
+	return km
+}
+
+function convertPrecipitation(mm: number, units: Units): number {
+	if (units === Units.imperial) {
+		return mm * 0.0393701
+	}
+	return mm
+}
+
+function convertPressure(mb: number, units: Units): number {
+	if (units === Units.imperial) {
+		return mb * 0.02953
+	}
+	return mb
+}
+
+function createCurrentWeatherFeedItem(
+	current: CurrentWeather,
+	timestamp: Date,
+	units: Units,
+): CurrentWeatherFeedItem {
+	const signals: FeedItemSignals = {
+		urgency: adjustUrgencyForCondition(BASE_URGENCY.current, current.conditionCode),
+		timeRelevance: timeRelevanceForCondition(current.conditionCode),
+	}
+
+	return {
+		id: `weather-current-${timestamp.getTime()}`,
+		sourceId: SOURCE_ID,
+		type: WeatherFeedItemType.Current,
+		timestamp,
+		data: {
+			conditionCode: current.conditionCode,
+			daylight: current.daylight,
+			humidity: current.humidity,
+			precipitationIntensity: convertPrecipitation(current.precipitationIntensity, units),
+			pressure: convertPressure(current.pressure, units),
+			pressureTrend: current.pressureTrend,
+			temperature: convertTemperature(current.temperature, units),
+			temperatureApparent: convertTemperature(current.temperatureApparent, units),
+			uvIndex: current.uvIndex,
+			visibility: convertDistance(current.visibility, units),
+			windDirection: current.windDirection,
+			windGust: convertSpeed(current.windGust, units),
+			windSpeed: convertSpeed(current.windSpeed, units),
+		},
+		signals,
+	}
+}
+
+function createHourlyWeatherFeedItem(
+	hourly: HourlyForecast,
+	index: number,
+	timestamp: Date,
+	units: Units,
+): HourlyWeatherFeedItem {
+	const signals: FeedItemSignals = {
+		urgency: adjustUrgencyForCondition(BASE_URGENCY.hourly, hourly.conditionCode),
+		timeRelevance: timeRelevanceForCondition(hourly.conditionCode),
+	}
+
+	return {
+		id: `weather-hourly-${timestamp.getTime()}-${index}`,
+		sourceId: SOURCE_ID,
+		type: WeatherFeedItemType.Hourly,
+		timestamp,
+		data: {
+			forecastTime: new Date(hourly.forecastStart),
+			conditionCode: hourly.conditionCode,
+			daylight: hourly.daylight,
+			humidity: hourly.humidity,
+			precipitationAmount: convertPrecipitation(hourly.precipitationAmount, units),
+			precipitationChance: hourly.precipitationChance,
+			precipitationType: hourly.precipitationType,
+			temperature: convertTemperature(hourly.temperature, units),
+			temperatureApparent: convertTemperature(hourly.temperatureApparent, units),
+			uvIndex: hourly.uvIndex,
+			windDirection: hourly.windDirection,
+			windGust: convertSpeed(hourly.windGust, units),
+			windSpeed: convertSpeed(hourly.windSpeed, units),
+		},
+		signals,
+	}
+}
+
+function createDailyWeatherFeedItem(
+	daily: DailyForecast,
+	index: number,
+	timestamp: Date,
+	units: Units,
+): DailyWeatherFeedItem {
+	const signals: FeedItemSignals = {
+		urgency: adjustUrgencyForCondition(BASE_URGENCY.daily, daily.conditionCode),
+		timeRelevance: timeRelevanceForCondition(daily.conditionCode),
+	}
+
+	return {
+		id: `weather-daily-${timestamp.getTime()}-${index}`,
+		sourceId: SOURCE_ID,
+		type: WeatherFeedItemType.Daily,
+		timestamp,
+		data: {
+			forecastDate: new Date(daily.forecastStart),
+			conditionCode: daily.conditionCode,
+			maxUvIndex: daily.maxUvIndex,
+			precipitationAmount: convertPrecipitation(daily.precipitationAmount, units),
+			precipitationChance: daily.precipitationChance,
+			precipitationType: daily.precipitationType,
+			snowfallAmount: convertPrecipitation(daily.snowfallAmount, units),
+			sunrise: new Date(daily.sunrise),
+			sunset: new Date(daily.sunset),
+			temperatureMax: convertTemperature(daily.temperatureMax, units),
+			temperatureMin: convertTemperature(daily.temperatureMin, units),
+		},
+		signals,
+	}
+}
+
+function createWeatherAlertFeedItem(alert: WeatherAlert, timestamp: Date): WeatherAlertFeedItem {
+	const signals: FeedItemSignals = {
+		urgency: adjustUrgencyForAlertSeverity(alert.severity),
+		timeRelevance: timeRelevanceForAlertSeverity(alert.severity),
+	}
+
+	return {
+		id: `weather-alert-${alert.id}`,
+		sourceId: SOURCE_ID,
+		type: WeatherFeedItemType.Alert,
+		timestamp,
+		data: {
+			alertId: alert.id,
+			areaName: alert.areaName,
+			certainty: alert.certainty,
+			description: alert.description,
+			detailsUrl: alert.detailsUrl,
+			effectiveTime: new Date(alert.effectiveTime),
+			expireTime: new Date(alert.expireTime),
+			severity: alert.severity,
+			source: alert.source,
+			urgency: alert.urgency,
+		},
+		signals,
+	}
+}

packages/aelis-data-source-weatherkit/src/feed-items.ts

@@ -0,0 +1,97 @@
+import type { FeedItem } from "@aelis/core"
+
+import type { Certainty, ConditionCode, PrecipitationType, Severity, Urgency } from "./weatherkit"
+
+export const WeatherFeedItemType = {
+	Current: "weather-current",
+	Hourly: "weather-hourly",
+	Daily: "weather-daily",
+	Alert: "weather-alert",
+} as const
+
+export type WeatherFeedItemType = (typeof WeatherFeedItemType)[keyof typeof WeatherFeedItemType]
+
+export type CurrentWeatherData = {
+	conditionCode: ConditionCode
+	daylight: boolean
+	humidity: number
+	precipitationIntensity: number
+	pressure: number
+	pressureTrend: "rising" | "falling" | "steady"
+	temperature: number
+	temperatureApparent: number
+	uvIndex: number
+	visibility: number
+	windDirection: number
+	windGust: number
+	windSpeed: number
+}
+
+export interface CurrentWeatherFeedItem extends FeedItem<
+	typeof WeatherFeedItemType.Current,
+	CurrentWeatherData
+> {}
+
+export type HourlyWeatherData = {
+	forecastTime: Date
+	conditionCode: ConditionCode
+	daylight: boolean
+	humidity: number
+	precipitationAmount: number
+	precipitationChance: number
+	precipitationType: PrecipitationType
+	temperature: number
+	temperatureApparent: number
+	uvIndex: number
+	windDirection: number
+	windGust: number
+	windSpeed: number
+}
+
+export interface HourlyWeatherFeedItem extends FeedItem<
+	typeof WeatherFeedItemType.Hourly,
+	HourlyWeatherData
+> {}
+
+export type DailyWeatherData = {
+	forecastDate: Date
+	conditionCode: ConditionCode
+	maxUvIndex: number
+	precipitationAmount: number
+	precipitationChance: number
+	precipitationType: PrecipitationType
+	snowfallAmount: number
+	sunrise: Date
+	sunset: Date
+	temperatureMax: number
+	temperatureMin: number
+}
+
+export interface DailyWeatherFeedItem extends FeedItem<
+	typeof WeatherFeedItemType.Daily,
+	DailyWeatherData
+> {}
+
+export type WeatherAlertData = {
+	alertId: string
+	areaName: string
+	certainty: Certainty
+	description: string
+	detailsUrl: string
+	effectiveTime: Date
+	expireTime: Date
+	severity: Severity
+	source: string
+	urgency: Urgency
+}
+
+export interface WeatherAlertFeedItem extends FeedItem<
+	typeof WeatherFeedItemType.Alert,
+	WeatherAlertData
+> {}
+
+export type WeatherFeedItem =
+	| CurrentWeatherFeedItem
+	| HourlyWeatherFeedItem
+	| DailyWeatherFeedItem
+	| WeatherAlertFeedItem

packages/aelis-data-source-weatherkit/src/index.ts

@@ -0,0 +1,38 @@
+export {
+	WeatherKitDataSource,
+	Units,
+	type Units as UnitsType,
+	type WeatherKitDataSourceOptions,
+	type WeatherKitQueryConfig,
+} from "./data-source"
+
+export {
+	WeatherFeedItemType,
+	type WeatherFeedItemType as WeatherFeedItemTypeType,
+	type CurrentWeatherData,
+	type CurrentWeatherFeedItem,
+	type DailyWeatherData,
+	type DailyWeatherFeedItem,
+	type HourlyWeatherData,
+	type HourlyWeatherFeedItem,
+	type WeatherAlertData,
+	type WeatherAlertFeedItem,
+	type WeatherFeedItem,
+} from "./feed-items"
+
+export {
+	Severity,
+	Urgency,
+	Certainty,
+	PrecipitationType,
+	ConditionCode,
+	DefaultWeatherKitClient,
+	type Severity as SeverityType,
+	type Urgency as UrgencyType,
+	type Certainty as CertaintyType,
+	type PrecipitationType as PrecipitationTypeType,
+	type ConditionCode as ConditionCodeType,
+	type WeatherKitCredentials,
+	type WeatherKitClient,
+	type WeatherKitQueryOptions,
+} from "./weatherkit"

packages/aelis-data-source-weatherkit/src/weatherkit.ts

@@ -0,0 +1,367 @@
+// WeatherKit REST API client and response types
+// https://developer.apple.com/documentation/weatherkitrestapi
+
+import { type } from "arktype"
+
+export interface WeatherKitCredentials {
+	privateKey: string
+	keyId: string
+	teamId: string
+	serviceId: string
+}
+
+export interface WeatherKitQueryOptions {
+	lat: number
+	lng: number
+	language?: string
+	timezone?: string
+}
+
+export interface WeatherKitClient {
+	fetch(query: WeatherKitQueryOptions): Promise<WeatherKitResponse>
+}
+
+export class DefaultWeatherKitClient implements WeatherKitClient {
+	private readonly credentials: WeatherKitCredentials
+
+	constructor(credentials: WeatherKitCredentials) {
+		this.credentials = credentials
+	}
+
+	async fetch(query: WeatherKitQueryOptions): Promise<WeatherKitResponse> {
+		const token = await generateJwt(this.credentials)
+
+		const dataSets = ["currentWeather", "forecastHourly", "forecastDaily", "weatherAlerts"].join(
+			",",
+		)
+
+		const url = new URL(
+			`${WEATHERKIT_API_BASE}/weather/${query.language ?? "en"}/${query.lat}/${query.lng}`,
+		)
+		url.searchParams.set("dataSets", dataSets)
+		if (query.timezone) {
+			url.searchParams.set("timezone", query.timezone)
+		}
+
+		const response = await fetch(url.toString(), {
+			headers: {
+				Authorization: `Bearer ${token}`,
+			},
+		})
+
+		if (!response.ok) {
+			const body = await response.text()
+			throw new Error(`WeatherKit API error: ${response.status} ${response.statusText}: ${body}`)
+		}
+
+		const json = await response.json()
+		const result = weatherKitResponseSchema(json)
+
+		if (result instanceof type.errors) {
+			throw new Error(`WeatherKit API response validation failed: ${result.summary}`)
+		}
+
+		return result
+	}
+}
+
+export const Severity = {
+	Minor: "minor",
+	Moderate: "moderate",
+	Severe: "severe",
+	Extreme: "extreme",
+} as const
+
+export type Severity = (typeof Severity)[keyof typeof Severity]
+
+export const Urgency = {
+	Immediate: "immediate",
+	Expected: "expected",
+	Future: "future",
+	Past: "past",
+	Unknown: "unknown",
+} as const
+
+export type Urgency = (typeof Urgency)[keyof typeof Urgency]
+
+export const Certainty = {
+	Observed: "observed",
+	Likely: "likely",
+	Possible: "possible",
+	Unlikely: "unlikely",
+	Unknown: "unknown",
+} as const
+
+export type Certainty = (typeof Certainty)[keyof typeof Certainty]
+
+export const PrecipitationType = {
+	Clear: "clear",
+	Precipitation: "precipitation",
+	Rain: "rain",
+	Snow: "snow",
+	Sleet: "sleet",
+	Hail: "hail",
+	Mixed: "mixed",
+} as const
+
+export type PrecipitationType = (typeof PrecipitationType)[keyof typeof PrecipitationType]
+
+export const ConditionCode = {
+	Clear: "Clear",
+	Cloudy: "Cloudy",
+	Dust: "Dust",
+	Fog: "Fog",
+	Haze: "Haze",
+	MostlyClear: "MostlyClear",
+	MostlyCloudy: "MostlyCloudy",
+	PartlyCloudy: "PartlyCloudy",
+	ScatteredThunderstorms: "ScatteredThunderstorms",
+	Smoke: "Smoke",
+	Breezy: "Breezy",
+	Windy: "Windy",
+	Drizzle: "Drizzle",
+	HeavyRain: "HeavyRain",
+	Rain: "Rain",
+	Showers: "Showers",
+	Flurries: "Flurries",
+	HeavySnow: "HeavySnow",
+	MixedRainAndSleet: "MixedRainAndSleet",
+	MixedRainAndSnow: "MixedRainAndSnow",
+	MixedRainfall: "MixedRainfall",
+	MixedSnowAndSleet: "MixedSnowAndSleet",
+	ScatteredShowers: "ScatteredShowers",
+	ScatteredSnowShowers: "ScatteredSnowShowers",
+	Sleet: "Sleet",
+	Snow: "Snow",
+	SnowShowers: "SnowShowers",
+	Blizzard: "Blizzard",
+	BlowingSnow: "BlowingSnow",
+	FreezingDrizzle: "FreezingDrizzle",
+	FreezingRain: "FreezingRain",
+	Frigid: "Frigid",
+	Hail: "Hail",
+	Hot: "Hot",
+	Hurricane: "Hurricane",
+	IsolatedThunderstorms: "IsolatedThunderstorms",
+	SevereThunderstorm: "SevereThunderstorm",
+	Thunderstorm: "Thunderstorm",
+	Tornado: "Tornado",
+	TropicalStorm: "TropicalStorm",
+} as const
+
+export type ConditionCode = (typeof ConditionCode)[keyof typeof ConditionCode]
+
+const WEATHERKIT_API_BASE = "https://weatherkit.apple.com/api/v1"
+
+const severitySchema = type.enumerated(
+	Severity.Minor,
+	Severity.Moderate,
+	Severity.Severe,
+	Severity.Extreme,
+)
+
+const urgencySchema = type.enumerated(
+	Urgency.Immediate,
+	Urgency.Expected,
+	Urgency.Future,
+	Urgency.Past,
+	Urgency.Unknown,
+)
+
+const certaintySchema = type.enumerated(
+	Certainty.Observed,
+	Certainty.Likely,
+	Certainty.Possible,
+	Certainty.Unlikely,
+	Certainty.Unknown,
+)
+
+const precipitationTypeSchema = type.enumerated(
+	PrecipitationType.Clear,
+	PrecipitationType.Precipitation,
+	PrecipitationType.Rain,
+	PrecipitationType.Snow,
+	PrecipitationType.Sleet,
+	PrecipitationType.Hail,
+	PrecipitationType.Mixed,
+)
+
+const conditionCodeSchema = type.enumerated(...Object.values(ConditionCode))
+
+const pressureTrendSchema = type.enumerated("rising", "falling", "steady")
+
+const currentWeatherSchema = type({
+	asOf: "string",
+	conditionCode: conditionCodeSchema,
+	daylight: "boolean",
+	humidity: "number",
+	precipitationIntensity: "number",
+	pressure: "number",
+	pressureTrend: pressureTrendSchema,
+	temperature: "number",
+	temperatureApparent: "number",
+	temperatureDewPoint: "number",
+	uvIndex: "number",
+	visibility: "number",
+	windDirection: "number",
+	windGust: "number",
+	windSpeed: "number",
+})
+
+export type CurrentWeather = typeof currentWeatherSchema.infer
+
+const hourlyForecastSchema = type({
+	forecastStart: "string",
+	conditionCode: conditionCodeSchema,
+	daylight: "boolean",
+	humidity: "number",
+	precipitationAmount: "number",
+	precipitationChance: "number",
+	precipitationType: precipitationTypeSchema,
+	pressure: "number",
+	snowfallIntensity: "number",
+	temperature: "number",
+	temperatureApparent: "number",
+	temperatureDewPoint: "number",
+	uvIndex: "number",
+	visibility: "number",
+	windDirection: "number",
+	windGust: "number",
+	windSpeed: "number",
+})
+
+export type HourlyForecast = typeof hourlyForecastSchema.infer
+
+const dayWeatherConditionsSchema = type({
+	conditionCode: conditionCodeSchema,
+	humidity: "number",
+	precipitationAmount: "number",
+	precipitationChance: "number",
+	precipitationType: precipitationTypeSchema,
+	snowfallAmount: "number",
+	temperatureMax: "number",
+	temperatureMin: "number",
+	windDirection: "number",
+	"windGust?": "number",
+	windSpeed: "number",
+})
+
+export type DayWeatherConditions = typeof dayWeatherConditionsSchema.infer
+
+const dailyForecastSchema = type({
+	forecastStart: "string",
+	forecastEnd: "string",
+	conditionCode: conditionCodeSchema,
+	maxUvIndex: "number",
+	moonPhase: "string",
+	"moonrise?": "string",
+	"moonset?": "string",
+	precipitationAmount: "number",
+	precipitationChance: "number",
+	precipitationType: precipitationTypeSchema,
+	snowfallAmount: "number",
+	sunrise: "string",
+	sunriseCivil: "string",
+	sunriseNautical: "string",
+	sunriseAstronomical: "string",
+	sunset: "string",
+	sunsetCivil: "string",
+	sunsetNautical: "string",
+	sunsetAstronomical: "string",
+	temperatureMax: "number",
+	temperatureMin: "number",
+	"daytimeForecast?": dayWeatherConditionsSchema,
+	"overnightForecast?": dayWeatherConditionsSchema,
+})
+
+export type DailyForecast = typeof dailyForecastSchema.infer
+
+const weatherAlertSchema = type({
+	id: "string",
+	areaId: "string",
+	areaName: "string",
+	certainty: certaintySchema,
+	countryCode: "string",
+	description: "string",
+	detailsUrl: "string",
+	effectiveTime: "string",
+	expireTime: "string",
+	issuedTime: "string",
+	responses: "string[]",
+	severity: severitySchema,
+	source: "string",
+	urgency: urgencySchema,
+})
+
+export type WeatherAlert = typeof weatherAlertSchema.infer
+
+const weatherKitResponseSchema = type({
+	"currentWeather?": currentWeatherSchema,
+	"forecastHourly?": type({
+		hours: hourlyForecastSchema.array(),
+	}),
+	"forecastDaily?": type({
+		days: dailyForecastSchema.array(),
+	}),
+	"weatherAlerts?": type({
+		alerts: weatherAlertSchema.array(),
+	}),
+})
+
+export type WeatherKitResponse = typeof weatherKitResponseSchema.infer
+
+async function generateJwt(credentials: WeatherKitCredentials): Promise<string> {
+	const header = {
+		alg: "ES256",
+		kid: credentials.keyId,
+		id: `${credentials.teamId}.${credentials.serviceId}`,
+	}
+
+	const now = Math.floor(Date.now() / 1000)
+	const payload = {
+		iss: credentials.teamId,
+		iat: now,
+		exp: now + 3600,
+		sub: credentials.serviceId,
+	}
+
+	const encoder = new TextEncoder()
+	const headerB64 = btoa(JSON.stringify(header))
+		.replace(/\+/g, "-")
+		.replace(/\//g, "_")
+		.replace(/=+$/, "")
+	const payloadB64 = btoa(JSON.stringify(payload))
+		.replace(/\+/g, "-")
+		.replace(/\//g, "_")
+		.replace(/=+$/, "")
+
+	const signingInput = `${headerB64}.${payloadB64}`
+
+	const pemContents = credentials.privateKey
+		.replace(/-----BEGIN PRIVATE KEY-----/, "")
+		.replace(/-----END PRIVATE KEY-----/, "")
+		.replace(/\s/g, "")
+
+	const binaryKey = Uint8Array.from(atob(pemContents), (c) => c.charCodeAt(0))
+
+	const cryptoKey = await crypto.subtle.importKey(
+		"pkcs8",
+		binaryKey,
+		{ name: "ECDSA", namedCurve: "P-256" },
+		false,
+		["sign"],
+	)
+
+	const signature = await crypto.subtle.sign(
+		{ name: "ECDSA", hash: "SHA-256" },
+		cryptoKey,
+		encoder.encode(signingInput),
+	)
+
+	const signatureB64 = btoa(String.fromCharCode(...new Uint8Array(signature)))
+		.replace(/\+/g, "-")
+		.replace(/\//g, "_")
+		.replace(/=+$/, "")
+
+	return `${signingInput}.${signatureB64}`
+}

packages/aelis-source-tfl/src/index.ts

@@ -10,7 +10,5 @@ export {
 	type TflAlertSeverity,
 	type TflLineStatus,
 	type TflSourceOptions,
-	type TflStatusData,
-	type TflStatusFeedItem,
 } from "./types.ts"
-export { renderTflStatus } from "./renderer.tsx"
+export { renderTflAlert } from "./renderer.tsx"

packages/aelis-source-tfl/src/renderer.test.tsx

@@ -2,140 +2,102 @@
 import { render } from "@nym.sh/jrx"
 import { describe, expect, test } from "bun:test"
 
-import type { TflAlertData, TflStatusFeedItem } from "./types.ts"
+import type { TflAlertFeedItem } from "./types.ts"
 
-import { renderTflStatus } from "./renderer.tsx"
+import { renderTflAlert } from "./renderer.tsx"
 
-function makeAlert(overrides: Partial<TflAlertData> = {}): TflAlertData {
+function makeItem(overrides: Partial<TflAlertFeedItem["data"]> = {}): TflAlertFeedItem {
 	return {
+		id: "tfl-alert-northern-minor-delays",
+		type: "tfl-alert",
+		timestamp: new Date("2026-01-15T12:00:00Z"),
+		data: {
 			line: "northern",
 			lineName: "Northern",
 			severity: "minor-delays",
 			description: "Minor delays due to signal failure",
 			closestStationDistance: null,
 			...overrides,
+		},
 	}
 }
 
-function makeItem(alerts: TflAlertData[]): TflStatusFeedItem {
-	return {
-		id: "tfl-status",
-		sourceId: "aelis.tfl",
-		type: "tfl-status",
-		timestamp: new Date("2026-01-15T12:00:00Z"),
-		data: { alerts },
-	}
-}
-
-/** Collect all SansSerifText elements from a rendered spec, filtering out Fragments. */
-function collectTextElements(spec: ReturnType<typeof render>) {
-	return Object.values(spec.elements).filter((el) => el.type === "SansSerifText")
-}
-
-describe("renderTflStatus", () => {
-	test("renders a single FeedCard", () => {
-		const node = renderTflStatus(makeItem([makeAlert()]))
+describe("renderTflAlert", () => {
+	test("renders a FeedCard with title and description", () => {
+		const node = renderTflAlert(makeItem())
 		const spec = render(node)
 
 		const root = spec.elements[spec.root]!
 		expect(root.type).toBe("FeedCard")
-	})
+		expect(root.children!.length).toBeGreaterThanOrEqual(2)
 
-	test("renders one alert with title and description", () => {
-		const node = renderTflStatus(makeItem([makeAlert()]))
-		const spec = render(node)
+		const title = spec.elements[root.children![0]!]!
+		expect(title.type).toBe("SansSerifText")
+		expect(title.props.content).toBe("Northern · Minor delays")
 
-		const texts = collectTextElements(spec)
-		const titleText = texts.find((el) => el.props.content === "Northern · Minor delays")
-		const bodyText = texts.find((el) => el.props.content === "Minor delays due to signal failure")
-
-		expect(titleText).toBeDefined()
-		expect(bodyText).toBeDefined()
-	})
-
-	test("renders multiple alerts stacked in one card", () => {
-		const alerts = [
-			makeAlert({ line: "northern", lineName: "Northern", severity: "minor-delays" }),
-			makeAlert({
-				line: "central",
-				lineName: "Central",
-				severity: "closure",
-				description: "Closed due to strike",
-			}),
-		]
-		const node = renderTflStatus(makeItem(alerts))
-		const spec = render(node)
-
-		const root = spec.elements[spec.root]!
-		expect(root.type).toBe("FeedCard")
-
-		const texts = collectTextElements(spec)
-		const northernTitle = texts.find((el) => el.props.content === "Northern · Minor delays")
-		const centralTitle = texts.find((el) => el.props.content === "Central · Closed")
-		const centralBody = texts.find((el) => el.props.content === "Closed due to strike")
-
-		expect(northernTitle).toBeDefined()
-		expect(centralTitle).toBeDefined()
-		expect(centralBody).toBeDefined()
+		const body = spec.elements[root.children![1]!]!
+		expect(body.type).toBe("SansSerifText")
+		expect(body.props.content).toBe("Minor delays due to signal failure")
 	})
 
 	test("shows nearest station distance when available", () => {
-		const node = renderTflStatus(makeItem([makeAlert({ closestStationDistance: 0.35 })]))
+		const node = renderTflAlert(makeItem({ closestStationDistance: 0.35 }))
 		const spec = render(node)
 
-		const texts = collectTextElements(spec)
-		const caption = texts.find((el) => el.props.content === "Nearest station: 350m away")
-		expect(caption).toBeDefined()
+		const root = spec.elements[spec.root]!
+		expect(root.children).toHaveLength(3)
+
+		const caption = spec.elements[root.children![2]!]!
+		expect(caption.type).toBe("SansSerifText")
+		expect(caption.props.content).toBe("Nearest station: 350m away")
 	})
 
 	test("formats distance in km when >= 1km", () => {
-		const node = renderTflStatus(makeItem([makeAlert({ closestStationDistance: 2.456 })]))
+		const node = renderTflAlert(makeItem({ closestStationDistance: 2.456 }))
 		const spec = render(node)
 
-		const texts = collectTextElements(spec)
-		const caption = texts.find((el) => el.props.content === "Nearest station: 2.5km away")
-		expect(caption).toBeDefined()
+		const root = spec.elements[spec.root]!
+		const caption = spec.elements[root.children![2]!]!
+		expect(caption.props.content).toBe("Nearest station: 2.5km away")
 	})
 
 	test("formats near-1km boundary as km not meters", () => {
-		const node = renderTflStatus(makeItem([makeAlert({ closestStationDistance: 0.9999 })]))
+		const node = renderTflAlert(makeItem({ closestStationDistance: 0.9999 }))
 		const spec = render(node)
 
-		const texts = collectTextElements(spec)
-		const caption = texts.find((el) => el.props.content === "Nearest station: 1.0km away")
-		expect(caption).toBeDefined()
+		const root = spec.elements[spec.root]!
+		const caption = spec.elements[root.children![2]!]!
+		expect(caption.props.content).toBe("Nearest station: 1.0km away")
 	})
 
 	test("omits station distance when null", () => {
-		const node = renderTflStatus(makeItem([makeAlert({ closestStationDistance: null })]))
+		const node = renderTflAlert(makeItem({ closestStationDistance: null }))
 		const spec = render(node)
 
-		const texts = collectTextElements(spec)
-		const distanceTexts = texts.filter((el) =>
-			(el.props.content as string).startsWith("Nearest station:"),
-		)
-		expect(distanceTexts).toHaveLength(0)
+		const root = spec.elements[spec.root]!
+		// Title + body only, no caption (empty fragment doesn't produce a child)
+		const children = root.children!.filter((key) => {
+			const el = spec.elements[key]
+			return el && el.type !== "Fragment"
+		})
+		expect(children).toHaveLength(2)
 	})
 
 	test("renders closure severity label", () => {
-		const node = renderTflStatus(
-			makeItem([makeAlert({ severity: "closure", lineName: "Central" })]),
-		)
+		const node = renderTflAlert(makeItem({ severity: "closure", lineName: "Central" }))
 		const spec = render(node)
 
-		const texts = collectTextElements(spec)
-		const title = texts.find((el) => el.props.content === "Central · Closed")
-		expect(title).toBeDefined()
+		const root = spec.elements[spec.root]!
+		const title = spec.elements[root.children![0]!]!
+		expect(title.props.content).toBe("Central · Closed")
 	})
 
 	test("renders major delays severity label", () => {
-		const node = renderTflStatus(
-			makeItem([makeAlert({ severity: "major-delays", lineName: "Jubilee" })]),
-		)
+		const node = renderTflAlert(makeItem({ severity: "major-delays", lineName: "Jubilee" }))
 		const spec = render(node)
 
-		const texts = collectTextElements(spec)
-		const title = texts.find((el) => el.props.content === "Jubilee · Major delays")
-		expect(title).toBeDefined()
+		const root = spec.elements[spec.root]!
+		const title = spec.elements[root.children![0]!]!
+		expect(title.props.content).toBe("Jubilee · Major delays")
 	})
 })

packages/aelis-source-tfl/src/renderer.tsx

@@ -3,7 +3,7 @@ import type { FeedItemRenderer } from "@aelis/core"
 
 import { FeedCard, SansSerifText } from "@aelis/components"
 
-import type { TflAlertData, TflStatusData } from "./types.ts"
+import type { TflAlertData } from "./types.ts"
 
 import { TflAlertSeverity } from "./types.ts"
 
@@ -21,26 +21,20 @@ function formatDistance(km: number): string {
 	return `${(meters / 1000).toFixed(1)}km away`
 }
 
-function renderAlertRow(alert: TflAlertData) {
-	const severityLabel = SEVERITY_LABEL[alert.severity]
+export const renderTflAlert: FeedItemRenderer<"tfl-alert", TflAlertData> = (item) => {
+	const { lineName, severity, description, closestStationDistance } = item.data
+	const severityLabel = SEVERITY_LABEL[severity]
 
 	return (
-		<>
+		<FeedCard>
+			<SansSerifText content={`${lineName} · ${severityLabel}`} style="text-base font-semibold" />
+			<SansSerifText content={description} style="text-sm" />
+			{closestStationDistance !== null ? (
 				<SansSerifText
-				content={`${alert.lineName} · ${severityLabel}`}
-				style="text-base font-semibold"
-			/>
-			<SansSerifText content={alert.description} style="text-sm" />
-			{alert.closestStationDistance !== null ? (
-				<SansSerifText
-					content={`Nearest station: ${formatDistance(alert.closestStationDistance)}`}
+					content={`Nearest station: ${formatDistance(closestStationDistance)}`}
 					style="text-xs text-stone-500"
 				/>
 			) : null}
-		</>
+		</FeedCard>
 	)
 }
-
-export const renderTflStatus: FeedItemRenderer<"tfl-status", TflStatusData> = (item) => {
-	return <FeedCard>{item.data.alerts.map((alert) => renderAlertRow(alert))}</FeedCard>
-}

packages/aelis-source-tfl/src/tfl-api.ts

@@ -69,7 +69,7 @@ export class TflApi {
 	}
 
 	async fetchLineStatuses(lines?: TflLineId[]): Promise<TflLineStatus[]> {
-		const lineIds = lines?.length ? lines : ALL_LINE_IDS
+		const lineIds = lines ?? ALL_LINE_IDS
 		const data = await this.fetch<unknown>(`/Line/${lineIds.join(",")}/Status`)
 
 		const parsed = lineResponseArray(data)
@@ -101,8 +101,8 @@ export class TflApi {
 			return this.stationsCache
 		}
 
-		// Fetch stations for all lines in parallel, tolerating individual failures
-		const results = await Promise.allSettled(
+		// Fetch stations for all lines in parallel
+		const responses = await Promise.all(
 			ALL_LINE_IDS.map(async (id) => {
 				const data = await this.fetch<unknown>(`/Line/${id}/StopPoints`)
 				const parsed = lineStopPointsArray(data)
@@ -116,12 +116,7 @@ export class TflApi {
 		// Merge stations, combining lines for shared stations
 		const stationMap = new Map<string, StationLocation>()
 
-		for (const result of results) {
-			if (result.status === "rejected") {
-				continue
-			}
-
-			const { lineId: currentLineId, stops } = result.value
+		for (const { lineId: currentLineId, stops } of responses) {
 			for (const stop of stops) {
 				const existing = stationMap.get(stop.naptanId)
 				if (existing) {
@@ -140,15 +135,8 @@ export class TflApi {
 			}
 		}
 
-		// Only cache if all requests succeeded — partial results shouldn't persist
-		const allSucceeded = results.every((r) => r.status === "fulfilled")
-		const stations = Array.from(stationMap.values())
-
-		if (allSucceeded) {
-			this.stationsCache = stations
-		}
-
-		return stations
+		this.stationsCache = Array.from(stationMap.values())
+		return this.stationsCache
 	}
 }
 

packages/aelis-source-tfl/src/tfl-source.test.ts

@@ -138,15 +138,13 @@ describe("TflSource", () => {
 		test("changes which lines are fetched", async () => {
 			const source = new TflSource({ client: lineFilteringApi })
 			const before = await source.fetchItems(createContext())
-			expect(before).toHaveLength(1)
-			expect(before[0]!.data.alerts).toHaveLength(2)
+			expect(before.length).toBe(2)
 
 			source.setLinesOfInterest(["northern"])
 			const after = await source.fetchItems(createContext())
 
-			expect(after).toHaveLength(1)
-			expect(after[0]!.data.alerts).toHaveLength(1)
-			expect(after[0]!.data.alerts[0]!.line).toBe("northern")
+			expect(after.length).toBe(1)
+			expect(after[0]!.data.line).toBe("northern")
 		})
 
 		test("DEFAULT_LINES_OF_INTEREST restores all lines", async () => {
@@ -155,52 +153,23 @@ describe("TflSource", () => {
 				lines: ["northern"],
 			})
 			const filtered = await source.fetchItems(createContext())
-			expect(filtered[0]!.data.alerts).toHaveLength(1)
+			expect(filtered.length).toBe(1)
 
 			source.setLinesOfInterest([...TflSource.DEFAULT_LINES_OF_INTEREST])
 			const all = await source.fetchItems(createContext())
 
-			expect(all[0]!.data.alerts).toHaveLength(2)
+			expect(all.length).toBe(2)
 		})
 	})
 
 	describe("fetchItems", () => {
-		test("returns at most one feed item", async () => {
+		test("returns feed items array", async () => {
 			const source = new TflSource({ client: api })
 			const items = await source.fetchItems(createContext())
-			expect(items).toHaveLength(1)
+			expect(Array.isArray(items)).toBe(true)
 		})
 
-		test("returns empty array when no disruptions", async () => {
-			const emptyApi: ITflApi = {
-				async fetchLineStatuses(): Promise<TflLineStatus[]> {
-					return []
-				},
-				async fetchStations(): Promise<StationLocation[]> {
-					return []
-				},
-			}
-			const source = new TflSource({ client: emptyApi })
-			const items = await source.fetchItems(createContext())
-			expect(items).toHaveLength(0)
-		})
-
-		test("combined item has correct base structure", async () => {
-			const source = new TflSource({ client: api })
-			const items = await source.fetchItems(createContext())
-
-			const item = items[0]!
-			expect(item.id).toBe("tfl-status")
-			expect(item.type).toBe("tfl-status")
-			expect(item.sourceId).toBe("aelis.tfl")
-			expect(item.signals).toBeDefined()
-			expect(typeof item.signals!.urgency).toBe("number")
-			expect(item.timestamp).toBeInstanceOf(Date)
-			expect(Array.isArray(item.data.alerts)).toBe(true)
-			expect(item.data.alerts.length).toBeGreaterThan(0)
-		})
-
-		test("alerts have correct data structure", async () => {
+		test("feed items have correct base structure", async () => {
 			const source = new TflSource({ client: api })
 			const location: Location = {
 				lat: 51.5074,
@@ -209,140 +178,72 @@ describe("TflSource", () => {
 				timestamp: new Date(),
 			}
 			const items = await source.fetchItems(createContext(location))
-			const alerts = items[0]!.data.alerts
 
-			for (const alert of alerts) {
-				expect(typeof alert.line).toBe("string")
-				expect(typeof alert.lineName).toBe("string")
-				expect(["minor-delays", "major-delays", "closure"]).toContain(alert.severity)
-				expect(typeof alert.description).toBe("string")
+			for (const item of items) {
+				expect(typeof item.id).toBe("string")
+				expect(item.id).toMatch(/^tfl-alert-/)
+				expect(item.type).toBe("tfl-alert")
+				expect(item.signals).toBeDefined()
+				expect(typeof item.signals!.urgency).toBe("number")
+				expect(item.timestamp).toBeInstanceOf(Date)
+			}
+		})
+
+		test("feed items have correct data structure", async () => {
+			const source = new TflSource({ client: api })
+			const location: Location = {
+				lat: 51.5074,
+				lng: -0.1278,
+				accuracy: 10,
+				timestamp: new Date(),
+			}
+			const items = await source.fetchItems(createContext(location))
+
+			for (const item of items) {
+				expect(typeof item.data.line).toBe("string")
+				expect(typeof item.data.lineName).toBe("string")
+				expect(["minor-delays", "major-delays", "closure"]).toContain(item.data.severity)
+				expect(typeof item.data.description).toBe("string")
 				expect(
-					alert.closestStationDistance === null || typeof alert.closestStationDistance === "number",
+					item.data.closestStationDistance === null ||
+						typeof item.data.closestStationDistance === "number",
 				).toBe(true)
 			}
 		})
 
-		test("signals use highest severity urgency", async () => {
-			const mixedApi: ITflApi = {
-				async fetchLineStatuses(): Promise<TflLineStatus[]> {
-					return [
-						{
-							lineId: "northern",
-							lineName: "Northern",
-							severity: "minor-delays",
-							description: "Minor delays",
-						},
-						{
-							lineId: "central",
-							lineName: "Central",
-							severity: "closure",
-							description: "Closed",
-						},
-						{
-							lineId: "jubilee",
-							lineName: "Jubilee",
-							severity: "major-delays",
-							description: "Major delays",
-						},
-					]
-				},
-				async fetchStations(): Promise<StationLocation[]> {
-					return []
-				},
-			}
-			const source = new TflSource({ client: mixedApi })
+		test("feed item ids are unique", async () => {
+			const source = new TflSource({ client: api })
 			const items = await source.fetchItems(createContext())
 
-			expect(items[0]!.signals!.urgency).toBe(1.0) // closure urgency
-			expect(items[0]!.signals!.timeRelevance).toBe("imminent") // closure time relevance
+			const ids = items.map((item) => item.id)
+			const uniqueIds = new Set(ids)
+			expect(uniqueIds.size).toBe(ids.length)
 		})
 
-		test("signals use single alert severity when only one disruption", async () => {
-			const singleApi: ITflApi = {
-				async fetchLineStatuses(): Promise<TflLineStatus[]> {
-					return [
-						{
-							lineId: "northern",
-							lineName: "Northern",
-							severity: "minor-delays",
-							description: "Minor delays",
-						},
-					]
-				},
-				async fetchStations(): Promise<StationLocation[]> {
-					return []
-				},
-			}
-			const source = new TflSource({ client: singleApi })
+		test("feed items are sorted by urgency descending", async () => {
+			const source = new TflSource({ client: api })
 			const items = await source.fetchItems(createContext())
 
-			expect(items[0]!.signals!.urgency).toBe(0.6) // minor-delays urgency
-			expect(items[0]!.signals!.timeRelevance).toBe("upcoming")
+			for (let i = 1; i < items.length; i++) {
+				const prev = items[i - 1]!
+				const curr = items[i]!
+				expect(prev.signals!.urgency).toBeGreaterThanOrEqual(curr.signals!.urgency!)
+			}
 		})
 
-		test("alerts sorted by closestStationDistance ascending, nulls last", async () => {
-			const distanceApi: ITflApi = {
-				async fetchLineStatuses(): Promise<TflLineStatus[]> {
-					return [
-						{
-							lineId: "northern",
-							lineName: "Northern",
-							severity: "minor-delays",
-							description: "Delays",
-						},
-						{
-							lineId: "central",
-							lineName: "Central",
-							severity: "minor-delays",
-							description: "Delays",
-						},
-						{
-							lineId: "jubilee",
-							lineName: "Jubilee",
-							severity: "minor-delays",
-							description: "Delays",
-						},
-					]
-				},
-				async fetchStations(): Promise<StationLocation[]> {
-					return [
-						{ id: "s1", name: "Station A", lat: 51.51, lng: -0.13, lines: ["central"] },
-						{ id: "s2", name: "Station B", lat: 51.52, lng: -0.14, lines: ["northern"] },
-						// No stations for jubilee — its distance will be null
-					]
-				},
-			}
-			const source = new TflSource({ client: distanceApi })
-			const location: Location = {
-				lat: 51.5074,
-				lng: -0.1278,
-				accuracy: 10,
-				timestamp: new Date(),
-			}
-			const items = await source.fetchItems(createContext(location))
-			const alerts = items[0]!.data.alerts
+		test("urgency values match severity levels", async () => {
+			const source = new TflSource({ client: api })
+			const items = await source.fetchItems(createContext())
 
-			// Alerts with distances should come before nulls
-			const withDistance = alerts.filter((a) => a.closestStationDistance !== null)
-			const withoutDistance = alerts.filter((a) => a.closestStationDistance === null)
-
-			// All distance alerts come first
-			const firstNullIndex = alerts.findIndex((a) => a.closestStationDistance === null)
-			if (firstNullIndex !== -1) {
-				for (let i = 0; i < firstNullIndex; i++) {
-					expect(alerts[i]!.closestStationDistance).not.toBeNull()
-				}
+			const severityUrgency: Record<string, number> = {
+				closure: 1.0,
+				"major-delays": 0.8,
+				"minor-delays": 0.6,
 			}
 
-			// Distance alerts are in ascending order
-			for (let i = 1; i < withDistance.length; i++) {
-				expect(withDistance[i]!.closestStationDistance!).toBeGreaterThanOrEqual(
-					withDistance[i - 1]!.closestStationDistance!,
-				)
+			for (const item of items) {
+				expect(item.signals!.urgency).toBe(severityUrgency[item.data.severity]!)
 			}
-
-			expect(withoutDistance.length).toBe(1)
-			expect(withoutDistance[0]!.line).toBe("jubilee")
 		})
 
 		test("closestStationDistance is number when location provided", async () => {
@@ -355,9 +256,9 @@ describe("TflSource", () => {
 			}
 			const items = await source.fetchItems(createContext(location))
 
-			for (const alert of items[0]!.data.alerts) {
-				expect(typeof alert.closestStationDistance).toBe("number")
-				expect(alert.closestStationDistance!).toBeGreaterThan(0)
+			for (const item of items) {
+				expect(typeof item.data.closestStationDistance).toBe("number")
+				expect(item.data.closestStationDistance!).toBeGreaterThan(0)
 			}
 		})
 
@@ -365,8 +266,8 @@ describe("TflSource", () => {
 			const source = new TflSource({ client: api })
 			const items = await source.fetchItems(createContext())
 
-			for (const alert of items[0]!.data.alerts) {
-				expect(alert.closestStationDistance).toBeNull()
+			for (const item of items) {
+				expect(item.data.closestStationDistance).toBeNull()
 			}
 		})
 	})
@@ -408,9 +309,8 @@ describe("TflSource", () => {
 			await source.executeAction("set-lines-of-interest", ["northern"])
 
 			const items = await source.fetchItems(createContext())
-			expect(items).toHaveLength(1)
-			expect(items[0]!.data.alerts).toHaveLength(1)
-			expect(items[0]!.data.alerts[0]!.line).toBe("northern")
+			expect(items.length).toBe(1)
+			expect(items[0]!.data.line).toBe("northern")
 		})
 
 		test("executeAction throws on invalid input", async () => {

packages/aelis-source-tfl/src/tfl-source.ts

@@ -8,10 +8,10 @@ import type {
 	ITflApi,
 	StationLocation,
 	TflAlertData,
+	TflAlertFeedItem,
 	TflAlertSeverity,
 	TflLineId,
 	TflSourceOptions,
-	TflStatusFeedItem,
 } from "./types.ts"
 
 import { TflApi, lineId } from "./tfl-api.ts"
@@ -51,7 +51,7 @@ const SEVERITY_TIME_RELEVANCE: Record<TflAlertSeverity, TimeRelevance> = {
  * const { items } = await engine.refresh()
  * ```
  */
-export class TflSource implements FeedSource<TflStatusFeedItem> {
+export class TflSource implements FeedSource<TflAlertFeedItem> {
 	static readonly DEFAULT_LINES_OF_INTEREST: readonly TflLineId[] = [
 		"bakerloo",
 		"central",
@@ -84,7 +84,7 @@ export class TflSource implements FeedSource<TflStatusFeedItem> {
 			throw new Error("Either client or apiKey must be provided")
 		}
 		this.client = options.client ?? new TflApi(options.apiKey!)
-		this.lines = options.lines?.length ? options.lines : [...TflSource.DEFAULT_LINES_OF_INTEREST]
+		this.lines = options.lines ?? [...TflSource.DEFAULT_LINES_OF_INTEREST]
 	}
 
 	async listActions(): Promise<Record<string, ActionDefinition>> {
@@ -123,58 +123,56 @@ export class TflSource implements FeedSource<TflStatusFeedItem> {
 		this.lines = lines
 	}
 
-	async fetchItems(context: Context): Promise<TflStatusFeedItem[]> {
+	async fetchItems(context: Context): Promise<TflAlertFeedItem[]> {
 		const [statuses, stations] = await Promise.all([
 			this.client.fetchLineStatuses(this.lines),
 			this.client.fetchStations(),
 		])
 
-		if (statuses.length === 0) {
-			return []
-		}
-
 		const location = context.get(LocationKey)
 
-		const alerts: TflAlertData[] = statuses.map((status) => ({
+		const items: TflAlertFeedItem[] = statuses.map((status) => {
+			const closestStationDistance = location
+				? findClosestStationDistance(status.lineId, stations, location.lat, location.lng)
+				: null
+
+			const data: TflAlertData = {
 				line: status.lineId,
 				lineName: status.lineName,
 				severity: status.severity,
 				description: status.description,
-			closestStationDistance: location
-				? findClosestStationDistance(status.lineId, stations, location.lat, location.lng)
-				: null,
-		}))
-
-		// Sort by closest station distance ascending, nulls last
-		alerts.sort((a, b) => {
-			if (a.closestStationDistance === null && b.closestStationDistance === null) return 0
-			if (a.closestStationDistance === null) return 1
-			if (b.closestStationDistance === null) return -1
-			return a.closestStationDistance - b.closestStationDistance
-		})
-
-		// Signals from the highest-severity alert
-		const highestSeverity = alerts.reduce<TflAlertSeverity>(
-			(worst, alert) =>
-				SEVERITY_URGENCY[alert.severity] > SEVERITY_URGENCY[worst] ? alert.severity : worst,
-			alerts[0]!.severity,
-		)
-
-		const signals: FeedItemSignals = {
-			urgency: SEVERITY_URGENCY[highestSeverity],
-			timeRelevance: SEVERITY_TIME_RELEVANCE[highestSeverity],
+				closestStationDistance,
 			}
 
-		return [
-			{
-				id: "tfl-status",
+			const signals: FeedItemSignals = {
+				urgency: SEVERITY_URGENCY[status.severity],
+				timeRelevance: SEVERITY_TIME_RELEVANCE[status.severity],
+			}
+
+			return {
+				id: `tfl-alert-${status.lineId}-${status.severity}`,
 				sourceId: this.id,
-				type: TflFeedItemType.Status,
+				type: TflFeedItemType.Alert,
 				timestamp: context.time,
-				data: { alerts },
+				data,
 				signals,
-			},
-		]
+			}
+		})
+
+		// Sort by urgency (desc), then by proximity (asc) if location available
+		items.sort((a, b) => {
+			const aUrgency = a.signals?.urgency ?? 0
+			const bUrgency = b.signals?.urgency ?? 0
+			if (bUrgency !== aUrgency) {
+				return bUrgency - aUrgency
+			}
+			if (a.data.closestStationDistance !== null && b.data.closestStationDistance !== null) {
+				return a.data.closestStationDistance - b.data.closestStationDistance
+			}
+			return 0
+		})
+
+		return items
 	}
 }
 

packages/aelis-source-tfl/src/types.ts

@@ -22,19 +22,12 @@ export interface TflAlertData extends Record<string, unknown> {
 
 export const TflFeedItemType = {
 	Alert: "tfl-alert",
-	Status: "tfl-status",
 } as const
 
 export type TflFeedItemType = (typeof TflFeedItemType)[keyof typeof TflFeedItemType]
 
 export type TflAlertFeedItem = FeedItem<typeof TflFeedItemType.Alert, TflAlertData>
 
-export interface TflStatusData extends Record<string, unknown> {
-	alerts: TflAlertData[]
-}
-
-export type TflStatusFeedItem = FeedItem<typeof TflFeedItemType.Status, TflStatusData>
-
 export interface TflSourceOptions {
 	apiKey?: string
 	client?: ITflApi

packages/aelis-source-weatherkit/src/feed-items.ts

@@ -32,7 +32,7 @@ export interface CurrentWeatherFeedItem extends FeedItem<
 	CurrentWeatherData
 > {}
 
-export type HourlyWeatherEntry = {
+export type HourlyWeatherData = {
 	forecastTime: Date
 	conditionCode: ConditionCode
 	daylight: boolean
@@ -48,16 +48,12 @@ export type HourlyWeatherEntry = {
 	windSpeed: number
 }
 
-export type HourlyWeatherData = {
-	hours: HourlyWeatherEntry[]
-}
-
 export interface HourlyWeatherFeedItem extends FeedItem<
 	typeof WeatherFeedItemType.Hourly,
 	HourlyWeatherData
 > {}
 
-export type DailyWeatherEntry = {
+export type DailyWeatherData = {
 	forecastDate: Date
 	conditionCode: ConditionCode
 	maxUvIndex: number
@@ -71,10 +67,6 @@ export type DailyWeatherEntry = {
 	temperatureMin: number
 }
 
-export type DailyWeatherData = {
-	days: DailyWeatherEntry[]
-}
-
 export interface DailyWeatherFeedItem extends FeedItem<
 	typeof WeatherFeedItemType.Daily,
 	DailyWeatherData

packages/aelis-source-weatherkit/src/index.ts

@@ -8,10 +8,8 @@ export {
 	type CurrentWeatherData,
 	type HourlyWeatherFeedItem,
 	type HourlyWeatherData,
-	type HourlyWeatherEntry,
 	type DailyWeatherFeedItem,
 	type DailyWeatherData,
-	type DailyWeatherEntry,
 	type WeatherAlertFeedItem,
 	type WeatherAlertData,
 } from "./feed-items"

packages/aelis-source-weatherkit/src/weather-source.test.ts

@@ -4,10 +4,10 @@ import { Context } from "@aelis/core"
 import { LocationKey } from "@aelis/source-location"
 import { describe, expect, test } from "bun:test"
 
-import type { WeatherKitClient, WeatherKitResponse, HourlyForecast, DailyForecast } from "./weatherkit"
+import type { WeatherKitClient, WeatherKitResponse } from "./weatherkit"
 
 import fixture from "../fixtures/san-francisco.json"
-import { WeatherFeedItemType, type DailyWeatherData, type HourlyWeatherData } from "./feed-items"
+import { WeatherFeedItemType } from "./feed-items"
 import { WeatherKey, type Weather } from "./weather-context"
 import { WeatherSource, Units } from "./weather-source"
 
@@ -131,125 +131,8 @@ describe("WeatherSource", () => {
 			const hourlyItems = items.filter((i) => i.type === WeatherFeedItemType.Hourly)
 			const dailyItems = items.filter((i) => i.type === WeatherFeedItemType.Daily)
 
-			expect(hourlyItems.length).toBe(1)
-			expect((hourlyItems[0]!.data as HourlyWeatherData).hours.length).toBe(3)
-			expect(dailyItems.length).toBe(1)
-			expect((dailyItems[0]!.data as DailyWeatherData).days.length).toBe(2)
-		})
-
-		test("produces a single hourly item with hours array", async () => {
-			const source = new WeatherSource({ client: mockClient })
-			const context = createMockContext({ lat: 37.7749, lng: -122.4194 })
-
-			const items = await source.fetchItems(context)
-
-			const hourlyItems = items.filter((i) => i.type === WeatherFeedItemType.Hourly)
-			expect(hourlyItems.length).toBe(1)
-
-			const hourlyData = hourlyItems[0]!.data as HourlyWeatherData
-			expect(Array.isArray(hourlyData.hours)).toBe(true)
-			expect(hourlyData.hours.length).toBeGreaterThan(0)
-			expect(hourlyData.hours.length).toBeLessThanOrEqual(12)
-		})
-
-		test("averages urgency across hours with mixed conditions", async () => {
-			const mildHour: HourlyForecast = {
-				forecastStart: "2026-01-17T01:00:00Z",
-				conditionCode: "Clear",
-				daylight: true,
-				humidity: 0.5,
-				precipitationAmount: 0,
-				precipitationChance: 0,
-				precipitationType: "clear",
-				pressure: 1013,
-				snowfallIntensity: 0,
-				temperature: 20,
-				temperatureApparent: 20,
-				temperatureDewPoint: 10,
-				uvIndex: 3,
-				visibility: 20000,
-				windDirection: 180,
-				windGust: 10,
-				windSpeed: 5,
-			}
-			const severeHour: HourlyForecast = {
-				...mildHour,
-				forecastStart: "2026-01-17T02:00:00Z",
-				conditionCode: "SevereThunderstorm",
-			}
-			const mixedResponse: WeatherKitResponse = {
-				forecastHourly: { hours: [mildHour, severeHour] },
-			}
-			const source = new WeatherSource({ client: createMockClient(mixedResponse) })
-			const context = createMockContext({ lat: 37.7749, lng: -122.4194 })
-
-			const items = await source.fetchItems(context)
-			const hourlyItem = items.find((i) => i.type === WeatherFeedItemType.Hourly)
-
-			expect(hourlyItem).toBeDefined()
-			// Mild urgency = 0.3, severe urgency = 0.6, average = 0.45
-			expect(hourlyItem!.signals!.urgency).toBeCloseTo(0.45, 5)
-			// Worst-case: SevereThunderstorm → Imminent
-			expect(hourlyItem!.signals!.timeRelevance).toBe("imminent")
-		})
-
-		test("produces a single daily item with days array", async () => {
-			const source = new WeatherSource({ client: mockClient })
-			const context = createMockContext({ lat: 37.7749, lng: -122.4194 })
-
-			const items = await source.fetchItems(context)
-
-			const dailyItems = items.filter((i) => i.type === WeatherFeedItemType.Daily)
-			expect(dailyItems.length).toBe(1)
-
-			const dailyData = dailyItems[0]!.data as DailyWeatherData
-			expect(Array.isArray(dailyData.days)).toBe(true)
-			expect(dailyData.days.length).toBeGreaterThan(0)
-			expect(dailyData.days.length).toBeLessThanOrEqual(7)
-		})
-
-		test("averages urgency across days with mixed conditions", async () => {
-			const mildDay: DailyForecast = {
-				forecastStart: "2026-01-17T00:00:00Z",
-				forecastEnd: "2026-01-18T00:00:00Z",
-				conditionCode: "Clear",
-				maxUvIndex: 3,
-				moonPhase: "firstQuarter",
-				precipitationAmount: 0,
-				precipitationChance: 0,
-				precipitationType: "clear",
-				snowfallAmount: 0,
-				sunrise: "2026-01-17T07:00:00Z",
-				sunriseCivil: "2026-01-17T06:30:00Z",
-				sunriseNautical: "2026-01-17T06:00:00Z",
-				sunriseAstronomical: "2026-01-17T05:30:00Z",
-				sunset: "2026-01-17T17:00:00Z",
-				sunsetCivil: "2026-01-17T17:30:00Z",
-				sunsetNautical: "2026-01-17T18:00:00Z",
-				sunsetAstronomical: "2026-01-17T18:30:00Z",
-				temperatureMax: 15,
-				temperatureMin: 5,
-			}
-			const severeDay: DailyForecast = {
-				...mildDay,
-				forecastStart: "2026-01-18T00:00:00Z",
-				forecastEnd: "2026-01-19T00:00:00Z",
-				conditionCode: "SevereThunderstorm",
-			}
-			const mixedResponse: WeatherKitResponse = {
-				forecastDaily: { days: [mildDay, severeDay] },
-			}
-			const source = new WeatherSource({ client: createMockClient(mixedResponse) })
-			const context = createMockContext({ lat: 37.7749, lng: -122.4194 })
-
-			const items = await source.fetchItems(context)
-			const dailyItem = items.find((i) => i.type === WeatherFeedItemType.Daily)
-
-			expect(dailyItem).toBeDefined()
-			// Mild urgency = 0.2, severe urgency = 0.5, average = 0.35
-			expect(dailyItem!.signals!.urgency).toBeCloseTo(0.35, 5)
-			// Worst-case: SevereThunderstorm → Imminent
-			expect(dailyItem!.signals!.timeRelevance).toBe("imminent")
+			expect(hourlyItems.length).toBe(3)
+			expect(dailyItems.length).toBe(2)
 		})
 
 		test("sets timestamp from context.time", async () => {

packages/aelis-source-weatherkit/src/weather-source.ts

@@ -3,7 +3,7 @@ import type { ActionDefinition, ContextEntry, FeedItemSignals, FeedSource } from
 import { Context, TimeRelevance, UnknownActionError } from "@aelis/core"
 import { LocationKey } from "@aelis/source-location"
 
-import { WeatherFeedItemType, type DailyWeatherEntry, type HourlyWeatherEntry, type WeatherFeedItem } from "./feed-items"
+import { WeatherFeedItemType, type WeatherFeedItem } from "./feed-items"
 import currentWeatherInsightPrompt from "./prompts/current-weather-insight.txt"
 import { WeatherKey, type Weather } from "./weather-context"
 import {
@@ -174,15 +174,21 @@ export class WeatherSource implements FeedSource<WeatherFeedItem> {
 
 		if (response.forecastHourly?.hours) {
 			const hours = response.forecastHourly.hours.slice(0, this.hourlyLimit)
-			if (hours.length > 0) {
-				items.push(createHourlyForecastFeedItem(hours, timestamp, this.units, this.id))
+			for (let i = 0; i < hours.length; i++) {
+				const hour = hours[i]
+				if (hour) {
+					items.push(createHourlyWeatherFeedItem(hour, i, timestamp, this.units, this.id))
+				}
 			}
 		}
 
 		if (response.forecastDaily?.days) {
 			const days = response.forecastDaily.days.slice(0, this.dailyLimit)
-			if (days.length > 0) {
-				items.push(createDailyForecastFeedItem(days, timestamp, this.units, this.id))
+			for (let i = 0; i < days.length; i++) {
+				const day = days[i]
+				if (day) {
+					items.push(createDailyWeatherFeedItem(day, i, timestamp, this.units, this.id))
+				}
 			}
 		}
 
@@ -317,18 +323,24 @@ function createCurrentWeatherFeedItem(
 	}
 }
 
-function createHourlyForecastFeedItem(
-	hourlyForecasts: HourlyForecast[],
+function createHourlyWeatherFeedItem(
+	hourly: HourlyForecast,
+	index: number,
 	timestamp: Date,
 	units: Units,
 	sourceId: string,
 ): WeatherFeedItem {
-	const hours: HourlyWeatherEntry[] = []
-	let totalUrgency = 0
-	let worstTimeRelevance: TimeRelevance = TimeRelevance.Ambient
+	const signals: FeedItemSignals = {
+		urgency: adjustUrgencyForCondition(BASE_URGENCY.hourly, hourly.conditionCode),
+		timeRelevance: timeRelevanceForCondition(hourly.conditionCode),
+	}
 
-	for (const hourly of hourlyForecasts) {
-		hours.push({
+	return {
+		id: `weather-hourly-${timestamp.getTime()}-${index}`,
+		sourceId,
+		type: WeatherFeedItemType.Hourly,
+		timestamp,
+		data: {
 			forecastTime: new Date(hourly.forecastStart),
 			conditionCode: hourly.conditionCode,
 			daylight: hourly.daylight,
@@ -342,43 +354,29 @@ function createHourlyForecastFeedItem(
 			windDirection: hourly.windDirection,
 			windGust: convertSpeed(hourly.windGust, units),
 			windSpeed: convertSpeed(hourly.windSpeed, units),
-		})
-		totalUrgency += adjustUrgencyForCondition(BASE_URGENCY.hourly, hourly.conditionCode)
-		const rel = timeRelevanceForCondition(hourly.conditionCode)
-		if (rel === TimeRelevance.Imminent) {
-			worstTimeRelevance = TimeRelevance.Imminent
-		} else if (rel === TimeRelevance.Upcoming && worstTimeRelevance !== TimeRelevance.Imminent) {
-			worstTimeRelevance = TimeRelevance.Upcoming
-		}
-	}
-
-	const signals: FeedItemSignals = {
-		urgency: totalUrgency / hours.length,
-		timeRelevance: worstTimeRelevance,
-	}
-
-	return {
-		id: `weather-hourly-${timestamp.getTime()}`,
-		sourceId,
-		type: WeatherFeedItemType.Hourly,
-		timestamp,
-		data: { hours },
+		},
 		signals,
 	}
 }
 
-function createDailyForecastFeedItem(
-	dailyForecasts: DailyForecast[],
+function createDailyWeatherFeedItem(
+	daily: DailyForecast,
+	index: number,
 	timestamp: Date,
 	units: Units,
 	sourceId: string,
 ): WeatherFeedItem {
-	const days: DailyWeatherEntry[] = []
-	let totalUrgency = 0
-	let worstTimeRelevance: TimeRelevance = TimeRelevance.Ambient
+	const signals: FeedItemSignals = {
+		urgency: adjustUrgencyForCondition(BASE_URGENCY.daily, daily.conditionCode),
+		timeRelevance: timeRelevanceForCondition(daily.conditionCode),
+	}
 
-	for (const daily of dailyForecasts) {
-		days.push({
+	return {
+		id: `weather-daily-${timestamp.getTime()}-${index}`,
+		sourceId,
+		type: WeatherFeedItemType.Daily,
+		timestamp,
+		data: {
 			forecastDate: new Date(daily.forecastStart),
 			conditionCode: daily.conditionCode,
 			maxUvIndex: daily.maxUvIndex,
@@ -390,27 +388,7 @@ function createDailyForecastFeedItem(
 			sunset: new Date(daily.sunset),
 			temperatureMax: convertTemperature(daily.temperatureMax, units),
 			temperatureMin: convertTemperature(daily.temperatureMin, units),
-		})
-		totalUrgency += adjustUrgencyForCondition(BASE_URGENCY.daily, daily.conditionCode)
-		const rel = timeRelevanceForCondition(daily.conditionCode)
-		if (rel === TimeRelevance.Imminent) {
-			worstTimeRelevance = TimeRelevance.Imminent
-		} else if (rel === TimeRelevance.Upcoming && worstTimeRelevance !== TimeRelevance.Imminent) {
-			worstTimeRelevance = TimeRelevance.Upcoming
-		}
-	}
-
-	const signals: FeedItemSignals = {
-		urgency: totalUrgency / days.length,
-		timeRelevance: worstTimeRelevance,
-	}
-
-	return {
-		id: `weather-daily-${timestamp.getTime()}`,
-		sourceId,
-		type: WeatherFeedItemType.Daily,
-		timestamp,
-		data: { days },
+		},
 		signals,
 	}
 }