@c9up/aurora 0.1.18 → 0.1.20

package/dist/AuroraManager.d.ts

@@ -38,6 +38,19 @@ export interface AuroraManagerConfig {
      * for an underscore-free scheme. An explicit `pages.urlPrefix` still wins.
      */
     assetsPrefix?: string;
+    /**
+     * App-level importmap overrides, configured ONCE here (the AdonisJS model:
+     * config lives in `config/aurora.ts`, controllers stay thin and never hand-write
+     * importmaps). Merged over aurora's auto defaults (`@c9up/aurora`,
+     * `@c9up/aurora/rpc`, `@c9up/comet`) on every `render()`. Use to point a bare
+     * specifier at a curated browser entry, e.g.
+     * `{ '@c9up/aurora': '/_assets/pages/browser/aurora.js' }`. A per-call
+     * `render(..., { importmap })` still wins over this.
+     *
+     * (Importmaps are aurora's no-bundler particularity — AdonisJS bundles via Vite
+     * and has no importmap; we keep the config-driven shape to stay Adonis-idiomatic.)
+     */
+    importmap?: Record<string, string>;
 }
 export declare class AuroraManager {
     readonly pages: Pages;
@@ -52,12 +65,15 @@ export declare class AuroraManager {
     readonly cometAssetPath: string;
     /** Resolved `@c9up/comet` dist dir, or `null` when comet isn't installed. */
     readonly cometDistRoot: string | null;
+    /** App-level importmap overrides from `config/aurora.ts`, merged on render. */
+    readonly importmap: Record<string, string>;
     constructor(config: AuroraManagerConfig);
     /**
-     * SSR + hydrate + ship the document. The importmap default points
-     * `@c9up/aurora` at this manager's `assetsPrefix`; a caller's
-     * `options.importmap` still overrides (e.g. to remap to an app-curated
-     * browser entry).
+     * SSR + hydrate + ship the document. The importmap layers, last wins:
+     * aurora's auto defaults (`@c9up/aurora`, `@c9up/aurora/rpc`, `@c9up/comet`)
+     * < the config-level `importmap` (from `config/aurora.ts`) < a per-call
+     * `options.importmap`. So a thin controller calls `render(ctx, name, props)`
+     * with no importmap, and any curation lives once in config.
      */
     render(ctx: RenderHttpContext, name: string, props: unknown, options?: RenderPageOptions): Promise<void>;
     /**

package/dist/AuroraManager.js

@@ -48,12 +48,15 @@ export class AuroraManager {
     cometAssetPath;
     /** Resolved `@c9up/comet` dist dir, or `null` when comet isn't installed. */
     cometDistRoot;
+    /** App-level importmap overrides from `config/aurora.ts`, merged on render. */
+    importmap;
     constructor(config) {
         this.assetsPrefix = normalizePrefix(config.assetsPrefix ?? "/_assets");
         this.auroraAssetPath = `${this.assetsPrefix}/aurora`;
         this.pageAssetPath = `${this.assetsPrefix}/pages`;
         this.cometAssetPath = `${this.assetsPrefix}/comet`;
         this.cometDistRoot = config.cometDistRoot ?? resolveCometDist();
+        this.importmap = config.importmap ?? {};
         // Pages serve their compiled JS from the same prefix unless the app
         // pins an explicit urlPrefix.
         this.pages = new Pages({
@@ -63,22 +66,31 @@ export class AuroraManager {
         this.auroraDistRoot = config.auroraDistRoot ?? DEFAULT_AURORA_DIST;
     }
     /**
-     * SSR + hydrate + ship the document. The importmap default points
-     * `@c9up/aurora` at this manager's `assetsPrefix`; a caller's
-     * `options.importmap` still overrides (e.g. to remap to an app-curated
-     * browser entry).
+     * SSR + hydrate + ship the document. The importmap layers, last wins:
+     * aurora's auto defaults (`@c9up/aurora`, `@c9up/aurora/rpc`, `@c9up/comet`)
+     * < the config-level `importmap` (from `config/aurora.ts`) < a per-call
+     * `options.importmap`. So a thin controller calls `render(ctx, name, props)`
+     * with no importmap, and any curation lives once in config.
      */
     render(ctx, name, props, options) {
         return renderPage(ctx, this.pages, name, props, {
             ...options,
             importmap: {
                 "@c9up/aurora": `${this.auroraAssetPath}/index.js`,
-                // Auto-map @c9up/comet when installed so `@c9up/aurora/rpc`'s bare
+                // The browser-facing subpath (RPC client) needs an explicit entry —
+                // importmaps don't read package `exports`, and an extensionless bare
+                // specifier won't hit a trailing-slash prefix map. Served from the
+                // same aurora dist; harmless when a page never imports it.
+                "@c9up/aurora/rpc": `${this.auroraAssetPath}/rpc.js`,
+                // Auto-map @c9up/comet when installed so the rpc client's bare
                 // `import '@c9up/comet'` resolves in the no-bundler browser — no
                 // app-side importmap wiring. Omitted when comet isn't present.
                 ...(this.cometDistRoot
                     ? { "@c9up/comet": `${this.cometAssetPath}/index.js` }
                     : {}),
+                // Config-level overrides (config/aurora.ts) — Adonis-style config-driven,
+                // so controllers never hand-write an importmap. A per-call override wins.
+                ...this.importmap,
                 ...options?.importmap,
             },
         });

package/dist/live.d.ts

@@ -53,3 +53,8 @@ export interface LiveSession {
  * every session then reads the same signal and patches on its change.
  */
 export declare function mountLiveSession(factory: () => LiveComponentDefinition): LiveSession;
+export { connectPatches, type LiveStore, liveStore, type RelayBroadcaster, } from "./liveBroadcast.js";
+export { buildLiveTransport, type LiveClientOptions, type LiveClientTransport, type LiveHttpPoster, liveClient, type RelaySubscribeClient, } from "./liveClient.js";
+export { createLiveRegistry, type LiveRegistry, type LiveSessionHandle, } from "./liveRegistry.js";
+export { createLiveRouter, type LiveMount, type LiveRouter, } from "./liveRouter.js";
+export { DEFAULT_LIVE_EVENT_PATH, type LiveHttpContext, type LiveHttpRouter, type WireLiveEventsOptions, wireLiveEvents, } from "./liveServer.js";

package/dist/live.js

@@ -94,3 +94,15 @@ export function mountLiveSession(factory) {
         },
     };
 }
+// ─── `@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, liveStore, } from "./liveBroadcast.js";
+export { buildLiveTransport, liveClient, } from "./liveClient.js";
+export { createLiveRegistry, } from "./liveRegistry.js";
+export { createLiveRouter, } from "./liveRouter.js";
+export { DEFAULT_LIVE_EVENT_PATH, wireLiveEvents, } from "./liveServer.js";

package/dist/middleware.d.ts

@@ -0,0 +1,32 @@
+/**
+ * `auroraContext` — binds `ctx.aurora.render(name, props)` onto the request
+ * context, the AdonisJS ctx-service idiom (the `ctx.view` / `ctx.inertia`
+ * analog). Register it globally in your kernel; a thin controller then does:
+ *
+ *   async show({ aurora }: HttpContext) {
+ *     return aurora.render('Dashboard', { user, stats })
+ *   }
+ *
+ * Agnostic: it resolves the AuroraManager from the request container
+ * (`ctx.containerResolver.make('aurora')`) — never imports `@c9up/ream` — and is
+ * a no-op when no manager is registered. The module-level `aurora.render(ctx, …)`
+ * service still works; this is the ctx-bound sugar.
+ */
+import type { RenderHttpContext, RenderPageOptions } from "./server/renderPage.js";
+/** The `ctx.aurora` surface — ctx-bound render (no explicit ctx argument). */
+export interface AuroraRequestRenderer {
+    render(name: string, props?: unknown, options?: RenderPageOptions): Promise<void>;
+}
+/** Request context the middleware needs: render target + optional resolver/slot. */
+interface AuroraMiddlewareContext extends RenderHttpContext {
+    containerResolver?: {
+        make(token: unknown): unknown;
+    };
+    aurora?: AuroraRequestRenderer;
+}
+/**
+ * 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 declare function auroraContext(ctx: AuroraMiddlewareContext, next: () => Promise<void>): Promise<void>;
+export {};

package/dist/middleware.js

@@ -0,0 +1,43 @@
+/**
+ * `auroraContext` — binds `ctx.aurora.render(name, props)` onto the request
+ * context, the AdonisJS ctx-service idiom (the `ctx.view` / `ctx.inertia`
+ * analog). Register it globally in your kernel; a thin controller then does:
+ *
+ *   async show({ aurora }: HttpContext) {
+ *     return aurora.render('Dashboard', { user, stats })
+ *   }
+ *
+ * Agnostic: it resolves the AuroraManager from the request container
+ * (`ctx.containerResolver.make('aurora')`) — never imports `@c9up/ream` — and is
+ * a no-op when no manager is registered. The module-level `aurora.render(ctx, …)`
+ * service still works; this is the ctx-bound sugar.
+ */
+/** Structural check that a resolved value is render-capable (an AuroraManager). */
+function isManager(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "render" in value &&
+        typeof value.render === "function");
+}
+function resolveManager(resolver) {
+    try {
+        const resolved = resolver?.make("aurora");
+        return isManager(resolved) ? resolved : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * 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(ctx, next) {
+    const manager = resolveManager(ctx.containerResolver);
+    if (manager) {
+        ctx.aurora = {
+            render: (name, props, options) => manager.render(ctx, name, props, options),
+        };
+    }
+    return next();
+}

package/dist/server.d.ts

@@ -1,4 +1,5 @@
 export { AuroraManager, type AuroraManagerConfig } from "./AuroraManager.js";
+export { type AuroraRequestRenderer, auroraContext, } from "./middleware.js";
 export { type PageFactory, Pages, type PagesConfig } from "./Pages.js";
 export { type RenderHttpContext, type RenderPageOptions, type RenderResponse, renderPage, } from "./server/renderPage.js";
 export { type AssetsHttpContext, type AssetsRequest, type AssetsResponse, packageAssetDir, type ServeAssetsOptions, serveAssets, } from "./server/serveAssets.js";

package/dist/server.js

@@ -5,6 +5,7 @@
 // Node built-ins through the import graph. Server code imports from
 // `@c9up/aurora/server`; the client `.` entry stays node-free.
 export { AuroraManager } from "./AuroraManager.js";
+export { auroraContext, } from "./middleware.js";
 export { Pages } from "./Pages.js";
 export { renderPage, } from "./server/renderPage.js";
 export { packageAssetDir, serveAssets, } from "./server/serveAssets.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c9up/aurora",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "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",

package/src/AuroraManager.ts

@@ -50,6 +50,19 @@ export interface AuroraManagerConfig {
 	 * for an underscore-free scheme. An explicit `pages.urlPrefix` still wins.
 	 */
 	assetsPrefix?: string;
+	/**
+	 * App-level importmap overrides, configured ONCE here (the AdonisJS model:
+	 * config lives in `config/aurora.ts`, controllers stay thin and never hand-write
+	 * importmaps). Merged over aurora's auto defaults (`@c9up/aurora`,
+	 * `@c9up/aurora/rpc`, `@c9up/comet`) on every `render()`. Use to point a bare
+	 * specifier at a curated browser entry, e.g.
+	 * `{ '@c9up/aurora': '/_assets/pages/browser/aurora.js' }`. A per-call
+	 * `render(..., { importmap })` still wins over this.
+	 *
+	 * (Importmaps are aurora's no-bundler particularity — AdonisJS bundles via Vite
+	 * and has no importmap; we keep the config-driven shape to stay Adonis-idiomatic.)
+	 */
+	importmap?: Record<string, string>;
 }
 
 const DEFAULT_AURORA_DIST = resolvePath(
@@ -89,6 +102,8 @@ export class AuroraManager {
 	readonly cometAssetPath: string;
 	/** Resolved `@c9up/comet` dist dir, or `null` when comet isn't installed. */
 	readonly cometDistRoot: string | null;
+	/** App-level importmap overrides from `config/aurora.ts`, merged on render. */
+	readonly importmap: Record<string, string>;
 
 	constructor(config: AuroraManagerConfig) {
 		this.assetsPrefix = normalizePrefix(config.assetsPrefix ?? "/_assets");
@@ -96,6 +111,7 @@ export class AuroraManager {
 		this.pageAssetPath = `${this.assetsPrefix}/pages`;
 		this.cometAssetPath = `${this.assetsPrefix}/comet`;
 		this.cometDistRoot = config.cometDistRoot ?? resolveCometDist();
+		this.importmap = config.importmap ?? {};
 		// Pages serve their compiled JS from the same prefix unless the app
 		// pins an explicit urlPrefix.
 		this.pages = new Pages({
@@ -106,10 +122,11 @@ export class AuroraManager {
 	}
 
 	/**
-	 * SSR + hydrate + ship the document. The importmap default points
-	 * `@c9up/aurora` at this manager's `assetsPrefix`; a caller's
-	 * `options.importmap` still overrides (e.g. to remap to an app-curated
-	 * browser entry).
+	 * SSR + hydrate + ship the document. The importmap layers, last wins:
+	 * aurora's auto defaults (`@c9up/aurora`, `@c9up/aurora/rpc`, `@c9up/comet`)
+	 * < the config-level `importmap` (from `config/aurora.ts`) < a per-call
+	 * `options.importmap`. So a thin controller calls `render(ctx, name, props)`
+	 * with no importmap, and any curation lives once in config.
 	 */
 	render(
 		ctx: RenderHttpContext,
@@ -121,12 +138,20 @@ export class AuroraManager {
 			...options,
 			importmap: {
 				"@c9up/aurora": `${this.auroraAssetPath}/index.js`,
-				// Auto-map @c9up/comet when installed so `@c9up/aurora/rpc`'s bare
+				// The browser-facing subpath (RPC client) needs an explicit entry —
+				// importmaps don't read package `exports`, and an extensionless bare
+				// specifier won't hit a trailing-slash prefix map. Served from the
+				// same aurora dist; harmless when a page never imports it.
+				"@c9up/aurora/rpc": `${this.auroraAssetPath}/rpc.js`,
+				// Auto-map @c9up/comet when installed so the rpc client's bare
 				// `import '@c9up/comet'` resolves in the no-bundler browser — no
 				// app-side importmap wiring. Omitted when comet isn't present.
 				...(this.cometDistRoot
 					? { "@c9up/comet": `${this.cometAssetPath}/index.js` }
 					: {}),
+				// Config-level overrides (config/aurora.ts) — Adonis-style config-driven,
+				// so controllers never hand-write an importmap. A per-call override wins.
+				...this.importmap,
 				...options?.importmap,
 			},
 		});

package/src/live.ts

@@ -130,3 +130,42 @@ export function mountLiveSession(
 		},
 	};
 }
+
+// ─── `@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,
+	liveStore,
+	type RelayBroadcaster,
+} from "./liveBroadcast.js";
+export {
+	buildLiveTransport,
+	type LiveClientOptions,
+	type LiveClientTransport,
+	type LiveHttpPoster,
+	liveClient,
+	type RelaySubscribeClient,
+} from "./liveClient.js";
+export {
+	createLiveRegistry,
+	type LiveRegistry,
+	type LiveSessionHandle,
+} from "./liveRegistry.js";
+export {
+	createLiveRouter,
+	type LiveMount,
+	type LiveRouter,
+} from "./liveRouter.js";
+export {
+	DEFAULT_LIVE_EVENT_PATH,
+	type LiveHttpContext,
+	type LiveHttpRouter,
+	type WireLiveEventsOptions,
+	wireLiveEvents,
+} from "./liveServer.js";

package/src/middleware.ts

@@ -0,0 +1,74 @@
+/**
+ * `auroraContext` — binds `ctx.aurora.render(name, props)` onto the request
+ * context, the AdonisJS ctx-service idiom (the `ctx.view` / `ctx.inertia`
+ * analog). Register it globally in your kernel; a thin controller then does:
+ *
+ *   async show({ aurora }: HttpContext) {
+ *     return aurora.render('Dashboard', { user, stats })
+ *   }
+ *
+ * Agnostic: it resolves the AuroraManager from the request container
+ * (`ctx.containerResolver.make('aurora')`) — never imports `@c9up/ream` — and is
+ * a no-op when no manager is registered. The module-level `aurora.render(ctx, …)`
+ * service still works; this is the ctx-bound sugar.
+ */
+
+import type { AuroraManager } from "./AuroraManager.js";
+import type {
+	RenderHttpContext,
+	RenderPageOptions,
+} from "./server/renderPage.js";
+
+/** The `ctx.aurora` surface — ctx-bound render (no explicit ctx argument). */
+export interface AuroraRequestRenderer {
+	render(
+		name: string,
+		props?: unknown,
+		options?: RenderPageOptions,
+	): Promise<void>;
+}
+
+/** Request context the middleware needs: render target + optional resolver/slot. */
+interface AuroraMiddlewareContext extends RenderHttpContext {
+	containerResolver?: { make(token: unknown): unknown };
+	aurora?: AuroraRequestRenderer;
+}
+
+/** Structural check that a resolved value is render-capable (an AuroraManager). */
+function isManager(value: unknown): value is AuroraManager {
+	return (
+		typeof value === "object" &&
+		value !== null &&
+		"render" in value &&
+		typeof value.render === "function"
+	);
+}
+
+function resolveManager(
+	resolver: { make(token: unknown): unknown } | undefined,
+): AuroraManager | undefined {
+	try {
+		const resolved = resolver?.make("aurora");
+		return isManager(resolved) ? resolved : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * 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(
+	ctx: AuroraMiddlewareContext,
+	next: () => Promise<void>,
+): Promise<void> {
+	const manager = resolveManager(ctx.containerResolver);
+	if (manager) {
+		ctx.aurora = {
+			render: (name, props, options) =>
+				manager.render(ctx, name, props, options),
+		};
+	}
+	return next();
+}

package/src/server.ts

@@ -6,6 +6,10 @@
 // `@c9up/aurora/server`; the client `.` entry stays node-free.
 
 export { AuroraManager, type AuroraManagerConfig } from "./AuroraManager.js";
+export {
+	type AuroraRequestRenderer,
+	auroraContext,
+} from "./middleware.js";
 export { type PageFactory, Pages, type PagesConfig } from "./Pages.js";
 export {
 	type RenderHttpContext,