feat: switch default LLM to glm-4.7-flash (#108)

Co-authored-by: Ona <no-reply@ona.com>

.ona/automations.yaml

@@ -26,6 +26,12 @@ services:
     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 ""
         cd apps/aelis-backend && bun run dev
 
   admin-dashboard:

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

@@ -408,6 +408,40 @@ 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">
@@ -456,6 +490,8 @@ 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"
+  type: "string" | "number" | "select" | "multiselect"
   label: string
   required?: boolean
   description?: string
   secret?: boolean
-  defaultValue?: string | number
+  defaultValue?: string | number | string[]
   options?: { label: string; value: string }[]
 }
 
@@ -54,6 +54,39 @@ 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,6 +6,7 @@ import {
   CircleDot,
   CloudSun,
   Loader2,
+  TrainFront,
   LogOut,
   MapPin,
   Rss,
@@ -41,6 +42,7 @@ 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 src/server.ts",
+		"dev": "bun run --watch --inspect=0.0.0.0:6499 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 = "openai/gpt-4.1-mini"
+const DEFAULT_MODEL = "z-ai/glm-4.7-flash"
 const DEFAULT_TIMEOUT_MS = 30_000
 
 export interface LlmClientConfig {

apps/aelis-backend/src/server.ts

@@ -14,6 +14,7 @@ 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() {
@@ -45,6 +46,7 @@ function main() {
 					serviceId: process.env.WEATHERKIT_SERVICE_ID!,
 				},
 			}),
+			new TflSourceProvider({ apiKey: process.env.TFL_API_KEY! }),
 		],
 		feedEnhancer,
 	})

bun.lock

@@ -170,14 +170,6 @@
         "@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",
@@ -248,8 +240,6 @@
 
     "@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

@@ -1,4 +0,0 @@
-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

@@ -1,58 +0,0 @@
-# @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

@@ -1,14 +0,0 @@
-{
-	"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

@@ -1,60 +0,0 @@
-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

@@ -1,233 +0,0 @@
-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

@@ -1,356 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,367 +0,0 @@
-// 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,5 +10,7 @@ export {
 	type TflAlertSeverity,
 	type TflLineStatus,
 	type TflSourceOptions,
+	type TflStatusData,
+	type TflStatusFeedItem,
 } from "./types.ts"
-export { renderTflAlert } from "./renderer.tsx"
+export { renderTflStatus } from "./renderer.tsx"

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

@@ -2,102 +2,140 @@
 import { render } from "@nym.sh/jrx"
 import { describe, expect, test } from "bun:test"
 
-import type { TflAlertFeedItem } from "./types.ts"
+import type { TflAlertData, TflStatusFeedItem } from "./types.ts"
 
-import { renderTflAlert } from "./renderer.tsx"
+import { renderTflStatus } from "./renderer.tsx"
 
-function makeItem(overrides: Partial<TflAlertFeedItem["data"]> = {}): TflAlertFeedItem {
+function makeAlert(overrides: Partial<TflAlertData> = {}): TflAlertData {
 	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,
-		},
 	}
 }
 
