@junejs/server 0.1.2 → 0.2.0

package/dist/agent-native.d.ts

@@ -1,40 +1,71 @@
 import { SyncSqlite } from "./sqlite-driver.js";
 import { AgentDefinition, ChannelContext } from "@junejs/core/agent-config";
-import { AgentSession, Model, Runtime, Tool } from "@junejs/core/agent-runtime";
+import { AgentSession, ChannelPolicy, InputAnnouncement, Model, Runtime, Tool } from "@junejs/core/agent-runtime";
+import { FileStore } from "@junejs/core/agent-files";
 //#region src/agent-native.d.ts
-type AgentDef = {
+export type AgentDef = {
   model: Model;
   tools: Tool[];
   instructions?: string;
+  channelInstructions?: Record<string, string | ChannelPolicy>;
+  onInputAnnouncement?: (a: InputAnnouncement) => void | Promise<void>;
 };
-declare class NativeRuntime implements Runtime {
+export declare function toAgentDef(agent: AgentDefinition, model: Model): AgentDef;
+export type NativeRuntimeOptions = {
+  maxSessions?: number;
+  files?: FileStore;
+};
+export declare class NativeRuntime implements Runtime {
   private actors;
   private readonly agents;
   private readonly db;
-  constructor(agents: Record<string, AgentDef>, db: SyncSqlite);
+  private readonly announceRetry;
+  private readonly maxSessions;
+  private closing;
+  readonly files: FileStore | undefined;
+  constructor(agents: Record<string, AgentDef>, db: SyncSqlite, opts?: NativeRuntimeOptions);
+  agentDef(name: string): AgentDef | undefined;
   session(agent: string, id: string): AgentSession;
+  get sessionCount(): number;
+  recoverAnnouncements(): void;
+  close(): Promise<void>;
+  private evictIdle;
 }
-declare function createNativeRuntime(agents: Record<string, AgentDef>, path?: string): Promise<NativeRuntime>;
-declare class MemoryRuntime implements Runtime {
+export declare function createNativeRuntime(agents: Record<string, AgentDef>, path?: string, opts?: NativeRuntimeOptions): Promise<NativeRuntime>;
+export declare class MemoryRuntime implements Runtime {
   private actors;
   private stores;
   private readonly agents;
-  constructor(agents: Record<string, AgentDef>);
+  private readonly announceRetry;
+  private closed;
+  readonly files: FileStore | undefined;
+  constructor(agents: Record<string, AgentDef>, opts?: {
+    files?: FileStore;
+  });
+  agentDef(name: string): AgentDef | undefined;
   session(agent: string, id: string): AgentSession;
+  close(): Promise<void>;
 }
-type AgentBackend = "native" | "memory" | "durable";
-declare function createAgentRuntime(agents: Record<string, AgentDef>, opts?: {
+export type AgentBackend = "native" | "memory" | "durable";
+export type InProcessRuntime = Runtime & {
+  close(): Promise<void>;
+  readonly files?: FileStore;
+};
+export declare function createAgentRuntime(agents: Record<string, AgentDef>, opts?: {
   backend?: AgentBackend;
   path?: string;
-}): Promise<Runtime>;
-declare function mountAgent(agent: AgentDefinition, runtime: Runtime, opts?: {
+  maxSessions?: number;
+  files?: FileStore;
+}): Promise<InProcessRuntime>;
+export declare function mountAgent(agent: AgentDefinition, runtime: Runtime, opts?: {
   chatPath?: string;
   channels?: boolean;
+  services?: unknown;
+  files?: FileStore;
 }): {
   surface: (req: Request) => Promise<Response | null>;
   fetch: (req: Request) => Promise<Response | null>;
   startAll: () => Promise<void>;
   ctx: ChannelContext;
 };
-//#endregion
-export { AgentBackend, AgentDef, MemoryRuntime, NativeRuntime, createAgentRuntime, createNativeRuntime, mountAgent };
+//#endregion

package/dist/agent-native.js

@@ -1,10 +1,13 @@
+import { observeTurnEvents } from "./turn-events.js";
+import { assertCoreRuntimeVersion } from "./core-version.js";
 import { openLocalSqliteSync } from "./sqlite-driver.js";
-import { channelFetch } from "@junejs/core/agent-config";
-import { AgentSession, withSystem } from "@junejs/core/agent-runtime";
+import { buildSystemPrompt, channelFetch } from "@junejs/core/agent-config";
+import { AgentSession, grantAnswer, withSystem } from "@junejs/core/agent-runtime";
 //#region src/agent-native.ts
 function initSchema(db) {
 	db.exec(`CREATE TABLE IF NOT EXISTS agent_sessions (session_id TEXT PRIMARY KEY, status TEXT)`);
 	db.exec(`CREATE TABLE IF NOT EXISTS agent_messages (seq INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT, body TEXT)`);
+	db.exec(`CREATE INDEX IF NOT EXISTS agent_messages_session ON agent_messages (session_id, seq)`);
 	db.exec(`CREATE TABLE IF NOT EXISTS agent_steps (session_id TEXT, id TEXT, output TEXT, PRIMARY KEY (session_id, id))`);
 }
 var SqliteSessionStore = class {
@@ -20,8 +23,8 @@ var SqliteSessionStore = class {
 	messages() {
 		return this.db.query("SELECT body FROM agent_messages WHERE session_id = ? ORDER BY seq").all(this.sid).map((r) => JSON.parse(r.body));
 	}
-	hasUserTurn(turnId) {
-		return this.messages().some((m) => m.role === "user" && m.turnId === turnId);
+	hasOpeningMessage(turnId) {
+		return this.db.query("SELECT 1 FROM agent_messages WHERE session_id = ? AND json_extract(body, '$.turnId') = ? AND json_extract(body, '$.role') IN ('user', 'trigger') LIMIT 1").get(this.sid, turnId) != null;
 	}
 	getStep(id) {
 		const r = this.db.query("SELECT output FROM agent_steps WHERE session_id = ? AND id = ?").get(this.sid, id);
@@ -30,6 +33,9 @@ var SqliteSessionStore = class {
 	putStep(id, output) {
 		this.db.query("INSERT INTO agent_steps (session_id, id, output) VALUES (?, ?, ?)").run(this.sid, id, JSON.stringify(output));
 	}
+	delStep(id) {
+		this.db.query("DELETE FROM agent_steps WHERE session_id = ? AND id = ?").run(this.sid, id);
+	}
 	getStatus() {
 		return this.db.query("SELECT status FROM agent_sessions WHERE session_id = ?").get(this.sid)?.status ?? "new";
 	}
@@ -47,16 +53,32 @@ var SqliteSessionStore = class {
 			throw e;
 		}
 	}
+	reset(inTx) {
+		return this.tx(() => {
+			this.db.exec(`CREATE TABLE IF NOT EXISTS agent_messages_archive (session_id TEXT, generation INTEGER, seq INTEGER, body TEXT)`);
+			this.db.exec(`CREATE TABLE IF NOT EXISTS agent_steps_archive (session_id TEXT, generation INTEGER, id TEXT, output TEXT)`);
+			this.db.exec(`CREATE TABLE IF NOT EXISTS agent_session_generations (session_id TEXT PRIMARY KEY, generation INTEGER)`);
+			const generation = this.db.query("SELECT generation FROM agent_session_generations WHERE session_id = ?").get(this.sid)?.generation ?? 0;
+			this.db.query("INSERT INTO agent_messages_archive (session_id, generation, seq, body) SELECT session_id, ?, seq, body FROM agent_messages WHERE session_id = ?").run(generation, this.sid);
+			this.db.query("DELETE FROM agent_messages WHERE session_id = ?").run(this.sid);
+			this.db.query("INSERT INTO agent_steps_archive (session_id, generation, id, output) SELECT session_id, ?, id, output FROM agent_steps WHERE session_id = ?").run(generation, this.sid);
+			this.db.query("DELETE FROM agent_steps WHERE session_id = ?").run(this.sid);
+			this.db.query("INSERT INTO agent_sessions (session_id, status) VALUES (?, 'new') ON CONFLICT(session_id) DO UPDATE SET status = 'new'").run(this.sid);
+			this.db.query("INSERT INTO agent_session_generations (session_id, generation) VALUES (?, ?) ON CONFLICT(session_id) DO UPDATE SET generation = ?").run(this.sid, generation + 1, generation + 1);
+			inTx?.();
+			return generation;
+		});
+	}
 	unwrap() {
 		return this.db;
 	}
 };
-var InProcBroadcaster = class {
+var InProcEventSink = class {
 	subs = /* @__PURE__ */ new Set();
-	publish(turnId) {
+	emit(e) {
 		this.subs.forEach((cb) => {
 			try {
-				cb(turnId);
+				cb(e);
 			} catch {}
 		});
 	}
@@ -64,44 +86,176 @@ var InProcBroadcaster = class {
 		this.subs.add(cb);
 		return () => this.subs.delete(cb);
 	}
+	get size() {
+		return this.subs.size;
+	}
 };
+var AnnouncementRetry = class {
+	flush;
+	state = /* @__PURE__ */ new Map();
+	stopped = false;
+	constructor(flush) {
+		this.flush = flush;
+	}
+	delivered(key) {
+		const s = this.state.get(key);
+		if (s?.timer) clearTimeout(s.timer);
+		this.state.delete(key);
+	}
+	failed(key, agent, id) {
+		if (this.stopped) return;
+		const s = this.state.get(key) ?? { failures: 0 };
+		this.state.set(key, s);
+		if (s.timer) return;
+		const delay = Math.min(5e3 * 2 ** s.failures, 3e5);
+		s.failures++;
+		s.timer = setTimeout(() => {
+			s.timer = void 0;
+			this.flush(agent, id);
+		}, delay);
+		s.timer.unref?.();
+	}
+	stop() {
+		this.stopped = true;
+		for (const s of this.state.values()) if (s.timer) clearTimeout(s.timer);
+		this.state.clear();
+	}
+};
+const ownedDbs = /* @__PURE__ */ new WeakSet();
+function wireAnnouncements(session, def, retry) {
+	const hook = def.onInputAnnouncement;
+	if (hook) {
+		const key = `${session.agent}:${session.id}`;
+		session.onAnnounce = async (a) => {
+			try {
+				await hook(a);
+			} catch (err) {
+				retry.failed(key, session.agent, session.id);
+				throw err;
+			}
+			retry.delivered(key);
+		};
+		session.flushAnnouncements();
+	}
+	return session;
+}
+const ANNOUNCE_OUTBOX_STEP = "announce-outbox";
+function toAgentDef(agent, model) {
+	return {
+		model,
+		tools: agent.tools,
+		instructions: buildSystemPrompt(agent),
+		...agent.channelInstructions ? { channelInstructions: agent.channelInstructions } : {},
+		...agent.onInputAnnouncement ? { onInputAnnouncement: agent.onInputAnnouncement } : {}
+	};
+}
 var NativeRuntime = class {
 	actors = /* @__PURE__ */ new Map();
 	agents;
 	db;
-	constructor(agents, db) {
+	announceRetry = new AnnouncementRetry((agent, id) => {
+		this.session(agent, id).flushAnnouncements();
+	});
+	maxSessions;
+	closing;
+	files;
+	constructor(agents, db, opts = {}) {
+		assertCoreRuntimeVersion("NativeRuntime");
 		this.agents = agents;
 		this.db = db;
+		this.files = opts.files;
+		const max = opts.maxSessions ?? 1e3;
+		if (!(Number.isInteger(max) && max >= 1) && max !== Infinity) throw new RangeError(`NativeRuntime: maxSessions must be an integer >= 1 (or Infinity for no cap), got ${max}`);
+		this.maxSessions = max;
 		initSchema(db);
 	}
+	agentDef(name) {
+		return this.agents[name];
+	}
 	session(agent, id) {
 		const key = `${agent}:${id}`;
-		let a = this.actors.get(key);
-		if (!a) {
-			const def = this.agents[agent];
-			if (!def) throw new Error(`unknown agent: ${agent}`);
-			const model = def.instructions ? withSystem(def.model, def.instructions) : def.model;
-			a = new AgentSession(agent, id, new SqliteSessionStore(this.db, key), new InProcBroadcaster(), model, def.tools, this);
-			this.actors.set(key, a);
+		const hit = this.actors.get(key);
+		if (!hit && this.closing) throw new Error(`NativeRuntime is closed: cannot open session "${key}"`);
+		if (hit) {
+			this.actors.delete(key);
+			this.actors.set(key, hit);
+			return hit.session;
+		}
+		const def = this.agents[agent];
+		if (!def) throw new Error(`unknown agent: ${agent}`);
+		const model = def.instructions ? withSystem(def.model, def.instructions) : def.model;
+		const sink = new InProcEventSink();
+		const built = new AgentSession(agent, id, new SqliteSessionStore(this.db, key), sink, model, def.tools, this, def.channelInstructions);
+		built.files = this.files;
+		const session = wireAnnouncements(built, def, this.announceRetry);
+		this.evictIdle();
+		this.actors.set(key, {
+			session,
+			sink
+		});
+		return session;
+	}
+	get sessionCount() {
+		return this.actors.size;
+	}
+	recoverAnnouncements() {
+		const rows = this.db.query("SELECT output FROM agent_steps WHERE id = ?").all(ANNOUNCE_OUTBOX_STEP);
+		for (const { output } of rows) {
+			const [first] = JSON.parse(output);
+			if (first && this.agents[first.agent]?.onInputAnnouncement) this.session(first.agent, first.session);
+		}
+	}
+	close() {
+		this.closing ??= (async () => {
+			this.announceRetry.stop();
+			while ([...this.actors.values()].some((a) => !a.session.idle())) await new Promise((r) => setTimeout(r, 10));
+			this.actors.clear();
+			if (ownedDbs.has(this.db)) {
+				ownedDbs.delete(this.db);
+				this.db.close();
+			}
+		})();
+		return this.closing;
+	}
+	evictIdle() {
+		if (this.actors.size < this.maxSessions) return;
+		for (const [key, a] of this.actors) {
+			if (this.actors.size < this.maxSessions) break;
+			if (a.session.idle() && a.sink.size === 0) this.actors.delete(key);
 		}
-		return a;
 	}
 };
-async function createNativeRuntime(agents, path = ":memory:") {
-	return new NativeRuntime(agents, await openLocalSqliteSync(path));
+async function createNativeRuntime(agents, path = ":memory:", opts = {}) {
+	const db = await openLocalSqliteSync(path);
+	ownedDbs.add(db);
+	let runtime;
+	try {
+		runtime = new NativeRuntime(agents, db, opts);
+		runtime.recoverAnnouncements();
+		return runtime;
+	} catch (err) {
+		if (runtime) await runtime.close();
+		else {
+			ownedDbs.delete(db);
+			db.close();
+		}
+		throw err;
+	}
 }
 var MemorySessionStore = class {
 	msgs = [];
 	steps = /* @__PURE__ */ new Map();
 	status = "new";
+	generation = 0;
+	archives = [];
 	appendMessage(m) {
 		this.msgs.push(m);
 	}
 	messages() {
 		return this.msgs.slice();
 	}
-	hasUserTurn(turnId) {
-		return this.msgs.some((m) => m.role === "user" && m.turnId === turnId);
+	hasOpeningMessage(turnId) {
+		return this.msgs.some((m) => (m.role === "user" || m.role === "trigger") && m.turnId === turnId);
 	}
 	getStep(id) {
 		return this.steps.has(id) ? this.steps.get(id) : void 0;
@@ -109,6 +263,9 @@ var MemorySessionStore = class {
 	putStep(id, output) {
 		this.steps.set(id, output);
 	}
+	delStep(id) {
+		this.steps.delete(id);
+	}
 	getStatus() {
 		return this.status;
 	}
@@ -118,44 +275,124 @@ var MemorySessionStore = class {
 	tx(fn) {
 		return fn();
 	}
+	reset(inTx) {
+		const generation = this.generation++;
+		this.archives.push({
+			generation,
+			msgs: this.msgs,
+			steps: this.steps
+		});
+		this.msgs = [];
+		this.steps = /* @__PURE__ */ new Map();
+		this.status = "new";
+		inTx?.();
+		return generation;
+	}
 	unwrap() {}
 };
 var MemoryRuntime = class {
 	actors = /* @__PURE__ */ new Map();
 	stores = /* @__PURE__ */ new Map();
 	agents;
-	constructor(agents) {
+	announceRetry = new AnnouncementRetry((agent, id) => {
+		this.session(agent, id).flushAnnouncements();
+	});
+	closed = false;
+	files;
+	constructor(agents, opts = {}) {
+		assertCoreRuntimeVersion("MemoryRuntime");
 		this.agents = agents;
+		this.files = opts.files;
+	}
+	agentDef(name) {
+		return this.agents[name];
 	}
 	session(agent, id) {
 		const key = `${agent}:${id}`;
 		let a = this.actors.get(key);
 		if (!a) {
+			if (this.closed) throw new Error(`MemoryRuntime is closed: cannot open session "${key}"`);
 			const def = this.agents[agent];
 			if (!def) throw new Error(`unknown agent: ${agent}`);
 			const store = new MemorySessionStore();
 			this.stores.set(key, store);
-			a = new AgentSession(agent, id, store, new InProcBroadcaster(), def.model, def.tools, this);
+			const model = def.instructions ? withSystem(def.model, def.instructions) : def.model;
+			const built = new AgentSession(agent, id, store, new InProcEventSink(), model, def.tools, this, def.channelInstructions);
+			built.files = this.files;
+			a = wireAnnouncements(built, def, this.announceRetry);
 			this.actors.set(key, a);
 		}
 		return a;
 	}
+	async close() {
+		this.closed = true;
+		this.announceRetry.stop();
+		this.actors.clear();
+		this.stores.clear();
+	}
 };
 async function createAgentRuntime(agents, opts = {}) {
 	const backend = opts.backend ?? "native";
-	if (backend === "memory") return new MemoryRuntime(agents);
-	if (backend === "native") return createNativeRuntime(agents, opts.path);
+	if (backend === "memory") return new MemoryRuntime(agents, { files: opts.files });
+	if (backend === "native") return createNativeRuntime(agents, opts.path, {
+		maxSessions: opts.maxSessions,
+		files: opts.files
+	});
 	throw new Error("backend 'durable' is the Cloudflare Durable Object target — construct AgentDurableObject in your worker, not via createAgentRuntime");
 }
+function warnOnDrift(agent, runtime) {
+	const def = runtime.agentDef?.(agent.name);
+	if (!def) return;
+	const names = (tools) => tools.map((t) => t.spec.name).sort();
+	const want = names(agent.tools), have = names(def.tools);
+	if (want.join("\0") !== have.join("\0")) {
+		const missing = want.filter((n) => !have.includes(n)), extra = have.filter((n) => !want.includes(n));
+		console.warn(`[june] mountAgent("${agent.name}"): the runtime's tools differ from the agent definition's` + (missing.length ? ` — missing from the runtime: ${missing.join(", ")}` : "") + (extra.length ? ` — only in the runtime: ${extra.join(", ")}` : "") + `. Build the runtime entry with toAgentDef(agent, model) so both come from one definition.`);
+	}
+}
 function mountAgent(agent, runtime, opts = {}) {
 	const chatPath = opts.chatPath ?? "/message";
 	const channelsOn = opts.channels ?? true;
+	warnOnDrift(agent, runtime);
 	const ctx = {
 		agent,
+		services: opts.services,
+		files: opts.files ?? runtime.files,
 		run: (message, o) => runtime.session(agent.name, o?.session ?? "default").turn({
 			turnId: o?.turnId,
-			userText: message
-		})
+			userText: message,
+			event: o?.event,
+			trigger: o?.trigger,
+			replace: o?.replace
+		}),
+		runDetached: async (message, o) => runtime.session(agent.name, o?.session ?? "default").start({
+			turnId: o?.turnId,
+			userText: message,
+			event: o?.event,
+			trigger: o?.trigger,
+			replace: o?.replace
+		}),
+		runStream: async function* (message, o) {
+			const session = runtime.session(agent.name, o?.session ?? "default");
+			const { turnId } = session.start({
+				turnId: o?.turnId,
+				userText: message,
+				event: o?.event,
+				trigger: o?.trigger,
+				replace: o?.replace
+			});
+			yield* observeTurnEvents(session, turnId);
+		},
+		resumeStream: async function* (o) {
+			const session = runtime.session(agent.name, o.session ?? "default");
+			const granted = await grantAnswer(session, o, agent.authorizeAnswer);
+			const { turnId } = session.resume(o.turnId, o.inputId, o.input, {
+				by: o.by,
+				granted
+			});
+			yield* observeTurnEvents(session, turnId);
+		},
+		resetSession: (o) => runtime.session(agent.name, o?.session ?? "default").reset()
 	};
 	const channels = channelFetch(agent, ctx);
 	const surface = async (req) => {
@@ -176,4 +413,4 @@ function mountAgent(agent, runtime, opts = {}) {
 	};
 }
 //#endregion
-export { MemoryRuntime, NativeRuntime, createAgentRuntime, createNativeRuntime, mountAgent };
+export { MemoryRuntime, NativeRuntime, createAgentRuntime, createNativeRuntime, mountAgent, toAgentDef };

package/dist/app.d.ts

@@ -1,15 +1,15 @@
 import { JuneConfig } from "@junejs/core/config";
 //#region src/app.d.ts
-type CreateAppOptions = {
+export type CreateAppOptions = {
   appDir: string;
   config?: JuneConfig;
 };
-type JuneApp = {
+export type JuneApp = {
   fetch(request: Request): Promise<Response>;
   warmup(): Promise<void>;
   routePaths(): Promise<string[]>;
   earlyHints(): string[];
+  close(): Promise<void>;
 };
-declare function createApp({ appDir: appDirInput, config }: CreateAppOptions): JuneApp;
-//#endregion
-export { CreateAppOptions, JuneApp, createApp };
+export declare function createApp({ appDir: appDirInput, config }: CreateAppOptions): JuneApp;
+//#endregion

package/dist/app.js

@@ -1,21 +1,24 @@
 import { discoverAgent } from "./agent-discover.js";
-import { createAgentRuntime, mountAgent } from "./agent-native.js";
+import { createAgentRuntime, mountAgent, toAgentDef } from "./agent-native.js";
 import { findMiddlewareFile, isResourceFile, listRoutes, matchRouteTree, resolveNotFound, routeFiles } from "./router.js";
+import { routeProblems, scanRoutes } from "./route-scan.js";
 import { createPipeline } from "./pipeline.js";
 import { resolveBoundary } from "./segment.js";
 import { memoizeResources } from "./resources.js";
+import { localBlob } from "./blob.js";
 import { MODULE_STYLES_URL, buildModuleCss, registerCssModules } from "./css-modules.js";
 import { CLIENT_SCRIPT_URL, bundleClientSplit, findClientEntry } from "./client-bundle.js";
 import { generateIslandRegistry } from "./island-registry.js";
 import { STYLES_URL, findGlobalCss, globalCssUsesTailwind, processCssCached } from "./css.js";
 import { contentTypeFor, safeRelativePath } from "./static-files.js";
+import { GENERATED_ICONS, googleFontFetcher, publicFileCheck, renderIcons, resolveIcons } from "./favicon.js";
 import { existsSync, lstatSync, realpathSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
-import { buildSystemPrompt } from "@junejs/core/agent-config";
+import { blobFileStore, memoryFileStore } from "@junejs/core/agent-files";
 import { routeFromModule } from "@junejs/core/route";
-import { resolveAgent, resolveClientRouter, resolveSpeculationRules } from "@junejs/core/config";
+import { deployOrigin, resolveAgent, resolveClientRouter, resolveSpeculationRules } from "@junejs/core/config";
 import { runWithTrace } from "@junejs/core/instrumentation";
 import { anthropic } from "@junejs/core/agent-models";
 //#region src/app.ts
@@ -69,19 +72,31 @@ function createApp({ appDir: appDirInput, config = {} }) {
 	try {
 		if (lstatSync(publicDir).isDirectory()) publicRoot = realpathSync(publicDir);
 	} catch {}
+	const iconPlan = resolveIcons(config.site ?? {}, publicFileCheck(publicDir));
+	let iconsPromise;
+	const getIcons = () => iconsPromise ??= renderIcons({
+		site: config.site ?? {},
+		fetchFont: googleFontFetcher(join(dirname(appDir), "node_modules", ".cache", "june", "fonts")),
+		warn: (msg) => console.warn(msg)
+	}).catch((err) => {
+		iconsPromise = void 0;
+		throw err;
+	});
 	const agent = resolveAgent(config.agent);
 	const speculation = config.speculation;
 	const clientEntry = findClientEntry(appDir) ?? findClientEntry(join(dirname(appDir), ".june", "routes"));
 	const cssEntry = findGlobalCss(appDir);
 	const docConfig = {
 		site: config.site ?? {},
+		deployOrigin: deployOrigin(config),
 		speculationRules: resolveSpeculationRules(speculation ?? void 0),
 		speculationDelivery: speculation ? speculation.delivery ?? "inline" : "inline",
 		viewTransitions: config.viewTransitions ?? true,
 		cssReset: config.cssReset ?? !globalCssUsesTailwind(appDir),
 		clientRouter: resolveClientRouter(config.clientRouter),
 		clientScript: clientEntry ? CLIENT_SCRIPT_URL : null,
-		styles: cssEntry ? STYLES_URL : null
+		styles: cssEntry ? STYLES_URL : null,
+		icons: iconPlan.icons
 	};
 	let moduleCssPromise;
 	const getModuleCss = () => moduleCssPromise ??= buildModuleCss(appDir, dirname(appDir));
@@ -103,6 +118,7 @@ function createApp({ appDir: appDirInput, config = {} }) {
 	config.dataLayer?.install();
 	let pipelinePromise;
 	const getPipeline = () => pipelinePromise ??= buildPipeline();
+	let agentRuntime;
 	async function buildPipeline() {
 		const { maps, css } = await getModuleCss();
 		await registerCssModules(maps);
@@ -125,11 +141,14 @@ function createApp({ appDir: appDirInput, config = {} }) {
 			const def = await discoverAgent(agentDir);
 			const backend = agent.runtime.backend === "durable" ? "native" : agent.runtime.backend;
 			const model = anthropic({ model: def.model });
-			const mounted = mountAgent(def, await createAgentRuntime({ [def.name]: {
-				model,
-				tools: def.tools,
-				instructions: buildSystemPrompt(def)
-			} }, { backend }), {
+			let blobOpened;
+			const files = backend === "memory" ? memoryFileStore() : blobFileStore(() => blobOpened ??= resources().then(async (r) => r.blob ?? await localBlob().open()));
+			const rt = await createAgentRuntime({ [def.name]: toAgentDef(def, model) }, {
+				backend,
+				files
+			});
+			agentRuntime = rt;
+			const mounted = mountAgent(def, rt, {
 				chatPath: agent.runtime.chat.path,
 				channels: agent.runtime.channels
 			});
@@ -238,9 +257,18 @@ function createApp({ appDir: appDirInput, config = {} }) {
 					}
 				}
 			}
+			if (iconPlan.generate && (request.method === "GET" || request.method === "HEAD")) {
+				const name = new URL(request.url).pathname.slice(1);
+				if (GENERATED_ICONS.includes(name)) return getIcons().then((icons) => new Response(request.method === "HEAD" ? null : icons[name], { headers: {
+					"content-type": contentTypeFor(name),
+					"cache-control": "public, max-age=0, must-revalidate"
+				} }), () => toPipeline());
+			}
 			return toPipeline();
 		},
 		async warmup() {
+			const problems = routeProblems([await scanRoutes(appDir), hasJuneRoutes ? await scanRoutes(juneRoutesDir) : []], dirname(appDir));
+			if (problems) console.error(problems);
 			const files = await routeFiles(appDir, { pageConvention: true });
 			if (hasJuneRoutes) files.push(...await routeFiles(juneRoutesDir, { pageConvention: true }));
 			for (const file of files) await import(pathToFileURL(file).href).catch((err) => {
@@ -248,7 +276,11 @@ function createApp({ appDir: appDirInput, config = {} }) {
 			});
 		},
 		routePaths,
-		earlyHints: () => config.earlyHints ?? []
+		earlyHints: () => config.earlyHints ?? [],
+		async close() {
+			await pipelinePromise?.catch(() => {});
+			await agentRuntime?.close();
+		}
 	};
 }
 //#endregion

package/dist/blob.d.ts

@@ -1,12 +1,12 @@
 import { BlobFactory } from "@junejs/core/resources";
 //#region src/blob.d.ts
-declare function localBlob(opts?: {
+export declare function localBlob(opts?: {
   dir?: string;
 }): BlobFactory;
 interface R2ObjectBody {
   arrayBuffer(): Promise<ArrayBuffer>;
 }
-interface R2Bucket {
+export interface R2Bucket {
   get(key: string): Promise<R2ObjectBody | null>;
   put(key: string, data: ArrayBuffer | Uint8Array | string): Promise<unknown>;
   delete(key: string): Promise<void>;
@@ -18,6 +18,5 @@ interface R2Bucket {
     }[];
   }>;
 }
-declare function r2(bucket: R2Bucket): BlobFactory;
-//#endregion
-export { R2Bucket, localBlob, r2 };
+export declare function r2(bucket: R2Bucket): BlobFactory;
+//#endregion