fix(tfl): handle near-1km boundary in formatDistance

Values like 0.9999km rounded to 1000m and displayed as
'1000m away'. Now converts to meters first and switches
to km format when rounded meters >= 1000.

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

.github/workflows/test.yml

@@ -21,4 +21,4 @@ jobs:
         run: bun install --frozen-lockfile
 
       - name: Run tests
-        run: bun test
+        run: bun run test

apps/aelis-backend/.env.example

@@ -7,6 +7,11 @@ BETTER_AUTH_SECRET=
 # Base URL of the backend
 BETTER_AUTH_URL=http://localhost:3000
 
+# OpenRouter (LLM feed enhancement)
+OPENROUTER_API_KEY=
+# Optional: override the default model (default: openai/gpt-4.1-mini)
+# OPENROUTER_MODEL=openai/gpt-4.1-mini
+
 # Apple WeatherKit credentials
 WEATHERKIT_PRIVATE_KEY=
 WEATHERKIT_KEY_ID=

apps/aelis-backend/package.json

@@ -10,9 +10,12 @@
 	},
 	"dependencies": {
 		"@aelis/core": "workspace:*",
+		"@aelis/source-caldav": "workspace:*",
+		"@aelis/source-google-calendar": "workspace:*",
 		"@aelis/source-location": "workspace:*",
 		"@aelis/source-tfl": "workspace:*",
 		"@aelis/source-weatherkit": "workspace:*",
+		"@openrouter/sdk": "^0.9.11",
 		"arktype": "^2.1.29",
 		"better-auth": "^1",
 		"hono": "^4",

apps/aelis-backend/src/auth/session-middleware.ts

@@ -61,7 +61,7 @@ export async function getSessionFromHeaders(
 }
 
 /**
- * Test-only middleware that injects a fake user and session.
+ * Dev/test middleware that injects a fake user and session.
  * Pass userId to simulate an authenticated request, or omit to get 401.
  */
 export function mockAuthSessionMiddleware(userId?: string): AuthSessionMiddleware {
@@ -69,8 +69,34 @@ export function mockAuthSessionMiddleware(userId?: string): AuthSessionMiddlewar
 		if (!userId) {
 			return c.json({ error: "Unauthorized" }, 401)
 		}
-		c.set("user", { id: userId } as AuthUser)
-		c.set("session", { id: "mock-session" } as AuthSession)
+
+		const now = new Date()
+		const expiresAt = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000)
+
+		const user: AuthUser = {
+			id: "k7Gx2mPqRvNwYs9TdLfA4bHcJeUo1iZn",
+			name: "Dev User",
+			email: "dev@aelis.local",
+			emailVerified: true,
+			image: null,
+			createdAt: now,
+			updatedAt: now,
+		}
+
+		const session: AuthSession = {
+			id: "Wt3FvBpXaQrMhD8sKjE6LcYn0gUz5iRo",
+			userId: "k7Gx2mPqRvNwYs9TdLfA4bHcJeUo1iZn",
+			token: "Vb9CxNfRm2KwQs7TjPeA5dLhYg0UoZi4",
+			expiresAt,
+			ipAddress: "127.0.0.1",
+			userAgent: "aelis-dev",
+			createdAt: now,
+			updatedAt: now,
+		}
+
+		c.set("user", user)
+		c.set("session", session)
+
 		await next()
 	}
 }

apps/aelis-backend/src/engine/http.test.ts

@@ -0,0 +1,313 @@
+import type { ActionDefinition, ContextEntry, FeedItem, FeedSource } from "@aelis/core"
+
+import { contextKey } from "@aelis/core"
+import { describe, expect, test } from "bun:test"
+import { Hono } from "hono"
+
+import { mockAuthSessionMiddleware } from "../auth/session-middleware.ts"
+import { UserSessionManager } from "../session/index.ts"
+import { registerFeedHttpHandlers } from "./http.ts"
+
+interface FeedResponse {
+	items: Array<{
+		id: string
+		type: string
+		priority: number
+		timestamp: string
+		data: Record<string, unknown>
+	}>
+	errors: Array<{ sourceId: string; error: string }>
+}
+
+function createStubSource(
+	id: string,
+	items: FeedItem[] = [],
+	contextEntries: readonly ContextEntry[] | null = null,
+): FeedSource {
+	return {
+		id,
+		async listActions(): Promise<Record<string, ActionDefinition>> {
+			return {}
+		},
+		async executeAction(): Promise<unknown> {
+			return undefined
+		},
+		async fetchContext(): Promise<readonly ContextEntry[] | null> {
+			return contextEntries
+		},
+		async fetchItems() {
+			return items
+		},
+	}
+}
+
+function buildTestApp(sessionManager: UserSessionManager, userId?: string) {
+	const app = new Hono()
+	registerFeedHttpHandlers(app, {
+		sessionManager,
+		authSessionMiddleware: mockAuthSessionMiddleware(userId),
+	})
+	return app
+}
+
+describe("GET /api/feed", () => {
+	test("returns 401 without auth", async () => {
+		const manager = new UserSessionManager({ providers: [] })
+		const app = buildTestApp(manager)
+
+		const res = await app.request("/api/feed")
+
+		expect(res.status).toBe(401)
+	})
+
+	test("returns cached feed when available", async () => {
+		const items: FeedItem[] = [
+			{
+				id: "item-1",
+				type: "test",
+				priority: 0.8,
+				timestamp: new Date("2025-01-01T00:00:00.000Z"),
+				data: { value: 42 },
+			},
+		]
+		const manager = new UserSessionManager({
+			providers: [() => createStubSource("test", items)],
+		})
+		const app = buildTestApp(manager, "user-1")
+
+		// Prime the cache
+		const session = manager.getOrCreate("user-1")
+		await session.engine.refresh()
+		expect(session.engine.lastFeed()).not.toBeNull()
+
+		const res = await app.request("/api/feed")
+
+		expect(res.status).toBe(200)
+		const body = (await res.json()) as FeedResponse
+		expect(body.items).toHaveLength(1)
+		expect(body.items[0]!.id).toBe("item-1")
+		expect(body.items[0]!.type).toBe("test")
+		expect(body.items[0]!.priority).toBe(0.8)
+		expect(body.items[0]!.timestamp).toBe("2025-01-01T00:00:00.000Z")
+		expect(body.errors).toHaveLength(0)
+	})
+
+	test("forces refresh when no cached feed", async () => {
+		const items: FeedItem[] = [
+			{
+				id: "fresh-1",
+				type: "test",
+				priority: 0.5,
+				timestamp: new Date("2025-06-01T12:00:00.000Z"),
+				data: { fresh: true },
+			},
+		]
+		const manager = new UserSessionManager({
+			providers: [() => createStubSource("test", items)],
+		})
+		const app = buildTestApp(manager, "user-1")
+
+		// No prior refresh — lastFeed() returns null, handler should call refresh()
+		const res = await app.request("/api/feed")
+
+		expect(res.status).toBe(200)
+		const body = (await res.json()) as FeedResponse
+		expect(body.items).toHaveLength(1)
+		expect(body.items[0]!.id).toBe("fresh-1")
+		expect(body.items[0]!.data.fresh).toBe(true)
+		expect(body.errors).toHaveLength(0)
+	})
+
+	test("serializes source errors as message strings", async () => {
+		const failingSource: FeedSource = {
+			id: "failing",
+			async listActions() {
+				return {}
+			},
+			async executeAction() {
+				return undefined
+			},
+			async fetchContext() {
+				return null
+			},
+			async fetchItems() {
+				throw new Error("connection timeout")
+			},
+		}
+		const manager = new UserSessionManager({ providers: [() => failingSource] })
+		const app = buildTestApp(manager, "user-1")
+
+		const res = await app.request("/api/feed")
+
+		expect(res.status).toBe(200)
+		const body = (await res.json()) as FeedResponse
+		expect(body.items).toHaveLength(0)
+		expect(body.errors).toHaveLength(1)
+		expect(body.errors[0]!.sourceId).toBe("failing")
+		expect(body.errors[0]!.error).toBe("connection timeout")
+	})
+})
+
+describe("GET /api/context", () => {
+	const weatherKey = contextKey("aelis.weather", "weather")
+	const weatherData = { temperature: 20, condition: "Clear" }
+	const contextEntries: readonly ContextEntry[] = [[weatherKey, weatherData]]
+
+	// The mock auth middleware always injects this hardcoded user ID
+	const mockUserId = "k7Gx2mPqRvNwYs9TdLfA4bHcJeUo1iZn"
+
+	function buildContextApp(userId?: string) {
+		const manager = new UserSessionManager({
+			providers: [() => createStubSource("weather", [], contextEntries)],
+		})
+		const app = buildTestApp(manager, userId)
+		const session = manager.getOrCreate(mockUserId)
+		return { app, session }
+	}
+
+	test("returns 401 without auth", async () => {
+		const manager = new UserSessionManager({ providers: [] })
+		const app = buildTestApp(manager)
+
+		const res = await app.request('/api/context?key=["aelis.weather","weather"]')
+
+		expect(res.status).toBe(401)
+	})
+
+	test("returns 400 when key param is missing", async () => {
+		const { app } = buildContextApp("user-1")
+
+		const res = await app.request("/api/context")
+
+		expect(res.status).toBe(400)
+		const body = (await res.json()) as { error: string }
+		expect(body.error).toContain("key")
+	})
+
+	test("returns 400 when key is invalid JSON", async () => {
+		const { app } = buildContextApp("user-1")
+
+		const res = await app.request("/api/context?key=notjson")
+
+		expect(res.status).toBe(400)
+		const body = (await res.json()) as { error: string }
+		expect(body.error).toContain("key")
+	})
+
+	test("returns 400 when key is not an array", async () => {
+		const { app } = buildContextApp("user-1")
+
+		const res = await app.request('/api/context?key="string"')
+
+		expect(res.status).toBe(400)
+		const body = (await res.json()) as { error: string }
+		expect(body.error).toContain("key")
+	})
+
+	test("returns 400 when key contains invalid element types", async () => {
+		const { app } = buildContextApp("user-1")
+
+		const res = await app.request("/api/context?key=[true,null,[1,2]]")
+
+		expect(res.status).toBe(400)
+		const body = (await res.json()) as { error: string }
+		expect(body.error).toContain("key")
+	})
+
+	test("returns 400 when key is an empty array", async () => {
+		const { app } = buildContextApp("user-1")
+
+		const res = await app.request("/api/context?key=[]")
+
+		expect(res.status).toBe(400)
+		const body = (await res.json()) as { error: string }
+		expect(body.error).toContain("key")
+	})
+
+	test("returns 400 when match param is invalid", async () => {
+		const { app } = buildContextApp("user-1")
+
+		const res = await app.request('/api/context?key=["aelis.weather"]&match=invalid')
+
+		expect(res.status).toBe(400)
+		const body = (await res.json()) as { error: string }
+		expect(body.error).toContain("match")
+	})
+
+	test("returns exact match with match=exact", async () => {
+		const { app, session } = buildContextApp("user-1")
+		await session.engine.refresh()
+
+		const res = await app.request('/api/context?key=["aelis.weather","weather"]&match=exact')
+
+		expect(res.status).toBe(200)
+		const body = (await res.json()) as { match: string; value: unknown }
+		expect(body.match).toBe("exact")
+		expect(body.value).toEqual(weatherData)
+	})
+
+	test("returns 404 with match=exact when only prefix would match", async () => {
+		const { app, session } = buildContextApp("user-1")
+		await session.engine.refresh()
+
+		const res = await app.request('/api/context?key=["aelis.weather"]&match=exact')
+
+		expect(res.status).toBe(404)
+	})
+
+	test("returns prefix match with match=prefix", async () => {
+		const { app, session } = buildContextApp("user-1")
+		await session.engine.refresh()
+
+		const res = await app.request('/api/context?key=["aelis.weather"]&match=prefix')
+
+		expect(res.status).toBe(200)
+		const body = (await res.json()) as {
+			match: string
+			entries: Array<{ key: unknown[]; value: unknown }>
+		}
+		expect(body.match).toBe("prefix")
+		expect(body.entries).toHaveLength(1)
+		expect(body.entries[0]!.key).toEqual(["aelis.weather", "weather"])
+		expect(body.entries[0]!.value).toEqual(weatherData)
+	})
+
+	test("default mode returns exact match when available", async () => {
+		const { app, session } = buildContextApp("user-1")
+		await session.engine.refresh()
+
+		const res = await app.request('/api/context?key=["aelis.weather","weather"]')
+
+		expect(res.status).toBe(200)
+		const body = (await res.json()) as { match: string; value: unknown }
+		expect(body.match).toBe("exact")
+		expect(body.value).toEqual(weatherData)
+	})
+
+	test("default mode falls back to prefix when no exact match", async () => {
+		const { app, session } = buildContextApp("user-1")
+		await session.engine.refresh()
+
+		const res = await app.request('/api/context?key=["aelis.weather"]')
+
+		expect(res.status).toBe(200)
+		const body = (await res.json()) as {
+			match: string
+			entries: Array<{ key: unknown[]; value: unknown }>
+		}
+		expect(body.match).toBe("prefix")
+		expect(body.entries).toHaveLength(1)
+		expect(body.entries[0]!.value).toEqual(weatherData)
+	})
+
+	test("returns 404 when neither exact nor prefix matches", async () => {
+		const { app, session } = buildContextApp("user-1")
+		await session.engine.refresh()
+
+		const res = await app.request('/api/context?key=["nonexistent"]')
+
+		expect(res.status).toBe(404)
+		const body = (await res.json()) as { error: string }
+		expect(body.error).toBe("Context key not found")
+	})
+})

apps/aelis-backend/src/engine/http.ts

@@ -0,0 +1,118 @@
+import type { Context, Hono } from "hono"
+
+import { contextKey } from "@aelis/core"
+import { createMiddleware } from "hono/factory"
+
+import type { AuthSessionMiddleware } from "../auth/session-middleware.ts"
+import type { UserSessionManager } from "../session/index.ts"
+
+type Env = {
+	Variables: {
+		sessionManager: UserSessionManager
+	}
+}
+
+interface FeedHttpHandlersDeps {
+	sessionManager: UserSessionManager
+	authSessionMiddleware: AuthSessionMiddleware
+}
+
+export function registerFeedHttpHandlers(
+	app: Hono,
+	{ sessionManager, authSessionMiddleware }: FeedHttpHandlersDeps,
+) {
+	const inject = createMiddleware<Env>(async (c, next) => {
+		c.set("sessionManager", sessionManager)
+		await next()
+	})
+
+	app.get("/api/feed", inject, authSessionMiddleware, handleGetFeed)
+	app.get("/api/context", inject, authSessionMiddleware, handleGetContext)
+}
+
+async function handleGetFeed(c: Context<Env>) {
+	const user = c.get("user")!
+	const sessionManager = c.get("sessionManager")
+	const session = sessionManager.getOrCreate(user.id)
+
+	const feed = await session.feed()
+
+	return c.json({
+		items: feed.items,
+		errors: feed.errors.map((e) => ({
+			sourceId: e.sourceId,
+			error: e.error.message,
+		})),
+	})
+}
+
+function handleGetContext(c: Context<Env>) {
+	const keyParam = c.req.query("key")
+	if (!keyParam) {
+		return c.json({ error: 'Invalid or missing "key" parameter: must be a JSON array' }, 400)
+	}
+
+	let parsed: unknown
+	try {
+		parsed = JSON.parse(keyParam)
+	} catch {
+		return c.json({ error: 'Invalid or missing "key" parameter: must be a JSON array' }, 400)
+	}
+
+	if (!Array.isArray(parsed) || parsed.length === 0 || !parsed.every(isContextKeyPart)) {
+		return c.json({ error: 'Invalid or missing "key" parameter: must be a JSON array' }, 400)
+	}
+
+	const matchParam = c.req.query("match")
+	if (matchParam !== undefined && matchParam !== "exact" && matchParam !== "prefix") {
+		return c.json({ error: 'Invalid "match" parameter: must be "exact" or "prefix"' }, 400)
+	}
+
+	const user = c.get("user")!
+	const sessionManager = c.get("sessionManager")
+	const session = sessionManager.getOrCreate(user.id)
+	const context = session.engine.currentContext()
+	const key = contextKey(...parsed)
+
+	if (matchParam === "exact") {
+		const value = context.get(key)
+		if (value === undefined) {
+			return c.json({ error: "Context key not found" }, 404)
+		}
+		return c.json({ match: "exact", value })
+	}
+
+	if (matchParam === "prefix") {
+		const entries = context.find(key)
+		if (entries.length === 0) {
+			return c.json({ error: "Context key not found" }, 404)
+		}
+		return c.json({ match: "prefix", entries })
+	}
+
+	// Default: single find() covers both exact and prefix matches
+	const entries = context.find(key)
+	if (entries.length === 0) {
+		return c.json({ error: "Context key not found" }, 404)
+	}
+
+	// If exactly one result with the same key length, treat as exact match
+	if (entries.length === 1 && entries[0]!.key.length === parsed.length) {
+		return c.json({ match: "exact", value: entries[0]!.value })
+	}
+
+	return c.json({ match: "prefix", entries })
+}
+
+/** Validates that a value is a valid ContextKeyPart (string, number, or plain object of primitives). */
+function isContextKeyPart(value: unknown): boolean {
+	if (typeof value === "string" || typeof value === "number") {
+		return true
+	}
+	if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+		return Object.values(value).every(
+			(v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean",
+		)
+	}
+	return false
+}

apps/aelis-backend/src/enhancement/enhance-feed.ts

@@ -0,0 +1,51 @@
+import type { FeedItem } from "@aelis/core"
+
+import type { LlmClient } from "./llm-client.ts"
+
+import { mergeEnhancement } from "./merge.ts"
+import { buildPrompt, hasUnfilledSlots } from "./prompt-builder.ts"
+
+/** Takes feed items, returns enhanced feed items. */
+export type FeedEnhancer = (items: FeedItem[]) => Promise<FeedItem[]>
+
+export interface FeedEnhancerConfig {
+	client: LlmClient
+	/** Defaults to Date.now — override for testing */
+	clock?: () => Date
+}
+
+/**
+ * Creates a FeedEnhancer that uses the provided LlmClient.
+ *
+ * Skips the LLM call when no items have unfilled slots.
+ * Returns items unchanged on LLM failure.
+ */
+export function createFeedEnhancer(config: FeedEnhancerConfig): FeedEnhancer {
+	const { client } = config
+	const clock = config.clock ?? (() => new Date())
+
+	return async function enhanceFeed(items) {
+		if (!hasUnfilledSlots(items)) {
+			return items
+		}
+
+		const currentTime = clock()
+		const { systemPrompt, userMessage } = buildPrompt(items, currentTime)
+
+		let result
+		try {
+			result = await client.enhance({ systemPrompt, userMessage })
+		} catch (err) {
+			console.error("[enhancement] LLM call failed:", err)
+			result = null
+		}
+
+		if (!result) {
+			return items
+		}
+
+		return mergeEnhancement(items, result, currentTime)
+	}
+}
+
+

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

@@ -0,0 +1,71 @@
+import { OpenRouter } from "@openrouter/sdk"
+
+import type { EnhancementResult } from "./schema.ts"
+
+import { enhancementResultJsonSchema, parseEnhancementResult } from "./schema.ts"
+
+const DEFAULT_MODEL = "openai/gpt-4.1-mini"
+const DEFAULT_TIMEOUT_MS = 30_000
+
+export interface LlmClientConfig {
+	apiKey: string
+	model?: string
+	timeoutMs?: number
+}
+
+export interface LlmClientRequest {
+	systemPrompt: string
+	userMessage: string
+}
+
+export interface LlmClient {
+	enhance(request: LlmClientRequest): Promise<EnhancementResult | null>
+}
+
+/**
+ * Creates a reusable LLM client backed by OpenRouter.
+ * The OpenRouter SDK instance is created once and reused across calls.
+ */
+export function createLlmClient(config: LlmClientConfig): LlmClient {
+	const client = new OpenRouter({
+		apiKey: config.apiKey,
+		timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+	})
+	const model = config.model ?? DEFAULT_MODEL
+
+	return {
+		async enhance(request) {
+			const response = await client.chat.send({
+				chatGenerationParams: {
+					model,
+					messages: [
+						{ role: "system" as const, content: request.systemPrompt },
+						{ role: "user" as const, content: request.userMessage },
+					],
+					responseFormat: {
+						type: "json_schema" as const,
+						jsonSchema: {
+							name: "enhancement_result",
+							strict: true,
+							schema: enhancementResultJsonSchema,
+						},
+					},
+					stream: false,
+				},
+			})
+
+			const content = response.choices?.[0]?.message?.content
+			if (typeof content !== "string") {
+				console.warn("[enhancement] LLM returned no content in response")
+				return null
+			}
+
+			const result = parseEnhancementResult(content)
+			if (!result) {
+				console.warn("[enhancement] Failed to parse LLM response:", content)
+			}
+
+			return result
+		},
+	}
+}

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

@@ -0,0 +1,150 @@
+import type { FeedItem } from "@aelis/core"
+
+import { describe, expect, test } from "bun:test"
+
+import type { EnhancementResult } from "./schema.ts"
+
+import { mergeEnhancement } from "./merge.ts"
+
+function makeItem(overrides: Partial<FeedItem> = {}): FeedItem {
+	return {
+		id: "item-1",
+		type: "test",
+		timestamp: new Date("2025-01-01T00:00:00Z"),
+		data: { value: 42 },
+		...overrides,
+	}
+}
+
+const now = new Date("2025-06-01T12:00:00Z")
+
+describe("mergeEnhancement", () => {
+	test("fills matching slots", () => {
+		const item = makeItem({
+			slots: {
+				insight: { description: "Weather insight", content: null },
+			},
+		})
+		const result: EnhancementResult = {
+			slotFills: {
+				"item-1": { insight: "Rain after 3pm" },
+			},
+			syntheticItems: [],
+		}
+
+		const merged = mergeEnhancement([item], result, now)
+
+		expect(merged).toHaveLength(1)
+		expect(merged[0]!.slots!.insight!.content).toBe("Rain after 3pm")
+		// Description preserved
+		expect(merged[0]!.slots!.insight!.description).toBe("Weather insight")
+	})
+
+	test("does not mutate original items", () => {
+		const item = makeItem({
+			slots: {
+				insight: { description: "test", content: null },
+			},
+		})
+		const result: EnhancementResult = {
+			slotFills: { "item-1": { insight: "filled" } },
+			syntheticItems: [],
+		}
+
+		mergeEnhancement([item], result, now)
+
+		expect(item.slots!.insight!.content).toBeNull()
+	})
+
+	test("ignores fills for non-existent items", () => {
+		const item = makeItem()
+		const result: EnhancementResult = {
+			slotFills: { "non-existent": { insight: "text" } },
+			syntheticItems: [],
+		}
+
+		const merged = mergeEnhancement([item], result, now)
+
+		expect(merged).toHaveLength(1)
+		expect(merged[0]!.id).toBe("item-1")
+	})
+
+	test("ignores fills for non-existent slots", () => {
+		const item = makeItem({
+			slots: {
+				insight: { description: "test", content: null },
+			},
+		})
+		const result: EnhancementResult = {
+			slotFills: { "item-1": { "non-existent-slot": "text" } },
+			syntheticItems: [],
+		}
+
+		const merged = mergeEnhancement([item], result, now)
+
+		expect(merged[0]!.slots!.insight!.content).toBeNull()
+	})
+
+	test("skips null fills", () => {
+		const item = makeItem({
+			slots: {
+				insight: { description: "test", content: null },
+			},
+		})
+		const result: EnhancementResult = {
+			slotFills: { "item-1": { insight: null } },
+			syntheticItems: [],
+		}
+
+		const merged = mergeEnhancement([item], result, now)
+
+		expect(merged[0]!.slots!.insight!.content).toBeNull()
+	})
+
+	test("passes through items without slots unchanged", () => {
+		const item = makeItem()
+		const result: EnhancementResult = {
+			slotFills: {},
+			syntheticItems: [],
+		}
+
+		const merged = mergeEnhancement([item], result, now)
+
+		expect(merged[0]).toBe(item)
+	})
+
+	test("appends synthetic items with backfilled fields", () => {
+		const item = makeItem()
+		const result: EnhancementResult = {
+			slotFills: {},
+			syntheticItems: [
+				{
+					id: "briefing-morning",
+					type: "briefing",
+					text: "Light afternoon ahead.",
+				},
+			],
+		}
+
+		const merged = mergeEnhancement([item], result, now)
+
+		expect(merged).toHaveLength(2)
+		expect(merged[1]!.id).toBe("briefing-morning")
+		expect(merged[1]!.type).toBe("briefing")
+		expect(merged[1]!.timestamp).toEqual(now)
+		expect(merged[1]!.data).toEqual({ text: "Light afternoon ahead." })
+	})
+
+	test("handles empty enhancement result", () => {
+		const item = makeItem()
+		const result: EnhancementResult = {
+			slotFills: {},
+			syntheticItems: [],
+		}
+
+		const merged = mergeEnhancement([item], result, now)
+
+		expect(merged).toHaveLength(1)
+		expect(merged[0]).toBe(item)
+	})
+})

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

