@junejs/server 0.1.2 → 0.2.0

package/dist/router.d.ts

@@ -1,32 +1,31 @@
 //#region src/router.d.ts
-type RouteMatch = {
+export type RouteMatch = {
   file: string;
   params: Record<string, string>;
 };
-type SegmentMatch = {
+export type SegmentMatch = {
   dir: string;
   layout?: string;
   loading?: string;
   error?: string;
   notFound?: string;
 };
-type RouteTreeMatch = {
+export type RouteTreeMatch = {
   file: string;
   params: Record<string, string>;
   segments: SegmentMatch[];
 };
-declare function findMiddlewareFile(appDir: string): string | null;
-type MatchOptions = {
+export declare function findMiddlewareFile(appDir: string): string | null;
+export type MatchOptions = {
   pageConvention?: boolean;
 };
-declare function isResourceFile(file: string): boolean;
-declare function matchRouteTree(appDir: string, pathname: string, options?: MatchOptions): Promise<RouteTreeMatch | null>;
-declare function resolveNotFound(appDir: string, pathname: string): Promise<{
+export declare function isResourceFile(file: string): boolean;
+export declare function matchRouteTree(appDir: string, pathname: string, options?: MatchOptions): Promise<RouteTreeMatch | null>;
+export declare function resolveNotFound(appDir: string, pathname: string): Promise<{
   segments: SegmentMatch[];
   notFound?: string;
 }>;
-declare function routeFiles(appDir: string, options?: MatchOptions): Promise<string[]>;
-declare function listRoutes(appDir: string, options?: MatchOptions): Promise<string[]>;
-declare function matchRoute(appDir: string, pathname: string, options?: MatchOptions): Promise<RouteMatch | null>;
-//#endregion
-export { MatchOptions, RouteMatch, RouteTreeMatch, SegmentMatch, findMiddlewareFile, isResourceFile, listRoutes, matchRoute, matchRouteTree, resolveNotFound, routeFiles };
+export declare function routeFiles(appDir: string, options?: MatchOptions): Promise<string[]>;
+export declare function listRoutes(appDir: string, options?: MatchOptions): Promise<string[]>;
+export declare function matchRoute(appDir: string, pathname: string, options?: MatchOptions): Promise<RouteMatch | null>;
+//#endregion

package/dist/router.js

@@ -1,3 +1,4 @@
+import { compareSegments, parseSegment } from "./route-rank.js";
 import { existsSync } from "node:fs";
 import { readdir } from "node:fs/promises";
 import { join, relative, sep } from "node:path";
@@ -42,11 +43,11 @@ function isSpecialFile(file) {
 	return SPECIAL_FILES.has(baseName(file));
 }
 const isRouteGroup = (name) => /^\(.+\)$/.test(name);
-const isParamDir = (name) => /^\[([A-Za-z_][A-Za-z0-9_]*)\]$/.test(name);
-const isOptionalDir = (name) => /^\[\[([A-Za-z_][A-Za-z0-9_]*)\]\]$/.test(name);
-const isOptionalCatchAllDir = (name) => /^\[\[\.\.\.([A-Za-z_][A-Za-z0-9_]*)\]\]$/.test(name);
-const isCatchAllDir = (name) => /^\[\.\.\.([A-Za-z_][A-Za-z0-9_]*)\]$/.test(name);
-const paramName = (name) => name.replace(/^\[+(\.\.\.)?|\]+$/g, "");
+const isParamDir = (name) => parseSegment(name).kind === "param";
+const isOptionalDir = (name) => parseSegment(name).kind === "optional";
+const isOptionalCatchAllDir = (name) => parseSegment(name).kind === "optionalCatchAll";
+const isCatchAllDir = (name) => parseSegment(name).kind === "catchAll";
+const paramName = (name) => parseSegment(name).name;
 async function listDir(dir) {
 	return (await readdir(dir, { withFileTypes: true }).catch(() => [])).filter((e) => !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => ({
 		name: e.name,
@@ -84,63 +85,76 @@ function routePath(appDir, file) {
 }
 async function matchRouteTree(appDir, pathname, options = {}) {
 	const urlSegments = pathname.split("/").filter(Boolean).map(decodeURIComponent);
-	async function descend(dir, rest, params, chain) {
-		const entries = await listDir(dir);
+	async function levelAt(dir, chain) {
+		const entries = (await listDir(dir)).sort((a, b) => compareSegments(a.name, b.name));
 		const segments = [...chain, segmentAt(dir, entries)];
-		if (rest.length === 0) {
-			const page = fileFor(entries, dir, "page") ?? fileFor(entries, dir, "index") ?? fileFor(entries, dir, "route");
-			if (page) return {
-				file: page,
+		const levels = [{
+			dir,
+			entries,
+			segments
+		}];
+		for (const e of entries) if (e.dir && isRouteGroup(e.name)) levels.push(...await levelAt(join(dir, e.name), segments));
+		return levels;
+	}
+	async function descend(nodes, rest, params) {
+		const levels = (await Promise.all(nodes.map((n) => levelAt(n.dir, n.chain)))).flat();
+		if (rest.length === 0) for (const base of [["page", "index"], ["route"]]) for (const { dir: d, entries, segments } of levels) {
+			const file = base.map((b) => fileFor(entries, d, b)).find(Boolean);
+			if (file) return {
+				file,
 				params,
 				segments
 			};
-		} else if (!options.pageConvention) {
-			if (rest.length === 1) {
-				const leaf = fileFor(entries, dir, rest[0]);
-				if (leaf && !isSpecialFile(leaf) && !isPageFile(leaf)) return {
-					file: leaf,
-					params,
-					segments
-				};
-			}
 		}
-		for (const e of entries) {
-			if (!e.dir || !isRouteGroup(e.name)) continue;
-			const hit = await descend(join(dir, e.name), rest, params, segments);
-			if (hit) return hit;
+		else if (!options.pageConvention && rest.length === 1) for (const { dir: d, entries, segments } of levels) {
+			const leaf = fileFor(entries, d, rest[0]);
+			if (leaf && !isSpecialFile(leaf) && !isPageFile(leaf)) return {
+				file: leaf,
+				params,
+				segments
+			};
+		}
+		const children = /* @__PURE__ */ new Map();
+		for (const lv of levels) for (const e of lv.entries) {
+			if (!e.dir || isRouteGroup(e.name)) continue;
+			const node = {
+				dir: join(lv.dir, e.name),
+				chain: lv.segments
+			};
+			const same = children.get(e.name);
+			if (same) same.push(node);
+			else children.set(e.name, [node]);
 		}
+		const names = [...children.keys()].sort(compareSegments);
 		if (rest.length === 0) {
-			for (const e of entries) {
-				if (!e.dir || !(isOptionalDir(e.name) || isOptionalCatchAllDir(e.name))) continue;
-				const hit = await descend(join(dir, e.name), [], params, segments);
+			for (const name of names) {
+				if (!(isOptionalDir(name) || isOptionalCatchAllDir(name))) continue;
+				const hit = await descend(children.get(name), [], params);
 				if (hit) return hit;
 			}
 			return null;
 		}
 		const [head, ...tail] = rest;
-		if (entries.find((e) => e.dir && e.name === head)) {
-			const hit = await descend(join(dir, head), tail, params, segments);
-			if (hit) return hit;
-		}
-		for (const e of entries) {
-			if (!e.dir || !(isParamDir(e.name) || isOptionalDir(e.name))) continue;
-			const hit = await descend(join(dir, e.name), tail, {
+		for (const name of names) {
+			const into = children.get(name);
+			let hit = null;
+			if (isParamDir(name) || isOptionalDir(name)) hit = await descend(into, tail, {
 				...params,
-				[paramName(e.name)]: head
-			}, segments);
-			if (hit) return hit;
-		}
-		for (const e of entries) {
-			if (!e.dir || !(isCatchAllDir(e.name) || isOptionalCatchAllDir(e.name))) continue;
-			const hit = await descend(join(dir, e.name), [], {
+				[paramName(name)]: head
+			});
+			else if (isCatchAllDir(name) || isOptionalCatchAllDir(name)) hit = await descend(into, [], {
 				...params,
-				[paramName(e.name)]: rest.join("/")
-			}, segments);
+				[paramName(name)]: rest.join("/")
+			});
+			else if (name === head) hit = await descend(into, tail, params);
 			if (hit) return hit;
 		}
 		return null;
 	}
-	return descend(appDir, urlSegments, {}, []);
+	return descend([{
+		dir: appDir,
+		chain: []
+	}], urlSegments, {});
 }
 async function resolveNotFound(appDir, pathname) {
 	const urlSegments = pathname.split("/").filter(Boolean).map(decodeURIComponent);

package/dist/rsc-build.d.ts

@@ -1,17 +1,16 @@
 import { DocumentConfig } from "@junejs/core/document";
 //#region src/rsc-build.d.ts
-type RscRoute = {
+export type RscRoute = {
   path: string;
   file: string;
 };
-declare function findRscRoutes(appDir: string): RscRoute[];
-type RscBuildResult = {
+export declare function findRscRoutes(appDir: string): RscRoute[];
+export type RscBuildResult = {
   worker: string;
   server: string;
   paths: string[];
 } | null;
-declare function buildRsc(appRoot: string, outDir: string, docConfig: DocumentConfig): Promise<RscBuildResult>;
+export declare function buildRsc(appRoot: string, outDir: string, docConfig: DocumentConfig): Promise<RscBuildResult>;
 type Fetcher = (request: Request) => Promise<Response>;
-declare function createRscDispatch(ssrFetch: Fetcher, rscFetch: Fetcher, rscPaths: Iterable<string>): Fetcher;
-//#endregion
-export { RscBuildResult, RscRoute, buildRsc, createRscDispatch, findRscRoutes };
+export declare function createRscDispatch(ssrFetch: Fetcher, rscFetch: Fetcher, rscPaths: Iterable<string>): Fetcher;
+//#endregion

package/dist/rsc-bundle.d.ts

@@ -1,8 +1,7 @@
 //#region src/rsc-bundle.d.ts
-type RscGraph = "server" | "ssr";
-type RscAliases = Record<string, string>;
-declare function bundleServerGraph(entryFile: string, cwd: string, aliases?: RscAliases, appDir?: string): Promise<string>;
-declare function bundleSsrGraph(entryFile: string, cwd: string, aliases?: RscAliases): Promise<string>;
-declare function referencesNodeBuiltins(code: string): boolean;
-//#endregion
-export { RscAliases, RscGraph, bundleServerGraph, bundleSsrGraph, referencesNodeBuiltins };
+export type RscGraph = "server" | "ssr";
+export type RscAliases = Record<string, string>;
+export declare function bundleServerGraph(entryFile: string, cwd: string, aliases?: RscAliases, appDir?: string): Promise<string>;
+export declare function bundleSsrGraph(entryFile: string, cwd: string, aliases?: RscAliases): Promise<string>;
+export declare function referencesNodeBuiltins(code: string): boolean;
+//#endregion

package/dist/rsc-manifest.d.ts

@@ -1,8 +1,7 @@
 import { Plugin } from "rolldown";
 //#region src/rsc-manifest.d.ts
-declare const RSC_SERVER_MANIFEST_FILE = "_rsc-server.gen.ts";
-declare const RSC_CLIENT_MANIFEST_FILE = "_rsc-client.gen.ts";
-declare function rscClientReferencesPlugin(appDir: string): Plugin;
-declare function generateRscManifests(appDir: string): number;
-//#endregion
-export { RSC_CLIENT_MANIFEST_FILE, RSC_SERVER_MANIFEST_FILE, generateRscManifests, rscClientReferencesPlugin };
+export declare const RSC_SERVER_MANIFEST_FILE = "_rsc-server.gen.ts";
+export declare const RSC_CLIENT_MANIFEST_FILE = "_rsc-client.gen.ts";
+export declare function rscClientReferencesPlugin(appDir: string): Plugin;
+export declare function generateRscManifests(appDir: string): number;
+//#endregion

package/dist/rsc-runtime/flight-render-routes.d.ts

@@ -1,5 +1,4 @@
 //#region src/rsc-runtime/flight-render-routes.d.ts
-declare function renderFlight(path: string): Promise<string | null>;
-declare function rscPaths(): string[];
-//#endregion
-export { renderFlight, rscPaths };
+export declare function renderFlight(path: string): Promise<string | null>;
+export declare function rscPaths(): string[];
+//#endregion

package/dist/rsc-runtime/flight-render.d.ts

@@ -1,4 +1,3 @@
 //#region src/rsc-runtime/flight-render.d.ts
-declare function renderFlight(): Promise<string>;
-//#endregion
-export { renderFlight };
+export declare function renderFlight(): Promise<string>;
+//#endregion

package/dist/rsc-runtime/flight-to-html.d.ts

@@ -1,4 +1,3 @@
 //#region src/rsc-runtime/flight-to-html.d.ts
-declare function flightToHtml(flight: string, moduleMap?: Record<string, unknown>): Promise<string>;
-//#endregion
-export { flightToHtml };
+export declare function flightToHtml(flight: string, moduleMap?: Record<string, unknown>): Promise<string>;
+//#endregion

package/dist/rsc-runtime/flight-to-html.js

@@ -20,11 +20,12 @@ async function streamToString(stream) {
 }
 async function flightToHtml(flight, moduleMap = {}) {
 	const flightStream = new Response(flight).body;
-	const html = await renderToReadableStream(/* @__PURE__ */ jsx(Root, { tree: createFromReadableStream(flightStream, { serverConsumerManifest: {
+	const tree = createFromReadableStream(flightStream, { serverConsumerManifest: {
 		moduleMap,
 		serverModuleMap: null,
 		moduleLoading: null
-	} }) }));
+	} });
+	const html = await renderToReadableStream(/* @__PURE__ */ jsx(Root, { tree }));
 	if (typeof html.allReady?.then === "function") await html.allReady;
 	return streamToString(html);
 }

package/dist/rsc-runtime/rsc-worker.js

@@ -21,24 +21,27 @@ async function streamToString(stream) {
 	out += dec.decode();
 	return out;
 }
-async function renderDocument(path) {
+async function renderDocument(url) {
+	const path = url.pathname;
 	const flight = await (await import(new URL("./server.js", import.meta.url).href)).renderFlight(path);
 	if (flight === null) return null;
 	const flightStream = new Response(flight).body;
+	const tree = createFromReadableStream(flightStream, { serverConsumerManifest: {
+		moduleMap: MODULE_MAP,
+		serverModuleMap: null,
+		moduleLoading: null
+	} });
 	const html = await renderToReadableStream(/* @__PURE__ */ jsx(Document, {
 		config: DOC_CONFIG,
-		children: /* @__PURE__ */ jsx(Root, { tree: createFromReadableStream(flightStream, { serverConsumerManifest: {
-			moduleMap: MODULE_MAP,
-			serverModuleMap: null,
-			moduleLoading: null
-		} }) })
+		pageUrl: url.href,
+		isHome: path === "/",
+		children: /* @__PURE__ */ jsx(Root, { tree })
 	}));
 	if (typeof html.allReady?.then === "function") await html.allReady;
 	return "<!DOCTYPE html>" + await streamToString(html);
 }
 var rsc_worker_default = { async fetch(request) {
-	const path = new URL(request.url).pathname;
-	const body = await renderDocument(path);
+	const body = await renderDocument(new URL(request.url));
 	if (body === null) return new Response("Not Found", { status: 404 });
 	return new Response(body, { headers: { "content-type": "text/html; charset=utf-8" } });
 } };

package/dist/rsc-runtime/rsdw-shims.d.ts

@@ -39,4 +39,5 @@ declare module "june:rsc-client" {
 declare module "june:rsc-config" {
   import type { DocumentConfig } from "@junejs/core/document";
   export const DOC_CONFIG: DocumentConfig;
-}
+}
+export {};

package/dist/segment.d.ts

@@ -1,7 +1,7 @@
 //#region src/segment.d.ts
-declare const boundaryWarning: (file: string) => string;
-declare function boundaryKey(file: string): string;
-declare function resolveBoundary<C>(items: Array<{
+export declare const boundaryWarning: (file: string) => string;
+export declare function boundaryKey(file: string): string;
+export declare function resolveBoundary<C>(items: Array<{
   file: string;
   entry: C | null;
   boundary: boolean;
@@ -10,5 +10,4 @@ declare function resolveBoundary<C>(items: Array<{
   boundaryIndex: number | null;
   key: string | null;
 };
-//#endregion
-export { boundaryKey, boundaryWarning, resolveBoundary };
+//#endregion

package/dist/sqlite-driver.d.ts

@@ -1,6 +1,6 @@
 import { JuneDb } from "@junejs/core/resources";
 //#region src/sqlite-driver.d.ts
-type SyncStatement = {
+export type SyncStatement = {
   all(...params: unknown[]): unknown[];
   get(...params: unknown[]): unknown;
   run(...params: unknown[]): {
@@ -8,18 +8,18 @@ type SyncStatement = {
     lastInsertRowid?: number | bigint;
   };
 };
-type SyncSqlite = {
+export type SyncSqlite = {
   query(sql: string): SyncStatement;
   exec(sql: string): void;
   close(): void;
 };
-declare const NODE_SQLITE_MIN_LTS = "22.13.0";
-declare const NODE_SQLITE_MIN_ODD = "23.4.0";
-declare function nodeSqliteHelp(nodeVersion: string): string;
-declare function isNodeSqliteExperimentalWarning(type: unknown, message: string): boolean;
+export declare const NODE_SQLITE_MIN_LTS = "22.13.0";
+export declare const NODE_SQLITE_MIN_ODD = "23.4.0";
+export declare function nodeSqliteHelp(nodeVersion: string): string;
+export declare function isNodeSqliteExperimentalWarning(type: unknown, message: string): boolean;
 type EmitWarning = (warning: string | Error, ...rest: unknown[]) => void;
-declare function makeWarningFilter(original: EmitWarning): EmitWarning;
-declare function openLocalSqliteSync(path: string): Promise<SyncSqlite>;
-declare function openLocalSqlite(path: string): Promise<JuneDb>;
-//#endregion
-export { NODE_SQLITE_MIN_LTS, NODE_SQLITE_MIN_ODD, SyncSqlite, SyncStatement, isNodeSqliteExperimentalWarning, makeWarningFilter, nodeSqliteHelp, openLocalSqlite, openLocalSqliteSync };
+export declare function makeWarningFilter(original: EmitWarning): EmitWarning;
+export declare function useDurableJournal(db: SyncSqlite, path: string): SyncSqlite;
+export declare function openLocalSqliteSync(path: string): Promise<SyncSqlite>;
+export declare function openLocalSqlite(path: string): Promise<JuneDb>;
+//#endregion

package/dist/sqlite-driver.js

@@ -72,10 +72,23 @@ function makeWarningFilter(original) {
 		original(warning, ...rest);
 	};
 }
+function useDurableJournal(db, path) {
+	if (path === ":memory:" || path === "") return db;
+	try {
+		db.exec("PRAGMA journal_mode=WAL");
+		db.exec("PRAGMA synchronous=FULL");
+	} catch (err) {
+		try {
+			db.close();
+		} catch {}
+		throw err;
+	}
+	return db;
+}
 async function openLocalSqliteSync(path) {
 	if (typeof Bun !== "undefined") {
 		const { Database } = await import("bun:sqlite");
-		return new Database(path, { create: true });
+		return useDurableJournal(new Database(path, { create: true }), path);
 	}
 	const specifier = "node:sqlite";
 	let mod;
@@ -89,14 +102,14 @@ async function openLocalSqliteSync(path) {
 		process.emitWarning = originalEmitWarning;
 	}
 	const db = new mod.DatabaseSync(path);
-	return {
+	return useDurableJournal({
 		query: (sql) => db.prepare(sql),
 		exec: (sql) => db.exec(sql),
 		close: () => db.close()
-	};
+	}, path);
 }
 async function openLocalSqlite(path) {
 	return asyncSqlite(await openLocalSqliteSync(path));
 }
 //#endregion
-export { NODE_SQLITE_MIN_LTS, NODE_SQLITE_MIN_ODD, isNodeSqliteExperimentalWarning, makeWarningFilter, nodeSqliteHelp, openLocalSqlite, openLocalSqliteSync };
+export { NODE_SQLITE_MIN_LTS, NODE_SQLITE_MIN_ODD, isNodeSqliteExperimentalWarning, makeWarningFilter, nodeSqliteHelp, openLocalSqlite, openLocalSqliteSync, useDurableJournal };

package/dist/static-files.d.ts

@@ -1,6 +1,5 @@
 //#region src/static-files.d.ts
-declare const RESERVED_PREFIX = "_june";
-declare function contentTypeFor(pathname: string): string;
-declare function safeRelativePath(pathname: string): string | null;
-//#endregion
-export { RESERVED_PREFIX, contentTypeFor, safeRelativePath };
+export declare const RESERVED_PREFIX = "_june";
+export declare function contentTypeFor(pathname: string): string;
+export declare function safeRelativePath(pathname: string): string | null;
+//#endregion

package/dist/tsconfig-jsx.d.ts

@@ -1,15 +1,15 @@
 //#region src/tsconfig-jsx.d.ts
+export declare const stripJsonc: (s: string) => string;
 /** Read the app's tsconfig.json and return compilerOptions.jsxImportSource.
  *  Follows one level of `extends` so apps that inherit from a base tsconfig
  *  (e.g. "@kurajs/docs/tsconfig.kura.json") are handled correctly.
  *  Returns undefined when absent or unreadable. */
-declare function appJsxImportSource(appRoot: string): Promise<string | undefined>;
+export declare function appJsxImportSource(appRoot: string): Promise<string | undefined>;
 /** The transform.jsx both bundles use: June's island JSX runtime, with the explicit importSource
  *  skipped when the app's tsconfig already declares it — rolldown then reads it from tsconfig
  *  silently instead of warning about the (same-value) override. */
-declare function jsxTransform(appRoot: string): Promise<{
+export declare function jsxTransform(appRoot: string): Promise<{
   runtime: "automatic";
   importSource?: string;
 }>;
-//#endregion
-export { appJsxImportSource, jsxTransform };
+//#endregion

package/dist/tsconfig-jsx.js

@@ -32,4 +32,4 @@ async function jsxTransform(appRoot) {
 	};
 }
 //#endregion
-export { appJsxImportSource, jsxTransform };
+export { appJsxImportSource, jsxTransform, stripJsonc };

package/dist/turn-events.d.ts

@@ -0,0 +1,4 @@
+import { AgentSession, TurnEvent } from "@junejs/core/agent-runtime";
+//#region src/turn-events.d.ts
+export declare function observeTurnEvents(session: AgentSession, turnId: string): AsyncIterable<TurnEvent>;
+//#endregion

package/dist/turn-events.js

@@ -0,0 +1,46 @@
+//#region src/turn-events.ts
+function observeTurnEvents(session, turnId) {
+	const queue = [];
+	let terminal = false;
+	let notify;
+	const unsub = session.observe((e) => {
+		queue.push(e);
+		if (e.type === "turn.completed" || e.type === "turn.failed" || e.type === "turn.cancelled" || e.type === "input.requested") terminal = true;
+		notify?.();
+	}, { turnId });
+	return { [Symbol.asyncIterator]() {
+		return {
+			async next() {
+				for (;;) {
+					const e = queue.shift();
+					if (e) return {
+						value: e,
+						done: false
+					};
+					if (terminal) {
+						unsub();
+						return {
+							value: void 0,
+							done: true
+						};
+					}
+					await new Promise((resolve) => {
+						notify = resolve;
+					});
+					notify = void 0;
+				}
+			},
+			async return() {
+				unsub();
+				terminal = true;
+				queue.length = 0;
+				return {
+					value: void 0,
+					done: true
+				};
+			}
+		};
+	} };
+}
+//#endregion
+export { observeTurnEvents };

package/dist/web-manifest.d.ts

@@ -0,0 +1,5 @@
+import { DocumentConfig } from "@junejs/core/document";
+//#region src/web-manifest.d.ts
+export declare const shortName: (site: DocumentConfig["site"]) => string | undefined;
+export declare function webManifest(config: DocumentConfig): string;
+//#endregion

package/dist/web-manifest.js

@@ -0,0 +1,42 @@
+import { siteShortName } from "@junejs/core/config";
+import { resolveThemeColor } from "@junejs/core/document";
+//#region src/web-manifest.ts
+const shortName = (site) => siteShortName(site);
+function webManifest(config) {
+	const base = config.basePath ?? "";
+	const theme = resolveThemeColor(config);
+	const color = typeof theme === "string" ? theme : void 0;
+	const manifest = {
+		name: config.site.name,
+		short_name: shortName(config.site),
+		description: config.site.description,
+		start_url: `${base}/`,
+		scope: `${base}/`,
+		display: "browser",
+		...color ? {
+			theme_color: color,
+			background_color: color
+		} : {},
+		icons: [
+			{
+				src: `${base}/icon-192.png`,
+				sizes: "192x192",
+				type: "image/png"
+			},
+			{
+				src: `${base}/icon-512.png`,
+				sizes: "512x512",
+				type: "image/png"
+			},
+			{
+				src: `${base}/icon-512.png`,
+				sizes: "512x512",
+				type: "image/png",
+				purpose: "maskable"
+			}
+		]
+	};
+	return JSON.stringify(manifest, null, 2) + "\n";
+}
+//#endregion
+export { shortName, webManifest };

package/dist/worker-2qbQjj2c.d.ts

@@ -0,0 +1,64 @@
+import { l as ResourceHandler, n as LayoutComponent, r as LoadingComponent, t as ExtraHandler } from "./pipeline-BHUjBO0G.js";
+import { Channel, ChannelFactory } from "@junejs/core/agent-config";
+import { BrandedRoute } from "@junejs/core/route";
+import { AgentConfig } from "@junejs/core/config";
+import React from "react";
+import { DocumentConfig } from "@junejs/core/document";
+import { I18nConfig } from "@junejs/core/i18n";
+import { Resources } from "@junejs/core/resources";
+//#region src/worker.d.ts
+type WorkerExecutionContext = {
+  waitUntil?(p: Promise<unknown>): void;
+};
+type WorkerManifest = {
+  routes: Record<string, BrandedRoute>;
+  dynamicRoutes?: Array<{
+    pattern: string;
+    def: BrandedRoute;
+  }>;
+  resourceRoutes?: Array<{
+    pattern: string;
+    handler: ResourceHandler;
+  }>;
+  generatedRoutes?: string[];
+  layoutChains?: Record<string, LayoutComponent[]>;
+  layoutBoundaries?: Record<string, {
+    index: number;
+    key: string;
+  }>;
+  loadings?: Record<string, LoadingComponent>;
+  document: DocumentConfig;
+  agent: AgentConfig;
+  agentName?: string;
+  agentChannels?: (Channel | ChannelFactory)[];
+  i18n?: I18nConfig;
+  earlyHints?: string[];
+  htmlCacheControl?: string;
+  notFound?: React.ComponentType<{
+    pathname: string;
+  }>;
+  extra?: ExtraHandler;
+  resources?: (env?: unknown) => Promise<Resources> | Resources;
+  services?: (env?: unknown) => unknown;
+};
+declare function createWorker(manifest: WorkerManifest, opts?: {
+  staticBuild?: boolean;
+}): {
+  fetch(request: Request, env?: unknown, ctx?: WorkerExecutionContext): Promise<Response>;
+};
+type AssetEnv = {
+  ASSETS?: {
+    fetch(request: Request): Promise<Response>;
+  };
+};
+type FetchPipeline = {
+  fetch(request: Request, env?: unknown, ctx?: WorkerExecutionContext): Promise<Response>;
+};
+declare function withAssets(pipeline: FetchPipeline, opts?: {
+  link?: string | null;
+}): {
+  fetch(request: Request, env?: AssetEnv, ctx?: WorkerExecutionContext): Promise<Response>;
+};
+declare function withDenoAssets(pipeline: FetchPipeline): (request: Request) => Promise<Response>;
+//#endregion
+export { withDenoAssets as a, withAssets as i, WorkerManifest as n, createWorker as r, WorkerExecutionContext as t };