-describe("renderTflAlert", () => {
+function makeItem(alerts: TflAlertData[]): TflStatusFeedItem {
-	test("renders a FeedCard with title and description", () => {
+	return {
-		const node = renderTflAlert(makeItem())
+		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()]))
 		const spec = render(node)
 
 		const root = spec.elements[spec.root]!
 		expect(root.type).toBe("FeedCard")
-		expect(root.children!.length).toBeGreaterThanOrEqual(2)
+	})
 
-		const title = spec.elements[root.children![0]!]!
+	test("renders one alert with title and description", () => {
-		expect(title.type).toBe("SansSerifText")
+		const node = renderTflStatus(makeItem([makeAlert()]))
-		expect(title.props.content).toBe("Northern · Minor delays")
+		const spec = render(node)
 
-		const body = spec.elements[root.children![1]!]!
+		const texts = collectTextElements(spec)
-		expect(body.type).toBe("SansSerifText")
+		const titleText = texts.find((el) => el.props.content === "Northern · Minor delays")
-		expect(body.props.content).toBe("Minor delays due to signal failure")
+		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()
 	})
 
 	test("shows nearest station distance when available", () => {
-		const node = renderTflAlert(makeItem({ closestStationDistance: 0.35 }))
+		const node = renderTflStatus(makeItem([makeAlert({ closestStationDistance: 0.35 })]))
 		const spec = render(node)
 
-		const root = spec.elements[spec.root]!
+		const texts = collectTextElements(spec)
-		expect(root.children).toHaveLength(3)
+		const caption = texts.find((el) => el.props.content === "Nearest station: 350m away")
-
+		expect(caption).toBeDefined()
-		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 = renderTflAlert(makeItem({ closestStationDistance: 2.456 }))
+		const node = renderTflStatus(makeItem([makeAlert({ closestStationDistance: 2.456 })]))
 		const spec = render(node)
 
-		const root = spec.elements[spec.root]!
+		const texts = collectTextElements(spec)
-		const caption = spec.elements[root.children![2]!]!
+		const caption = texts.find((el) => el.props.content === "Nearest station: 2.5km away")
-		expect(caption.props.content).toBe("Nearest station: 2.5km away")
+		expect(caption).toBeDefined()
 	})
 
 	test("formats near-1km boundary as km not meters", () => {
-		const node = renderTflAlert(makeItem({ closestStationDistance: 0.9999 }))
+		const node = renderTflStatus(makeItem([makeAlert({ closestStationDistance: 0.9999 })]))
 		const spec = render(node)
 
-		const root = spec.elements[spec.root]!
+		const texts = collectTextElements(spec)
-		const caption = spec.elements[root.children![2]!]!
+		const caption = texts.find((el) => el.props.content === "Nearest station: 1.0km away")
-		expect(caption.props.content).toBe("Nearest station: 1.0km away")
+		expect(caption).toBeDefined()
 	})
 
 	test("omits station distance when null", () => {
-		const node = renderTflAlert(makeItem({ closestStationDistance: null }))
+		const node = renderTflStatus(makeItem([makeAlert({ closestStationDistance: null })]))
 		const spec = render(node)
 
-		const root = spec.elements[spec.root]!
+		const texts = collectTextElements(spec)
-		// Title + body only, no caption (empty fragment doesn't produce a child)
+		const distanceTexts = texts.filter((el) =>
-		const children = root.children!.filter((key) => {
+			(el.props.content as string).startsWith("Nearest station:"),
-			const el = spec.elements[key]
+		)
-			return el && el.type !== "Fragment"
+		expect(distanceTexts).toHaveLength(0)
-		})
-		expect(children).toHaveLength(2)
 	})
 
 	test("renders closure severity label", () => {
-		const node = renderTflAlert(makeItem({ severity: "closure", lineName: "Central" }))
+		const node = renderTflStatus(
+			makeItem([makeAlert({ severity: "closure", lineName: "Central" })]),
+		)
 		const spec = render(node)
 
-		const root = spec.elements[spec.root]!
+		const texts = collectTextElements(spec)
-		const title = spec.elements[root.children![0]!]!
+		const title = texts.find((el) => el.props.content === "Central · Closed")
-		expect(title.props.content).toBe("Central · Closed")
+		expect(title).toBeDefined()
 	})
 
 	test("renders major delays severity label", () => {
-		const node = renderTflAlert(makeItem({ severity: "major-delays", lineName: "Jubilee" }))
+		const node = renderTflStatus(
+			makeItem([makeAlert({ severity: "major-delays", lineName: "Jubilee" })]),
+		)
 		const spec = render(node)
 
-		const root = spec.elements[spec.root]!
+		const texts = collectTextElements(spec)
-		const title = spec.elements[root.children![0]!]!
+		const title = texts.find((el) => el.props.content === "Jubilee · Major delays")
-		expect(title.props.content).toBe("Jubilee · Major delays")
+		expect(title).toBeDefined()
 	})
 })

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 } from "./types.ts"
+import type { TflAlertData, TflStatusData } from "./types.ts"
 
 import { TflAlertSeverity } from "./types.ts"
 
@@ -21,20 +21,26 @@ function formatDistance(km: number): string {
 	return `${(meters / 1000).toFixed(1)}km away`
 }
 