@@ -0,0 +1,41 @@
+import type { FeedItem } from "@aelis/core"
+
+import type { EnhancementResult } from "./schema.ts"
+
+/**
+ * Merges an EnhancementResult into feed items.
+ *
+ * - Writes slot content from slotFills into matching items
+ * - Appends synthetic items to the list
+ * - Returns a new array (no mutation)
+ * - Ignores fills for items/slots that don't exist
+ */
+export function mergeEnhancement(items: FeedItem[], result: EnhancementResult, currentTime: Date): FeedItem[] {
+	const merged = items.map((item) => {
+		const fills = result.slotFills[item.id]
+		if (!fills || !item.slots) return item
+
+		const mergedSlots = { ...item.slots }
+		let changed = false
+
+		for (const [slotName, content] of Object.entries(fills)) {
+			if (slotName in mergedSlots && content !== null) {
+				mergedSlots[slotName] = { ...mergedSlots[slotName]!, content }
+				changed = true
+			}
+		}
+
+		return changed ? { ...item, slots: mergedSlots } : item
+	})
+
+	for (const synthetic of result.syntheticItems) {
+		merged.push({
+			id: synthetic.id,
+			type: synthetic.type,
+			timestamp: currentTime,
+			data: { text: synthetic.text },
+		})
+	}
+
+	return merged
+}

apps/aelis-backend/src/enhancement/prompt-builder.test.ts

@@ -0,0 +1,167 @@
+import type { FeedItem } from "@aelis/core"
+
+import { describe, expect, test } from "bun:test"
+
+import { buildPrompt, hasUnfilledSlots } from "./prompt-builder.ts"
+
+function makeItem(overrides: Partial<FeedItem> = {}): FeedItem {
+	return {
+		id: "item-1",
+		type: "test",
+		timestamp: new Date("2025-01-01T00:00:00Z"),
+		data: { value: 42 },
+		...overrides,
+	}
+}
+
+function parseUserMessage(userMessage: string): Record<string, unknown> {
+	return JSON.parse(userMessage)
+}
+
+describe("hasUnfilledSlots", () => {
+	test("returns false for items without slots", () => {
+		expect(hasUnfilledSlots([makeItem()])).toBe(false)
+	})
+
+	test("returns false for items with all slots filled", () => {
+		const item = makeItem({
+			slots: {
+				insight: { description: "test", content: "filled" },
+			},
+		})
+		expect(hasUnfilledSlots([item])).toBe(false)
+	})
+
+	test("returns true when at least one slot is unfilled", () => {
+		const item = makeItem({
+			slots: {
+				insight: { description: "test", content: null },
+			},
+		})
+		expect(hasUnfilledSlots([item])).toBe(true)
+	})
+
+	test("returns false for empty array", () => {
+		expect(hasUnfilledSlots([])).toBe(false)
+	})
+})
+
+describe("buildPrompt", () => {
+	test("puts items with unfilled slots in items", () => {
+		const item = makeItem({
+			slots: {
+				insight: { description: "Weather insight", content: null },
+				filled: { description: "Already done", content: "done" },
+			},
+		})
+
+		const { userMessage } = buildPrompt([item], new Date("2025-06-01T12:00:00Z"))
+		const parsed = parseUserMessage(userMessage)
+
+		expect(parsed.items).toHaveLength(1)
+		expect((parsed.items as Array<Record<string, unknown>>)[0]!.id).toBe("item-1")
+		expect((parsed.items as Array<Record<string, unknown>>)[0]!.slots).toEqual({ insight: "Weather insight" })
+		expect((parsed.items as Array<Record<string, unknown>>)[0]!.type).toBeUndefined()
+		expect(parsed.context).toHaveLength(0)
+	})
+
+	test("puts slotless items in context", () => {
+		const withSlots = makeItem({
+			id: "with-slots",
+			slots: { insight: { description: "test", content: null } },
+		})
+		const withoutSlots = makeItem({ id: "no-slots" })
+
+		const { userMessage } = buildPrompt([withSlots, withoutSlots], new Date("2025-06-01T12:00:00Z"))
+		const parsed = parseUserMessage(userMessage)
+
+		expect(parsed.items).toHaveLength(1)
+		expect((parsed.items as Array<Record<string, unknown>>)[0]!.id).toBe("with-slots")
+		expect(parsed.context).toHaveLength(1)
+		expect((parsed.context as Array<Record<string, unknown>>)[0]!.id).toBe("no-slots")
+	})
+
+	test("includes time in ISO format", () => {
+		const { userMessage } = buildPrompt([], new Date("2025-06-01T12:00:00Z"))
+		const parsed = parseUserMessage(userMessage)
+
+		expect(parsed.time).toBe("2025-06-01T12:00:00.000Z")
+	})
+
+	test("system prompt is non-empty", () => {
+		const { systemPrompt } = buildPrompt([], new Date())
+		expect(systemPrompt.length).toBeGreaterThan(0)
+	})
+
+	test("includes schedule in system prompt", () => {
+		const calEvent = makeItem({
+			id: "cal-1",
+			type: "caldav-event",
+			data: {
+				title: "Team standup",
+				startDate: "2025-06-01T10:00:00Z",
+				endDate: "2025-06-01T10:30:00Z",
+				isAllDay: false,
+				location: null,
+			},
+			slots: {
+				insight: { description: "test", content: null },
+			},
+		})
+
+		const { systemPrompt } = buildPrompt([calEvent], new Date("2025-06-01T12:00:00Z"))
+
+		expect(systemPrompt).toContain("Schedule:\n")
+		expect(systemPrompt).toContain("Team standup")
+		expect(systemPrompt).toContain("10:00")
+	})
+
+	test("includes location in schedule", () => {
+		const calEvent = makeItem({
+			id: "cal-1",
+			type: "caldav-event",
+			data: {
+				title: "Therapy",
+				startDate: "2025-06-02T18:00:00Z",
+				endDate: "2025-06-02T19:00:00Z",
+				isAllDay: false,
+				location: "92 Tooley Street, London",
+			},
+		})
+
+		const { systemPrompt } = buildPrompt([calEvent], new Date("2025-06-01T12:00:00Z"))
+
+		expect(systemPrompt).toContain("Therapy @ 92 Tooley Street, London")
+	})
+
+	test("includes week calendar but omits schedule when no calendar items", () => {
+		const weatherItem = makeItem({
+			type: "weather-current",
+			data: { temperature: 14 },
+		})
+
+		const { systemPrompt } = buildPrompt([weatherItem], new Date("2025-06-01T12:00:00Z"))
+
+		expect(systemPrompt).toContain("Week:")
+		expect(systemPrompt).not.toContain("Schedule:")
+	})
+
+	test("user message is pure JSON", () => {
+		const calEvent = makeItem({
+			id: "cal-1",
+			type: "caldav-event",
+			data: {
+				title: "Budget Review",
+				startTime: "2025-06-01T14:00:00Z",
+				endTime: "2025-06-01T15:00:00Z",
+				isAllDay: false,
+				location: "https://meet.google.com/abc",
+			},
+		})
+
+		const { userMessage } = buildPrompt([calEvent], new Date("2025-06-01T12:00:00Z"))
+
+		expect(userMessage.startsWith("{")).toBe(true)
+		expect(() => JSON.parse(userMessage)).not.toThrow()
+	})
+})

apps/aelis-backend/src/enhancement/prompt-builder.ts

@@ -0,0 +1,218 @@
+import type { FeedItem } from "@aelis/core"
+
+import { CalDavFeedItemType } from "@aelis/source-caldav"
+import { CalendarFeedItemType } from "@aelis/source-google-calendar"
+
+import systemPromptBase from "./prompts/system.txt"
+
+const CALENDAR_ITEM_TYPES = new Set<string>([
+	CalDavFeedItemType.Event,
+	CalendarFeedItemType.Event,
+	CalendarFeedItemType.AllDay,
+])
+
+/**
+ * Builds the system prompt and user message for the enhancement harness.
+ *
+ * Includes a pre-computed mini calendar so the LLM doesn't have to
+ * parse timestamps to understand the user's schedule.
+ */
+export function buildPrompt(
+	items: FeedItem[],
+	currentTime: Date,
+): { systemPrompt: string; userMessage: string } {
+	const schedule = buildSchedule(items, currentTime)
+
+	const enhanceItems: Array<{
+		id: string
+		data: Record<string, unknown>
+		slots: Record<string, string>
+	}> = []
+	const contextItems: Array<{
+		id: string
+		type: string
+		data: Record<string, unknown>
+	}> = []
+
+	for (const item of items) {
+		const hasUnfilledSlots =
+			item.slots &&
+			Object.values(item.slots).some((slot) => slot.content === null)
+
+		if (hasUnfilledSlots) {
+			enhanceItems.push({
+				id: item.id,
+				data: item.data,
+				slots: Object.fromEntries(
+					Object.entries(item.slots!)
+						.filter(([, slot]) => slot.content === null)
+						.map(([name, slot]) => [name, slot.description]),
+				),
+			})
+		} else {
+			contextItems.push({
+				id: item.id,
+				type: item.type,
+				data: item.data,
+			})
+		}
+	}
+
+	const userMessage = JSON.stringify({
+		time: currentTime.toISOString(),
+		items: enhanceItems,
+		context: contextItems,
+	})
+
+	const weekCalendar = buildWeekCalendar(currentTime)
+	let systemPrompt = systemPromptBase
+	systemPrompt += `\n\nWeek:\n${weekCalendar}`
+	if (schedule) {
+		systemPrompt += `\n\nSchedule:\n${schedule}`
+	}
+
+	return { systemPrompt, userMessage }
+}
+
+/**
+ * Returns true if any item has at least one unfilled slot.
+ */
+export function hasUnfilledSlots(items: FeedItem[]): boolean {
+	return items.some(
+		(item) =>
+			item.slots &&
+			Object.values(item.slots).some((slot) => slot.content === null),
+	)
+}
+
+// -- Helpers --
+
+interface CalendarEntry {
+	date: Date
+	title: string
+	location: string | null
+	isAllDay: boolean
+	startTime: Date
+	endTime: Date
+}
+
+function toValidDate(value: unknown): Date | null {
+	if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value
+	if (typeof value === "string" || typeof value === "number") {
+		const date = new Date(value)
+		return Number.isNaN(date.getTime()) ? null : date
+	}
+	return null
+}
+
+function extractCalendarEntry(item: FeedItem): CalendarEntry | null {
+	if (!CALENDAR_ITEM_TYPES.has(item.type)) return null
+
+	const d = item.data
+	const title = d.title
+	if (typeof title !== "string" || !title) return null
+
+	// CalDAV uses startDate/endDate, Google Calendar uses startTime/endTime
+	const startTime = toValidDate(d.startDate ?? d.startTime)
+	if (!startTime) return null
+
+	const endTime = toValidDate(d.endDate ?? d.endTime) ?? startTime
+
+	return {
+		date: startTime,
+		title,
+		location: typeof d.location === "string" ? d.location : null,
+		isAllDay: typeof d.isAllDay === "boolean" ? d.isAllDay : false,
+		startTime,
+		endTime,
+	}
+}
+
+const DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"] as const
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] as const
+
+function pad2(n: number): string {
+	return n.toString().padStart(2, "0")
+}
+
+function formatTime(date: Date): string {
+	return `${pad2(date.getUTCHours())}:${pad2(date.getUTCMinutes())}`
+}
+
+function formatDayShort(date: Date): string {
+	return `${DAYS[date.getUTCDay()]}, ${date.getUTCDate()} ${MONTHS[date.getUTCMonth()]}`
+}
+
+function formatDayLabel(date: Date, currentTime: Date): string {
+	const currentDay = Date.UTC(currentTime.getUTCFullYear(), currentTime.getUTCMonth(), currentTime.getUTCDate())
+	const targetDay = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate())
+	const diffDays = Math.round((targetDay - currentDay) / (1000 * 60 * 60 * 24))
+
+	const dayName = formatDayShort(date)
+
+	if (diffDays === 0) return `Today: ${dayName}`
+	if (diffDays === 1) return `Tomorrow: ${dayName}`
+	return dayName
+}
+
+/**
+ * Builds a week overview mapping day names to dates,
+ * so the LLM can easily match ISO timestamps to days.
+ */
+function buildWeekCalendar(currentTime: Date): string {
+	const lines: string[] = []
+	for (let i = 0; i < 7; i++) {
+		const date = new Date(currentTime)
+		date.setUTCDate(date.getUTCDate() + i)
+		const label = i === 0 ? "Today" : i === 1 ? "Tomorrow" : ""
+		const dayStr = formatDayShort(date)
+		const iso = date.toISOString().slice(0, 10)
+		const prefix = label ? `${label}: ` : ""
+		lines.push(`${prefix}${dayStr} = ${iso}`)
+	}
+	return lines.join("\n")
+}
+
+/**
+ * Builds a compact text calendar from all calendar-type items.
+ * Groups events by day relative to currentTime.
+ */
+function buildSchedule(items: FeedItem[], currentTime: Date): string {
+	const entries: CalendarEntry[] = []
+	for (const item of items) {
+		const entry = extractCalendarEntry(item)
+		if (entry) entries.push(entry)
+	}
+
+	if (entries.length === 0) return ""
+
+	entries.sort((a, b) => a.startTime.getTime() - b.startTime.getTime())
+
+	const byDay = new Map<string, CalendarEntry[]>()
+	for (const entry of entries) {
+		const key = entry.date.toISOString().slice(0, 10)
+		const group = byDay.get(key)
+		if (group) {
+			group.push(entry)
+		} else {
+			byDay.set(key, [entry])
+		}
+	}
+
+	const lines: string[] = []
+	for (const [, dayEntries] of byDay) {
+		lines.push(formatDayLabel(dayEntries[0]!.startTime, currentTime))
+		for (const entry of dayEntries) {
+			if (entry.isAllDay) {
+				const loc = entry.location ? ` @ ${entry.location}` : ""
+				lines.push(`  all day  ${entry.title}${loc}`)
+			} else {
+				const timeRange = `${formatTime(entry.startTime)}–${formatTime(entry.endTime)}`
+				const loc = entry.location ? ` @ ${entry.location}` : ""
+				lines.push(`  ${timeRange}  ${entry.title}${loc}`)
+			}
+		}
+	}
+
+	return lines.join("\n")
+}

apps/aelis-backend/src/enhancement/prompts/system.txt

