feat: combine TFL alerts into single feed item

TflSource.fetchItems() now returns one TflStatusFeedItem with an
alerts array instead of separate items per line disruption. Signals
use the highest severity. Alerts sorted by station distance.

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/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,
-		},
+		line: "northern",
+		lineName: "Northern",
+		severity: "minor-delays",
+		description: "Minor delays due to signal failure",
+		closestStationDistance: null,
+		...overrides,
 	}
 }
 
-describe("renderTflAlert", () => {
-	test("renders a FeedCard with title and description", () => {
-		const node = renderTflAlert(makeItem())
+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()]))
 		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]!]!
-		expect(title.type).toBe("SansSerifText")
-		expect(title.props.content).toBe("Northern · Minor delays")
+	test("renders one alert with title and description", () => {
+		const node = renderTflStatus(makeItem([makeAlert()]))
+		const spec = render(node)
 
-		const body = spec.elements[root.children![1]!]!
-		expect(body.type).toBe("SansSerifText")
-		expect(body.props.content).toBe("Minor delays due to signal failure")
+		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()
 	})
 
 	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]!
-		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")
+		const texts = collectTextElements(spec)
+		const caption = texts.find((el) => el.props.content === "Nearest station: 350m away")
+		expect(caption).toBeDefined()
 	})
 
 	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 caption = spec.elements[root.children![2]!]!
-		expect(caption.props.content).toBe("Nearest station: 2.5km away")
+		const texts = collectTextElements(spec)
+		const caption = texts.find((el) => el.props.content === "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 caption = spec.elements[root.children![2]!]!
-		expect(caption.props.content).toBe("Nearest station: 1.0km away")
+		const texts = collectTextElements(spec)
+		const caption = texts.find((el) => el.props.content === "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]!
-		// 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)
+		const texts = collectTextElements(spec)
+		const distanceTexts = texts.filter((el) =>
+			(el.props.content as string).startsWith("Nearest station:"),
+		)
+		expect(distanceTexts).toHaveLength(0)
 	})
 
 	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 title = spec.elements[root.children![0]!]!