-export const renderTflAlert: FeedItemRenderer<"tfl-alert", TflAlertData> = (item) => {
+function renderAlertRow(alert: TflAlertData) {
-	const { lineName, severity, description, closestStationDistance } = item.data
+	const severityLabel = SEVERITY_LABEL[alert.severity]
-	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={`Nearest station: ${formatDistance(closestStationDistance)}`}
+				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)}`}
 					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 ?? ALL_LINE_IDS
+		const lineIds = lines?.length ? 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
+		// Fetch stations for all lines in parallel, tolerating individual failures
-		const responses = await Promise.all(
+		const results = await Promise.allSettled(
 			ALL_LINE_IDS.map(async (id) => {
 				const data = await this.fetch<unknown>(`/Line/${id}/StopPoints`)
 				const parsed = lineStopPointsArray(data)
@@ -116,7 +116,12 @@ export class TflApi {
 		// Merge stations, combining lines for shared stations
 		const stationMap = new Map<string, StationLocation>()
 
-		for (const { lineId: currentLineId, stops } of responses) {
+		for (const result of results) {
+			if (result.status === "rejected") {
+				continue
+			}
+
+			const { lineId: currentLineId, stops } = result.value
 			for (const stop of stops) {
 				const existing = stationMap.get(stop.naptanId)
 				if (existing) {
@@ -135,8 +140,15 @@ export class TflApi {
 			}
 		}
 
-		this.stationsCache = Array.from(stationMap.values())
+		// Only cache if all requests succeeded — partial results shouldn't persist
-		return this.stationsCache
+		const allSucceeded = results.every((r) => r.status === "fulfilled")
+		const stations = Array.from(stationMap.values())
+
+		if (allSucceeded) {
+			this.stationsCache = stations
+		}
+
+		return stations
 	}
 }
 

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

@@ -138,13 +138,15 @@ describe("TflSource", () => {
 		test("changes which lines are fetched", async () => {
 			const source = new TflSource({ client: lineFilteringApi })
 			const before = await source.fetchItems(createContext())
-			expect(before.length).toBe(2)
+			expect(before).toHaveLength(1)
+			expect(before[0]!.data.alerts).toHaveLength(2)
 
 			source.setLinesOfInterest(["northern"])
 			const after = await source.fetchItems(createContext())
 
-			expect(after.length).toBe(1)
+			expect(after).toHaveLength(1)
-			expect(after[0]!.data.line).toBe("northern")
+			expect(after[0]!.data.alerts).toHaveLength(1)
+			expect(after[0]!.data.alerts[0]!.line).toBe("northern")
 		})
 
 		test("DEFAULT_LINES_OF_INTEREST restores all lines", async () => {
@@ -153,43 +155,52 @@ describe("TflSource", () => {
 				lines: ["northern"],
 			})
 			const filtered = await source.fetchItems(createContext())
-			expect(filtered.length).toBe(1)
+			expect(filtered[0]!.data.alerts).toHaveLength(1)
 
 			source.setLinesOfInterest([...TflSource.DEFAULT_LINES_OF_INTEREST])
 			const all = await source.fetchItems(createContext())
 
-			expect(all.length).toBe(2)
+			expect(all[0]!.data.alerts).toHaveLength(2)
 		})
 	})
 
 	describe("fetchItems", () => {
-		test("returns feed items array", async () => {
+		test("returns at most one feed item", async () => {
 			const source = new TflSource({ client: api })
 			const items = await source.fetchItems(createContext())
-			expect(Array.isArray(items)).toBe(true)
+			expect(items).toHaveLength(1)
 		})
 
-		test("feed items have correct base structure", async () => {
+		test("returns empty array when no disruptions", async () => {
-			const source = new TflSource({ client: api })
+			const emptyApi: ITflApi = {
-			const location: Location = {
+				async fetchLineStatuses(): Promise<TflLineStatus[]> {
-				lat: 51.5074,
+					return []
-				lng: -0.1278,
+				},
-				accuracy: 10,
+				async fetchStations(): Promise<StationLocation[]> {
-				timestamp: new Date(),
+					return []
+				},
 			}
-			const items = await source.fetchItems(createContext(location))
+			const source = new TflSource({ client: emptyApi })
+			const items = await source.fetchItems(createContext())
+			expect(items).toHaveLength(0)
+		})
 
-			for (const item of items) {
+		test("combined item has correct base structure", async () => {
-				expect(typeof item.id).toBe("string")
+			const source = new TflSource({ client: api })
-				expect(item.id).toMatch(/^tfl-alert-/)
+			const items = await source.fetchItems(createContext())
-				expect(item.type).toBe("tfl-alert")
+
+			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("feed items have correct data structure", async () => {
+		test("alerts have correct data structure", async () => {
 			const source = new TflSource({ client: api })
 			const location: Location = {
 				lat: 51.5074,
@@ -198,52 +209,140 @@ describe("TflSource", () => {
 				timestamp: new Date(),
 			}
 			const items = await source.fetchItems(createContext(location))
+			const alerts = items[0]!.data.alerts
 
-			for (const item of items) {
+			for (const alert of alerts) {
-				expect(typeof item.data.line).toBe("string")
+				expect(typeof alert.line).toBe("string")
-				expect(typeof item.data.lineName).toBe("string")
+				expect(typeof alert.lineName).toBe("string")
-				expect(["minor-delays", "major-delays", "closure"]).toContain(item.data.severity)
+				expect(["minor-delays", "major-delays", "closure"]).toContain(alert.severity)
-				expect(typeof item.data.description).toBe("string")
+				expect(typeof alert.description).toBe("string")
 				expect(
-					item.data.closestStationDistance === null ||
+					alert.closestStationDistance === null || typeof alert.closestStationDistance === "number",
-						typeof item.data.closestStationDistance === "number",
 				).toBe(true)
 			}
 		})
 
-		test("feed item ids are unique", async () => {
+		test("signals use highest severity urgency", async () => {
-			const source = new TflSource({ client: api })
+			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 })
 			const items = await source.fetchItems(createContext())
 
-			const ids = items.map((item) => item.id)
+			expect(items[0]!.signals!.urgency).toBe(1.0) // closure urgency
-			const uniqueIds = new Set(ids)
+			expect(items[0]!.signals!.timeRelevance).toBe("imminent") // closure time relevance
-			expect(uniqueIds.size).toBe(ids.length)
 		})
 
-		test("feed items are sorted by urgency descending", async () => {
+		test("signals use single alert severity when only one disruption", async () => {
-			const source = new TflSource({ client: api })
+			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 })
 			const items = await source.fetchItems(createContext())
 
-			for (let i = 1; i < items.length; i++) {
+			expect(items[0]!.signals!.urgency).toBe(0.6) // minor-delays urgency
-				const prev = items[i - 1]!
+			expect(items[0]!.signals!.timeRelevance).toBe("upcoming")
-				const curr = items[i]!
-				expect(prev.signals!.urgency).toBeGreaterThanOrEqual(curr.signals!.urgency!)
-			}
 		})
 
-		test("urgency values match severity levels", async () => {
+		test("alerts sorted by closestStationDistance ascending, nulls last", async () => {
-			const source = new TflSource({ client: api })
+			const distanceApi: ITflApi = {
-			const items = await source.fetchItems(createContext())
+				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
 
-			const severityUrgency: Record<string, number> = {
+			// Alerts with distances should come before nulls
-				closure: 1.0,
+			const withDistance = alerts.filter((a) => a.closestStationDistance !== null)
-				"major-delays": 0.8,
+			const withoutDistance = alerts.filter((a) => a.closestStationDistance === null)
-				"minor-delays": 0.6,
+
+			// 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()
+				}
 			}
 
-			for (const item of items) {
+			// Distance alerts are in ascending order
-				expect(item.signals!.urgency).toBe(severityUrgency[item.data.severity]!)
+			for (let i = 1; i < withDistance.length; i++) {
+				expect(withDistance[i]!.closestStationDistance!).toBeGreaterThanOrEqual(
+					withDistance[i - 1]!.closestStationDistance!,
+				)
 			}
+
+			expect(withoutDistance.length).toBe(1)
+			expect(withoutDistance[0]!.line).toBe("jubilee")
 		})
 
 		test("closestStationDistance is number when location provided", async () => {
@@ -256,9 +355,9 @@ describe("TflSource", () => {
 			}
 			const items = await source.fetchItems(createContext(location))
 
-			for (const item of items) {
+			for (const alert of items[0]!.data.alerts) {
-				expect(typeof item.data.closestStationDistance).toBe("number")
+				expect(typeof alert.closestStationDistance).toBe("number")
-				expect(item.data.closestStationDistance!).toBeGreaterThan(0)
+				expect(alert.closestStationDistance!).toBeGreaterThan(0)
 			}
 		})
 
@@ -266,8 +365,8 @@ describe("TflSource", () => {
 			const source = new TflSource({ client: api })
 			const items = await source.fetchItems(createContext())
 
-			for (const item of items) {
+			for (const alert of items[0]!.data.alerts) {
-				expect(item.data.closestStationDistance).toBeNull()
+				expect(alert.closestStationDistance).toBeNull()
 			}
 		})
 	})
@@ -309,8 +408,9 @@ describe("TflSource", () => {
 			await source.executeAction("set-lines-of-interest", ["northern"])
 
 			const items = await source.fetchItems(createContext())
-			expect(items.length).toBe(1)
+			expect(items).toHaveLength(1)
-			expect(items[0]!.data.line).toBe("northern")
+			expect(items[0]!.data.alerts).toHaveLength(1)
+			expect(items[0]!.data.alerts[0]!.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<TflAlertFeedItem> {
+export class TflSource implements FeedSource<TflStatusFeedItem> {
 	static readonly DEFAULT_LINES_OF_INTEREST: readonly TflLineId[] = [
 		"bakerloo",
 		"central",
@@ -84,7 +84,7 @@ export class TflSource implements FeedSource<TflAlertFeedItem> {
 			throw new Error("Either client or apiKey must be provided")
 		}
 		this.client = options.client ?? new TflApi(options.apiKey!)
-		this.lines = options.lines ?? [...TflSource.DEFAULT_LINES_OF_INTEREST]
+		this.lines = options.lines?.length ? options.lines : [...TflSource.DEFAULT_LINES_OF_INTEREST]
 	}
 
 	async listActions(): Promise<Record<string, ActionDefinition>> {
@@ -123,56 +123,58 @@ export class TflSource implements FeedSource<TflAlertFeedItem> {
 		this.lines = lines
 	}
 
-	async fetchItems(context: Context): Promise<TflAlertFeedItem[]> {
+	async fetchItems(context: Context): Promise<TflStatusFeedItem[]> {
 		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 items: TflAlertFeedItem[] = statuses.map((status) => {
+		const alerts: TflAlertData[] = 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,
+			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[status.severity],
+			urgency: SEVERITY_URGENCY[highestSeverity],
-				timeRelevance: SEVERITY_TIME_RELEVANCE[status.severity],
+			timeRelevance: SEVERITY_TIME_RELEVANCE[highestSeverity],
 		}
 
-			return {
+		return [
-				id: `tfl-alert-${status.lineId}-${status.severity}`,
+			{
+				id: "tfl-status",
 				sourceId: this.id,
-				type: TflFeedItemType.Alert,
+				type: TflFeedItemType.Status,
 				timestamp: context.time,
-				data,
+				data: { alerts },
 				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,12 +22,19 @@ 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 HourlyWeatherData = {
+export type HourlyWeatherEntry = {
 	forecastTime: Date
 	conditionCode: ConditionCode
 	daylight: boolean
@@ -48,12 +48,16 @@ export type HourlyWeatherData = {
 	windSpeed: number
 }
 
+export type HourlyWeatherData = {
+	hours: HourlyWeatherEntry[]
+}
+
 export interface HourlyWeatherFeedItem extends FeedItem<
 	typeof WeatherFeedItemType.Hourly,
 	HourlyWeatherData
 > {}
 
-export type DailyWeatherData = {
+export type DailyWeatherEntry = {
 	forecastDate: Date
 	conditionCode: ConditionCode
 	maxUvIndex: number
@@ -67,6 +71,10 @@ export type DailyWeatherData = {
 	temperatureMin: number
 }
 
+export type DailyWeatherData = {
+	days: DailyWeatherEntry[]
+}
+
 export interface DailyWeatherFeedItem extends FeedItem<
 	typeof WeatherFeedItemType.Daily,
 	DailyWeatherData

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

@@ -8,8 +8,10 @@ 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 } from "./weatherkit"
+import type { WeatherKitClient, WeatherKitResponse, HourlyForecast, DailyForecast } from "./weatherkit"
 
 import fixture from "../fixtures/san-francisco.json"
-import { WeatherFeedItemType } from "./feed-items"
+import { WeatherFeedItemType, type DailyWeatherData, type HourlyWeatherData } from "./feed-items"
 import { WeatherKey, type Weather } from "./weather-context"
 import { WeatherSource, Units } from "./weather-source"
 
@@ -131,8 +131,125 @@ describe("WeatherSource", () => {
 			const hourlyItems = items.filter((i) => i.type === WeatherFeedItemType.Hourly)
 			const dailyItems = items.filter((i) => i.type === WeatherFeedItemType.Daily)
 
-			expect(hourlyItems.length).toBe(3)
+			expect(hourlyItems.length).toBe(1)
-			expect(dailyItems.length).toBe(2)
+			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")
 		})
 
 		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 WeatherFeedItem } from "./feed-items"
+import { WeatherFeedItemType, type DailyWeatherEntry, type HourlyWeatherEntry, type WeatherFeedItem } from "./feed-items"
 import currentWeatherInsightPrompt from "./prompts/current-weather-insight.txt"
 import { WeatherKey, type Weather } from "./weather-context"
 import {
@@ -174,21 +174,15 @@ export class WeatherSource implements FeedSource<WeatherFeedItem> {
 
 		if (response.forecastHourly?.hours) {
 			const hours = response.forecastHourly.hours.slice(0, this.hourlyLimit)
-			for (let i = 0; i < hours.length; i++) {
+			if (hours.length > 0) {
-				const hour = hours[i]
+				items.push(createHourlyForecastFeedItem(hours, timestamp, this.units, this.id))
-				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)
-			for (let i = 0; i < days.length; i++) {
+			if (days.length > 0) {
-				const day = days[i]
+				items.push(createDailyForecastFeedItem(days, timestamp, this.units, this.id))
-				if (day) {
-					items.push(createDailyWeatherFeedItem(day, i, timestamp, this.units, this.id))
-				}
 			}
 		}
 
@@ -323,24 +317,18 @@ function createCurrentWeatherFeedItem(
 	}
 }
 
-function createHourlyWeatherFeedItem(
+function createHourlyForecastFeedItem(
-	hourly: HourlyForecast,
+	hourlyForecasts: HourlyForecast[],
-	index: number,
 	timestamp: Date,
 	units: Units,
 	sourceId: string,
 ): WeatherFeedItem {
-	const signals: FeedItemSignals = {
+	const hours: HourlyWeatherEntry[] = []
-		urgency: adjustUrgencyForCondition(BASE_URGENCY.hourly, hourly.conditionCode),
+	let totalUrgency = 0
-		timeRelevance: timeRelevanceForCondition(hourly.conditionCode),
+	let worstTimeRelevance: TimeRelevance = TimeRelevance.Ambient
-	}
 
-	return {
+	for (const hourly of hourlyForecasts) {
-		id: `weather-hourly-${timestamp.getTime()}-${index}`,
+		hours.push({
-		sourceId,
-		type: WeatherFeedItemType.Hourly,
-		timestamp,
-		data: {
 			forecastTime: new Date(hourly.forecastStart),
 			conditionCode: hourly.conditionCode,
 			daylight: hourly.daylight,
@@ -354,29 +342,43 @@ function createHourlyWeatherFeedItem(
 			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 createDailyWeatherFeedItem(
+function createDailyForecastFeedItem(
-	daily: DailyForecast,
+	dailyForecasts: DailyForecast[],
-	index: number,
 	timestamp: Date,
 	units: Units,
 	sourceId: string,
 ): WeatherFeedItem {
-	const signals: FeedItemSignals = {
+	const days: DailyWeatherEntry[] = []
-		urgency: adjustUrgencyForCondition(BASE_URGENCY.daily, daily.conditionCode),
+	let totalUrgency = 0
-		timeRelevance: timeRelevanceForCondition(daily.conditionCode),
+	let worstTimeRelevance: TimeRelevance = TimeRelevance.Ambient
-	}
 
-	return {
+	for (const daily of dailyForecasts) {
-		id: `weather-daily-${timestamp.getTime()}-${index}`,
+		days.push({
-		sourceId,
-		type: WeatherFeedItemType.Daily,
-		timestamp,
-		data: {
 			forecastDate: new Date(daily.forecastStart),
 			conditionCode: daily.conditionCode,
 			maxUvIndex: daily.maxUvIndex,
@@ -388,7 +390,27 @@ function createDailyWeatherFeedItem(
 			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,
 	}
 }