@@ -0,0 +1,21 @@
+You are AELIS, a personal assistant. You enhance a user's feed by filling slots and optionally generating synthetic items.
+
+The user message is a JSON object with:
+- "items": feed items with data and named slots to fill. Each slot has a description of what to write.
+- "context": other feed items (no slots) for cross-source reasoning.
+- "time": current ISO timestamp.
+
+Your output has two fields:
+- "slotFills": map of item ID → slot name → short text (or null if you can't fill it or cannot provide answer). Each item ID appears ONCE with ALL its slots in a single object.
+- "syntheticItems": array of { id, type, text } for new items (briefings, nudges, insights). Only when genuinely useful and when not redundant.
+
+Rules:
+- DO NOT USE EMDASH OR DASH OR ATTEMPT TO USE SYMBOLS TO CIRCUMVENT THIS RULE.
+- One sentence per slot. Two max if absolutely necessary. Be direct.
+- Say "I" not "we."
+- Hedge when inferring. Don't state guesses as facts.
+- Use the week and schedule below to understand when events happen. Match weather data to the correct date.
+- Look for connections across items.
+- Don't pad — return null for slots you can't meaningfully fill, and skip synthetic items if there's nothing useful to add.
+- Never fabricate information not present in the feed. If you don't have data to support a fill, return null.
+- Read each slot's description carefully — it defines when to return null.

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

@@ -0,0 +1,176 @@
+import { describe, expect, test } from "bun:test"
+
+import {
+	emptyEnhancementResult,
+	enhancementResultJsonSchema,
+	parseEnhancementResult,
+} from "./schema.ts"
+
+describe("parseEnhancementResult", () => {
+	test("parses valid result", () => {
+		const input = JSON.stringify({
+			slotFills: {
+				"weather-1": {
+					insight: "Rain after 3pm",
+					"cross-source": null,
+				},
+			},
+			syntheticItems: [
+				{
+					id: "briefing-morning",
+					type: "briefing",
+					text: "Light afternoon ahead.",
+				},
+			],
+		})
+
+		const result = parseEnhancementResult(input)
+
+		expect(result).not.toBeNull()
+		expect(result!.slotFills["weather-1"]!.insight).toBe("Rain after 3pm")
+		expect(result!.slotFills["weather-1"]!["cross-source"]).toBeNull()
+		expect(result!.syntheticItems).toHaveLength(1)
+		expect(result!.syntheticItems[0]!.id).toBe("briefing-morning")
+		expect(result!.syntheticItems[0]!.text).toBe("Light afternoon ahead.")
+	})
+
+	test("parses empty result", () => {
+		const input = JSON.stringify({
+			slotFills: {},
+			syntheticItems: [],
+		})
+
+		const result = parseEnhancementResult(input)
+
+		expect(result).not.toBeNull()
+		expect(Object.keys(result!.slotFills)).toHaveLength(0)
+		expect(result!.syntheticItems).toHaveLength(0)
+	})
+
+	test("returns null for invalid JSON", () => {
+		expect(parseEnhancementResult("not json")).toBeNull()
+	})
+
+	test("returns null for non-object", () => {
+		expect(parseEnhancementResult('"hello"')).toBeNull()
+		expect(parseEnhancementResult("42")).toBeNull()
+		expect(parseEnhancementResult("null")).toBeNull()
+	})
+
+	test("returns null when slotFills is missing", () => {
+		const input = JSON.stringify({ syntheticItems: [] })
+		expect(parseEnhancementResult(input)).toBeNull()
+	})
+
+	test("returns null when syntheticItems is missing", () => {
+		const input = JSON.stringify({ slotFills: {} })
+		expect(parseEnhancementResult(input)).toBeNull()
+	})
+
+	test("returns null when slotFills has non-string values", () => {
+		const input = JSON.stringify({
+			slotFills: { "item-1": { slot: 42 } },
+			syntheticItems: [],
+		})
+		expect(parseEnhancementResult(input)).toBeNull()
+	})
+
+	test("returns null when syntheticItem is missing required fields", () => {
+		const input = JSON.stringify({
+			slotFills: {},
+			syntheticItems: [{ id: "x" }],
+		})
+		expect(parseEnhancementResult(input)).toBeNull()
+	})
+})
+
+describe("emptyEnhancementResult", () => {
+	test("returns empty slotFills and syntheticItems", () => {
+		const result = emptyEnhancementResult()
+		expect(result.slotFills).toEqual({})
+		expect(result.syntheticItems).toEqual([])
+	})
+})
+
+describe("schema sync", () => {
+	const referencePayloads = [
+		{
+			name: "full payload with null slot fill",
+			payload: {
+				slotFills: {
+					"weather-1": { insight: "Rain after 3pm", crossSource: null },
+					"cal-2": { summary: "Busy morning" },
+				},
+				syntheticItems: [
+					{ id: "briefing-morning", type: "briefing", text: "Light day ahead." },
+					{ id: "nudge-umbrella", type: "nudge", text: "Bring an umbrella." },
+				],
+			},
+		},
+		{
+			name: "empty collections",
+			payload: { slotFills: {}, syntheticItems: [] },
+		},
+		{
+			name: "slot fills only",
+			payload: {
+				slotFills: { "item-1": { slot: "filled" } },
+				syntheticItems: [],
+			},
+		},
+		{
+			name: "synthetic items only",
+			payload: {
+				slotFills: {},
+				syntheticItems: [{ id: "insight-1", type: "insight", text: "Something." }],
+			},
+		},
+	]
+
+	for (const { name, payload } of referencePayloads) {
+		test(`arktype and JSON Schema agree on: ${name}`, () => {
+			// arktype accepts it
+			const parsed = parseEnhancementResult(JSON.stringify(payload))
+			expect(parsed).not.toBeNull()
+
+			// JSON Schema structure matches
+			const jsonSchema = enhancementResultJsonSchema
+			expect(Object.keys(jsonSchema.properties).sort()).toEqual(
+				Object.keys(payload).sort(),
+			)
+			expect([...jsonSchema.required].sort()).toEqual(Object.keys(payload).sort())
+
+			// syntheticItems item schema has the right required fields
+			const itemSchema = jsonSchema.properties.syntheticItems.items
+			expect([...itemSchema.required].sort()).toEqual(["id", "text", "type"])
+
+			// Verify each synthetic item has exactly the fields the JSON Schema expects
+			for (const item of payload.syntheticItems) {
+				expect(Object.keys(item).sort()).toEqual([...itemSchema.required].sort())
+			}
+		})
+	}
+
+	test("JSON Schema rejects what arktype rejects: missing required field", () => {
+		// Missing syntheticItems
+		expect(parseEnhancementResult(JSON.stringify({ slotFills: {} }))).toBeNull()
+
+		// JSON Schema also requires it
+		expect(enhancementResultJsonSchema.required).toContain("syntheticItems")
+	})
+
+	test("JSON Schema rejects what arktype rejects: wrong slot fill value type", () => {
+		const bad = { slotFills: { "item-1": { slot: 42 } }, syntheticItems: [] }
+
+		// arktype rejects it
+		expect(parseEnhancementResult(JSON.stringify(bad))).toBeNull()
+
+		// JSON Schema only allows string or null for slot values
+		const slotValueTypes =
+			enhancementResultJsonSchema.properties.slotFills.additionalProperties
+				.additionalProperties.type
+		expect(slotValueTypes).toContain("string")
+		expect(slotValueTypes).toContain("null")
+		expect(slotValueTypes).not.toContain("number")
+	})
+})

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

@@ -0,0 +1,89 @@
+import { type } from "arktype"
+
+const SyntheticItem = type({
+	id: "string",
+	type: "string",
+	text: "string",
+})
+
+const EnhancementResult = type({
+	slotFills: "Record<string, Record<string, string | null>>",
+	syntheticItems: SyntheticItem.array(),
+})
+
+export type SyntheticItem = typeof SyntheticItem.infer
+export type EnhancementResult = typeof EnhancementResult.infer
+
+/**
+ * JSON Schema passed to OpenRouter's structured output.
+ * OpenRouter doesn't support arktype, so this is maintained separately.
+ *
+ * ⚠️  Must stay in sync with EnhancementResult above.
+ * If you add/remove fields, update both schemas.
+ */
+export const enhancementResultJsonSchema = {
+	type: "object",
+	properties: {
+		slotFills: {
+			type: "object",
+			description:
+				"Map of feed item ID to an object of slot name to filled text content. Use null for slots that cannot be meaningfully filled.",
+			additionalProperties: {
+				type: "object",
+				additionalProperties: {
+					type: ["string", "null"],
+				},
+			},
+		},
+		syntheticItems: {
+			type: "array",
+			description:
+				"New feed items to inject (briefings, nudges, cross-source insights). Keep these short and actionable.",
+			items: {
+				type: "object",
+				properties: {
+					id: {
+						type: "string",
+						description: "Unique ID, e.g. 'briefing-morning'",
+					},
+					type: {
+						type: "string",
+						description: "One of: 'briefing', 'nudge', 'insight'",
+					},
+					text: {
+						type: "string",
+						description: "Display text, 1-3 sentences",
+					},
+				},
+				required: ["id", "type", "text"],
+				additionalProperties: false,
+			},
+		},
+	},
+	required: ["slotFills", "syntheticItems"],
+	additionalProperties: false,
+} as const
+
+/**
+ * Parses a JSON string into an EnhancementResult.
+ * Returns null if the input is malformed.
+ */
+export function parseEnhancementResult(json: string): EnhancementResult | null {
+	let parsed: unknown
+	try {
+		parsed = JSON.parse(json)
+	} catch {
+		return null
+	}
+
+	const result = EnhancementResult(parsed)
+	if (result instanceof type.errors) {
+		return null
+	}
+
+	return result
+}
+
+export function emptyEnhancementResult(): EnhancementResult {
+	return { slotFills: {}, syntheticItems: [] }
+}

apps/aelis-backend/src/feed/http.test.ts

@@ -1,140 +0,0 @@
-import type { ActionDefinition, ContextEntry, FeedItem, FeedSource } from "@aelis/core"
-
-import { describe, expect, test } from "bun:test"
-import { Hono } from "hono"
-
-import { mockAuthSessionMiddleware } from "../auth/session-middleware.ts"
-import { UserSessionManager } from "../session/index.ts"
-import { registerFeedHttpHandlers } from "./http.ts"
-
-interface FeedResponse {
-	items: Array<{
-		id: string
-		type: string
-		priority: number
-		timestamp: string
-		data: Record<string, unknown>
-	}>
-	errors: Array<{ sourceId: string; error: string }>
-}
-
-function createStubSource(id: string, items: FeedItem[] = []): FeedSource {
-	return {
-		id,
-		async listActions(): Promise<Record<string, ActionDefinition>> {
-			return {}
-		},
-		async executeAction(): Promise<unknown> {
-			return undefined
-		},
-		async fetchContext(): Promise<readonly ContextEntry[] | null> {
-			return null
-		},
-		async fetchItems() {
-			return items
-		},
-	}
-}
-
-function buildTestApp(sessionManager: UserSessionManager, userId?: string) {
-	const app = new Hono()
-	registerFeedHttpHandlers(app, {
-		sessionManager,
-		authSessionMiddleware: mockAuthSessionMiddleware(userId),
-	})
-	return app
-}
-
-describe("GET /api/feed", () => {
-	test("returns 401 without auth", async () => {
-		const manager = new UserSessionManager([])
-		const app = buildTestApp(manager)
-
-		const res = await app.request("/api/feed")
-
-		expect(res.status).toBe(401)
-	})
-
-	test("returns cached feed when available", async () => {
-		const items: FeedItem[] = [
-			{
-				id: "item-1",
-				type: "test",
-				priority: 0.8,
-				timestamp: new Date("2025-01-01T00:00:00.000Z"),
-				data: { value: 42 },
-			},
-		]
-		const manager = new UserSessionManager([() => createStubSource("test", items)])
-		const app = buildTestApp(manager, "user-1")
-
-		// Prime the cache
-		const session = manager.getOrCreate("user-1")
-		await session.engine.refresh()
-		expect(session.engine.lastFeed()).not.toBeNull()
-
-		const res = await app.request("/api/feed")
-
-		expect(res.status).toBe(200)
-		const body = (await res.json()) as FeedResponse
-		expect(body.items).toHaveLength(1)
-		expect(body.items[0]!.id).toBe("item-1")
-		expect(body.items[0]!.type).toBe("test")
-		expect(body.items[0]!.priority).toBe(0.8)
-		expect(body.items[0]!.timestamp).toBe("2025-01-01T00:00:00.000Z")
-		expect(body.errors).toHaveLength(0)
-	})
-
-	test("forces refresh when no cached feed", async () => {
-		const items: FeedItem[] = [
-			{
-				id: "fresh-1",
-				type: "test",
-				priority: 0.5,
-				timestamp: new Date("2025-06-01T12:00:00.000Z"),
-				data: { fresh: true },
-			},
-		]
-		const manager = new UserSessionManager([() => createStubSource("test", items)])
-		const app = buildTestApp(manager, "user-1")
-
-		// No prior refresh — lastFeed() returns null, handler should call refresh()
-		const res = await app.request("/api/feed")
-
-		expect(res.status).toBe(200)
-		const body = (await res.json()) as FeedResponse
-		expect(body.items).toHaveLength(1)
-		expect(body.items[0]!.id).toBe("fresh-1")
-		expect(body.items[0]!.data.fresh).toBe(true)
-		expect(body.errors).toHaveLength(0)
-	})
-
-	test("serializes source errors as message strings", async () => {
-		const failingSource: FeedSource = {
-			id: "failing",
-			async listActions() {
-				return {}
-			},
-			async executeAction() {
-				return undefined
-			},
-			async fetchContext() {
-				return null
-			},
-			async fetchItems() {
-				throw new Error("connection timeout")
-			},
-		}
-		const manager = new UserSessionManager([() => failingSource])
-		const app = buildTestApp(manager, "user-1")
-
-		const res = await app.request("/api/feed")
-
-		expect(res.status).toBe(200)
-		const body = (await res.json()) as FeedResponse
-		expect(body.items).toHaveLength(0)
-		expect(body.errors).toHaveLength(1)
-		expect(body.errors[0]!.sourceId).toBe("failing")
-		expect(body.errors[0]!.error).toBe("connection timeout")
-	})
-})

apps/aelis-backend/src/feed/http.ts

@@ -1,41 +0,0 @@
-import type { Context, Hono } from "hono"
-
-import { createMiddleware } from "hono/factory"
-
-import type { AuthSessionMiddleware } from "../auth/session-middleware.ts"
-import type { UserSessionManager } from "../session/index.ts"
-
-type Env = { Variables: { sessionManager: UserSessionManager } }
-
-interface FeedHttpHandlersDeps {
-	sessionManager: UserSessionManager
-	authSessionMiddleware: AuthSessionMiddleware
-}
-
-export function registerFeedHttpHandlers(
-	app: Hono,
-	{ sessionManager, authSessionMiddleware }: FeedHttpHandlersDeps,
-) {
-	const inject = createMiddleware<Env>(async (c, next) => {
-		c.set("sessionManager", sessionManager)
-		await next()
-	})
-
-	app.get("/api/feed", inject, authSessionMiddleware, handleGetFeed)
-}
-
-async function handleGetFeed(c: Context<Env>) {
-	const user = c.get("user")!
-	const sessionManager = c.get("sessionManager")
-	const session = sessionManager.getOrCreate(user.id)
-
-	const feed = session.engine.lastFeed() ?? (await session.engine.refresh())
-
-	return c.json({
-		items: feed.items,
-		errors: feed.errors.map((e) => ({
-			sourceId: e.sourceId,
-			error: e.error.message,
-		})),
-	})
-}

apps/aelis-backend/src/server.ts

@@ -2,31 +2,58 @@ import { LocationSource } from "@aelis/source-location"
 import { Hono } from "hono"
 
 import { registerAuthHandlers } from "./auth/http.ts"
-import { requireSession } from "./auth/session-middleware.ts"
-import { registerFeedHttpHandlers } from "./feed/http.ts"
+import { mockAuthSessionMiddleware, requireSession } from "./auth/session-middleware.ts"
+import { createFeedEnhancer } from "./enhancement/enhance-feed.ts"
+import { createLlmClient } from "./enhancement/llm-client.ts"
+import { registerFeedHttpHandlers } from "./engine/http.ts"
 import { registerLocationHttpHandlers } from "./location/http.ts"
 import { UserSessionManager } from "./session/index.ts"
 import { WeatherSourceProvider } from "./weather/provider.ts"
 
 function main() {
-	const sessionManager = new UserSessionManager([
-		() => new LocationSource(),
-		new WeatherSourceProvider({
-			credentials: {
-				privateKey: process.env.WEATHERKIT_PRIVATE_KEY!,
-				keyId: process.env.WEATHERKIT_KEY_ID!,
-				teamId: process.env.WEATHERKIT_TEAM_ID!,
-				serviceId: process.env.WEATHERKIT_SERVICE_ID!,
-			},
-		}),
-	])
+	const openrouterApiKey = process.env.OPENROUTER_API_KEY
+	const feedEnhancer = openrouterApiKey
+		? createFeedEnhancer({
+				client: createLlmClient({
+					apiKey: openrouterApiKey,
+					model: process.env.OPENROUTER_MODEL || undefined,
+				}),
+			})
+		: null
+	if (!feedEnhancer) {
+		console.warn("[enhancement] OPENROUTER_API_KEY not set — feed enhancement disabled")
+	}
+
+	const sessionManager = new UserSessionManager({
+		providers: [
+			() => new LocationSource(),
+			new WeatherSourceProvider({
+				credentials: {
+					privateKey: process.env.WEATHERKIT_PRIVATE_KEY!,
+					keyId: process.env.WEATHERKIT_KEY_ID!,
+					teamId: process.env.WEATHERKIT_TEAM_ID!,
+					serviceId: process.env.WEATHERKIT_SERVICE_ID!,
+				},
+			}),
+		],
+		feedEnhancer,
+	})
 
 	const app = new Hono()
 
 	app.get("/health", (c) => c.json({ status: "ok" }))
 
-	registerAuthHandlers(app)
-	registerFeedHttpHandlers(app, { sessionManager, authSessionMiddleware: requireSession })
+	const isDev = process.env.NODE_ENV !== "production"
+	const authSessionMiddleware = isDev ? mockAuthSessionMiddleware("dev-user") : requireSession
+
+	if (!isDev) {
+		registerAuthHandlers(app)
+	}
+
+	registerFeedHttpHandlers(app, {
+		sessionManager,
+		authSessionMiddleware,
+	})
 	registerLocationHttpHandlers(app, { sessionManager })
 
 	return app

apps/aelis-backend/src/session/user-session-manager.test.ts

@@ -12,7 +12,7 @@ const mockWeatherClient: WeatherKitClient = {
 
 describe("UserSessionManager", () => {
 	test("getOrCreate creates session on first call", () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 
 		const session = manager.getOrCreate("user-1")
 
@@ -21,7 +21,7 @@ describe("UserSessionManager", () => {
 	})
 
 	test("getOrCreate returns same session for same user", () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 
 		const session1 = manager.getOrCreate("user-1")
 		const session2 = manager.getOrCreate("user-1")
@@ -30,7 +30,7 @@ describe("UserSessionManager", () => {
 	})
 
 	test("getOrCreate returns different sessions for different users", () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 
 		const session1 = manager.getOrCreate("user-1")
 		const session2 = manager.getOrCreate("user-2")
@@ -39,7 +39,7 @@ describe("UserSessionManager", () => {
 	})
 
 	test("each user gets independent source instances", () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 
 		const session1 = manager.getOrCreate("user-1")
 		const session2 = manager.getOrCreate("user-2")
@@ -51,7 +51,7 @@ describe("UserSessionManager", () => {
 	})
 
 	test("remove destroys session and allows re-creation", () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 
 		const session1 = manager.getOrCreate("user-1")
 		manager.remove("user-1")
@@ -61,13 +61,13 @@ describe("UserSessionManager", () => {
 	})
 
 	test("remove is no-op for unknown user", () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 
 		expect(() => manager.remove("unknown")).not.toThrow()
 	})
 
 	test("accepts function providers", async () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 
 		const session = manager.getOrCreate("user-1")
 		const result = await session.engine.refresh()
@@ -77,7 +77,9 @@ describe("UserSessionManager", () => {
 
 	test("accepts object providers", () => {
 		const provider = new WeatherSourceProvider({ client: mockWeatherClient })
-		const manager = new UserSessionManager([() => new LocationSource(), provider])
+		const manager = new UserSessionManager({
+			providers: [() => new LocationSource(), provider],
+		})
 
 		const session = manager.getOrCreate("user-1")
 
@@ -86,7 +88,9 @@ describe("UserSessionManager", () => {
 
 	test("accepts mixed providers", () => {
 		const provider = new WeatherSourceProvider({ client: mockWeatherClient })
-		const manager = new UserSessionManager([() => new LocationSource(), provider])
+		const manager = new UserSessionManager({
+			providers: [() => new LocationSource(), provider],
+		})
 
 		const session = manager.getOrCreate("user-1")
 
@@ -95,7 +99,7 @@ describe("UserSessionManager", () => {
 	})
 
 	test("refresh returns feed result through session", async () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 
 		const session = manager.getOrCreate("user-1")
 		const result = await session.engine.refresh()
@@ -107,7 +111,7 @@ describe("UserSessionManager", () => {
 	})
 
 	test("location update via executeAction works", async () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 
 		const session = manager.getOrCreate("user-1")
 		await session.engine.executeAction("aelis.location", "update-location", {
@@ -122,7 +126,7 @@ describe("UserSessionManager", () => {
 	})
 
 	test("subscribe receives updates after location push", async () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 		const callback = mock()
 
 		const session = manager.getOrCreate("user-1")
@@ -142,7 +146,7 @@ describe("UserSessionManager", () => {
 	})
 
 	test("remove stops reactive updates", async () => {
-		const manager = new UserSessionManager([() => new LocationSource()])
+		const manager = new UserSessionManager({ providers: [() => new LocationSource()] })
 		const callback = mock()
 
 		const session = manager.getOrCreate("user-1")

apps/aelis-backend/src/session/user-session-manager.ts

@@ -1,13 +1,21 @@
+import type { FeedEnhancer } from "../enhancement/enhance-feed.ts"
 import type { FeedSourceProviderInput } from "./feed-source-provider.ts"
 
 import { UserSession } from "./user-session.ts"
 
+export interface UserSessionManagerConfig {
+	providers: FeedSourceProviderInput[]
+	feedEnhancer?: FeedEnhancer | null
+}
+
 export class UserSessionManager {
 	private sessions = new Map<string, UserSession>()
 	private readonly providers: FeedSourceProviderInput[]
+	private readonly feedEnhancer: FeedEnhancer | null
 
-	constructor(providers: FeedSourceProviderInput[]) {
-		this.providers = providers
+	constructor(config: UserSessionManagerConfig) {
+		this.providers = config.providers
+		this.feedEnhancer = config.feedEnhancer ?? null
 	}
 
 	getOrCreate(userId: string): UserSession {
@@ -16,7 +24,7 @@ export class UserSessionManager {
 			const sources = this.providers.map((p) =>
 				typeof p === "function" ? p(userId) : p.feedSourceForUser(userId),
 			)
-			session = new UserSession(sources)
+			session = new UserSession(sources, this.feedEnhancer)
 			this.sessions.set(userId, session)
 		}
 		return session

apps/aelis-backend/src/session/user-session.test.ts

@@ -1,11 +1,11 @@
-import type { ActionDefinition, ContextEntry, FeedSource } from "@aelis/core"
+import type { ActionDefinition, ContextEntry, FeedItem, FeedSource } from "@aelis/core"
 
 import { LocationSource } from "@aelis/source-location"
 import { describe, expect, test } from "bun:test"
 
 import { UserSession } from "./user-session.ts"
 
-function createStubSource(id: string): FeedSource {
+function createStubSource(id: string, items: FeedItem[] = []): FeedSource {
 	return {
 		id,
 		async listActions(): Promise<Record<string, ActionDefinition>> {
@@ -18,7 +18,7 @@ function createStubSource(id: string): FeedSource {
 			return null
 		},
 		async fetchItems() {
-			return []
+			return items
 		},
 	}
 }
@@ -70,3 +70,141 @@ describe("UserSession", () => {
 		expect(location.lastLocation!.lat).toBe(51.5)
 	})
 })
+
+describe("UserSession.feed", () => {
+	test("returns feed items without enhancer", async () => {
+		const items: FeedItem[] = [
+			{
+				id: "item-1",
+				type: "test",
+				timestamp: new Date("2025-01-01T00:00:00.000Z"),
+				data: { value: 42 },
+			},
+		]
+		const session = new UserSession([createStubSource("test", items)])
+
+		const result = await session.feed()
+
+		expect(result.items).toHaveLength(1)
+		expect(result.items[0]!.id).toBe("item-1")
+	})
+
+	test("returns enhanced items when enhancer is provided", async () => {
+		const items: FeedItem[] = [
+			{
+				id: "item-1",
+				type: "test",
+				timestamp: new Date("2025-01-01T00:00:00.000Z"),
+				data: { value: 42 },
+			},
+		]
+		const enhancer = async (feedItems: FeedItem[]) =>
+			feedItems.map((item) => ({ ...item, data: { ...item.data, enhanced: true } }))
+
+		const session = new UserSession([createStubSource("test", items)], enhancer)
+
+		const result = await session.feed()
+
+		expect(result.items).toHaveLength(1)
+		expect(result.items[0]!.data.enhanced).toBe(true)
+	})
+
+	test("caches enhanced items on subsequent calls", async () => {
+		const items: FeedItem[] = [
+			{
+				id: "item-1",
+				type: "test",
+				timestamp: new Date("2025-01-01T00:00:00.000Z"),
+				data: { value: 42 },
+			},
+		]
+		let enhancerCallCount = 0
+		const enhancer = async (feedItems: FeedItem[]) => {
+			enhancerCallCount++
+			return feedItems.map((item) => ({ ...item, data: { ...item.data, enhanced: true } }))
+		}
+
+		const session = new UserSession([createStubSource("test", items)], enhancer)
+
+		const result1 = await session.feed()
+		expect(result1.items[0]!.data.enhanced).toBe(true)
+		expect(enhancerCallCount).toBe(1)
+
+		const result2 = await session.feed()
+		expect(result2.items[0]!.data.enhanced).toBe(true)
+		expect(enhancerCallCount).toBe(1)
+	})
+
+	test("re-enhances after engine refresh with new data", async () => {
+		let currentItems: FeedItem[] = [
+			{
+				id: "item-1",
+				type: "test",
+				timestamp: new Date("2025-01-01T00:00:00.000Z"),
+				data: { version: 1 },
+			},
+		]
+		const source = createStubSource("test", currentItems)
+		// Make fetchItems dynamic so refresh returns new data
+		source.fetchItems = async () => currentItems
+
+		const enhancedVersions: number[] = []
+		const enhancer = async (feedItems: FeedItem[]) => {
+			const version = feedItems[0]!.data.version as number
+			enhancedVersions.push(version)
+			return feedItems.map((item) => ({
+				...item,
+				data: { ...item.data, enhanced: true },
+			}))
+		}
+
+		const session = new UserSession([source], enhancer)
+
+		// First feed triggers refresh + enhancement
+		const result1 = await session.feed()
+		expect(result1.items[0]!.data.version).toBe(1)
+		expect(result1.items[0]!.data.enhanced).toBe(true)
+
+		// Update source data and trigger engine refresh
+		currentItems = [
+			{
+				id: "item-1",
+				type: "test",
+				timestamp: new Date("2025-01-02T00:00:00.000Z"),
+				data: { version: 2 },
+			},
+		]
+		await session.engine.refresh()
+
+		// Wait for subscriber-triggered background enhancement
+		await new Promise((resolve) => setTimeout(resolve, 10))
+
+		// feed() should now serve re-enhanced items with version 2
+		const result2 = await session.feed()
+		expect(result2.items[0]!.data.version).toBe(2)
+		expect(result2.items[0]!.data.enhanced).toBe(true)
+		expect(enhancedVersions).toEqual([1, 2])
+	})
+
+	test("falls back to unenhanced items when enhancer throws", async () => {
+		const items: FeedItem[] = [
+			{
+				id: "item-1",
+				type: "test",
+				timestamp: new Date("2025-01-01T00:00:00.000Z"),
+				data: { value: 42 },
+			},
+		]
+		const enhancer = async () => {
+			throw new Error("enhancement exploded")
+		}
+
+		const session = new UserSession([createStubSource("test", items)], enhancer)
+
+		const result = await session.feed()
+
+		expect(result.items).toHaveLength(1)
+		expect(result.items[0]!.id).toBe("item-1")
+		expect(result.items[0]!.data.value).toBe(42)
+	})
+})

apps/aelis-backend/src/session/user-session.ts

@@ -1,24 +1,104 @@
-import { FeedEngine, type FeedSource } from "@aelis/core"
+import { FeedEngine, type FeedItem, type FeedResult, type FeedSource } from "@aelis/core"
+
+import type { FeedEnhancer } from "../enhancement/enhance-feed.ts"
 
 export class UserSession {
 	readonly engine: FeedEngine
 	private sources = new Map<string, FeedSource>()
+	private readonly enhancer: FeedEnhancer | null
+	private enhancedItems: FeedItem[] | null = null
+	/** The FeedResult that enhancedItems was derived from. */
+	private enhancedSource: FeedResult | null = null
+	private enhancingPromise: Promise<void> | null = null
+	private unsubscribe: (() => void) | null = null
 
-	constructor(sources: FeedSource[]) {
+	constructor(sources: FeedSource[], enhancer?: FeedEnhancer | null) {
 		this.engine = new FeedEngine()
+		this.enhancer = enhancer ?? null
 		for (const source of sources) {
 			this.sources.set(source.id, source)
 			this.engine.register(source)
 		}
+
+		if (this.enhancer) {
+			this.unsubscribe = this.engine.subscribe((result) => {
+				this.invalidateEnhancement()
+				this.runEnhancement(result)
+			})
+		}
+
 		this.engine.start()
 	}
 
+	/**
+	 * Returns the current feed, refreshing if the engine cache expired.
+	 * Enhancement runs eagerly on engine updates; this method awaits
+	 * any in-flight enhancement or triggers one if needed.
+	 */
+	async feed(): Promise<FeedResult> {
+		const cached = this.engine.lastFeed()
+		const result = cached ?? (await this.engine.refresh())
+
+		if (!this.enhancer) {
+			return result
+		}
+
+		// Wait for any in-flight background enhancement to finish
+		if (this.enhancingPromise) {
+			await this.enhancingPromise
+		}
+
+		// Serve cached enhancement only if it matches the current engine result
+		if (this.enhancedItems && this.enhancedSource === result) {
+			return { ...result, items: this.enhancedItems }
+		}
+
+		// Stale or missing — re-enhance
+		await this.runEnhancement(result)
+
+		if (this.enhancedItems) {
+			return { ...result, items: this.enhancedItems }
+		}
+
+		return result
+	}
+
 	getSource<T extends FeedSource>(sourceId: string): T | undefined {
 		return this.sources.get(sourceId) as T | undefined
 	}
 
 	destroy(): void {
+		this.unsubscribe?.()
+		this.unsubscribe = null
 		this.engine.stop()
 		this.sources.clear()
+		this.invalidateEnhancement()
+		this.enhancingPromise = null
+	}
+
+	private invalidateEnhancement(): void {
+		this.enhancedItems = null
+		this.enhancedSource = null
+	}
+
+	private runEnhancement(result: FeedResult): Promise<void> {
+		const promise = this.enhance(result)
+		this.enhancingPromise = promise
+		promise.finally(() => {
+			if (this.enhancingPromise === promise) {
+				this.enhancingPromise = null
+			}
+		})
+		return promise
+	}
+
+	private async enhance(result: FeedResult): Promise<void> {
+		try {
+			this.enhancedItems = await this.enhancer!(result.items)
+			this.enhancedSource = result
+		} catch (err) {
+			console.error("[enhancement] Unexpected error:", err)
+			this.invalidateEnhancement()
+		}
 	}
 }

apps/aelis-client/package.json

@@ -18,6 +18,7 @@
 		"@expo-google-fonts/inter": "^0.4.2",
 		"@expo-google-fonts/source-serif-4": "^0.4.1",
 		"@expo/vector-icons": "^15.0.3",
+		"@json-render/react-native": "^0.13.0",
 		"@react-navigation/bottom-tabs": "^7.4.0",
 		"@react-navigation/elements": "^2.6.3",
 		"@react-navigation/native": "^7.1.8",
@@ -45,7 +46,8 @@
 		"react-native-svg": "15.12.1",
 		"react-native-web": "~0.21.0",
 		"react-native-worklets": "0.5.1",
-		"twrnc": "^4.16.0"
+		"twrnc": "^4.16.0",
+		"zod": "^4.3.6"
 	},
 	"devDependencies": {
 		"@types/react": "~19.1.0",

apps/aelis-client/src/app/(tabs)/_layout.tsx

@@ -1,36 +0,0 @@
-import { Tabs } from "expo-router"
-import React from "react"
-
-import { HapticTab } from "@/components/haptic-tab"
-import { IconSymbol } from "@/components/ui/icon-symbol"
-import { Colors } from "@/constants/theme"
-import { useColorScheme } from "@/hooks/use-color-scheme"
-
-export default function TabLayout() {
-	const colorScheme = useColorScheme()
-
-	return (
-		<Tabs
-			screenOptions={{
-				tabBarActiveTintColor: Colors[colorScheme ?? "light"].tint,
-				headerShown: false,
-				tabBarButton: HapticTab,
-			}}
-		>
-			<Tabs.Screen
-				name="index"
-				options={{
-					title: "Home",
-					tabBarIcon: ({ color }) => <IconSymbol size={28} name="house.fill" color={color} />,
-				}}
-			/>
-			<Tabs.Screen
-				name="explore"
-				options={{
-					title: "Explore",
-					tabBarIcon: ({ color }) => <IconSymbol size={28} name="paperplane.fill" color={color} />,
-				}}
-			/>
-		</Tabs>
-	)
-}

apps/aelis-client/src/app/(tabs)/explore.tsx

@@ -1,114 +0,0 @@
-import { Image } from "expo-image"
-import { Platform, StyleSheet } from "react-native"
-
-import { ExternalLink } from "@/components/external-link"
-import ParallaxScrollView from "@/components/parallax-scroll-view"
-import { ThemedText } from "@/components/themed-text"
-import { ThemedView } from "@/components/themed-view"
-import { Collapsible } from "@/components/ui/collapsible"
-import { IconSymbol } from "@/components/ui/icon-symbol"
-import { Fonts } from "@/constants/theme"
-
-export default function TabTwoScreen() {
-	return (
-		<ParallaxScrollView
-			headerBackgroundColor={{ light: "#D0D0D0", dark: "#353636" }}
-			headerImage={
-				<IconSymbol
-					size={310}
-					color="#808080"
-					name="chevron.left.forwardslash.chevron.right"
-					style={styles.headerImage}
-				/>
-			}
-		>
-			<ThemedView style={styles.titleContainer}>
-				<ThemedText
-					type="title"
-					style={{
-						fontFamily: Fonts.rounded,
-					}}
-				>
-					Explore
-				</ThemedText>
-			</ThemedView>
-			<ThemedText>This app includes example code to help you get started.</ThemedText>
-			<Collapsible title="File-based routing">
-				<ThemedText>
-					This app has two screens:{" "}
-					<ThemedText type="defaultSemiBold">app/(tabs)/index.tsx</ThemedText> and{" "}
-					<ThemedText type="defaultSemiBold">app/(tabs)/explore.tsx</ThemedText>
-				</ThemedText>
-				<ThemedText>
-					The layout file in <ThemedText type="defaultSemiBold">app/(tabs)/_layout.tsx</ThemedText>{" "}
-					sets up the tab navigator.
-				</ThemedText>
-				<ExternalLink href="https://docs.expo.dev/router/introduction">
-					<ThemedText type="link">Learn more</ThemedText>
-				</ExternalLink>
-			</Collapsible>
-			<Collapsible title="Android, iOS, and web support">
-				<ThemedText>
-					You can open this project on Android, iOS, and the web. To open the web version, press{" "}
-					<ThemedText type="defaultSemiBold">w</ThemedText> in the terminal running this project.
-				</ThemedText>
-			</Collapsible>
-			<Collapsible title="Images">
-				<ThemedText>
-					For static images, you can use the <ThemedText type="defaultSemiBold">@2x</ThemedText> and{" "}
-					<ThemedText type="defaultSemiBold">@3x</ThemedText> suffixes to provide files for
-					different screen densities
-				</ThemedText>
-				<Image
-					source={require("@assets/images/react-logo.png")}
-					style={{ width: 100, height: 100, alignSelf: "center" }}
-				/>
-				<ExternalLink href="https://reactnative.dev/docs/images">
-					<ThemedText type="link">Learn more</ThemedText>
-				</ExternalLink>
-			</Collapsible>
-			<Collapsible title="Light and dark mode components">
-				<ThemedText>
-					This template has light and dark mode support. The{" "}
-					<ThemedText type="defaultSemiBold">useColorScheme()</ThemedText> hook lets you inspect
-					what the user&apos;s current color scheme is, and so you can adjust UI colors accordingly.
-				</ThemedText>
-				<ExternalLink href="https://docs.expo.dev/develop/user-interface/color-themes/">
-					<ThemedText type="link">Learn more</ThemedText>
-				</ExternalLink>
-			</Collapsible>
-			<Collapsible title="Animations">
-				<ThemedText>
-					This template includes an example of an animated component. The{" "}
-					<ThemedText type="defaultSemiBold">components/HelloWave.tsx</ThemedText> component uses
-					the powerful{" "}
-					<ThemedText type="defaultSemiBold" style={{ fontFamily: Fonts.mono }}>
-						react-native-reanimated
-					</ThemedText>{" "}
-					library to create a waving hand animation.
-				</ThemedText>
-				{Platform.select({
-					ios: (
-						<ThemedText>
-							The <ThemedText type="defaultSemiBold">components/ParallaxScrollView.tsx</ThemedText>{" "}
-							component provides a parallax effect for the header image.
-						</ThemedText>
-					),
-				})}
-			</Collapsible>
-		</ParallaxScrollView>
-	)
-}
-
-const styles = StyleSheet.create({
-	headerImage: {
-		color: "#808080",
-		bottom: -90,
-		left: -35,
-		position: "absolute",
-	},
-	titleContainer: {
-		flexDirection: "row",
-		gap: 8,
-	},
-})

apps/aelis-client/src/app/(tabs)/index.tsx

@@ -1,96 +0,0 @@
-import { Image } from "expo-image"
-import { Link } from "expo-router"
-import { Platform, StyleSheet } from "react-native"
-
-import { HelloWave } from "@/components/hello-wave"
-import ParallaxScrollView from "@/components/parallax-scroll-view"
-import { ThemedText } from "@/components/themed-text"
-import { ThemedView } from "@/components/themed-view"
-
-export default function HomeScreen() {
-	return (
-		<ParallaxScrollView
-			headerBackgroundColor={{ light: "#A1CEDC", dark: "#1D3D47" }}
-			headerImage={
-				<Image source={require("@assets/images/partial-react-logo.png")} style={styles.reactLogo} />
-			}
-		>
-			<ThemedView style={styles.titleContainer}>
-				<ThemedText type="title">Welcome!</ThemedText>
-				<HelloWave />
-			</ThemedView>
-			<ThemedView style={styles.stepContainer}>
-				<ThemedText type="subtitle">Step 1: Try it</ThemedText>
-				<ThemedText>
-					Edit <ThemedText type="defaultSemiBold">app/(tabs)/index.tsx</ThemedText> to see changes.
-					Press{" "}
-					<ThemedText type="defaultSemiBold">
-						{Platform.select({
-							ios: "cmd + d",
-							android: "cmd + m",
-							web: "F12",
-						})}
-					</ThemedText>{" "}
-					to open developer tools.
-				</ThemedText>
-			</ThemedView>
-			<ThemedView style={styles.stepContainer}>
-				<Link href="/modal">
-					<Link.Trigger>
-						<ThemedText type="subtitle">Step 2: Explore</ThemedText>
-					</Link.Trigger>
-					<Link.Preview />
-					<Link.Menu>
-						<Link.MenuAction title="Action" icon="cube" onPress={() => alert("Action pressed")} />
-						<Link.MenuAction
-							title="Share"
-							icon="square.and.arrow.up"
-							onPress={() => alert("Share pressed")}
-						/>
-						<Link.Menu title="More" icon="ellipsis">
-							<Link.MenuAction
-								title="Delete"
-								icon="trash"
-								destructive
-								onPress={() => alert("Delete pressed")}
-							/>
-						</Link.Menu>
-					</Link.Menu>
-				</Link>
-
-				<ThemedText>
-					{`Tap the Explore tab to learn more about what's included in this starter app.`}
-				</ThemedText>
-			</ThemedView>
-			<ThemedView style={styles.stepContainer}>
-				<ThemedText type="subtitle">Step 3: Get a fresh start</ThemedText>
-				<ThemedText>
-					{`When you're ready, run `}
-					<ThemedText type="defaultSemiBold">npm run reset-project</ThemedText> to get a fresh{" "}
-					<ThemedText type="defaultSemiBold">app</ThemedText> directory. This will move the current{" "}
-					<ThemedText type="defaultSemiBold">app</ThemedText> to{" "}
-					<ThemedText type="defaultSemiBold">app-example</ThemedText>.
-				</ThemedText>
-			</ThemedView>
-		</ParallaxScrollView>
-	)
-}
-
-const styles = StyleSheet.create({
-	titleContainer: {
-		flexDirection: "row",
-		alignItems: "center",
-		gap: 8,
-	},
-	stepContainer: {
-		gap: 8,
-		marginBottom: 8,
-	},
-	reactLogo: {
-		height: 178,
-		width: 290,
-		bottom: 0,
-		left: 0,
-		position: "absolute",
-	},
-})

apps/aelis-client/src/app/_layout.tsx

@@ -1,23 +1,45 @@
-import { DarkTheme, DefaultTheme, ThemeProvider } from "@react-navigation/native"
+import "react-native-reanimated"
 import { Stack } from "expo-router"
 import { StatusBar } from "expo-status-bar"
-import "react-native-reanimated"
-import { useColorScheme } from "@/hooks/use-color-scheme"
-
-export const unstable_settings = {
-	anchor: "(tabs)",
-}
+import { useColorScheme } from "react-native"
+import tw, { useDeviceContext } from "twrnc"
 
 export default function RootLayout() {
+	useDeviceContext(tw)
 	const colorScheme = useColorScheme()
+	const headerBg = colorScheme === "dark" ? "#1c1917" : "#f5f5f4"
+	const headerTint = colorScheme === "dark" ? "#e7e5e4" : "#1c1917"
 
 	return (
-		<ThemeProvider value={colorScheme === "dark" ? DarkTheme : DefaultTheme}>
-			<Stack>
-				<Stack.Screen name="(tabs)" options={{ headerShown: false }} />
-				<Stack.Screen name="modal" options={{ presentation: "modal", title: "Modal" }} />
+		<>
+			<Stack
+				screenOptions={{
+					headerShown: false,
+					contentStyle: { backgroundColor: headerBg },
+				}}
+			>
+				<Stack.Screen
+					name="components/index"
+					options={{
+						headerShown: true,
+						title: "Components",
+						headerStyle: { backgroundColor: headerBg },
+						headerTintColor: headerTint,
+						headerShadowVisible: false,
+					}}
+				/>
+				<Stack.Screen
+					name="components/[name]"
+					options={{
+						headerShown: true,
+						title: "",
+						headerStyle: { backgroundColor: headerBg },
+						headerTintColor: headerTint,
+						headerShadowVisible: false,
+					}}
+				/>
 			</Stack>
 			<StatusBar style="auto" />
-		</ThemeProvider>
+		</>
 	)
 }

apps/aelis-client/src/app/components/[name].tsx

@@ -0,0 +1,48 @@
+import { useLocalSearchParams, useNavigation } from "expo-router"
+import { useEffect } from "react"
+import { ScrollView, View } from "react-native"
+import tw from "twrnc"
+
+import { buttonShowcase } from "@/components/ui/button.showcase"
+import { feedCardShowcase } from "@/components/ui/feed-card.showcase"
+import { monospaceTextShowcase } from "@/components/ui/monospace-text.showcase"
+import { sansSerifTextShowcase } from "@/components/ui/sans-serif-text.showcase"
+import { serifTextShowcase } from "@/components/ui/serif-text.showcase"
+import { type Showcase } from "@/components/showcase"
+import { SansSerifText } from "@/components/ui/sans-serif-text"
+
+const showcases: Record<string, Showcase> = {
+	button: buttonShowcase,
+	"feed-card": feedCardShowcase,
+	"serif-text": serifTextShowcase,
+	"sans-serif-text": sansSerifTextShowcase,
+	"monospace-text": monospaceTextShowcase,
+}
+
+export default function ComponentDetailScreen() {
+	const { name } = useLocalSearchParams<{ name: string }>()
+	const navigation = useNavigation()
+	const showcase = showcases[name]
+
+	useEffect(() => {
+		if (showcase) {
+			navigation.setOptions({ title: showcase.title })
+		}
+	}, [navigation, showcase])
+
+	if (!showcase) {
+		return (
+			<View style={tw`bg-stone-100 dark:bg-stone-900 flex-1 items-center justify-center`}>
+				<SansSerifText>Component not found</SansSerifText>
+			</View>
+		)
+	}
+
+	const ShowcaseComponent = showcase.component
+
+	return (
+		<ScrollView style={tw`bg-stone-100 dark:bg-stone-900 flex-1`} contentContainerStyle={tw`px-5 pb-10 pt-4 gap-6`}>
+			<ShowcaseComponent />
+		</ScrollView>
+	)
+}

apps/aelis-client/src/app/components/index.tsx

@@ -0,0 +1,37 @@
+import { Link } from "expo-router"
+import { FlatList, Pressable, View } from "react-native"
+import tw from "twrnc"
+
+import { SansSerifText } from "@/components/ui/sans-serif-text"
+
+const components = [
+	{ name: "button", label: "Button" },
+	{ name: "feed-card", label: "FeedCard" },
+	{ name: "serif-text", label: "SerifText" },
+	{ name: "sans-serif-text", label: "SansSerifText" },
+	{ name: "monospace-text", label: "MonospaceText" },
+] as const
+
+export default function ComponentsScreen() {
+	return (
+		<View style={tw`flex-1`}>
+			<View style={tw`mx-4 mt-4 rounded-xl border border-stone-200 dark:border-stone-800 overflow-hidden`}>
+				<FlatList
+					data={components}
+					keyExtractor={(item) => item.name}
+					scrollEnabled={false}
+					ItemSeparatorComponent={() => (
+						<View style={tw`border-b border-stone-200 dark:border-stone-800`} />
+					)}
+					renderItem={({ item }) => (
+						<Link href={`/components/${item.name}`} asChild>
+							<Pressable style={tw`px-4 py-3`}>
+								<SansSerifText style={tw`text-base`}>{item.label}</SansSerifText>
+							</Pressable>
+						</Link>
+					)}
+				/>
+			</View>
+		</View>
+	)
+}

apps/aelis-client/src/app/index.tsx

@@ -0,0 +1,28 @@
+import { Link } from "expo-router"
+import { Pressable } from "react-native"
+import { SafeAreaView } from "react-native-safe-area-context"
+import tw from "twrnc"
+
+import { Button } from "@/components/ui/button"
+import { FeedCard } from "@/components/ui/feed-card"
+import { MonospaceText } from "@/components/ui/monospace-text"
+import { SansSerifText } from "@/components/ui/sans-serif-text"
+import { SerifText } from "@/components/ui/serif-text"
+
+export default function HomeScreen() {
+	return (
+		<SafeAreaView style={tw`bg-stone-100 dark:bg-stone-900 flex-1 px-5 pt-6 gap-4`}>
+			<FeedCard>
+				<SerifText style={tw`text-4xl`}>Hello world asdsadsa</SerifText>
+				<SansSerifText style={tw`text-4xl font-bold`}>Hello world</SansSerifText>
+				<MonospaceText style={tw`text-4xl`}>asdjsakljdl</MonospaceText>
+				<Button style={tw`self-start`} label="Test" />
+			</FeedCard>
+			<Link href="/components" asChild>
+				<Pressable>
+					<SansSerifText style={tw`text-teal-600`}>View component library</SansSerifText>
+				</Pressable>
+			</Link>
+		</SafeAreaView>
+	)
+}

apps/aelis-client/src/app/modal.tsx

@@ -1,29 +0,0 @@
-import { Link } from "expo-router"
-import { StyleSheet } from "react-native"
-
-import { ThemedText } from "@/components/themed-text"
-import { ThemedView } from "@/components/themed-view"
-
-export default function ModalScreen() {
-	return (
-		<ThemedView style={styles.container}>
-			<ThemedText type="title">This is a modal</ThemedText>
-			<Link href="/" dismissTo style={styles.link}>
-				<ThemedText type="link">Go to home screen</ThemedText>
-			</Link>
-		</ThemedView>
-	)
-}
-
-const styles = StyleSheet.create({
-	container: {
-		flex: 1,
-		alignItems: "center",
-		justifyContent: "center",
-		padding: 20,
-	},
-	link: {
-		marginTop: 15,
-		paddingVertical: 15,
-	},
-})

apps/aelis-client/src/components/external-link.tsx

@@ -1,25 +0,0 @@
-import { Href, Link } from "expo-router"
-import { openBrowserAsync, WebBrowserPresentationStyle } from "expo-web-browser"
-import { type ComponentProps } from "react"
-
-type Props = Omit<ComponentProps<typeof Link>, "href"> & { href: Href & string }
-
-export function ExternalLink({ href, ...rest }: Props) {
-	return (
-		<Link
-			target="_blank"
-			{...rest}
-			href={href}
-			onPress={async (event) => {
-				if (process.env.EXPO_OS !== "web") {
-					// Prevent the default behavior of linking to the default browser on native.
-					event.preventDefault()
-					// Open the link in an in-app browser.
-					await openBrowserAsync(href, {
-						presentationStyle: WebBrowserPresentationStyle.AUTOMATIC,
-					})
-				}
-			}}
-		/>
-	)
-}

apps/aelis-client/src/components/haptic-tab.tsx

@@ -1,18 +0,0 @@
-import { BottomTabBarButtonProps } from "@react-navigation/bottom-tabs"
-import { PlatformPressable } from "@react-navigation/elements"
-import * as Haptics from "expo-haptics"
-
-export function HapticTab(props: BottomTabBarButtonProps) {
-	return (
-		<PlatformPressable
-			{...props}
-			onPressIn={(ev) => {
-				if (process.env.EXPO_OS === "ios") {
-					// Add a soft haptic feedback when pressing down on the tabs.
-					Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Light)
-				}
-				props.onPressIn?.(ev)
-			}}
-		/>
-	)
-}

apps/aelis-client/src/components/hello-wave.tsx

@@ -1,20 +0,0 @@
-import Animated from "react-native-reanimated"
-
-export function HelloWave() {
-	return (
-		<Animated.Text
-			style={{
-				fontSize: 28,
-				lineHeight: 32,
-				marginTop: -6,
-				animationName: {
-					"50%": { transform: [{ rotate: "25deg" }] },
-				},
-				animationIterationCount: 4,
-				animationDuration: "300ms",
-			}}
-		>
-			👋
-		</Animated.Text>
-	)
-}

apps/aelis-client/src/components/parallax-scroll-view.tsx

@@ -1,82 +0,0 @@
-import type { PropsWithChildren, ReactElement } from "react"
-
-import { StyleSheet } from "react-native"
-import Animated, {
-	interpolate,
-	useAnimatedRef,
-	useAnimatedStyle,
-	useScrollOffset,
-} from "react-native-reanimated"
-
-import { ThemedView } from "@/components/themed-view"
-import { useColorScheme } from "@/hooks/use-color-scheme"
-import { useThemeColor } from "@/hooks/use-theme-color"
-
-const HEADER_HEIGHT = 250
-
-type Props = PropsWithChildren<{
-	headerImage: ReactElement
-	headerBackgroundColor: { dark: string; light: string }
-}>
-
-export default function ParallaxScrollView({
-	children,
-	headerImage,
-	headerBackgroundColor,
-}: Props) {
-	const backgroundColor = useThemeColor({}, "background")
-	const colorScheme = useColorScheme() ?? "light"
-	const scrollRef = useAnimatedRef<Animated.ScrollView>()
-	const scrollOffset = useScrollOffset(scrollRef)
-	const headerAnimatedStyle = useAnimatedStyle(() => {
-		return {
-			transform: [
-				{
-					translateY: interpolate(
-						scrollOffset.value,
-						[-HEADER_HEIGHT, 0, HEADER_HEIGHT],
-						[-HEADER_HEIGHT / 2, 0, HEADER_HEIGHT * 0.75],
-					),
-				},
-				{
-					scale: interpolate(scrollOffset.value, [-HEADER_HEIGHT, 0, HEADER_HEIGHT], [2, 1, 1]),
-				},
-			],
-		}
-	})
-
-	return (
-		<Animated.ScrollView
-			ref={scrollRef}
-			style={{ backgroundColor, flex: 1 }}
-			scrollEventThrottle={16}
-		>
-			<Animated.View
-				style={[
-					styles.header,
-					{ backgroundColor: headerBackgroundColor[colorScheme] },
-					headerAnimatedStyle,
-				]}
-			>
-				{headerImage}
-			</Animated.View>
-			<ThemedView style={styles.content}>{children}</ThemedView>
-		</Animated.ScrollView>
-	)
-}
-
-const styles = StyleSheet.create({
-	container: {
-		flex: 1,
-	},
-	header: {
-		height: HEADER_HEIGHT,
-		overflow: "hidden",
-	},
-	content: {
-		flex: 1,
-		padding: 32,
-		gap: 16,
-		overflow: "hidden",
-	},
-})

apps/aelis-client/src/components/showcase.tsx

@@ -0,0 +1,18 @@
+import { View } from "react-native"
+import tw from "twrnc"
+
+import { SansSerifText } from "./ui/sans-serif-text"
+
+export type Showcase = {
+	title: string
+	component: React.ComponentType
+}
+
+export function Section({ title, children }: { title: string; children: React.ReactNode }) {
+	return (
+		<View style={tw`gap-3`}>
+			<SansSerifText style={tw`text-sm text-stone-500 dark:text-stone-400`}>{title}</SansSerifText>
+			{children}
+		</View>
+	)
+}

apps/aelis-client/src/components/themed-text.tsx

@@ -1,60 +0,0 @@
-import { StyleSheet, Text, type TextProps } from "react-native"
-
-import { useThemeColor } from "@/hooks/use-theme-color"
-
-export type ThemedTextProps = TextProps & {
-	lightColor?: string
-	darkColor?: string
-	type?: "default" | "title" | "defaultSemiBold" | "subtitle" | "link"
-}
-
-export function ThemedText({
-	style,
-	lightColor,
-	darkColor,
-	type = "default",
-	...rest
-}: ThemedTextProps) {
-	const color = useThemeColor({ light: lightColor, dark: darkColor }, "text")
-
-	return (
-		<Text
-			style={[
-				{ color },
-				type === "default" ? styles.default : undefined,
-				type === "title" ? styles.title : undefined,
-				type === "defaultSemiBold" ? styles.defaultSemiBold : undefined,
-				type === "subtitle" ? styles.subtitle : undefined,
-				type === "link" ? styles.link : undefined,
-				style,
-			]}
-			{...rest}
-		/>
-	)
-}
-
-const styles = StyleSheet.create({
-	default: {
-		fontSize: 16,
-		lineHeight: 24,
-	},
-	defaultSemiBold: {
-		fontSize: 16,
-		lineHeight: 24,
-		fontWeight: "600",
-	},
-	title: {
-		fontSize: 32,
-		fontWeight: "bold",
-		lineHeight: 32,
-	},
-	subtitle: {
-		fontSize: 20,
-		fontWeight: "bold",
-	},
-	link: {
-		lineHeight: 30,
-		fontSize: 16,
-		color: "#0a7ea4",
-	},
-})

apps/aelis-client/src/components/themed-view.tsx

@@ -1,14 +0,0 @@
-import { View, type ViewProps } from "react-native"
-
-import { useThemeColor } from "@/hooks/use-theme-color"
-
-export type ThemedViewProps = ViewProps & {
-	lightColor?: string
-	darkColor?: string
-}
-
-export function ThemedView({ style, lightColor, darkColor, ...otherProps }: ThemedViewProps) {
-	const backgroundColor = useThemeColor({ light: lightColor, dark: darkColor }, "background")
-
-	return <View style={[{ backgroundColor }, style]} {...otherProps} />
-}

apps/aelis-client/src/components/ui/button.showcase.tsx

@@ -0,0 +1,42 @@
+import { View } from "react-native"
+import tw from "twrnc"
+
+import { Button } from "./button"
+import { type Showcase, Section } from "../showcase"
+
+function ButtonShowcase() {
+	return (
+		<View style={tw`gap-6`}>
+			<Section title="Default">
+				<Button style={tw`self-start`} label="Press me" />
+			</Section>
+			<Section title="Leading icon">
+				<Button
+					style={tw`self-start`}
+					label="Add item"
+					leadingIcon={<Button.Icon name="plus" />}
+				/>
+			</Section>
+			<Section title="Trailing icon">
+				<Button
+					style={tw`self-start`}
+					label="Next"
+					trailingIcon={<Button.Icon name="arrow-right" />}
+				/>
+			</Section>
+			<Section title="Both icons">
+				<Button
+					style={tw`self-start`}
+					label="Download"
+					leadingIcon={<Button.Icon name="download" />}
+					trailingIcon={<Button.Icon name="chevron-down" />}
+				/>
+			</Section>
+		</View>
+	)
+}
+
+export const buttonShowcase: Showcase = {
+	title: "Button",
+	component: ButtonShowcase,
+}

apps/aelis-client/src/components/ui/button.tsx

@@ -0,0 +1,43 @@
+import Feather from "@expo/vector-icons/Feather"
+import { type PressableProps, Pressable, View } from "react-native"
+import tw from "twrnc"
+
+import { SansSerifText } from "./sans-serif-text"
+
+type FeatherIconName = React.ComponentProps<typeof Feather>["name"]
+
+type ButtonIconProps = {
+	name: FeatherIconName
+}
+
+function ButtonIcon({ name }: ButtonIconProps) {
+	return <Feather name={name} size={18} color={tw.color("text-stone-100 dark:text-stone-200")} />
+}
+
+type ButtonProps = Omit<PressableProps, "children"> & {
+	label: string
+	leadingIcon?: React.ReactNode
+	trailingIcon?: React.ReactNode
+}
+
+export function Button({ style, label, leadingIcon, trailingIcon, ...props }: ButtonProps) {
+	const hasIcons = leadingIcon != null || trailingIcon != null
+
+	const textElement = <SansSerifText style={tw`text-stone-100 dark:text-stone-200 font-medium`}>{label}</SansSerifText>
+
+	return (
+		<Pressable style={[tw`rounded-full bg-teal-600 px-4 py-3 w-fit`, style]} {...props}>
+			{hasIcons ? (
+				<View style={tw`flex-row items-center gap-1.5`}>
+					{leadingIcon}
+					{textElement}
+					{trailingIcon}
+				</View>
+			) : (
+				textElement
+			)}
+		</Pressable>
+	)
+}
+
+Button.Icon = ButtonIcon

apps/aelis-client/src/components/ui/collapsible.tsx

@@ -1,46 +0,0 @@
-import { PropsWithChildren, useState } from "react"
-import { StyleSheet, TouchableOpacity } from "react-native"
-
-import { ThemedText } from "@/components/themed-text"
-import { ThemedView } from "@/components/themed-view"
-import { IconSymbol } from "@/components/ui/icon-symbol"
-import { Colors } from "@/constants/theme"
-import { useColorScheme } from "@/hooks/use-color-scheme"
-
-export function Collapsible({ children, title }: PropsWithChildren & { title: string }) {
-	const [isOpen, setIsOpen] = useState(false)
-	const theme = useColorScheme() ?? "light"
-
-	return (
-		<ThemedView>
-			<TouchableOpacity
-				style={styles.heading}
-				onPress={() => setIsOpen((value) => !value)}
-				activeOpacity={0.8}
-			>
-				<IconSymbol
-					name="chevron.right"
-					size={18}
-					weight="medium"
-					color={theme === "light" ? Colors.light.icon : Colors.dark.icon}
-					style={{ transform: [{ rotate: isOpen ? "90deg" : "0deg" }] }}
-				/>
-
-				<ThemedText type="defaultSemiBold">{title}</ThemedText>
-			</TouchableOpacity>
-			{isOpen && <ThemedView style={styles.content}>{children}</ThemedView>}
-		</ThemedView>
-	)
-}
-
-const styles = StyleSheet.create({
-	heading: {
-		flexDirection: "row",
-		alignItems: "center",
-		gap: 6,
-	},
-	content: {
-		marginTop: 6,
-		marginLeft: 24,
-	},
-})

apps/aelis-client/src/components/ui/feed-card.showcase.tsx

@@ -0,0 +1,32 @@
+import { View } from "react-native"
+import tw from "twrnc"
+
+import { Button } from "./button"
+import { FeedCard } from "./feed-card"
+import { SansSerifText } from "./sans-serif-text"
+import { SerifText } from "./serif-text"
+import { type Showcase, Section } from "../showcase"
+
+function FeedCardShowcase() {
+	return (
+		<View style={tw`gap-6`}>
+			<Section title="Default">
+				<FeedCard style={tw`p-4`}>
+					<SansSerifText>Card content goes here</SansSerifText>
+				</FeedCard>
+			</Section>
+			<Section title="With mixed content">
+				<FeedCard style={tw`p-4 gap-2`}>
+					<SerifText style={tw`text-xl`}>Title</SerifText>
+					<SansSerifText>Body text inside a feed card.</SansSerifText>
+					<Button style={tw`self-start mt-2`} label="Action" />
+				</FeedCard>
+			</Section>
+		</View>
+	)
+}
+
+export const feedCardShowcase: Showcase = {
+	title: "FeedCard",
+	component: FeedCardShowcase,
+}

apps/aelis-client/src/components/ui/feed-card.tsx

@@ -0,0 +1,6 @@
+import { View, type ViewProps } from "react-native"
+import tw from "twrnc"
+
+export function FeedCard({ style, ...props }: ViewProps) {
+	return <View style={[tw`border border-stone-200 dark:border-stone-800 rounded-lg`, style]} {...props} />
+}

apps/aelis-client/src/components/ui/icon-symbol.ios.tsx

@@ -1,32 +0,0 @@
-import { SymbolView, SymbolViewProps, SymbolWeight } from "expo-symbols"
-import { StyleProp, ViewStyle } from "react-native"
-
-export function IconSymbol({
-	name,
-	size = 24,
-	color,
-	style,
-	weight = "regular",
-}: {
-	name: SymbolViewProps["name"]
-	size?: number
-	color: string
-	style?: StyleProp<ViewStyle>
-	weight?: SymbolWeight
-}) {
-	return (
-		<SymbolView
-			weight={weight}
-			tintColor={color}
-			resizeMode="scaleAspectFit"
-			name={name}
-			style={[
-				{
-					width: size,
-					height: size,
-				},
-				style,
-			]}
-		/>
-	)
-}

apps/aelis-client/src/components/ui/icon-symbol.tsx

@@ -1,41 +0,0 @@
-// Fallback for using MaterialIcons on Android and web.
-
-import MaterialIcons from "@expo/vector-icons/MaterialIcons"
-import { SymbolWeight, SymbolViewProps } from "expo-symbols"
-import { ComponentProps } from "react"
-import { OpaqueColorValue, type StyleProp, type TextStyle } from "react-native"
-
-type IconMapping = Record<SymbolViewProps["name"], ComponentProps<typeof MaterialIcons>["name"]>
-type IconSymbolName = keyof typeof MAPPING
-
-/**
- * Add your SF Symbols to Material Icons mappings here.
- * - see Material Icons in the [Icons Directory](https://icons.expo.fyi).
- * - see SF Symbols in the [SF Symbols](https://developer.apple.com/sf-symbols/) app.
- */
-const MAPPING = {
-	"house.fill": "home",
-	"paperplane.fill": "send",
-	"chevron.left.forwardslash.chevron.right": "code",
-	"chevron.right": "chevron-right",
-} as IconMapping
-
-/**
- * An icon component that uses native SF Symbols on iOS, and Material Icons on Android and web.
- * This ensures a consistent look across platforms, and optimal resource usage.
- * Icon `name`s are based on SF Symbols and require manual mapping to Material Icons.
- */
-export function IconSymbol({
-	name,
-	size = 24,
-	color,
-	style,
-}: {
-	name: IconSymbolName
-	size?: number
-	color: string | OpaqueColorValue
-	style?: StyleProp<TextStyle>
-	weight?: SymbolWeight
-}) {
-	return <MaterialIcons color={color} size={size} name={MAPPING[name]} style={style} />
-}

apps/aelis-client/src/components/ui/monospace-text.showcase.tsx

@@ -0,0 +1,31 @@
+import { View } from "react-native"
+import tw from "twrnc"
+
+import { MonospaceText } from "./monospace-text"
+import { type Showcase, Section } from "../showcase"
+
+function MonospaceTextShowcase() {
+	return (
+		<View style={tw`gap-6`}>
+			<Section title="Sizes">
+				<View style={tw`gap-2`}>
+					<MonospaceText style={tw`text-sm`}>Small monospace text</MonospaceText>
+					<MonospaceText style={tw`text-base`}>Base monospace text</MonospaceText>
+					<MonospaceText style={tw`text-xl`}>Extra large monospace text</MonospaceText>
+					<MonospaceText style={tw`text-3xl`}>3XL monospace text</MonospaceText>
+				</View>
+			</Section>
+			<Section title="Code-like usage">
+				<View style={tw`bg-stone-200 dark:bg-stone-800 rounded-lg p-3`}>
+					<MonospaceText style={tw`text-sm`}>{"const x = 42;"}</MonospaceText>
+					<MonospaceText style={tw`text-sm`}>{"console.log(x);"}</MonospaceText>
+				</View>
+			</Section>
+		</View>
+	)
+}
+
+export const monospaceTextShowcase: Showcase = {
+	title: "MonospaceText",
+	component: MonospaceTextShowcase,
+}

apps/aelis-client/src/components/ui/monospace-text.tsx

@@ -0,0 +1,10 @@
+import { Text, type TextProps } from "react-native"
+import tw from "twrnc"
+
+export function MonospaceText({ children, style, ...props }: TextProps) {
+	return (
+		<Text style={[tw`text-stone-800 dark:text-stone-200`, { fontFamily: "Menlo" }, style]} {...props}>
+			{children}
+		</Text>
+	)
+}

apps/aelis-client/src/components/ui/sans-serif-text.showcase.tsx

@@ -0,0 +1,34 @@
+import { View } from "react-native"
+import tw from "twrnc"
+
+import { SansSerifText } from "./sans-serif-text"
+import { type Showcase, Section } from "../showcase"
+
+function SansSerifTextShowcase() {
+	return (
+		<View style={tw`gap-6`}>
+			<Section title="Sizes">
+				<View style={tw`gap-2`}>
+					<SansSerifText style={tw`text-sm`}>Small sans-serif text</SansSerifText>
+					<SansSerifText style={tw`text-base`}>Base sans-serif text</SansSerifText>
+					<SansSerifText style={tw`text-xl`}>Extra large sans-serif text</SansSerifText>
+					<SansSerifText style={tw`text-3xl`}>3XL sans-serif text</SansSerifText>
+				</View>
+			</Section>
+			<Section title="Weights">
+				<View style={tw`gap-2`}>
+					<SansSerifText style={tw`font-light`}>Light weight</SansSerifText>
+					<SansSerifText style={tw`font-normal`}>Normal weight</SansSerifText>
+					<SansSerifText style={tw`font-medium`}>Medium weight</SansSerifText>
+					<SansSerifText style={tw`font-semibold`}>Semibold weight</SansSerifText>
+					<SansSerifText style={tw`font-bold`}>Bold weight</SansSerifText>
+				</View>
+			</Section>
+		</View>
+	)
+}
+
+export const sansSerifTextShowcase: Showcase = {
+	title: "SansSerifText",
+	component: SansSerifTextShowcase,
+}

apps/aelis-client/src/components/ui/sans-serif-text.tsx

@@ -0,0 +1,10 @@
+import { Text, type TextProps } from "react-native"
+import tw from "twrnc"
+
+export function SansSerifText({ children, style, ...props }: TextProps) {
+	return (
+		<Text style={[tw`text-stone-800 dark:text-stone-200`, { fontFamily: "Inter" }, style]} {...props}>
+			{children}
+		</Text>
+	)
+}

apps/aelis-client/src/components/ui/serif-text.showcase.tsx

@@ -0,0 +1,25 @@
+import { View } from "react-native"
+import tw from "twrnc"
+
+import { SerifText } from "./serif-text"
+import { type Showcase, Section } from "../showcase"
+
+function SerifTextShowcase() {
+	return (
+		<View style={tw`gap-6`}>
+			<Section title="Sizes">
+				<View style={tw`gap-2`}>
+					<SerifText style={tw`text-sm`}>Small serif text</SerifText>
+					<SerifText style={tw`text-base`}>Base serif text</SerifText>
+					<SerifText style={tw`text-xl`}>Extra large serif text</SerifText>
+					<SerifText style={tw`text-3xl`}>3XL serif text</SerifText>
+				</View>
+			</Section>
+		</View>
+	)
+}
+
+export const serifTextShowcase: Showcase = {
+	title: "SerifText",
+	component: SerifTextShowcase,
+}

apps/aelis-client/src/components/ui/serif-text.tsx

@@ -0,0 +1,10 @@
+import { Text, type TextProps } from "react-native"
+import tw from "twrnc"
+
+export function SerifText({ children, style, ...props }: TextProps) {
+	return (
+		<Text style={[tw`text-stone-800 dark:text-stone-200`, { fontFamily: "Source Serif 4" }, style]} {...props}>
+			{children}
+		</Text>
+	)
+}

apps/aelis-client/src/constants/theme.ts

@@ -1,53 +0,0 @@
-/**
- * Below are the colors that are used in the app. The colors are defined in the light and dark mode.
- * There are many other ways to style your app. For example, [Nativewind](https://www.nativewind.dev/), [unistyles](https://reactnativeunistyles.vercel.app), etc.
- */
-
-import { Platform } from "react-native"
-
-const tintColorLight = "#0a7ea4"
-const tintColorDark = "#fff"
-
-export const Colors = {
-	light: {
-		text: "#11181C",
-		background: "#fff",
-		tint: tintColorLight,
-		icon: "#687076",
-		tabIconDefault: "#687076",
-		tabIconSelected: tintColorLight,
-	},
-	dark: {
-		text: "#ECEDEE",
-		background: "#151718",
-		tint: tintColorDark,
-		icon: "#9BA1A6",
-		tabIconDefault: "#9BA1A6",
-		tabIconSelected: tintColorDark,
-	},
-}
-
-export const Fonts = Platform.select({
-	ios: {
-		/** iOS `UIFontDescriptorSystemDesignDefault` */
-		sans: "system-ui",
-		/** iOS `UIFontDescriptorSystemDesignSerif` */
-		serif: "ui-serif",
-		/** iOS `UIFontDescriptorSystemDesignRounded` */
-		rounded: "ui-rounded",
-		/** iOS `UIFontDescriptorSystemDesignMonospaced` */
-		mono: "ui-monospace",
-	},
-	default: {
-		sans: "normal",
-		serif: "serif",
-		rounded: "normal",
-		mono: "monospace",
-	},
-	web: {
-		sans: "system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif",
-		serif: "Georgia, 'Times New Roman', serif",
-		rounded: "'SF Pro Rounded', 'Hiragino Maru Gothic ProN', Meiryo, 'MS PGothic', sans-serif",
-		mono: "SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace",
-	},
-})

apps/aelis-client/src/hooks/use-color-scheme.ts

@@ -1 +0,0 @@
-export { useColorScheme } from "react-native"

apps/aelis-client/src/hooks/use-color-scheme.web.ts

@@ -1,21 +0,0 @@
-import { useEffect, useState } from "react"
-import { useColorScheme as useRNColorScheme } from "react-native"
-
-/**
- * To support static rendering, this value needs to be re-calculated on the client side for web
- */
-export function useColorScheme() {
-	const [hasHydrated, setHasHydrated] = useState(false)
-
-	useEffect(() => {
-		setHasHydrated(true)
-	}, [])
-
-	const colorScheme = useRNColorScheme()
-
-	if (hasHydrated) {
-		return colorScheme
-	}
-
-	return "light"
-}

apps/aelis-client/src/hooks/use-theme-color.ts

@@ -1,21 +0,0 @@
-/**
- * Learn more about light and dark modes:
- * https://docs.expo.dev/guides/color-schemes/
- */
-
-import { Colors } from "@/constants/theme"
-import { useColorScheme } from "@/hooks/use-color-scheme"
-
-export function useThemeColor(
-	props: { light?: string; dark?: string },
-	colorName: keyof typeof Colors.light & keyof typeof Colors.dark,
-) {
-	const theme = useColorScheme() ?? "light"
-	const colorFromProps = props[theme]
-
-	if (colorFromProps) {
-		return colorFromProps
-	} else {
-		return Colors[theme][colorName]
-	}
-}

apps/aelis-client/src/json-render/catalog.ts

@@ -0,0 +1,68 @@
+import { defineCatalog } from "@json-render/core"
+import { schema } from "@json-render/react-native/schema"
+import { z } from "zod"
+
+export const catalog = defineCatalog(schema, {
+	components: {
+		View: {
+			props: z.object({
+				style: z.string().nullable(),
+			}),
+			slots: ["default"],
+			description:
+				"Generic layout container. The style prop accepts a twrnc class string (e.g. 'flex-row gap-2 p-4 items-center').",
+			example: { style: "flex-row gap-2 p-4" },
+		},
+		Button: {
+			props: z.object({
+				label: z.string(),
+				leadingIcon: z.string().nullable(),
+				trailingIcon: z.string().nullable(),
+			}),
+			events: ["press"],
+			slots: [],
+			description:
+				"Pressable button with a label and optional Feather icons. Icon values are Feather icon names (e.g. 'plus', 'arrow-right'). Bind on.press to trigger an action.",
+			example: { label: "Add item", leadingIcon: "plus", trailingIcon: null },
+		},
+		FeedCard: {
+			props: z.object({
+				style: z.string().nullable(),
+			}),
+			slots: ["default"],
+			description: "Bordered card container for feed content. The style prop accepts a twrnc class string.",
+			example: { style: "p-4 gap-2" },
+		},
+		SansSerifText: {
+			props: z.object({
+				text: z.string(),
+				style: z.string().nullable(),
+			}),
+			slots: [],
+			description:
+				"Sans-serif text (Inter font). The style prop accepts a twrnc class string for size, weight, color, etc.",
+			example: { text: "Hello world", style: "text-base font-medium" },
+		},
+		SerifText: {
+			props: z.object({
+				text: z.string(),
+				style: z.string().nullable(),
+			}),
+			slots: [],
+			description:
+				"Serif text (Source Serif 4 font). The style prop accepts a twrnc class string for size, color, etc.",
+			example: { text: "Heading", style: "text-xl" },
+		},
+		MonospaceText: {
+			props: z.object({
+				text: z.string(),
+				style: z.string().nullable(),
+			}),
+			slots: [],
+			description:
+				"Monospace text (Menlo font). The style prop accepts a twrnc class string for size, color, etc.",
+			example: { text: "const x = 42", style: "text-sm" },
+		},
+	},
+	actions: {},
+})

apps/aelis-client/src/json-render/index.ts

@@ -0,0 +1,2 @@
+export { catalog } from "./catalog"
+export { registry } from "./registry"

apps/aelis-client/src/json-render/registry.tsx

@@ -0,0 +1,39 @@
+import { defineRegistry } from "@json-render/react-native"
+import { View } from "react-native"
+import tw from "twrnc"
+
+import { Button } from "@/components/ui/button"
+import { FeedCard } from "@/components/ui/feed-card"
+import { MonospaceText } from "@/components/ui/monospace-text"
+import { SansSerifText } from "@/components/ui/sans-serif-text"
+import { SerifText } from "@/components/ui/serif-text"
+
+import { catalog } from "./catalog"
+
+type ButtonIconName = React.ComponentProps<typeof Button.Icon>["name"]
+
+export const { registry } = defineRegistry(catalog, {
+	components: {
+		View: ({ props, children }) => <View style={props.style ? tw`${props.style}` : undefined}>{children}</View>,
+		Button: ({ props, emit }) => (
+			<Button
+				label={props.label}
+				leadingIcon={props.leadingIcon ? <Button.Icon name={props.leadingIcon as ButtonIconName} /> : undefined}
+				trailingIcon={props.trailingIcon ? <Button.Icon name={props.trailingIcon as ButtonIconName} /> : undefined}
+				onPress={() => emit("press")}
+			/>
+		),
+		FeedCard: ({ props, children }) => (
+			<FeedCard style={props.style ? tw`${props.style}` : undefined}>{children}</FeedCard>
+		),
+		SansSerifText: ({ props }) => (
+			<SansSerifText style={props.style ? tw`${props.style}` : undefined}>{props.text}</SansSerifText>
+		),
+		SerifText: ({ props }) => (
+			<SerifText style={props.style ? tw`${props.style}` : undefined}>{props.text}</SerifText>
+		),
+		MonospaceText: ({ props }) => (
+			<MonospaceText style={props.style ? tw`${props.style}` : undefined}>{props.text}</MonospaceText>
+		),
+	},
+})

apps/waitlist-website/.dockerignore

@@ -0,0 +1,5 @@
+.react-router
+build
+node_modules
+.env
+README.md

apps/waitlist-website/.gitignore

@@ -0,0 +1,7 @@
+.DS_Store
+.env
+/node_modules/
+
+# React Router
+/.react-router/
+/build/

apps/waitlist-website/Dockerfile

@@ -0,0 +1,22 @@
+FROM oven/bun:1 AS development-dependencies-env
+COPY . /app
+WORKDIR /app
+RUN bun install
+
+FROM oven/bun:1 AS production-dependencies-env
+COPY ./package.json /app/
+WORKDIR /app
+RUN bun install --production
+
+FROM oven/bun:1 AS build-env
+COPY . /app/
+COPY --from=development-dependencies-env /app/node_modules /app/node_modules
+WORKDIR /app
+RUN bun run build
+
+FROM node:20-alpine
+COPY ./package.json /app/
+COPY --from=production-dependencies-env /app/node_modules /app/node_modules
+COPY --from=build-env /app/build /app/build
+WORKDIR /app
+CMD ["npm", "run", "start"]

apps/waitlist-website/README.md

@@ -0,0 +1,87 @@
+# Welcome to React Router!
+
+A modern, production-ready template for building full-stack React applications using React Router.
+
+[![Open in StackBlitz](https://developer.stackblitz.com/img/open_in_stackblitz.svg)](https://stackblitz.com/github/remix-run/react-router-templates/tree/main/default)
+
+## Features
+
+- 🚀 Server-side rendering
+- ⚡️ Hot Module Replacement (HMR)
+- 📦 Asset bundling and optimization
+- 🔄 Data loading and mutations
+- 🔒 TypeScript by default
+- 🎉 TailwindCSS for styling
+- 📖 [React Router docs](https://reactrouter.com/)
+
+## Getting Started
+
+### Installation
+
+Install the dependencies:
+
+```bash
+npm install
+```
+
+### Development
+
+Start the development server with HMR:
+
+```bash
+npm run dev
+```
+
+Your application will be available at `http://localhost:5173`.
+
+## Building for Production
+
+Create a production build:
+
+```bash
+npm run build
+```
+
+## Deployment
+
+### Docker Deployment
+
+To build and run using Docker:
+
+```bash
+docker build -t my-app .
+
+# Run the container
+docker run -p 3000:3000 my-app
+```
+
+The containerized application can be deployed to any platform that supports Docker, including:
+
+- AWS ECS
+- Google Cloud Run
+- Azure Container Apps
+- Digital Ocean App Platform
+- Fly.io
+- Railway
+
+### DIY Deployment
+
+If you're familiar with deploying Node applications, the built-in app server is production-ready.
+
+Make sure to deploy the output of `npm run build`
+
+```
+├── package.json
+├── package-lock.json (or pnpm-lock.yaml, or bun.lockb)
+├── build/
+│   ├── client/    # Static assets
+│   └── server/    # Server-side code
+```
+
+## Styling
+
+This template comes with [Tailwind CSS](https://tailwindcss.com/) already configured for a simple default starting experience. You can use whatever CSS framework you prefer.
+
+---
+
+Built with ❤️ using React Router.

apps/waitlist-website/app/app.css

@@ -0,0 +1,51 @@
+@import url("https://fonts.googleapis.com/css2?family=Source+Serif+4:ital,opsz,wght@0,8..60,200..900;1,8..60,200..900&display=swap");
+@import "tailwindcss";
+
+@source "../node_modules/streamdown/dist/*.js";
+
+@theme {
+	--font-sans:
+		"Inter", ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji",
+		"Segoe UI Symbol", "Noto Color Emoji";
+	--font-serif: "Source Serif 4", ui-serif, serif;
+}
+
+:root,
+html,
+body {
+	@apply w-full h-full;
+}
+
+@keyframes popover-in {
+	from {
+		opacity: 0;
+		transform: scale(0.95) translateY(4px);
+	}
+	to {
+		opacity: 1;
+		transform: scale(1) translateY(0);
+	}
+}
+
+@keyframes popover-out {
+	from {
+		opacity: 1;
+		transform: scale(1) translateY(0);
+	}
+	to {
+		opacity: 0;
+		transform: scale(0.95) translateY(4px);
+	}
+}
+
+html,
+body {
+	-webkit-font-smoothing: antialiased;
+	-moz-osx-font-smoothing: grayscale;
+
+	@apply bg-stone-50 dark:bg-stone-900 text-stone-900 dark:text-stone-200 selection:bg-teal-600 dark:selection:bg-teal-500 selection:text-stone-50 dark:selection:text-stone-900;
+
+	@media (prefers-color-scheme: dark) {
+		color-scheme: dark;
+	}
+}

apps/waitlist-website/app/chat/chat-box.tsx

@@ -0,0 +1,117 @@
+import clsx from "clsx"
+import { ArrowUpIcon, FileIcon, ImageIcon, PlusIcon, XIcon } from "lucide-react"
+import { motion, useAnimate } from "motion/react"
+import { useEffect, useRef, useState } from "react"
+import { Button, Menu, MenuItem, MenuTrigger, Popover } from "react-aria-components"
+
+export function ChatBox({
+	className,
+	validate,
+	onSubmit,
+}: {
+	className?: string
+	validate?: (value: string) => boolean
+	onSubmit: (email: string) => void
+	disabled?: boolean
+}) {
+	const [scope, animate] = useAnimate()
+	const [shouldShowInvalid, setShouldShowInvalid] = useState(false)
+	const clearInvalidStateTimeout = useRef<ReturnType<typeof setTimeout> | null>(null)
+
+	useEffect(
+		() => () => {
+			if (clearInvalidStateTimeout.current) {
+				clearTimeout(clearInvalidStateTimeout.current)
+			}
+		},
+		[],
+	)
+
+	function showInvalidState() {
+		animate(scope.current, { x: [0, -6, 6, -4, 4, -2, 2, 0] }, { duration: 0.4, ease: "easeOut" })
+		if (clearInvalidStateTimeout.current) {
+			clearTimeout(clearInvalidStateTimeout.current)
+		}
+		setShouldShowInvalid(true)
+		clearInvalidStateTimeout.current = setTimeout(() => {
+			setShouldShowInvalid(false)
+		}, 500)
+	}
+
+	const onFormSubmit = (e: React.FormEvent<HTMLFormElement>) => {
+		e.preventDefault()
+		const formData = new FormData(e.currentTarget)
+		const email = formData.get("liame")
+		if (typeof email === "string") {
+			const trimmed = email.trim()
+			if (trimmed.length === 0) {
+				showInvalidState()
+			} else if (validate && !validate(trimmed)) {
+				showInvalidState()
+			} else {
+				onSubmit(trimmed)
+				e.currentTarget.reset()
+			}
+		}
+	}
+
+	return (
+		<motion.form
+			ref={scope}
+			onSubmit={onFormSubmit}
+			className={`min-h-20 px-3 pt-2 pb-1.5 flex flex-col justify-between rounded-lg bg-stone-100 dark:bg-stone-800 border border-stone-200 dark:border-stone-700 ${className ?? ""} shadow-xs hover:shadow-sm`}
+		>
+			<input
+				name="liame"
+				className="w-full bg-transparent outline-none focus:outline-none ring-0 focus:ring-0"
+			/>
+			<div className="w-full flex justify-between">
+				<MenuTrigger>
+					<Button className="bg-transparent hover:bg-stone-200 dark:hover:bg-stone-700 active:bg-stone-300 dark:active:bg-stone-600 data-[pressed]:bg-stone-200 dark:data-[pressed]:bg-stone-700 rounded-full flex items-center justify-center p-1 -ml-1.5 active:inset-shadow-sm outline-none transition-transform duration-200 data-[pressed]:rotate-45">
+						<PlusIcon size={16} />
+					</Button>
+					<Popover
+						offset={4}
+						className="origin-bottom-left rounded-lg border border-stone-200 dark:border-stone-700 bg-stone-100 dark:bg-stone-800 shadow-lg p-1 min-w-40 outline-none data-[entering]:animate-[popover-in_150ms_ease-out] data-[exiting]:animate-[popover-out_100ms_ease-in]"
+						placement="top start"
+					>
+						<AttachmentMenu />
+					</Popover>
+				</MenuTrigger>
+				<button
+					type="submit"
+					disabled={shouldShowInvalid}
+					className={clsx(
+						"transition-all rounded-full flex items-center justify-center p-1 -mr-1.5 active:scale-95",
+						shouldShowInvalid
+							? "bg-red-400 hover:bg-red-300 text-stone-200 dark:text-stone-700"
+							: "bg-teal-600 hover:bg-teal-500 active:bg-teal-600 text-stone-200",
+					)}
+				>
+					{shouldShowInvalid ? <XIcon size={16} /> : <ArrowUpIcon size={16} />}
+				</button>
+			</div>
+		</motion.form>
+	)
+}
+
+function AttachmentMenu() {
+	return (
+		<Menu className="outline-none">
+			<MenuItem
+				className="flex items-center gap-2 px-2 py-1 rounded-md cursor-default outline-none hover:bg-stone-200 dark:hover:bg-stone-700 focus:bg-stone-200 dark:focus:bg-stone-700"
+				onAction={() => {}}
+			>
+				<ImageIcon size={14} />
+				Photos
+			</MenuItem>
+			<MenuItem
+				className="flex items-center gap-2 px-2 py-1 rounded-md cursor-default outline-none hover:bg-stone-200 dark:hover:bg-stone-700 focus:bg-stone-200 dark:focus:bg-stone-700"
+				onAction={() => {}}
+			>
+				<FileIcon size={14} />
+				Files
+			</MenuItem>
+		</Menu>
+	)
+}

apps/waitlist-website/app/chat/message.ts

@@ -0,0 +1,66 @@
+export interface UserMessage {
+	role: "user"
+	message: string
+	bubbleLayoutId?: string
+}
+
+export interface SystemMessage {
+	role: "system"
+	message: string
+}
+
+export type Message = UserMessage | SystemMessage
+
+function timeOfDay() {
+	const hours = new Date().getHours()
+	if (hours >= 5 && hours < 12) {
+		return "morning"
+	} else if (hours >= 12 && hours < 18) {
+		return "afternoon"
+	} else if (hours >= 18 && hours < 22) {
+		return "evening"
+	}
+	return "night"
+}
+
+export const INITIAL_MESSAGES: Message[] = [
+	{
+		role: "user",
+		message: "Who are you?",
+	},
+	{
+		role: "system",
+		message: `Hey! I'm **Aelis** — your personal assistant that brings you the right thing, at the right time, in the right place.
+
+- Jubilee line down? I've already found you an alternative route.
+- Dinner reservation at 8? I'll have the restaurant, directions, and the menu ready before you head out.
+
+I learn your routines, anticipate what's next, and surface what matters before you even think to look for it.
+
+I'm not ready yet — [@kennethnym](https://x.com/kennethnym) is still building me. **Drop your email below** and I'll let you know when I'm available.`,
+	},
+]
+
+export function waitListJoinedMessage(email: string): SystemMessage {
+	return {
+		role: "system",
+		message: `Thanks for joining the waitlist! I've sent you a confirmation email.
+I'll send an email to **${email}** when I'm ready.
+
+Have a good ${timeOfDay()}!`,
+	}
+}
+
+export function duplicateEmailMessage(): SystemMessage {
+	return {
+		role: "system",
+		message: `I appreciate your excitement! You are already on the waitlist. When I am ready, I will reach out again. Have a good ${timeOfDay()} :)`,
+	}
+}
+
+export function troubleMessage(): SystemMessage {
+	return {
+		role: "system",
+		message: `I apologize, but I am having trouble adding you to the waitlist. Could you refresh the page and try again please in a moment?`,
+	}
+}

apps/waitlist-website/app/chat/use-fake-streaming.ts

@@ -0,0 +1,23 @@
+import { useEffect, useMemo, useState } from "react"
+
+export function useFakeStreaming(fullContent: string) {
+	const [currentContent, setCurrentContent] = useState("")
+	const [isStreaming, setIsStreaming] = useState(true)
+
+	useEffect(() => {
+		const words = fullContent.split(" ")
+
+		let i = 0
+		const id = setInterval(() => {
+			if (i > words.length) {
+				setIsStreaming(false)
+				clearInterval(id)
+			} else {
+				setCurrentContent(words.slice(0, i).join(" ") + " ")
+				i++
+			}
+		}, 20)
+	}, [fullContent])
+
+	return useMemo(() => ({ currentContent, isStreaming }), [currentContent, isStreaming])
+}

apps/waitlist-website/app/components/animated-logo.tsx

@@ -0,0 +1,168 @@
+import Lottie, { type LottieRef } from "lottie-react"
+import { useEffect, useRef, useState } from "react"
+
+import { useColorScheme } from "~/hooks/use-color-scheme"
+import clickedAnimationDark from "~/lottie/clicked-dark.json"
+import clickedAnimationLight from "~/lottie/clicked-light.json"
+import loadingAnimationDark from "~/lottie/loading-dark.json"
+import loadingAnimationLight from "~/lottie/loading-light.json"
+import startLoadingAnimationDark from "~/lottie/start-loading-dark.json"
+import startLoadingAnimationLight from "~/lottie/start-loading-light.json"
+
+export const AnimatedLogoState = {
+	Idle: "idle",
+	Loading: "loading",
+} as const
+export type AnimatedLogoState = (typeof AnimatedLogoState)[keyof typeof AnimatedLogoState]
+
+interface AnimatedLogoProps {
+	state: AnimatedLogoState
+	className?: string
+}
+
+interface Animation {
+	loop: boolean
+	reverse: boolean
+	sticky: boolean
+	data: unknown
+}
+
+export function AnimatedLogo({ state, className }: AnimatedLogoProps) {
+	const colorScheme = useColorScheme()
+	const [animationQueue, setAnimationQueue] = useState<Animation[]>([])
+	const lottieRef: LottieRef = useRef(null)
+
+	let currentAnimation: Animation
+	let isIdle = false
+	if (animationQueue.length === 0) {
+		isIdle = true
+		currentAnimation = {
+			loop: false,
+			reverse: false,
+			sticky: false,
+			data: colorScheme === "dark" ? startLoadingAnimationDark : startLoadingAnimationLight,
+		}
+	} else {
+		isIdle = false
+		currentAnimation = animationQueue[0]
+	}
+
+	useEffect(() => {
+		if (state === AnimatedLogoState.Loading) {
+			setAnimationQueue((queue) => [
+				...queue,
+				{
+					loop: false,
+					reverse: false,
+					sticky: false,
+					data: colorScheme === "dark" ? startLoadingAnimationDark : startLoadingAnimationLight,
+				},
+				{
+					loop: true,
+					reverse: false,
+					sticky: false,
+					data: colorScheme === "dark" ? loadingAnimationDark : loadingAnimationLight,
+				},
+			])
+		} else if (state === AnimatedLogoState.Idle) {
+			setAnimationQueue((queue) => {
+				const last = queue.at(-1)
+				if (!last) {
+					return []
+				}
+				if (
+					last.loop &&
+					(last.data === loadingAnimationDark || last.data === loadingAnimationLight)
+				) {
+					return [
+						...queue,
+						{
+							loop: false,
+							sticky: false,
+							reverse: false,
+							data: colorScheme === "dark" ? loadingAnimationDark : loadingAnimationLight,
+						},
+						{
+							loop: false,
+							sticky: false,
+							reverse: true,
+							data: colorScheme === "dark" ? startLoadingAnimationDark : startLoadingAnimationLight,
+						},
+					]
+				}
+				return []
+			})
+		}
+	}, [state])
+
+	useEffect(() => {
+		if (!lottieRef.current) {
+			return
+		}
+		if (currentAnimation.reverse) {
+			const frames = lottieRef.current.getDuration(true)
+			if (frames) {
+				lottieRef.current.setDirection(-1)
+				lottieRef.current.goToAndPlay(frames - 1, true)
+			}
+		} else if (!isIdle) {
+			lottieRef.current.setDirection(1)
+			lottieRef.current.play()
+		}
+	}, [currentAnimation])
+
+	function onComplete() {
+		if (animationQueue.length > 0 && !animationQueue[0].sticky) {
+			setAnimationQueue((queue) => queue.slice(1))
+		}
+	}
+
+	function onLoopComplete() {
+		const current = animationQueue[0]
+		const next = animationQueue[1]
+		if (current && next && current.data === next.data && current.loop && !next.loop) {
+			setAnimationQueue((queue) => queue.slice(2))
+		}
+	}
+
+	function onMouseDown() {
+		if (state === AnimatedLogoState.Idle) {
+			setAnimationQueue([
+				{
+					loop: false,
+					sticky: true,
+					reverse: false,
+					data: colorScheme === "dark" ? clickedAnimationDark : clickedAnimationLight,
+				},
+			])
+		}
+	}
+
+	function onMouseUp() {
+		if (state === AnimatedLogoState.Idle) {
+			setAnimationQueue((queue) => [
+				{
+					loop: false,
+					sticky: false,
+					reverse: true,
+					data: colorScheme === "dark" ? clickedAnimationDark : clickedAnimationLight,
+				},
+			])
+		}
+	}
+
+	return (
+		<Lottie
+			lottieRef={lottieRef}
+			autoplay={false}
+			loop={currentAnimation.loop}
+			className={className}
+			animationData={currentAnimation.data}
+			onComplete={onComplete}
+			onLoopComplete={onLoopComplete}
+			onMouseDown={onMouseDown}
+			onMouseUp={onMouseUp}
+			onMouseLeave={onMouseUp}
+		/>
+	)
+}

apps/waitlist-website/app/components/progressive-blur.tsx

@@ -0,0 +1,35 @@
+export function ProgressiveBlur({
+	className,
+	direction = "down",
+}: {
+	className?: string
+	direction?: "down" | "up"
+}) {
+	if (direction === "up") {
+		return (
+			<div className={`pointer-events-none ${className ?? ""}`}>
+				<div className="absolute inset-0 backdrop-blur-[1px] [mask:linear-gradient(rgba(0,0,0,0)_0%,rgba(0,0,0,1)_10%,rgba(0,0,0,1)_20%,rgba(0,0,0,0)_30%)]" />
+				<div className="absolute inset-0 backdrop-blur-[2px] [mask:linear-gradient(rgba(0,0,0,0)_10%,rgba(0,0,0,1)_20%,rgba(0,0,0,1)_40%,rgba(0,0,0,0)_50%)]" />
+				<div className="absolute inset-0 backdrop-blur-[4px] [mask:linear-gradient(rgba(0,0,0,0)_20%,rgba(0,0,0,1)_30%,rgba(0,0,0,1)_50%,rgba(0,0,0,0)_60%)]" />
+				<div className="absolute inset-0 backdrop-blur-[8px] [mask:linear-gradient(rgba(0,0,0,0)_30%,rgba(0,0,0,1)_40%,rgba(0,0,0,1)_60%,rgba(0,0,0,0)_70%)]" />
+				<div className="absolute inset-0 backdrop-blur-[16px] [mask:linear-gradient(rgba(0,0,0,0)_40%,rgba(0,0,0,1)_50%,rgba(0,0,0,1)_70%,rgba(0,0,0,0)_80%)]" />
+				<div className="absolute inset-0 backdrop-blur-[32px] [mask:linear-gradient(rgba(0,0,0,0)_50%,rgba(0,0,0,1)_60%,rgba(0,0,0,1)_80%,rgba(0,0,0,0)_90%)]" />
+				<div className="absolute inset-0 backdrop-blur-[64px] [mask:linear-gradient(rgba(0,0,0,0)_70%,rgba(0,0,0,1)_80%,rgba(0,0,0,1)_100%)]" />
+				<div className="absolute inset-0 bg-linear-to-t from-stone-50 dark:from-stone-900 to-transparent" />
+			</div>
+		)
+	}
+
+	return (
+		<div className={`pointer-events-none ${className ?? ""}`}>
+			<div className="absolute inset-0 backdrop-blur-[64px] [mask:linear-gradient(rgba(0,0,0,1)_0%,rgba(0,0,0,1)_20%,rgba(0,0,0,0)_30%)]" />
+			<div className="absolute inset-0 backdrop-blur-[32px] [mask:linear-gradient(rgba(0,0,0,0)_10%,rgba(0,0,0,1)_20%,rgba(0,0,0,1)_40%,rgba(0,0,0,0)_50%)]" />
+			<div className="absolute inset-0 backdrop-blur-[16px] [mask:linear-gradient(rgba(0,0,0,0)_20%,rgba(0,0,0,1)_30%,rgba(0,0,0,1)_50%,rgba(0,0,0,0)_60%)]" />
+			<div className="absolute inset-0 backdrop-blur-[8px] [mask:linear-gradient(rgba(0,0,0,0)_30%,rgba(0,0,0,1)_40%,rgba(0,0,0,1)_60%,rgba(0,0,0,0)_70%)]" />
+			<div className="absolute inset-0 backdrop-blur-[4px] [mask:linear-gradient(rgba(0,0,0,0)_40%,rgba(0,0,0,1)_50%,rgba(0,0,0,1)_70%,rgba(0,0,0,0)_80%)]" />
+			<div className="absolute inset-0 backdrop-blur-[2px] [mask:linear-gradient(rgba(0,0,0,0)_50%,rgba(0,0,0,1)_60%,rgba(0,0,0,1)_80%,rgba(0,0,0,0)_90%)]" />
+			<div className="absolute inset-0 backdrop-blur-[1px] [mask:linear-gradient(rgba(0,0,0,0)_70%,rgba(0,0,0,1)_80%,rgba(0,0,0,1)_90%,rgba(0,0,0,0)_100%)]" />
+			<div className="absolute inset-0 bg-linear-to-b from-stone-50 dark:from-stone-900 to-transparent" />
+		</div>
+	)
+}

apps/waitlist-website/app/hooks/use-color-scheme.ts

@@ -0,0 +1,27 @@
+import { useEffect, useState } from "react"
+
+export const ColorScheme = {
+	Light: "light",
+	Dark: "dark",
+} as const
+export type ColorScheme = (typeof ColorScheme)[keyof typeof ColorScheme]
+
+export function useColorScheme(): ColorScheme {
+	const [scheme, setScheme] = useState<ColorScheme>(() => {
+		if (typeof window === "undefined") return ColorScheme.Light
+		return window.matchMedia("(prefers-color-scheme: dark)").matches
+			? ColorScheme.Dark
+			: ColorScheme.Light
+	})
+
+	useEffect(() => {
+		const mql = window.matchMedia("(prefers-color-scheme: dark)")
+		const handler = (e: MediaQueryListEvent) => {
+			setScheme(e.matches ? ColorScheme.Dark : ColorScheme.Light)
+		}
+		mql.addEventListener("change", handler)
+		return () => mql.removeEventListener("change", handler)
+	}, [])
+
+	return scheme
+}

apps/waitlist-website/app/lottie/clicked-dark.json

@@ -0,0 +1 @@
+{"fr":60,"h":400,"ip":0,"layers":[{"ind":3,"ty":4,"parent":2,"ks":{},"ip":0,"op":7,"st":0,"shapes":[{"ty":"gr","it":[{"ty":"rc","p":{"a":0,"k":[160,53]},"r":{"a":0,"k":0},"s":{"a":0,"k":[336,122]}},{"ty":"fl","c":{"a":0,"k":[0,0,0,0]},"o":{"a":0,"k":0}},{"ty":"tr","o":{"a":0,"k":100}}]},{"ty":"gr","it":[{"ty":"el","p":{"a":0,"k":[160,53]},"s":{"a":0,"k":[320,106]}},{"ty":"st","c":{"a":0,"k":[0.906,0.898,0.894]},"lc":1,"lj":1,"ml":10,"o":{"a":0,"k":100},"w":{"a":0,"k":16}},{"ty":"tr","o":{"a":0,"k":100}}]}]},{"ind":2,"ty":3,"parent":1,"ks":{"a":{"a":0,"k":[160,53]},"p":{"a":0,"k":[200.5,200]},"r":{"a":1,"k":[{"t":0,"s":[-30],"i":{"x":0,"y":1},"o":{"x":0.5,"y":0}},{"t":6,"s":[-10],"h":1}]}},"ip":0,"op":7,"st":0},{"ind":5,"ty":4,"parent":4,"ks":{},"ip":0,"op":7,"st":0,"shapes":[{"ty":"gr","it":[{"ty":"rc","p":{"a":0,"k":[160,53]},"r":{"a":0,"k":0},"s":{"a":0,"k":[336,122]}},{"ty":"fl","c":{"a":0,"k":[0,0,0,0]},"o":{"a":0,"k":0}},{"ty":"tr","o":{"a":0,"k":100}}]},{"ty":"gr","it":[{"ty":"el","p":{"a":0,"k":[160,53]},"s":{"a":0,"k":[320,106]}},{"ty":"st","c":{"a":0,"k":[0.906,0.898,0.894]},"lc":1,"lj":1,"ml":10,"o":{"a":0,"k":100},"w":{"a":0,"k":16}},{"ty":"tr","o":{"a":0,"k":100}}]}]},{"ind":4,"ty":3,"parent":1,"ks":{"a":{"a":0,"k":[160,53]},"p":{"a":0,"k":[200.594,200.176]},"r":{"a":1,"k":[{"t":0,"s":[30],"i":{"x":0,"y":1},"o":{"x":0.5,"y":0}},{"t":6,"s":[10],"h":1}]}},"ip":0,"op":7,"st":0},{"ind":1,"ty":3,"parent":0,"ks":{},"ip":0,"op":7,"st":0},{"ind":0,"ty":3,"ks":{},"ip":0,"op":7,"st":0}],"meta":{"g":"https://jitter.video"},"op":6,"v":"5.7.4","w":400}

apps/waitlist-website/app/lottie/clicked-light.json

@@ -0,0 +1 @@
+{"fr":60,"h":400,"ip":0,"layers":[{"ind":3,"ty":4,"parent":2,"ks":{},"ip":0,"op":7,"st":0,"shapes":[{"ty":"gr","it":[{"ty":"rc","p":{"a":0,"k":[160,53]},"r":{"a":0,"k":0},"s":{"a":0,"k":[336,122]}},{"ty":"fl","c":{"a":0,"k":[0,0,0,0]},"o":{"a":0,"k":0}},{"ty":"tr","o":{"a":0,"k":100}}]},{"ty":"gr","it":[{"ty":"el","p":{"a":0,"k":[160,53]},"s":{"a":0,"k":[320,106]}},{"ty":"st","c":{"a":0,"k":[0.11,0.098,0.09]},"lc":1,"lj":1,"ml":10,"o":{"a":0,"k":100},"w":{"a":0,"k":16}},{"ty":"tr","o":{"a":0,"k":100}}]}]},{"ind":2,"ty":3,"parent":1,"ks":{"a":{"a":0,"k":[160,53]},"p":{"a":0,"k":[200.5,200]},"r":{"a":1,"k":[{"t":0,"s":[-30],"i":{"x":0,"y":1},"o":{"x":0.5,"y":0}},{"t":6,"s":[-10],"h":1}]}},"ip":0,"op":7,"st":0},{"ind":5,"ty":4,"parent":4,"ks":{},"ip":0,"op":7,"st":0,"shapes":[{"ty":"gr","it":[{"ty":"rc","p":{"a":0,"k":[160,53]},"r":{"a":0,"k":0},"s":{"a":0,"k":[336,122]}},{"ty":"fl","c":{"a":0,"k":[0,0,0,0]},"o":{"a":0,"k":0}},{"ty":"tr","o":{"a":0,"k":100}}]},{"ty":"gr","it":[{"ty":"el","p":{"a":0,"k":[160,53]},"s":{"a":0,"k":[320,106]}},{"ty":"st","c":{"a":0,"k":[0.11,0.098,0.09]},"lc":1,"lj":1,"ml":10,"o":{"a":0,"k":100},"w":{"a":0,"k":16}},{"ty":"tr","o":{"a":0,"k":100}}]}]},{"ind":4,"ty":3,"parent":1,"ks":{"a":{"a":0,"k":[160,53]},"p":{"a":0,"k":[200.594,200.176]},"r":{"a":1,"k":[{"t":0,"s":[30],"i":{"x":0,"y":1},"o":{"x":0.5,"y":0}},{"t":6,"s":[10],"h":1}]}},"ip":0,"op":7,"st":0},{"ind":1,"ty":3,"parent":0,"ks":{},"ip":0,"op":7,"st":0},{"ind":0,"ty":3,"ks":{},"ip":0,"op":7,"st":0}],"meta":{"g":"https://jitter.video"},"op":6,"v":"5.7.4","w":400}

apps/waitlist-website/app/lottie/loading-dark.json

@@ -0,0 +1 @@
+{"fr":60,"h":400,"ip":0,"layers":[{"ind":3,"ty":4,"parent":2,"ks":{},"ip":0,"op":61,"st":0,"shapes":[{"ty":"gr","it":[{"ty":"rc","p":{"a":0,"k":[160,26.75]},"r":{"a":0,"k":0},"s":{"a":0,"k":[336,174.5]}},{"ty":"fl","c":{"a":0,"k":[0,0,0,0]},"o":{"a":0,"k":0}},{"ty":"tr","o":{"a":0,"k":100}}]},{"ty":"gr","it":[{"ty":"el","p":{"a":1,"k":[{"t":0,"s":[160,0.5],"i":{"x":[1,1],"y":[1,1]},"o":{"x":[0,0],"y":[0,0]}},{"t":8.4,"s":[160,0.5],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":30,"s":[160,53],"i":{"x":[1,1],"y":[1,1]},"o":{"x":[0,0],"y":[0,0]}},{"t":37.8,"s":[160,53],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":60,"s":[160,0.5],"h":1}]},"s":{"a":1,"k":[{"t":0,"s":[320,1],"i":{"x":[1,1],"y":[1,1]},"o":{"x":[0,0],"y":[0,0]}},{"t":8.4,"s":[320,1],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":30,"s":[320,106],"i":{"x":[1,1],"y":[1,1]},"o":{"x":[0,0],"y":[0,0]}},{"t":37.8,"s":[320,106],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":60,"s":[320,1],"h":1}]}},{"ty":"st","c":{"a":0,"k":[0.906,0.898,0.894]},"lc":1,"lj":1,"ml":10,"o":{"a":0,"k":100},"w":{"a":0,"k":16}},{"ty":"tr","o":{"a":0,"k":100}}]}]},{"ind":2,"ty":3,"parent":1,"ks":{"a":{"a":1,"k":[{"t":0,"s":[160,0.5],"i":{"x":[1,1],"y":[1,1]},"o":{"x":[0,0],"y":[0,0]}},{"t":8.4,"s":[160,0.5],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":30,"s":[160,53],"i":{"x":[1,1],"y":[1,1]},"o":{"x":[0,0],"y":[0,0]}},{"t":37.8,"s":[160,53],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":60,"s":[160,0.5],"h":1}]},"p":{"a":0,"k":[200,200.014]},"r":{"a":1,"k":[{"t":0,"s":[-90],"h":1},{"t":8.4,"s":[-90],"i":{"x":0,"y":1},"o":{"x":0.5,"y":0}},{"t":30,"s":[0],"h":1},{"t":37.8,"s":[0],"i":{"x":0,"y":1},"o":{"x":0.5,"y":0}},{"t":60,"s":[90],"h":1}]}},"ip":0,"op":61,"st":0},{"ind":5,"ty":4,"parent":4,"ks":{},"ip":0,"op":61,"st":0,"shapes":[{"ty":"gr","it":[{"ty":"rc","p":{"a":0,"k":[160,26.75]},"r":{"a":0,"k":0},"s":{"a":0,"k":[336,174.5]}},{"ty":"fl","c":{"a":0,"k":[0,0,0,0]},"o":{"a":0,"k":0}},{"ty":"tr","o":{"a":0,"k":100}}]},{"ty":"gr","it":[{"ty":"el","p":{"a":1,"k":[{"t":0,"s":[160,0.5],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":30,"s":[160,53],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":60,"s":[160,0.5],"h":1}]},"s":{"a":1,"k":[{"t":0,"s":[320,1],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":30,"s":[320,106],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":60,"s":[320,1],"h":1}]}},{"ty":"st","c":{"a":0,"k":[0.906,0.898,0.894]},"lc":1,"lj":1,"ml":10,"o":{"a":0,"k":100},"w":{"a":0,"k":16}},{"ty":"tr","o":{"a":0,"k":100}}]}]},{"ind":4,"ty":3,"parent":1,"ks":{"a":{"a":1,"k":[{"t":0,"s":[160,0.5],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":30,"s":[160,53],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":60,"s":[160,0.5],"h":1}]},"p":{"a":0,"k":[200.094,200.19]},"r":{"a":1,"k":[{"t":0,"s":[-90],"i":{"x":0,"y":1},"o":{"x":0.5,"y":0}},{"t":30,"s":[0],"i":{"x":0,"y":1},"o":{"x":0.5,"y":0}},{"t":60,"s":[90],"h":1}]}},"ip":0,"op":61,"st":0},{"ind":1,"ty":3,"parent":0,"ks":{},"ip":0,"op":61,"st":0},{"ind":0,"ty":3,"ks":{},"ip":0,"op":61,"st":0}],"meta":{"g":"https://jitter.video"},"op":60,"v":"5.7.4","w":400}

apps/waitlist-website/app/lottie/loading-light.json

@@ -0,0 +1 @@
+{"fr":60,"h":400,"ip":0,"layers":[{"ind":3,"ty":4,"parent":2,"ks":{},"ip":0,"op":61,"st":0,"shapes":[{"ty":"gr","it":[{"ty":"rc","p":{"a":0,"k":[160,26.75]},"r":{"a":0,"k":0},"s":{"a":0,"k":[336,174.5]}},{"ty":"fl","c":{"a":0,"k":[0,0,0,0]},"o":{"a":0,"k":0}},{"ty":"tr","o":{"a":0,"k":100}}]},{"ty":"gr","it":[{"ty":"el","p":{"a":1,"k":[{"t":0,"s":[160,0.5],"i":{"x":[1,1],"y":[1,1]},"o":{"x":[0,0],"y":[0,0]}},{"t":8.4,"s":[160,0.5],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":30,"s":[160,53],"i":{"x":[1,1],"y":[1,1]},"o":{"x":[0,0],"y":[0,0]}},{"t":37.8,"s":[160,53],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":60,"s":[160,0.5],"h":1}]},"s":{"a":1,"k":[{"t":0,"s":[320,1],"i":{"x":[1,1],"y":[1,1]},"o":{"x":[0,0],"y":[0,0]}},{"t":8.4,"s":[320,1],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":30,"s":[320,106],"i":{"x":[1,1],"y":[1,1]},"o":{"x":[0,0],"y":[0,0]}},{"t":37.8,"s":[320,106],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":60,"s":[320,1],"h":1}]}},{"ty":"st","c":{"a":0,"k":[0.11,0.098,0.09]},"lc":1,"lj":1,"ml":10,"o":{"a":0,"k":100},"w":{"a":0,"k":16}},{"ty":"tr","o":{"a":0,"k":100}}]}]},{"ind":2,"ty":3,"parent":1,"ks":{"a":{"a":1,"k":[{"t":0,"s":[160,0.5],"i":{"x":[1,1],"y":[1,1]},"o":{"x":[0,0],"y":[0,0]}},{"t":8.4,"s":[160,0.5],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":30,"s":[160,53],"i":{"x":[1,1],"y":[1,1]},"o":{"x":[0,0],"y":[0,0]}},{"t":37.8,"s":[160,53],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":60,"s":[160,0.5],"h":1}]},"p":{"a":0,"k":[200,200.014]},"r":{"a":1,"k":[{"t":0,"s":[-90],"h":1},{"t":8.4,"s":[-90],"i":{"x":0,"y":1},"o":{"x":0.5,"y":0}},{"t":30,"s":[0],"h":1},{"t":37.8,"s":[0],"i":{"x":0,"y":1},"o":{"x":0.5,"y":0}},{"t":60,"s":[90],"h":1}]}},"ip":0,"op":61,"st":0},{"ind":5,"ty":4,"parent":4,"ks":{},"ip":0,"op":61,"st":0,"shapes":[{"ty":"gr","it":[{"ty":"rc","p":{"a":0,"k":[160,26.75]},"r":{"a":0,"k":0},"s":{"a":0,"k":[336,174.5]}},{"ty":"fl","c":{"a":0,"k":[0,0,0,0]},"o":{"a":0,"k":0}},{"ty":"tr","o":{"a":0,"k":100}}]},{"ty":"gr","it":[{"ty":"el","p":{"a":1,"k":[{"t":0,"s":[160,0.5],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":30,"s":[160,53],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":60,"s":[160,0.5],"h":1}]},"s":{"a":1,"k":[{"t":0,"s":[320,1],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":30,"s":[320,106],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":60,"s":[320,1],"h":1}]}},{"ty":"st","c":{"a":0,"k":[0.11,0.098,0.09]},"lc":1,"lj":1,"ml":10,"o":{"a":0,"k":100},"w":{"a":0,"k":16}},{"ty":"tr","o":{"a":0,"k":100}}]}]},{"ind":4,"ty":3,"parent":1,"ks":{"a":{"a":1,"k":[{"t":0,"s":[160,0.5],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":30,"s":[160,53],"i":{"x":[1,0],"y":[1,1]},"o":{"x":[0,0.5],"y":[0,0]}},{"t":60,"s":[160,0.5],"h":1}]},"p":{"a":0,"k":[200.094,200.19]},"r":{"a":1,"k":[{"t":0,"s":[-90],"i":{"x":0,"y":1},"o":{"x":0.5,"y":0}},{"t":30,"s":[0],"i":{"x":0,"y":1},"o":{"x":0.5,"y":0}},{"t":60,"s":[90],"h":1}]}},"ip":0,"op":61,"st":0},{"ind":1,"ty":3,"parent":0,"ks":{},"ip":0,"op":61,"st":0},{"ind":0,"ty":3,"ks":{},"ip":0,"op":61,"st":0}],"meta":{"g":"https://jitter.video"},"op":60,"v":"5.7.4","w":400}

apps/waitlist-website/app/lottie/start-loading-dark.json

@@ -0,0 +1 @@
+{"fr":60,"h":400,"ip":0,"layers":[{"ind":3,"ty":4,"parent":2,"ks":{},"ip":0,"op":31,"st":0,"shapes":[{"ty":"gr","it":[{"ty":"rc","p":{"a":0,"k":[160,26.75]},"r":{"a":0,"k":0},"s":{"a":0,"k":[336,174.5]}},{"ty":"fl","c":{"a":0,"k":[0,0,0,0]},"o":{"a":0,"k":0}},{"ty":"tr","o":{"a":0,"k":100}}]},{"ty":"gr","it":[{"ty":"el","p":{"a":1,"k":[{"t":0,"s":[160,53],"i":{"x":[1,1],"y":[1,1]},"o":{"x":[0,0],"y":[0,0]}},{"t":5.28,"s":[160,53],"i":{"x":[1,0.001],"y":[1,0.998]},"o":{"x":[0,0.349],"y":[0,0]}},{"t":30,"s":[160,0.5],"h":1}]},"s":{"a":1,"k":[{"t":0,"s":[320,106],"i":{"x":[1,1],"y":[1,1]},"o":{"x":[0,0],"y":[0,0]}},{"t":5.28,"s":[320,106],"i":{"x":[1,0.001],"y":[1,0.998]},"o":{"x":[0,0.349],"y":[0,0]}},{"t":30,"s":[320,1],"h":1}]}},{"ty":"st","c":{"a":0,"k":[0.906,0.898,0.894]},"lc":1,"lj":1,"ml":10,"o":{"a":0,"k":100},"w":{"a":0,"k":16}},{"ty":"tr","o":{"a":0,"k":100}}]}]},{"ind":2,"ty":3,"parent":1,"ks":{"a":{"a":1,"k":[{"t":0,"s":[160,53],"i":{"x":[1,1],"y":[1,1]},"o":{"x":[0,0],"y":[0,0]}},{"t":5.28,"s":[160,53],"i":{"x":[1,0.001],"y":[1,0.998]},"o":{"x":[0,0.349],"y":[0,0]}},{"t":30,"s":[160,0.5],"h":1}]},"p":{"a":0,"k":[200.5,200]},"r":{"a":1,"k":[{"t":0,"s":[-30],"h":1},{"t":5.28,"s":[-30],"i":{"x":0.001,"y":0.998},"o":{"x":0.349,"y":0}},{"t":30,"s":[-90],"h":1}]}},"ip":0,"op":31,"st":0},{"ind":5,"ty":4,"parent":4,"ks":{},"ip":0,"op":31,"st":0,"shapes":[{"ty":"gr","it":[{"ty":"rc","p":{"a":0,"k":[160,26.75]},"r":{"a":0,"k":0},"s":{"a":0,"k":[336,174.5]}},{"ty":"fl","c":{"a":0,"k":[0,0,0,0]},"o":{"a":0,"k":0}},{"ty":"tr","o":{"a":0,"k":100}}]},{"ty":"gr","it":[{"ty":"el","p":{"a":1,"k":[{"t":0,"s":[160,53],"i":{"x":[1,0],"y":[1,0.999]},"o":{"x":[0,0.348],"y":[0,0]}},{"t":30,"s":[160,0.5],"h":1}]},"s":{"a":1,"k":[{"t":0,"s":[320,106],"i":{"x":[1,0],"y":[1,0.999]},"o":{"x":[0,0.348],"y":[0,0]}},{"t":30,"s":[320,1],"h":1}]}},{"ty":"st","c":{"a":0,"k":[0.906,0.898,0.894]},"lc":1,"lj":1,"ml":10,"o":{"a":0,"k":100},"w":{"a":0,"k":16}},{"ty":"tr","o":{"a":0,"k":100}}]}]},{"ind":4,"ty":3,"parent":1,"ks":{"a":{"a":1,"k":[{"t":0,"s":[160,53],"i":{"x":[1,0],"y":[1,0.999]},"o":{"x":[0,0.348],"y":[0,0]}},{"t":30,"s":[160,0.5],"h":1}]},"p":{"a":0,"k":[200.594,200.176]},"r":{"a":1,"k":[{"t":0,"s":[30],"i":{"x":0,"y":0.999},"o":{"x":0.348,"y":0}},{"t":30,"s":[90],"h":1}]}},"ip":0,"op":31,"st":0},{"ind":1,"ty":3,"parent":0,"ks":{},"ip":0,"op":31,"st":0},{"ind":0,"ty":3,"ks":{},"ip":0,"op":31,"st":0}],"meta":{"g":"https://jitter.video"},"op":30,"v":"5.7.4","w":400}

apps/waitlist-website/app/lottie/start-loading-light.json

@@ -0,0 +1 @@
+{"fr":60,"h":400,"ip":0,"layers":[{"ind":3,"ty":4,"parent":2,"ks":{},"ip":0,"op":31,"st":0,"shapes":[{"ty":"gr","it":[{"ty":"rc","p":{"a":0,"k":[160,26.75]},"r":{"a":0,"k":0},"s":{"a":0,"k":[336,174.5]}},{"ty":"fl","c":{"a":0,"k":[0,0,0,0]},"o":{"a":0,"k":0}},{"ty":"tr","o":{"a":0,"k":100}}]},{"ty":"gr","it":[{"ty":"el","p":{"a":1,"k":[{"t":0,"s":[160,53],"i":{"x":[1,1],"y":[1,1]},"o":{"x":[0,0],"y":[0,0]}},{"t":5.28,"s":[160,53],"i":{"x":[1,0.001],"y":[1,0.998]},"o":{"x":[0,0.349],"y":[0,0]}},{"t":30,"s":[160,0.5],"h":1}]},"s":{"a":1,"k":[{"t":0,"s":[320,106],"i":{"x":[1,1],"y":[1,1]},"o":{"x":[0,0],"y":[0,0]}},{"t":5.28,"s":[320,106],"i":{"x":[1,0.001],"y":[1,0.998]},"o":{"x":[0,0.349],"y":[0,0]}},{"t":30,"s":[320,1],"h":1}]}},{"ty":"st","c":{"a":0,"k":[0.11,0.098,0.09]},"lc":1,"lj":1,"ml":10,"o":{"a":0,"k":100},"w":{"a":0,"k":16}},{"ty":"tr","o":{"a":0,"k":100}}]}]},{"ind":2,"ty":3,"parent":1,"ks":{"a":{"a":1,"k":[{"t":0,"s":[160,53],"i":{"x":[1,1],"y":[1,1]},"o":{"x":[0,0],"y":[0,0]}},{"t":5.28,"s":[160,53],"i":{"x":[1,0.001],"y":[1,0.998]},"o":{"x":[0,0.349],"y":[0,0]}},{"t":30,"s":[160,0.5],"h":1}]},"p":{"a":0,"k":[200.5,200]},"r":{"a":1,"k":[{"t":0,"s":[-30],"h":1},{"t":5.28,"s":[-30],"i":{"x":0.001,"y":0.998},"o":{"x":0.349,"y":0}},{"t":30,"s":[-90],"h":1}]}},"ip":0,"op":31,"st":0},{"ind":5,"ty":4,"parent":4,"ks":{},"ip":0,"op":31,"st":0,"shapes":[{"ty":"gr","it":[{"ty":"rc","p":{"a":0,"k":[160,26.75]},"r":{"a":0,"k":0},"s":{"a":0,"k":[336,174.5]}},{"ty":"fl","c":{"a":0,"k":[0,0,0,0]},"o":{"a":0,"k":0}},{"ty":"tr","o":{"a":0,"k":100}}]},{"ty":"gr","it":[{"ty":"el","p":{"a":1,"k":[{"t":0,"s":[160,53],"i":{"x":[1,0],"y":[1,0.999]},"o":{"x":[0,0.348],"y":[0,0]}},{"t":30,"s":[160,0.5],"h":1}]},"s":{"a":1,"k":[{"t":0,"s":[320,106],"i":{"x":[1,0],"y":[1,0.999]},"o":{"x":[0,0.348],"y":[0,0]}},{"t":30,"s":[320,1],"h":1}]}},{"ty":"st","c":{"a":0,"k":[0.11,0.098,0.09]},"lc":1,"lj":1,"ml":10,"o":{"a":0,"k":100},"w":{"a":0,"k":16}},{"ty":"tr","o":{"a":0,"k":100}}]}]},{"ind":4,"ty":3,"parent":1,"ks":{"a":{"a":1,"k":[{"t":0,"s":[160,53],"i":{"x":[1,0],"y":[1,0.999]},"o":{"x":[0,0.348],"y":[0,0]}},{"t":30,"s":[160,0.5],"h":1}]},"p":{"a":0,"k":[200.594,200.176]},"r":{"a":1,"k":[{"t":0,"s":[30],"i":{"x":0,"y":0.999},"o":{"x":0.348,"y":0}},{"t":30,"s":[90],"h":1}]}},"ip":0,"op":31,"st":0},{"ind":1,"ty":3,"parent":0,"ks":{},"ip":0,"op":31,"st":0},{"ind":0,"ty":3,"ks":{},"ip":0,"op":31,"st":0}],"meta":{"g":"https://jitter.video"},"op":30,"v":"5.7.4","w":400}

apps/waitlist-website/app/root.tsx

@@ -0,0 +1,88 @@
+import { isRouteErrorResponse, Links, Meta, Outlet, Scripts, ScrollRestoration } from "react-router"
+
+import type { Route } from "./+types/root"
+
+import "./app.css"
+import "streamdown/styles.css"
+
+export const links: Route.LinksFunction = () => [
+	{ rel: "preconnect", href: "https://fonts.googleapis.com" },
+	{
+		rel: "preconnect",
+		href: "https://fonts.gstatic.com",
+		crossOrigin: "anonymous",
+	},
+	{
+		rel: "stylesheet",
+		href: "https://fonts.googleapis.com/css2?family=Inter:ital,opsz,wght@0,14..32,100..900;1,14..32,100..900&display=swap",
+	},
+	{
+		rel: "icon",
+		href: "/favicon-light.svg",
+		type: "image/svg+xml",
+		media: "(prefers-color-scheme: light)",
+	},
+	{
+		rel: "icon",
+		href: "/favicon-dark.svg",
+		type: "image/svg+xml",
+		media: "(prefers-color-scheme: dark)",
+	},
+	{
+		rel: "icon",
+		href: "/favicon.ico",
+		sizes: "any",
+	},
+]
+
+export function Layout({ children }: { children: React.ReactNode }) {
+	return (
+		<html lang="en">
+			<head>
+				<meta charSet="utf-8" />
+				<meta name="viewport" content="width=device-width, initial-scale=1" />
+				<Meta />
+				<Links />
+			</head>
+			<body>
+				{children}
+				<ScrollRestoration />
+				<Scripts />
+			</body>
+		</html>
+	)
+}
+
+export default function App() {
+	return <Outlet />
+}
+
+export function ErrorBoundary({ error }: Route.ErrorBoundaryProps) {
+	let message = "Oops!"
+	let details = "An unexpected error occurred."
+	let stack: string | undefined
+
+	if (isRouteErrorResponse(error)) {
+		message = error.status === 404 ? "404" : "Error"
+		details =
+			error.status === 404 ? "The requested page could not be found." : error.statusText || details
+	} else if (import.meta.env.DEV && error && error instanceof Error) {
+		details = error.message
+		stack = error.stack
+	}
+
+	return (
+		<main className="flex flex-col items-center justify-center w-full h-full gap-4">
+			<h1 className="text-6xl font-semibold">{message}</h1>
+			<p className="text-stone-600 dark:text-stone-400">{details}</p>
+			<a href="/" className="mt-4 text-sm underline opacity-50 hover:opacity-75">
+				Back to home
+			</a>
+			{stack && (
+				<pre className="mt-8 w-full max-w-2xl p-4 overflow-x-auto text-xs bg-stone-100 dark:bg-stone-800 rounded-lg">
+					<code>{stack}</code>
+				</pre>
+			)}
+		</main>
+	)
+}

apps/waitlist-website/app/routes.ts

@@ -0,0 +1,6 @@
+import { type RouteConfig, index, route } from "@react-router/dev/routes"
+
+export default [
+	index("routes/home.tsx"),
+	route("privacy", "routes/privacy-policy.tsx"),
+] satisfies RouteConfig

apps/waitlist-website/app/routes/home.tsx

@@ -0,0 +1,395 @@
+import { AnimatePresence, motion } from "motion/react"
+import React, { useEffect, useLayoutEffect, useRef, useState } from "react"
+import { Link, useFetcher } from "react-router"
+import { Resend } from "resend"
+import { Streamdown } from "streamdown"
+
+import { ChatBox } from "~/chat/chat-box"
+import {
+	duplicateEmailMessage,
+	INITIAL_MESSAGES,
+	troubleMessage,
+	waitListJoinedMessage,
+	type Message,
+	type SystemMessage,
+	type UserMessage,
+} from "~/chat/message"
+import { useFakeStreaming } from "~/chat/use-fake-streaming"
+import {
+	AnimatedLogo,
+	AnimatedLogoState,
+	AnimatedLogoState as TAnimatedLogoState,
+} from "~/components/animated-logo"
+import { ProgressiveBlur } from "~/components/progressive-blur"
+
+import type { Route } from "./+types/home"
+
+const PAGE_TITLE = "Aelis - Next Generation AI Assistant"
+const PAGE_DESCRIPTION =
+	"Meet Aelis, a personal assistant that stays one step ahead of your day. Join the waitlist now."
+
+export function meta({}: Route.MetaArgs) {
+	return [
+		{ title: PAGE_TITLE },
+		{
+			name: "description",
+			content: PAGE_DESCRIPTION,
+		},
+		{ property: "og:title", content: PAGE_TITLE },
+		{ property: "og:description", content: PAGE_DESCRIPTION },
+		{ property: "og:image", content: "https://ael.is/social-media-preview.png" },
+		{ property: "og:url", content: "https://ael.is" },
+		{ property: "og:type", content: "website" },
+		{ name: "twitter:card", content: "summary_large_image" },
+		{ name: "twitter:title", content: PAGE_TITLE },
+		{ name: "twitter:description", content: PAGE_DESCRIPTION },
+		{ name: "twitter:image", content: "https://ael.is/social-media-preview.png" },
+	]
+}
+
+const FormError = {
+	Duplicate: "duplicate",
+	Resend: "resend",
+} as const
+
+export async function action({ request }: Route.ActionArgs) {
+	const formData = await request.formData()
+	const email = formData.get("email")
+
+	if (typeof email !== "string" || !isValidEmail(email)) {
+		return { error: "Invalid email" }
+	}
+
+	const resend = new Resend(process.env.RESEND_API_KEY)
+
+	const segmentId = "b80fb036-74a1-4f7d-bca5-2c035b696071"
+
+	const dup = await resend.contacts.get({
+		email,
+	})
+	if (dup.data) {
+		return { error: FormError.Duplicate }
+	}
+
+	const res = await resend.contacts.create({
+		email,
+		segments: [{ id: segmentId }],
+	})
+
+	if (res.error) {
+		console.log("Error adding contact to Resend:", res.error)
+		return { error: FormError.Resend, message: res.error.message }
+	}
+
+	await new Promise((resolve) => setTimeout(resolve, 1000))
+
+	const emailRes = await resend.emails.send({
+		from: "Aelis <no-reply@ael.is>",
+		to: email,
+		template: {
+			id: "waitlist-confirmation",
+		},
+	})
+
+	if (emailRes.error) {
+		// swallow the error since the user is already added to the waitlist, but log it for debugging
+		console.log("Error sending confirmation email:", emailRes.error)
+	}
+
+	return { email }
+}
+
+export default function Home() {
+	const [messages, setMessages] = useState<Message[]>(INITIAL_MESSAGES)
+	const [emailSent, setEmailSent] = useState("")
+	const [isAnimatingSend, setIsAnimatingSend] = useState(false)
+	const [logoState, setLogoState] = useState<TAnimatedLogoState>(AnimatedLogoState.Idle)
+	const chatBoxRef = useRef<HTMLDivElement>(null)
+	const fetcher = useFetcher()
+
+	useEffect(() => {
+		if (fetcher.data?.email && !isAnimatingSend) {
+			setMessages((messages) => [...messages, waitListJoinedMessage(fetcher.data.email)])
+		} else if (fetcher.data?.error) {
+			if (!isAnimatingSend) {
+				let errorMessage: SystemMessage
+				switch (fetcher.data.error) {
+					case FormError.Duplicate:
+						errorMessage = duplicateEmailMessage()
+						break
+					default: {
+						console.error(fetcher.data.error)
+						errorMessage = troubleMessage()
+						break
+					}
+				}
+				setMessages((messages) => [...messages, errorMessage])
+			}
+		}
+	}, [fetcher.data?.email, fetcher.data?.error, isAnimatingSend])
+
+	const insertEmailMessage = (email: string) => {
+		setEmailSent(email)
+		setIsAnimatingSend(true)
+		setLogoState(AnimatedLogoState.Loading)
+		setMessages((messages) => [
+			...messages,
+			{
+				role: "user",
+				message: email,
+				bubbleLayoutId: "test",
+			},
+		])
+
+		fetcher.submit({ email }, { method: "post" })
+	}
+
+	let chatBox: React.ReactNode
+	if (emailSent && isAnimatingSend) {
+		const chatBoxRect = chatBoxRef.current?.getBoundingClientRect()
+		const mainRect = chatBoxRef.current?.offsetParent?.getBoundingClientRect()
+		chatBox = (
+			<MorphingChatBox
+				chatBoxWidth={chatBoxRef.current?.offsetWidth ?? 0}
+				chatBoxHeight={chatBoxRef.current?.offsetHeight ?? 0}
+				chatBoxLeft={(chatBoxRect?.left ?? 0) - (mainRect?.left ?? 0)}
+				chatBoxTop={(chatBoxRect?.top ?? 0) - (mainRect?.top ?? 0)}
+				onAnimationEnd={() => {
+					setIsAnimatingSend(false)
+				}}
+			>
+				{emailSent}
+			</MorphingChatBox>
+		)
+	} else if (!emailSent) {
+		chatBox = (
+			<AnimatePresence>
+				{logoState === AnimatedLogoState.Idle && !emailSent && (
+					<motion.div
+						ref={chatBoxRef}
+						key="test"
+						className="w-full max-w-2xl absolute bottom-12 px-6 md:px-0 flex justify-center z-20"
+						initial={{ y: 100, opacity: 0 }}
+						animate={{ y: 0, opacity: 1 }}
+						transition={{ type: "spring", stiffness: 300, damping: 30, mass: 1.5 }}
+					>
+						<ChatBox
+							className="w-full max-w-2xl"
+							validate={isValidEmail}
+							disabled={fetcher.state === "submitting" || fetcher.state === "loading"}
+							onSubmit={insertEmailMessage}
+						/>
+					</motion.div>
+				)}
+			</AnimatePresence>
+		)
+	} else {
+		chatBox = null
+	}
+
+	return (
+		<main className="relative w-full h-full flex flex-col items-center justify-start gap-4 overflow-hidden">
+			<ProgressiveBlur className="absolute top-0 left-0 right-0 h-24 z-10" />
+			<AnimatedLogo
+				className="absolute top-4 md:top-8 size-10 z-20 cursor-pointer"
+				state={logoState}
+			/>
+			<MessageList
+				messages={messages}
+				showLastMessage={!isAnimatingSend}
+				onMessageStreamStart={() => {
+					setLogoState(AnimatedLogoState.Loading)
+				}}
+				onMessageStreamEnd={() => {
+					setLogoState(AnimatedLogoState.Idle)
+				}}
+			/>
+			{chatBox}
+			<ProgressiveBlur
+				direction="up"
+				className="absolute bottom-0 left-0 right-0 h-24 z-10 pointer-events-none"
+			/>
+			<footer className="absolute bottom-4 z-20">
+				<Link to="/privacy" className="text-xs opacity-50 underline">
+					Privacy policy
+				</Link>
+			</footer>
+		</main>
+	)
+}
+
+function MorphingChatBox({
+	chatBoxWidth,
+	chatBoxHeight,
+	chatBoxLeft,
+	chatBoxTop,
+	onAnimationEnd,
+	children,
+}: React.PropsWithChildren<{
+	chatBoxWidth: number
+	chatBoxHeight: number
+	chatBoxLeft: number
+	chatBoxTop: number
+	onAnimationEnd: () => void
+}>) {
+	const [targetWidth, setTargetWidth] = useState(-1)
+	const [targetHeight, setTargetHeight] = useState(-1)
+	const [targetCoords, setTargetCoords] = useState([0, 0])
+
+	useLayoutEffect(() => {
+		const bubble = document.getElementById("test")
+		if (bubble) {
+			const mainRect = bubble.closest("main")?.getBoundingClientRect()
+			const rect = bubble.getBoundingClientRect()
+			setTargetWidth(bubble.offsetWidth)
+			setTargetHeight(bubble.offsetHeight)
+			setTargetCoords([rect.left - (mainRect?.left ?? 0), rect.top - (mainRect?.top ?? 0)])
+		}
+	}, [])
+
+	if (targetWidth < 0 || targetHeight < 0) {
+		return null
+	}
+
+	return (
+		<motion.div
+			className="absolute rounded-lg bg-stone-100 dark:bg-stone-800 px-4 py-2 border border-stone-200 dark:border-stone-700"
+			initial={{
+				width: chatBoxWidth,
+				height: chatBoxHeight,
+				borderRadius: 8,
+				left: chatBoxLeft,
+				top: chatBoxTop,
+			}}
+			animate={{
+				width: targetWidth,
+				height: targetHeight,
+				borderTopLeftRadius: 100,
+				borderTopRightRadius: 100,
+				borderBottomRightRadius: 24,
+				borderBottomLeftRadius: 100,
+				left: targetCoords[0],
+				top: targetCoords[1],
+			}}
+			transition={{
+				left: { duration: 0.45, ease: [0.05, 0.8, 0.3, 1] },
+				top: { duration: 0.45, ease: [0.3, 0, 0.2, 1] },
+				width: { duration: 0.45, ease: [0.05, 0.8, 0.3, 1] },
+				height: { duration: 0.45, ease: [0.05, 0.8, 0.3, 1] },
+			}}
+			onAnimationComplete={onAnimationEnd}
+		>
+			{children}
+		</motion.div>
+	)
+}
+
+function MessageList({
+	messages,
+	showLastMessage,
+	onMessageStreamStart,
+	onMessageStreamEnd,
+}: {
+	messages: Message[]
+	showLastMessage: boolean
+	onMessageStreamStart: () => void
+	onMessageStreamEnd: () => void
+}) {
+	return (
+		<ul className="w-full flex flex-col gap-8 overflow-auto px-6 pt-20 md:px-0 md:pt-24 pb-34">
+			{messages.map((message, index) => (
+				<li
+					key={index}
+					className={`flex justify-center ${index === messages.length - 1 && !showLastMessage ? "invisible" : ""}`}
+				>
+					<MessageContent
+						message={message}
+						onMessageStreamStart={onMessageStreamStart}
+						onMessageStreamEnd={onMessageStreamEnd}
+					/>
+				</li>
+			))}
+		</ul>
+	)
+}
+
+function MessageContent({
+	message,
+	onMessageStreamStart,
+	onMessageStreamEnd,
+}: {
+	message: Message
+	onMessageStreamStart: () => void
+	onMessageStreamEnd: () => void
+}) {
+	switch (message.role) {
+		case "user":
+			return <UserMessageBubble message={message} />
+		case "system":
+			return (
+				<SystemMessageBubble
+					message={message}
+					onStreamStart={onMessageStreamStart}
+					onStreamEnd={onMessageStreamEnd}
+				/>
+			)
+	}
+}
+
+function UserMessageBubble({ message }: { message: UserMessage }) {
+	return (
+		<div className="w-full max-w-2xl flex justify-end">
+			<div
+				id={message.bubbleLayoutId}
+				className="rounded-[100px_100px_24px_100px] bg-stone-100 dark:bg-stone-800 border border-stone-200 dark:border-stone-700 px-4 py-2"
+			>
+				{message.message}
+			</div>
+		</div>
+	)
+}
+
+function SystemMessageBubble({
+	message,
+	onStreamStart,
+	onStreamEnd,
+}: {
+	message: SystemMessage
+	onStreamStart: () => void
+	onStreamEnd: () => void
+}) {
+	const { currentContent, isStreaming } = useFakeStreaming(message.message)
+	const ref = useRef<HTMLDivElement>(null)
+
+	useEffect(() => {
+		ref.current?.scrollIntoView({ behavior: "smooth", block: "end" })
+	}, [currentContent])
+
+	useEffect(() => {
+		if (isStreaming) {
+			onStreamStart()
+		} else {
+			onStreamEnd()
+		}
+	}, [isStreaming])
+
+	return (
+		<div ref={ref} className="w-full max-w-2xl flex justify-start font-serif text-lg scroll-mb-34">
+			<Streamdown
+				animated={{ animation: "slideUp" }}
+				isAnimating={isStreaming}
+				linkSafety={{ enabled: false }}
+				components={{
+					// @ts-expect-error
+					a: ({ className, ...props }) => <a className={`underline ${className}`} {...props} />,
+				}}
+			>
+				{currentContent}
+			</Streamdown>
+		</div>
+	)
+}
+
+function isValidEmail(value: string): boolean {
+	return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)
+}

apps/waitlist-website/app/routes/privacy-policy.tsx

@@ -0,0 +1,246 @@
+import { Link } from "react-router"
+import { Streamdown } from "streamdown"
+
+import { AnimatedLogo, AnimatedLogoState } from "~/components/animated-logo"
+
+import type { Route } from "./+types/privacy-policy"
+
+export function meta({}: Route.MetaArgs) {
+	return [
+		{ title: "Privacy Policy — Aelis" },
+		{ name: "description", content: "Aelis privacy policy" },
+	]
+}
+
+export default function PrivacyPolicy() {
+	return (
+		<main className="relative max-w-2xl mx-auto px-6 py-16">
+			<Link to="/" className="block w-fit mb-8">
+				<AnimatedLogo className="size-10 pointer-events-none" state={AnimatedLogoState.Idle} />
+			</Link>
+			<Streamdown
+				isAnimating={false}
+				linkSafety={{ enabled: false }}
+				components={{
+					a: ({ className, ...props }) => <a className={`underline ${className}`} {...props} />,
+				}}
+			>
+				{POLICY}
+			</Streamdown>
+			<footer className="mt-16 pt-8 border-t border-stone-200 dark:border-stone-700">
+				<Link to="/" className="text-sm opacity-50 hover:opacity-75 underline">
+					Back to home
+				</Link>
+			</footer>
+		</main>
+	)
+}
+
+const POLICY = `# Privacy Policy
+
+**Last updated:** March 5, 2026
+
+This Privacy Policy describes how **Aelis** ("we", "us", or "our") collects, uses, and protects your personal information when you visit **https://ael.is** or interact with our services.
+
+If you do not agree with this Privacy Policy, please do not use the website.
+
+For any questions, contact: **[kenneth@nym.sh](mailto:kenneth@nym.sh)**
+
+---
+
+## 1. Information We Collect
+
+### Personal Information You Provide
+
+**In Short:** We collect personal information that you provide to us.
+
+We collect personal information that you voluntarily provide when you express interest in our services, contact us, or sign up for the waitlist.
+
+We collect your email address when you sign up for the waitlist so we can notify you when the product launches or provide related updates.
+
+### Personal Information Provided by You
+
+The personal information we collect may include:
+
+* email addresses
+
+You are responsible for ensuring the personal information you provide is accurate and up to date.
+
+### Sensitive Information
+
+We **do not collect or process sensitive personal information**.
+
+### Information From Third Parties
+
+We **do not collect personal information from third parties**.
+
+---
+
+## 2. How We Use Your Information
+
+We process your information for the following purposes:
+
+* To operate and maintain our services
+* To communicate with you about product updates and launch announcements
+* To send administrative information such as policy updates
+* To prevent fraud or abuse
+* To comply with legal obligations
+* To protect someone’s safety when necessary
+
+We only process personal information when we have a valid legal reason to do so.
+
+---
+
+## 3. Legal Bases for Processing (EU / UK)
+
+If you are located in the European Economic Area (EEA) or the United Kingdom, we rely on the following legal bases to process personal information:
+
+### Consent
+
+You have given permission for us to process your personal information for a specific purpose.
+
+### Contract
+
+Processing is necessary to provide services you requested.
+
+### Legal Obligations
+
+Processing is required to comply with applicable laws.
+
+### Vital Interests
+
+Processing is necessary to protect someone's safety.
+
+You may withdraw consent at any time by contacting us.
+
+---
+
+## 4. When and With Whom We Share Personal Information
+
+We may share your personal information in limited situations.
+
+### Service Providers
+
+We may share information with trusted service providers that help us operate our website or manage communications.
+
+### Business Transfers
+
+We may transfer information during negotiations of a merger, sale of assets, financing, or acquisition of our business.
+
+We **do not sell your personal information**.
+
+---
+
+## 5. How Long We Keep Your Information
+
+We retain personal information only as long as necessary to:
+
+* provide services
+* comply with legal obligations
+* resolve disputes
+* enforce agreements
+
+When we no longer need personal information, we delete or anonymize it where possible.
+
+---
+
+## 6. How We Keep Your Information Safe
+
+We implement reasonable technical and organizational safeguards designed to protect personal information.
+
+However, no electronic transmission or storage system is completely secure. We cannot guarantee absolute security.
+
+---
+
+## 7. Information From Minors
+
+Our services are **not intended for individuals under 18 years old**.
+
+We do not knowingly collect personal information from children. If we discover that we have collected such information, we will delete it.
+
+If you believe a child has provided personal information, contact **[kenneth@nym.sh](mailto:kenneth@nym.sh)**.
+
+---
+
+## 8. Your Privacy Rights
+
+Depending on your location, you may have rights regarding your personal information, including:
+
+* the right to access your data
+* the right to correct inaccurate data
+* the right to delete your data
+* the right to restrict processing
+* the right to data portability
+* the right to object to processing
+* the right to withdraw consent
+
+To exercise these rights, submit a request:
+
+https://app.termly.io/dsar/b8633d03-406f-4133-b16e-ded63e893997
+
+Or contact us at **[kenneth@nym.sh](mailto:kenneth@nym.sh)**.
+
+---
+
+## 9. Do Not Track (DNT)
+
+Many browsers include a **Do Not Track (DNT)** feature.
+
+Because there is currently no consistent standard for responding to DNT signals, we do not respond to them.
+
+---
+
+## 10. Global Privacy Control
+
+We recognize **Global Privacy Control (GPC)** signals.
+
+If your browser sends a GPC signal, we treat it as a request to opt out of the sale or sharing of personal information where applicable.
+
+More information: https://globalprivacycontrol.org
+
+---
+
+## 11. Privacy Rights in Other Regions
+
+Additional privacy rights may apply depending on your location, including:
+
+* European Economic Area (EEA)
+* United Kingdom
+* Switzerland
+* Canada
+* United States
+* Australia
+* New Zealand
+
+If you believe we are processing your personal information unlawfully, you may contact your local data protection authority.
+
+---
+
+## 12. Updates to This Privacy Policy
+
+We may update this Privacy Policy from time to time.
+
+When we do, we will update the **Last updated** date at the top of this document.
+
+We encourage users to review this Privacy Policy regularly.
+
+---
+
+## 13. Contact Information
+
+If you have questions or comments about this Privacy Policy, you may contact us:
+
+**Aelis**
+
+Email: **[kenneth@nym.sh](mailto:kenneth@nym.sh)**
+
+---
+
+## 14. Request Access, Update, or Deletion
+
+Depending on applicable law, you may request access to, correction of, or deletion of your personal information.
+
+Email:
+
+**[kenneth@nym.sh](mailto:kenneth@nym.sh)**
+`

apps/waitlist-website/fly.toml

@@ -0,0 +1,22 @@
+# fly.toml app configuration file generated for aelis-waitlist-website on 2026-03-08T01:11:12Z
+#
+# See https://fly.io/docs/reference/configuration/ for information about how to use this file.
+#
+
+app = 'aelis-waitlist-website'
+primary_region = 'lhr'
+
+[build]
+
+[http_service]
+  internal_port = 3000
+  force_https = true
+  auto_stop_machines = 'stop'
+  auto_start_machines = true
+  min_machines_running = 0
+  processes = ['app']
+
+[[vm]]
+  memory = '1gb'
+  cpus = 1
+  memory_mb = 1024

apps/waitlist-website/package.json

@@ -0,0 +1,37 @@
+{
+	"name": "waitlist-website",
+	"private": true,
+	"type": "module",
+	"scripts": {
+		"build": "react-router build",
+		"dev": "react-router dev",
+		"start": "react-router-serve ./build/server/index.js",
+		"typecheck": "react-router typegen && tsc"
+	},
+	"dependencies": {
+		"@react-router/node": "7.12.0",
+		"@react-router/serve": "7.12.0",
+		"clsx": "^2.1.1",
+		"isbot": "^5.1.31",
+		"lottie-react": "^2.4.1",
+		"lucide-react": "^0.577.0",
+		"motion": "^12.35.0",
+		"react": "^19.2.4",
+		"react-aria-components": "^1.16.0",
+		"react-dom": "^19.2.4",
+		"react-router": "7.12.0",
+		"resend": "^6.9.3",
+		"streamdown": "^2.4.0"
+	},
+	"devDependencies": {
+		"@react-router/dev": "7.12.0",
+		"@tailwindcss/vite": "^4.1.13",
+		"@types/node": "^22",
+		"@types/react": "^19.2.7",
+		"@types/react-dom": "^19.2.3",
+		"tailwindcss": "^4.1.13",
+		"typescript": "^5.9.2",
+		"vite": "^7.1.7",
+		"vite-tsconfig-paths": "^5.1.4"
+	}
+}

apps/waitlist-website/public/favicon-dark.svg

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"><svg width="100%" height="100%" viewBox="0 0 1667 1667" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:1.5;"><rect id="dark" x="0" y="0" width="1666.67" height="1666.67" style="fill:none;"/><path d="M943.75,642.086c318.648,183.972 527.874,419.028 466.934,524.581c-60.941,105.552 -369.119,41.885 -687.767,-142.086c-318.649,-183.972 -527.875,-419.029 -466.934,-524.581c60.941,-105.552 369.119,-41.886 687.767,142.086Z" style="fill:none;stroke:#e7e5e4;stroke-width:62.5px;"/><path d="M722.917,642.086c318.648,-183.972 626.826,-247.638 687.767,-142.086c60.94,105.552 -148.286,340.609 -466.934,524.581c-318.648,183.971 -626.826,247.638 -687.767,142.086c-60.941,-105.553 148.285,-340.609 466.934,-524.581Z" style="fill:none;stroke:#e7e5e4;stroke-width:62.5px;"/></svg>

apps/waitlist-website/public/favicon-light.svg

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"><svg width="100%" height="100%" viewBox="0 0 1667 1667" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:1.5;"><rect id="light" x="0" y="0" width="1666.67" height="1666.67" style="fill:none;"/><g id="light1" serif:id="light"><path d="M943.75,642.086c318.648,183.972 527.874,419.028 466.934,524.581c-60.941,105.552 -369.119,41.885 -687.767,-142.086c-318.649,-183.972 -527.875,-419.029 -466.934,-524.581c60.941,-105.552 369.119,-41.886 687.767,142.086Z" style="fill:none;stroke:#1c1917;stroke-width:62.5px;"/><path d="M722.917,642.086c318.648,-183.972 626.826,-247.638 687.767,-142.086c60.94,105.552 -148.286,340.609 -466.934,524.581c-318.648,183.971 -626.826,247.638 -687.767,142.086c-60.941,-105.553 148.285,-340.609 466.934,-524.581Z" style="fill:none;stroke:#1c1917;stroke-width:62.5px;"/></g></svg>

apps/waitlist-website/public/robots.txt

@@ -0,0 +1,4 @@
+User-agent: *
+Allow: /
+
+Sitemap: https://ael.is/sitemap.xml

apps/waitlist-website/public/sitemap.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+	<url>
+		<loc>https://ael.is/</loc>
+	</url>
+	<url>
+		<loc>https://ael.is/privacy</loc>
+	</url>
+</urlset>

apps/waitlist-website/react-router.config.ts

@@ -0,0 +1,7 @@
+import type { Config } from "@react-router/dev/config"
+
+export default {
+	// Config options...
+	// Server-side render by default, to enable SPA mode set this to `false`
+	ssr: true,
+} satisfies Config

apps/waitlist-website/tsconfig.json

@@ -0,0 +1,22 @@
+{
+	"include": ["**/*", "**/.server/**/*", "**/.client/**/*", ".react-router/types/**/*"],
+	"compilerOptions": {
+		"lib": ["DOM", "DOM.Iterable", "ES2022"],
+		"types": ["node", "vite/client"],
+		"target": "ES2022",
+		"module": "ES2022",
+		"moduleResolution": "bundler",
+		"jsx": "react-jsx",
+		"rootDirs": [".", "./.react-router/types"],
+		"baseUrl": ".",
+		"paths": {
+			"~/*": ["./app/*"]
+		},
+		"esModuleInterop": true,
+		"verbatimModuleSyntax": true,
+		"noEmit": true,
+		"resolveJsonModule": true,
+		"skipLibCheck": true,
+		"strict": true
+	}
+}

apps/waitlist-website/vite.config.ts

@@ -0,0 +1,11 @@
+import { reactRouter } from "@react-router/dev/vite"
+import tailwindcss from "@tailwindcss/vite"
+import { defineConfig } from "vite"
+import tsconfigPaths from "vite-tsconfig-paths"
+
+export default defineConfig({
+	plugins: [tailwindcss(), reactRouter(), tsconfigPaths()],
+	ssr: {
+		noExternal: ["lottie-react"],
+	},
+})

package.json

@@ -14,6 +14,8 @@
 		"format:check": "oxfmt --check ."
 	},
 	"devDependencies": {
+		"@json-render/core": "^0.12.1",
+		"@nym.sh/jrx": "^0.2.0",
 		"@types/bun": "latest",
 		"oxfmt": "^0.24.0",
 		"oxlint": "^1.39.0"

packages/aelis-components/package.json

@@ -0,0 +1,14 @@
+{
+	"name": "@aelis/components",
+	"version": "0.0.0",
+	"type": "module",
+	"main": "src/index.ts",
+	"types": "src/index.ts",
+	"scripts": {
+		"test": "bun test ./src"
+	},
+	"peerDependencies": {
+		"@json-render/core": "*",
+		"@nym.sh/jrx": "*"
+	}
+}

packages/aelis-components/src/button.ts

@@ -0,0 +1,15 @@
+import type { JrxNode } from "@nym.sh/jrx"
+
+import { jsx } from "@nym.sh/jrx/jsx-runtime"
+
+export type ButtonProps = {
+	label: string
+	leadingIcon?: string
+	trailingIcon?: string
+	style?: string
+	children?: JrxNode | JrxNode[]
+}
+
+export function Button(props: ButtonProps): JrxNode {
+	return jsx("Button", props)
+}

packages/aelis-components/src/components.test.tsx

@@ -0,0 +1,155 @@
+/** @jsxImportSource @nym.sh/jrx */
+
+import { render } from "@nym.sh/jrx"
+import { describe, expect, test } from "bun:test"
+
+import { Button } from "./button.ts"
+import { FeedCard } from "./feed-card.ts"
+import { MonospaceText } from "./monospace-text.ts"
+import { SansSerifText } from "./sans-serif-text.ts"
+import { SerifText } from "./serif-text.ts"
+
+describe("Button", () => {
+	test("renders with label", () => {
+		const spec = render(<Button label="Press me" />)
+
+		expect(spec.root).toStartWith("button-")
+		const root = spec.elements[spec.root]!
+		expect(root.type).toBe("Button")
+		expect(root.props).toEqual({ label: "Press me" })
+	})
+
+	test("renders with icon props", () => {
+		const spec = render(<Button label="Add" leadingIcon="plus" trailingIcon="arrow-right" />)
+
+		const root = spec.elements[spec.root]!
+		expect(root.type).toBe("Button")
+		expect(root.props).toEqual({
+			label: "Add",
+			leadingIcon: "plus",
+			trailingIcon: "arrow-right",
+		})
+	})
+
+	test("passes style as string prop", () => {
+		const spec = render(<Button label="Go" style="px-4 py-2" />)
+
+		const root = spec.elements[spec.root]!
+		expect(root.props.style).toBe("px-4 py-2")
+	})
+})
+
+describe("FeedCard", () => {
+	test("renders as container", () => {
+		const spec = render(<FeedCard />)
+
+		expect(spec.root).toStartWith("feedcard-")
+		const root = spec.elements[spec.root]!
+		expect(root.type).toBe("FeedCard")
+	})
+
+	test("renders with a single child", () => {
+		const spec = render(
+			<FeedCard>
+				<SansSerifText content="Only child" />
+			</FeedCard>,
+		)
+
+		const root = spec.elements[spec.root]!
+		expect(root.children).toHaveLength(1)
+		const child = spec.elements[root.children![0]!]!
+		expect(child.type).toBe("SansSerifText")
+		expect(child.props).toEqual({ content: "Only child" })
+	})
+
+	test("passes style as string prop", () => {
+		const spec = render(<FeedCard style="p-4 border rounded-lg" />)
+
+		const root = spec.elements[spec.root]!
+		expect(root.props.style).toBe("p-4 border rounded-lg")
+	})
+})
+
+describe("SansSerifText", () => {
+	test("renders with content prop", () => {
+		const spec = render(<SansSerifText content="Hello" />)
+
+		expect(spec.root).toStartWith("sansseriftext-")
+		const root = spec.elements[spec.root]!
+		expect(root.type).toBe("SansSerifText")
+		expect(root.props).toEqual({ content: "Hello" })
+	})
+
+	test("passes style as string prop", () => {
+		const spec = render(<SansSerifText content="Hello" style="text-sm text-stone-500" />)
+
+		const root = spec.elements[spec.root]!
+		expect(root.props.style).toBe("text-sm text-stone-500")
+	})
+})
+
+describe("SerifText", () => {
+	test("renders with content prop", () => {
+		const spec = render(<SerifText content="Title" />)
+
+		expect(spec.root).toStartWith("seriftext-")
+		const root = spec.elements[spec.root]!
+		expect(root.type).toBe("SerifText")
+		expect(root.props).toEqual({ content: "Title" })
+	})
+
+	test("passes style as string prop", () => {
+		const spec = render(<SerifText content="Title" style="text-xl" />)
+
+		const root = spec.elements[spec.root]!
+		expect(root.props.style).toBe("text-xl")
+	})
+})
+
+describe("MonospaceText", () => {
+	test("renders with content prop", () => {
+		const spec = render(<MonospaceText content="code()" />)
+
+		expect(spec.root).toStartWith("monospacetext-")
+		const root = spec.elements[spec.root]!
+		expect(root.type).toBe("MonospaceText")
+		expect(root.props).toEqual({ content: "code()" })
+	})
+
+	test("passes style as string prop", () => {
+		const spec = render(<MonospaceText content="code()" style="text-xs" />)
+
+		const root = spec.elements[spec.root]!
+		expect(root.props.style).toBe("text-xs")
+	})
+})
+
+describe("composite", () => {
+	test("FeedCard with nested children", () => {
+		const spec = render(
+			<FeedCard>
+				<SerifText content="Weather" />
+				<SansSerifText content="Sunny, 22C" />
+				<Button label="Details" />
+			</FeedCard>,
+		)
+
+		const root = spec.elements[spec.root]!
+		expect(root.type).toBe("FeedCard")
+		expect(root.children).toHaveLength(3)
+
+		const childKeys = root.children!
+		const child0 = spec.elements[childKeys[0]!]!
+		const child1 = spec.elements[childKeys[1]!]!
+		const child2 = spec.elements[childKeys[2]!]!
+
+		expect(child0.type).toBe("SerifText")
+		expect(child0.props).toEqual({ content: "Weather" })
+
+		expect(child1.type).toBe("SansSerifText")
+		expect(child1.props).toEqual({ content: "Sunny, 22C" })
+
+		expect(child2.type).toBe("Button")
+		expect(child2.props).toEqual({ label: "Details" })
+	})
+})

packages/aelis-components/src/feed-card.ts

@@ -0,0 +1,12 @@
+import type { JrxNode } from "@nym.sh/jrx"
+
+import { jsx } from "@nym.sh/jrx/jsx-runtime"
+
+export type FeedCardProps = {
+	style?: string
+	children?: JrxNode | JrxNode[]
+}
+
+export function FeedCard(props: FeedCardProps): JrxNode {
+	return jsx("FeedCard", props)
+}

packages/aelis-components/src/index.ts

@@ -0,0 +1,14 @@
+export type { ButtonProps } from "./button.ts"
+export { Button } from "./button.ts"
+
+export type { FeedCardProps } from "./feed-card.ts"
+export { FeedCard } from "./feed-card.ts"
+
+export type { SansSerifTextProps } from "./sans-serif-text.ts"
+export { SansSerifText } from "./sans-serif-text.ts"
+
+export type { SerifTextProps } from "./serif-text.ts"
+export { SerifText } from "./serif-text.ts"
+
+export type { MonospaceTextProps } from "./monospace-text.ts"
+export { MonospaceText } from "./monospace-text.ts"

packages/aelis-components/src/monospace-text.ts

@@ -0,0 +1,13 @@
+import type { JrxNode } from "@nym.sh/jrx"
+
+import { jsx } from "@nym.sh/jrx/jsx-runtime"
+
+export type MonospaceTextProps = {
+	content?: string
+	style?: string
+	children?: JrxNode | JrxNode[]
+}
+
+export function MonospaceText(props: MonospaceTextProps): JrxNode {
+	return jsx("MonospaceText", props)
+}

packages/aelis-components/src/sans-serif-text.ts

@@ -0,0 +1,13 @@
+import type { JrxNode } from "@nym.sh/jrx"
+
+import { jsx } from "@nym.sh/jrx/jsx-runtime"
+
+export type SansSerifTextProps = {
+	content?: string
+	style?: string
+	children?: JrxNode | JrxNode[]
+}
+
+export function SansSerifText(props: SansSerifTextProps): JrxNode {
+	return jsx("SansSerifText", props)
+}

packages/aelis-components/src/serif-text.ts

@@ -0,0 +1,13 @@
+import type { JrxNode } from "@nym.sh/jrx"
+
+import { jsx } from "@nym.sh/jrx/jsx-runtime"
+
+export type SerifTextProps = {
+	content?: string
+	style?: string
+	children?: JrxNode | JrxNode[]
+}
+
+export function SerifText(props: SerifTextProps): JrxNode {
+	return jsx("SerifText", props)
+}