-		expect(title.props.content).toBe("Central · Closed")
+		const texts = collectTextElements(spec)
+		const title = texts.find((el) => el.props.content === "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 title = spec.elements[root.children![0]!]!
-		expect(title.props.content).toBe("Jubilee · Major delays")
+		const texts = collectTextElements(spec)
+		const title = texts.find((el) => el.props.content === "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) => {
-	const { lineName, severity, description, closestStationDistance } = item.data
-	const severityLabel = SEVERITY_LABEL[severity]
+function renderAlertRow(alert: TflAlertData) {
+	const severityLabel = SEVERITY_LABEL[alert.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(closestStationDistance)}`}
+					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
-		const responses = await Promise.all(
+		// Fetch stations for all lines in parallel, tolerating individual failures
+		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())
-		return this.stationsCache
+		// 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
 	}
 }
 

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[0]!.data.line).toBe("northern")
+			expect(after).toHaveLength(1)
+			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,23 +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 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 () => {
 			const source = new TflSource({ client: api })
 			const location: Location = {
 				lat: 51.5074,
@@ -178,72 +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) {
-				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")
+			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")
 				expect(
-					item.data.closestStationDistance === null ||
-						typeof item.data.closestStationDistance === "number",
+					alert.closestStationDistance === null || typeof alert.closestStationDistance === "number",
 				).toBe(true)
 			}
 		})
 
-		test("feed item ids are unique", async () => {
-			const source = new TflSource({ client: api })
+		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 })
 			const items = await source.fetchItems(createContext())
 
-			const ids = items.map((item) => item.id)
-			const uniqueIds = new Set(ids)
-			expect(uniqueIds.size).toBe(ids.length)
+			expect(items[0]!.signals!.urgency).toBe(1.0) // closure urgency
+			expect(items[0]!.signals!.timeRelevance).toBe("imminent") // closure time relevance
 		})
 
-		test("feed items are sorted by urgency descending", async () => {
-			const source = new TflSource({ client: api })
+		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 })
 			const items = await source.fetchItems(createContext())
 
-			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!)
-			}
+			expect(items[0]!.signals!.urgency).toBe(0.6) // minor-delays urgency
+			expect(items[0]!.signals!.timeRelevance).toBe("upcoming")
 		})
 
-		test("urgency values match severity levels", async () => {
-			const source = new TflSource({ client: api })
-			const items = await source.fetchItems(createContext())
+		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
 
-			const severityUrgency: Record<string, number> = {
-				closure: 1.0,
-				"major-delays": 0.8,
-				"minor-delays": 0.6,
+			// 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()
+				}
 			}
 
-			for (const item of items) {
-				expect(item.signals!.urgency).toBe(severityUrgency[item.data.severity]!)
+			// Distance alerts are in ascending order
+			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) {
-				expect(typeof item.data.closestStationDistance).toBe("number")
-				expect(item.data.closestStationDistance!).toBeGreaterThan(0)
+			for (const alert of items[0]!.data.alerts) {
+				expect(typeof alert.closestStationDistance).toBe("number")
+				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) {
-				expect(item.data.closestStationDistance).toBeNull()
+			for (const alert of items[0]!.data.alerts) {
+				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[0]!.data.line).toBe("northern")
+			expect(items).toHaveLength(1)
+			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 closestStationDistance = location
+		const alerts: TflAlertData[] = statuses.map((status) => ({
+			line: status.lineId,
+			lineName: status.lineName,
+			severity: status.severity,
+			description: status.description,
+			closestStationDistance: location
 				? findClosestStationDistance(status.lineId, stations, location.lat, location.lng)
-				: null
+				: null,
+		}))
 
-			const data: TflAlertData = {
-				line: status.lineId,
-				lineName: status.lineName,
-				severity: status.severity,
-				description: status.description,
-				closestStationDistance,
-			}
+		// 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
+		})
 
-			const signals: FeedItemSignals = {
-				urgency: SEVERITY_URGENCY[status.severity],
-				timeRelevance: SEVERITY_TIME_RELEVANCE[status.severity],
-			}
+		// 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,
+		)
 
-			return {
-				id: `tfl-alert-${status.lineId}-${status.severity}`,
+		const signals: FeedItemSignals = {
+			urgency: SEVERITY_URGENCY[highestSeverity],
+			timeRelevance: SEVERITY_TIME_RELEVANCE[highestSeverity],
+		}
+
+		return [
+			{
+				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

@@ -57,7 +57,7 @@ export interface HourlyWeatherFeedItem extends FeedItem<
 	HourlyWeatherData
 > {}
 
-export type DailyWeatherData = {
+export type DailyWeatherEntry = {
 	forecastDate: Date
 	conditionCode: ConditionCode
 	maxUvIndex: number
@@ -71,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

@@ -11,6 +11,7 @@ export {
 	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 } from "./weatherkit"
+import type { WeatherKitClient, WeatherKitResponse, HourlyForecast, DailyForecast } from "./weatherkit"
 
 import fixture from "../fixtures/san-francisco.json"
-import { WeatherFeedItemType, type HourlyWeatherData } 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"
 
@@ -133,7 +133,8 @@ describe("WeatherSource", () => {
 
 			expect(hourlyItems.length).toBe(1)
 			expect((hourlyItems[0]!.data as HourlyWeatherData).hours.length).toBe(3)
-			expect(dailyItems.length).toBe(2)
+			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 () => {
@@ -192,6 +193,65 @@ describe("WeatherSource", () => {
 			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 () => {
 			const source = new WeatherSource({ client: mockClient })
 			const queryTime = new Date("2026-01-17T12:00:00Z")

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 HourlyWeatherEntry, 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 {
@@ -181,11 +181,8 @@ export class WeatherSource implements FeedSource<WeatherFeedItem> {
 
 		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, this.units, this.id))
-				}
+			if (days.length > 0) {
+				items.push(createDailyForecastFeedItem(days, timestamp, this.units, this.id))
 			}
 		}
 
@@ -370,24 +367,18 @@ function createHourlyForecastFeedItem(
 	}
 }
 
-function createDailyWeatherFeedItem(
-	daily: DailyForecast,
-	index: number,
+function createDailyForecastFeedItem(
+	dailyForecasts: DailyForecast[],
 	timestamp: Date,
 	units: Units,
 	sourceId: string,
 ): WeatherFeedItem {
-	const signals: FeedItemSignals = {
-		urgency: adjustUrgencyForCondition(BASE_URGENCY.daily, daily.conditionCode),
-		timeRelevance: timeRelevanceForCondition(daily.conditionCode),
-	}
+	const days: DailyWeatherEntry[] = []
+	let totalUrgency = 0
+	let worstTimeRelevance: TimeRelevance = TimeRelevance.Ambient
 
-	return {
-		id: `weather-daily-${timestamp.getTime()}-${index}`,
-		sourceId,
-		type: WeatherFeedItemType.Daily,
-		timestamp,
-		data: {
+	for (const daily of dailyForecasts) {
+		days.push({
 			forecastDate: new Date(daily.forecastStart),
 			conditionCode: daily.conditionCode,
 			maxUvIndex: daily.maxUvIndex,
@@ -399,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,
 	}
 }