@c9up/aurora 0.1.22 → 0.1.24

package/dist/relay.js

@@ -22,22 +22,31 @@ const STATE = {
     uid: null,
     channels: new Map(),
     attached: new Set(),
+    status: "connecting",
+    statusListeners: new Map(),
+    reconnectAttempts: 0,
 };
 let CONFIG = {
     sseUrl: "/__relay/events",
     subscribeUrl: "/__relay/subscribe",
+    unsubscribeUrl: "/__relay/unsubscribe",
     bearer: "",
+    maxReconnectAttempts: 5,
 };
 /**
- * Configure the relay endpoints + bearer. Call once at boot if you
- * need to override the defaults. Multiple calls overwrite — last call
- * wins.
+ * Configure the relay endpoints + bearer + reconnect policy. Call once
+ * at boot if you need to override the defaults. Multiple calls overwrite
+ * — last call wins.
  */
 export function configureRelay(options) {
     CONFIG = {
         sseUrl: options.sseUrl ?? CONFIG.sseUrl,
         subscribeUrl: options.subscribeUrl ?? CONFIG.subscribeUrl,
+        unsubscribeUrl: options.unsubscribeUrl ?? CONFIG.unsubscribeUrl,
         bearer: options.bearer ?? CONFIG.bearer,
+        maxReconnectAttempts: options.maxReconnectAttempts ?? CONFIG.maxReconnectAttempts,
+        onReconnectAttempt: options.onReconnectAttempt ?? CONFIG.onReconnectAttempt,
+        onReconnectFailed: options.onReconnectFailed ?? CONFIG.onReconnectFailed,
     };
 }
 /**
@@ -74,11 +83,32 @@ const CLIENT = {
                 console.warn(`[aurora/relay] subscribe to ${channel} failed:`, err);
             });
         }
-        // Detacher — only removes the local listener. The server-side
-        // subscription stays open; closing it would interrupt other
-        // listeners on the same channel.
+        // Detacher — removes the local listener. When it was the LAST handler
+        // on the channel, the server-side subscription is dropped too (POST
+        // /__relay/unsubscribe), so the server stops streaming a channel
+        // nobody's listening to. Other channels / other listeners are
+        // untouched.
         return () => {
             handlers?.delete(adapted);
+            if (handlers && handlers.size === 0) {
+                STATE.channels.delete(channel);
+                if (STATE.uid) {
+                    postUnsubscribe(channel).catch((err) => {
+                        console.warn(`[aurora/relay] unsubscribe from ${channel} failed:`, err);
+                    });
+                }
+            }
+        };
+    },
+    on(status, callback) {
+        let set = STATE.statusListeners.get(status);
+        if (!set) {
+            set = new Set();
+            STATE.statusListeners.set(status, set);
+        }
+        set.add(callback);
+        return () => {
+            set?.delete(callback);
         };
     },
     close() {
@@ -89,16 +119,22 @@ const CLIENT = {
         STATE.uid = null;
         STATE.channels.clear();
         STATE.attached.clear();
+        STATE.reconnectAttempts = 0;
     },
 };
 function open() {
     const sse = new EventSource(CONFIG.sseUrl);
     STATE.sse = sse;
     STATE.attached = new Set();
+    changeStatus("connecting");
     sse.addEventListener("connected", (ev) => {
         const data = safeJson(messageData(ev));
         if (data && typeof data.uid === "string") {
             STATE.uid = data.uid;
+            // A successful (re)connect clears the failure counter and flips the
+            // status back to `connected`.
+            STATE.reconnectAttempts = 0;
+            changeStatus("connected");
             // Re-apply EVERY active subscription on each (re)connect. The server
             // assigns a fresh uid per connection and has no memory of prior
             // subscriptions, so both the first connect AND browser auto-reconnects
@@ -111,11 +147,46 @@ function open() {
             }
         }
     });
+    // The native EventSource auto-reconnects on a dropped connection, firing
+    // `error` each time. Mirror Transmit's reconnect bookkeeping: surface a
+    // `disconnected` → `reconnecting` transition, count attempts, and once the
+    // cap is reached close the stream (stopping the native retry loop) and fire
+    // `onReconnectFailed`.
+    sse.addEventListener("error", () => {
+        if (STATE.status !== "reconnecting")
+            changeStatus("disconnected");
+        changeStatus("reconnecting");
+        CONFIG.onReconnectAttempt?.(STATE.reconnectAttempts + 1);
+        if (CONFIG.maxReconnectAttempts > 0 &&
+            STATE.reconnectAttempts >= CONFIG.maxReconnectAttempts) {
+            sse.close();
+            if (STATE.sse === sse)
+                STATE.sse = null;
+            CONFIG.onReconnectFailed?.();
+            return;
+        }
+        STATE.reconnectAttempts++;
+    });
     // Re-attach channel listeners — a close()+reopen builds a fresh EventSource
     // that has lost the listeners wired by earlier subscribe() calls.
     for (const channel of STATE.channels.keys())
         attachChannel(sse, channel);
 }
+/** Update the status and notify every listener registered for it. */
+function changeStatus(status) {
+    STATE.status = status;
+    const set = STATE.statusListeners.get(status);
+    if (!set)
+        return;
+    for (const cb of set) {
+        try {
+            cb(status);
+        }
+        catch (err) {
+            console.warn(`[aurora/relay] status listener for ${status} threw:`, err);
+        }
+    }
+}
 /**
  * Wire one SSE listener for a channel's named broadcast events. The relay sends
  * `event: <channel>\ndata: <JSON payload>`, so each channel is its own named
@@ -150,21 +221,50 @@ function messageData(ev) {
         return ev.data;
     return null;
 }
-async function postSubscribe(channel) {
+function postSubscribe(channel) {
+    return postHandshake(CONFIG.subscribeUrl, channel);
+}
+function postUnsubscribe(channel) {
+    return postHandshake(CONFIG.unsubscribeUrl, channel);
+}
+/**
+ * POST a `{ uid, channel }` handshake to a relay endpoint. Sends the
+ * signed-CSRF trio blackhole expects: the `XSRF-TOKEN` cookie echoed as
+ * the `X-XSRF-TOKEN` header plus `credentials: 'include'` so the cookie
+ * itself rides along. Without both, the POST is rejected by the signed
+ * double-submit guard. Mirrors `HttpClient.#retrieveXsrfToken` /
+ * `createRequest` in `@adonisjs/transmit-client`.
+ */
+async function postHandshake(url, channel) {
     const headers = {
         "content-type": "application/json",
     };
     if (CONFIG.bearer)
         headers.authorization = `Bearer ${CONFIG.bearer}`;
-    const res = await fetch(CONFIG.subscribeUrl, {
+    const xsrf = retrieveXsrfToken();
+    if (xsrf !== null)
+        headers["x-xsrf-token"] = xsrf;
+    const res = await fetch(url, {
         method: "POST",
         headers,
         body: JSON.stringify({ uid: STATE.uid, channel }),
+        credentials: "include",
     });
     if (!res.ok) {
         throw new Error(`HTTP ${res.status}`);
     }
 }
+/**
+ * Read the `XSRF-TOKEN` cookie so it can be echoed as the `X-XSRF-TOKEN`
+ * header (signed double-submit CSRF). Browser-only — returns `null` under
+ * SSR / any environment without `document`.
+ */
+function retrieveXsrfToken() {
+    if (typeof document === "undefined")
+        return null;
+    const match = document.cookie.match(/(?:^|;\s*)XSRF-TOKEN=([^;]*)/);
+    return match ? decodeURIComponent(match[1]) : null;
+}
 function safeJson(raw) {
     if (typeof raw !== "string")
         return null;

package/dist/server/renderPage.d.ts

@@ -46,6 +46,12 @@ export interface RenderPageOptions {
     /**
      * Extra markup spliced into `<head>` after the importmap. Use to
      * inject `<title>`, meta tags, stylesheets.
+     *
+     * ⚠️ Injected RAW / unescaped — it IS `<head>` markup, so it cannot be
+     * HTML-escaped. Pass ONLY trusted, server-authored strings; NEVER
+     * interpolate request/user input into it (that is an HTML-injection
+     * sink). Build any dynamic head content through an escaping helper
+     * upstream before handing it here.
      */
     headExtra?: string;
     /**

package/dist/server/serveAssets.js

@@ -33,7 +33,10 @@ const CONTENT_TYPES = {
     ".json": "application/json; charset=utf-8",
 };
 export function serveAssets(options) {
-    const root = options.root;
+    // Normalize the root ONCE so the lexical containment gate below compares
+    // like-for-like: a raw root with a trailing slash or a non-normalized
+    // segment would never match the resolved request path → spurious 403s.
+    const root = resolvePath(options.root);
     const cacheControl = options.cacheControl ?? "public, max-age=60";
     // Canonicalize the root ONCE at handler creation. The realpath check
     // below compares against this canonical form so a symlinked root

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c9up/aurora",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "Aurora — reactive UI runtime for the Ream framework. Tagged-template DOM, signal-based state, isomorphic SSR + hydration, zero build step.",
   "license": "MIT",
   "type": "module",
@@ -53,14 +53,15 @@
     }
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.4.10",
     "@c9up/comet": "^0.1.0",
     "@types/node": "^22.19.15",
-    "@vitest/browser": "4.1.6",
-    "@vitest/browser-playwright": "^4.1.9",
+    "@vitest/browser": "4.1.9",
+    "@vitest/browser-playwright": "4.1.9",
     "happy-dom": "^15.11.7",
     "playwright": "^1.61.1",
     "typescript": "^6.0.2",
-    "vitest": "^4.1.2"
+    "vitest": "4.1.9"
   },
   "files": [
     "LICENSE",

package/src/Pages.ts

@@ -62,7 +62,11 @@ export class Pages {
 	private readonly registry = new Map<string, PageFactory>();
 
 	constructor(config: PagesConfig) {
-		this.root = config.root;
+		// Normalize the root ONCE so the `startsWith(root + sep)` containment
+		// check below compares like-for-like against the resolved page path.
+		// A raw root with a trailing slash, a relative segment, or `..` would
+		// otherwise never match the resolved absolute path → spurious 403s.
+		this.root = resolvePath(config.root);
 		this.urlPrefix = (config.urlPrefix ?? "/__assets/pages").replace(/\/$/, "");
 		this.extension = config.extension ?? ".js";
 	}

package/src/browser.ts

@@ -7,7 +7,7 @@
  * client barrel.
  */
 
-import { effect, type Signal, signal } from "./reactive.js";
+import { effect, onCleanup, type Signal, signal } from "./reactive.js";
 
 /** Navigate to `url` with a full page load. No-op during SSR. */
 export function redirect(url: string): void {
@@ -226,14 +226,21 @@ export function persistedSignal<T>(
 		typeof window !== "undefined"
 	) {
 		const fullKey = store.fullKey(key);
-		window.addEventListener("storage", (event) => {
+		const onStorage = (event: StorageEvent) => {
 			if (event.key !== fullKey || event.newValue === null) return;
 			try {
 				sig(JSON.parse(event.newValue) as T);
 			} catch {
 				// Ignore a malformed cross-tab write.
 			}
-		});
+		};
+		window.addEventListener("storage", onStorage);
+		// Tie the listener to the owning reactive scope so a persistedSignal
+		// created in a component's setup removes it on dispose (matching the
+		// mirror effect above — the JSDoc promises disposal-with-the-component).
+		// At module scope onCleanup is a no-op, so the listener lives for the
+		// page lifetime, as intended for a shared module-level signal.
+		onCleanup(() => window.removeEventListener("storage", onStorage));
 	}
 
 	return sig;

package/src/live.ts

@@ -1,143 +1,18 @@
 /**
- * Live components — server-resident reactive UI. The state lives on the server
- * as ordinary aurora signals; this module turns a fine-grained signal change
- * into a PRECISE per-slot patch (`{slot, value}`) instead of re-rendering the
- * whole component. That precision — each signal already knows which template
- * slot it feeds — is the angle that beats HTML-diffing live-view libraries.
+ * `@c9up/aurora/live` barrel — the whole Live surface behind ONE subpath.
  *
- * This is the transport-agnostic CORE (Stage 1): mount a session, render its
- * initial HTML, dispatch events that mutate signals, and drain / subscribe to
- * the patches produced. Wiring patches over `@c9up/relay` (SSE down, POST up)
- * and the thin client applier live in later stages.
+ * The transport-agnostic core (`mountLiveSession` + its types) lives in
+ * `./liveSession.js`; the transport stack (broadcast / client / registry /
+ * router / server) builds on it. Re-exporting everything here keeps the niche
+ * surface behind a single subpath and keeps the main `.` barrel lean (it no
+ * longer eager-pulls these into every browser graph), consistent with how
+ * `./ssr`, `./relay`, `./rpc` and `./hydrate` are already subpath-gated.
  *
- * Node-free / isomorphic: uses only `signal`/`effect`/`renderToString`, so it
- * sits in the main barrel alongside the rest of aurora's runtime.
+ * The core lives in a SEPARATE module (not inline here) so the transport files
+ * import it directly from `./liveSession.js` rather than through this barrel —
+ * which would otherwise form an import cycle (barrel → transport → barrel).
  */
 
-import { effect, isSignal } from "./reactive.js";
-import { renderToString } from "./ssr.js";
-import type { TemplateResult } from "./types.js";
-
-/** A precise per-slot update: slot index (positional in the template) + value. */
-export interface SlotPatch {
-	slot: number;
-	value: string;
-}
-
-/** A live component: its reactive view + named event handlers that mutate it. */
-export interface LiveComponentDefinition {
-	/** The reactive view. Slots reading signals become live-patchable. */
-	view: TemplateResult;
-	/**
-	 * Event handlers, by name. A client interaction (`@click="increment"`)
-	 * dispatches one of these; it mutates the component's signals, which the
-	 * patch tracker turns into a `{slot, value}` patch.
-	 */
-	handlers?: Record<string, (payload?: unknown) => void>;
-}
-
-/** A mounted live component instance — one per connected client session. */
-export interface LiveSession {
-	/** Initial server-side render (the first full-HTML response). */
-	renderToString(): string;
-	/** Run a named handler (mutates signals); emits a patch for the batch. */
-	dispatch(event: string, payload?: unknown): void;
-	/** Collect + clear the patches accumulated since the last drain (pull model). */
-	drainPatches(): SlotPatch[];
-	/**
-	 * Subscribe to patches as they are produced (push model — what the relay
-	 * transport hooks into). Use `onPatch` OR `drainPatches`, not both.
-	 */
-	onPatch(listener: (patch: SlotPatch[]) => void): () => void;
-	/** Stop every effect — call on client disconnect to free the session. */
-	dispose(): void;
-}
-
-/**
- * Mount a live session from a definition factory. Call once per connected
- * client: the factory's signals become that session's private state. To SHARE
- * state across sessions, close the factory over a signal created OUTSIDE it —
- * every session then reads the same signal and patches on its change.
- */
-export function mountLiveSession(
-	factory: () => LiveComponentDefinition,
-): LiveSession {
-	const { view, handlers = {} } = factory();
-	const listeners = new Set<(patch: SlotPatch[]) => void>();
-	// slot → latest value. `pending` = current (un-flushed) batch; `buffer` =
-	// accumulated for pull consumers. Both keyed by slot so repeated writes in
-	// one batch collapse to the last value.
-	const pending = new Map<number, string>();
-	const buffer = new Map<number, string>();
-	let priming = true;
-	let flushScheduled = false;
-
-	const flush = (): void => {
-		flushScheduled = false;
-		if (pending.size === 0) return;
-		const patch: SlotPatch[] = [];
-		for (const [slot, value] of pending) {
-			patch.push({ slot, value });
-			buffer.set(slot, value);
-		}
-		pending.clear();
-		for (const listener of listeners) listener(patch);
-	};
-
-	const scheduleFlush = (): void => {
-		if (flushScheduled) return;
-		flushScheduled = true;
-		queueMicrotask(flush);
-	};
-
-	// One fine-grained effect per reactive slot. The priming run only
-	// subscribes; later runs (a signal changed) record the slot's new value.
-	const stops = view.values.map((value, slot) => {
-		if (!isSignal(value) && typeof value !== "function") return () => {};
-		return effect(() => {
-			const next = String((value as () => unknown)());
-			if (priming) return;
-			pending.set(slot, next);
-			scheduleFlush();
-		});
-	});
-	priming = false;
-
-	return {
-		renderToString: () => renderToString(view),
-		dispatch(event, payload) {
-			const handler = handlers[event];
-			if (!handler) return;
-			handler(payload);
-			flush(); // synchronous — one patch per dispatch (batches the handler's writes)
-		},
-		drainPatches() {
-			flush();
-			const patch: SlotPatch[] = [];
-			for (const [slot, value] of buffer) patch.push({ slot, value });
-			buffer.clear();
-			return patch;
-		},
-		onPatch(listener) {
-			listeners.add(listener);
-			return () => listeners.delete(listener);
-		},
-		dispose() {
-			for (const stop of stops) stop();
-			listeners.clear();
-			pending.clear();
-			buffer.clear();
-		},
-	};
-}
-
-// ─── `@c9up/aurora/live` barrel ──────────────────────────────────────
-//
-// The Live stack (broadcast / client / registry / router / server) is
-// re-exported here so the whole niche surface lives behind ONE subpath,
-// `@c9up/aurora/live` — keeping the main `.` barrel lean (it no longer
-// eager-pulls these into every browser graph), consistent with how `./ssr`,
-// `./relay`, `./rpc` and `./hydrate` are already subpath-gated.
 export {
 	connectPatches,
 	type LiveStore,
@@ -169,3 +44,9 @@ export {
 	type WireLiveEventsOptions,
 	wireLiveEvents,
 } from "./liveServer.js";
+export {
+	type LiveComponentDefinition,
+	type LiveSession,
+	mountLiveSession,
+	type SlotPatch,
+} from "./liveSession.js";

package/src/liveBroadcast.ts

@@ -20,7 +20,7 @@ import {
 	type LiveSession,
 	mountLiveSession,
 	type SlotPatch,
-} from "./live.js";
+} from "./liveSession.js";
 
 /**
  * Minimal relay surface aurora needs. The real `@c9up/relay` `Relay` satisfies

package/src/liveClient.ts

@@ -16,8 +16,8 @@
  */
 
 import { hydrate } from "./hydrate.js";
+import type { SlotPatch } from "./liveSession.js";
 import { isSignal } from "./reactive.js";
-import type { SlotPatch } from "./live.js";
 import type { TemplateResult } from "./types.js";
 
 /** The transport the live client needs: a patch subscription + an event POST. */
@@ -67,7 +67,11 @@ export function liveClient(opts: LiveClientOptions): () => void {
 		const target = event.target;
 		if (!(target instanceof Element)) return;
 		const el = target.closest("[data-live-click]");
-		if (el) opts.transport.post(opts.mount.id, el.getAttribute("data-live-click") ?? "");
+		if (el)
+			opts.transport.post(
+				opts.mount.id,
+				el.getAttribute("data-live-click") ?? "",
+			);
 	};
 	opts.container.addEventListener("click", onClick);
 

package/src/liveRegistry.ts

@@ -15,7 +15,7 @@ import {
 	type LiveComponentDefinition,
 	type LiveSession,
 	mountLiveSession,
-} from "./live.js";
+} from "./liveSession.js";
 
 /** A mounted instance: its id, the owner (e.g. relay uid), and the session. */
 export interface LiveSessionHandle {

package/src/liveSession.ts

@@ -0,0 +1,133 @@
+/**
+ * Live components — server-resident reactive UI CORE. The state lives on the
+ * server as ordinary aurora signals; this module turns a fine-grained signal
+ * change into a PRECISE per-slot patch (`{slot, value}`) instead of re-rendering
+ * the whole component. That precision — each signal already knows which template
+ * slot it feeds — is the angle that beats HTML-diffing live-view libraries.
+ *
+ * This is the transport-agnostic core: mount a session, render its initial HTML,
+ * dispatch events that mutate signals, and drain / subscribe to the patches
+ * produced. The transport stack (broadcast / client / registry / router /
+ * server) builds ON this and re-exports through the `./live.js` barrel — kept in
+ * a separate module so those transport files import the core WITHOUT forming an
+ * import cycle back through the barrel.
+ *
+ * Node-free / isomorphic: uses only `signal`/`effect`/`renderToString`.
+ */
+
+import { effect, isSignal } from "./reactive.js";
+import { renderToString } from "./ssr.js";
+import type { TemplateResult } from "./types.js";
+
+/** A precise per-slot update: slot index (positional in the template) + value. */
+export interface SlotPatch {
+	slot: number;
+	value: string;
+}
+
+/** A live component: its reactive view + named event handlers that mutate it. */
+export interface LiveComponentDefinition {
+	/** The reactive view. Slots reading signals become live-patchable. */
+	view: TemplateResult;
+	/**
+	 * Event handlers, by name. A client interaction (`@click="increment"`)
+	 * dispatches one of these; it mutates the component's signals, which the
+	 * patch tracker turns into a `{slot, value}` patch.
+	 */
+	handlers?: Record<string, (payload?: unknown) => void>;
+}
+
+/** A mounted live component instance — one per connected client session. */
+export interface LiveSession {
+	/** Initial server-side render (the first full-HTML response). */
+	renderToString(): string;
+	/** Run a named handler (mutates signals); emits a patch for the batch. */
+	dispatch(event: string, payload?: unknown): void;
+	/** Collect + clear the patches accumulated since the last drain (pull model). */
+	drainPatches(): SlotPatch[];
+	/**
+	 * Subscribe to patches as they are produced (push model — what the relay
+	 * transport hooks into). Use `onPatch` OR `drainPatches`, not both.
+	 */
+	onPatch(listener: (patch: SlotPatch[]) => void): () => void;
+	/** Stop every effect — call on client disconnect to free the session. */
+	dispose(): void;
+}
+
+/**
+ * Mount a live session from a definition factory. Call once per connected
+ * client: the factory's signals become that session's private state. To SHARE
+ * state across sessions, close the factory over a signal created OUTSIDE it —
+ * every session then reads the same signal and patches on its change.
+ */
+export function mountLiveSession(
+	factory: () => LiveComponentDefinition,
+): LiveSession {
+	const { view, handlers = {} } = factory();
+	const listeners = new Set<(patch: SlotPatch[]) => void>();
+	// slot → latest value. `pending` = current (un-flushed) batch; `buffer` =
+	// accumulated for pull consumers. Both keyed by slot so repeated writes in
+	// one batch collapse to the last value.
+	const pending = new Map<number, string>();
+	const buffer = new Map<number, string>();
+	let priming = true;
+	let flushScheduled = false;
+
+	const flush = (): void => {
+		flushScheduled = false;
+		if (pending.size === 0) return;
+		const patch: SlotPatch[] = [];
+		for (const [slot, value] of pending) {
+			patch.push({ slot, value });
+			buffer.set(slot, value);
+		}
+		pending.clear();
+		for (const listener of listeners) listener(patch);
+	};
+
+	const scheduleFlush = (): void => {
+		if (flushScheduled) return;
+		flushScheduled = true;
+		queueMicrotask(flush);
+	};
+
+	// One fine-grained effect per reactive slot. The priming run only
+	// subscribes; later runs (a signal changed) record the slot's new value.
+	const stops = view.values.map((value, slot) => {
+		if (!isSignal(value) && typeof value !== "function") return () => {};
+		return effect(() => {
+			const next = String((value as () => unknown)());
+			if (priming) return;
+			pending.set(slot, next);
+			scheduleFlush();
+		});
+	});
+	priming = false;
+
+	return {
+		renderToString: () => renderToString(view),
+		dispatch(event, payload) {
+			const handler = handlers[event];
+			if (!handler) return;
+			handler(payload);
+			flush(); // synchronous — one patch per dispatch (batches the handler's writes)
+		},
+		drainPatches() {
+			flush();
+			const patch: SlotPatch[] = [];
+			for (const [slot, value] of buffer) patch.push({ slot, value });
+			buffer.clear();
+			return patch;
+		},
+		onPatch(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		dispose() {
+			for (const stop of stops) stop();
+			listeners.clear();
+			pending.clear();
+			buffer.clear();
+		},
+	};
+}

package/src/middleware.ts

@@ -30,7 +30,7 @@ export interface AuroraRequestRenderer {
 
 /** Request context the middleware needs: render target + optional resolver/slot. */
 interface AuroraMiddlewareContext extends RenderHttpContext {
-	containerResolver?: { make(token: unknown): unknown };
+	containerResolver?: { make(token: unknown): Promise<unknown> };
 	aurora?: AuroraRequestRenderer;
 }
 
@@ -44,11 +44,11 @@ function isManager(value: unknown): value is AuroraManager {
 	);
 }
 
-function resolveManager(
-	resolver: { make(token: unknown): unknown } | undefined,
-): AuroraManager | undefined {
+async function resolveManager(
+	resolver: { make(token: unknown): Promise<unknown> } | undefined,
+): Promise<AuroraManager | undefined> {
 	try {
-		const resolved = resolver?.make("aurora");
+		const resolved = await resolver?.make("aurora");
 		return isManager(resolved) ? resolved : undefined;
 	} catch {
 		return undefined;
@@ -59,11 +59,11 @@ function resolveManager(
  * Middleware: attach `ctx.aurora` for the request. No-op (passes through) when
  * the AuroraManager isn't registered, so it's safe to mount unconditionally.
  */
-export function auroraContext(
+export async function auroraContext(
 	ctx: AuroraMiddlewareContext,
 	next: () => Promise<void>,
 ): Promise<void> {
-	const manager = resolveManager(ctx.containerResolver);
+	const manager = await resolveManager(ctx.containerResolver);
 	if (manager) {
 		ctx.aurora = {
 			render: (name, props, options) =>