@junejs/server 1.0.0-dev.36 → 1.0.0-dev.45

package/dist/agent-durable.d.ts

@@ -1,5 +1,5 @@
 import { Channel, ChannelFactory } from "@junejs/core/agent-config";
-import { AuthorizeAnswer, ChannelPolicy, InboundEvent, Model, Msg, ProactiveTrigger, SessionStore, Tool, TurnError, TurnEvent, TurnFailurePhase } from "@junejs/core/agent-runtime";
+import { AuthorizeAnswer, ChannelPolicy, InboundEvent, InputAnnouncement, Model, Msg, NoteKind, ProactiveTrigger, SessionStore, Tool, TurnError, TurnEvent, TurnFailurePhase } from "@junejs/core/agent-runtime";
 import { Connection } from "@junejs/core/connections";
 import { Resources } from "@junejs/core/resources";
 //#region src/agent-durable.d.ts
@@ -14,6 +14,7 @@ export interface SqlStorage {
 export interface DurableStorage {
   sql: SqlStorage;
   transactionSync<T>(fn: () => T): T;
+  setAlarm?(scheduledTime: number): unknown;
 }
 export interface DurableObjectState {
   storage: DurableStorage;
@@ -40,7 +41,7 @@ export declare class DoSessionStore implements SessionStore {
   getSessionKey(): string | undefined;
   setSessionKey(key: string): void;
   tx<T>(fn: () => T): T;
-  reset(): number;
+  reset(inTx?: () => void): number;
   unwrap<H = unknown>(): H;
 }
 export type DoAgentDef = {
@@ -61,6 +62,7 @@ export type DoAgentDef = {
     step?: string;
   }) => void | Promise<void>;
   authorizeAnswer?: AuthorizeAnswer;
+  onInputAnnouncement?: (a: InputAnnouncement) => void | Promise<void>;
 };
 export declare class AgentDurableObject {
   private session;
@@ -79,11 +81,18 @@ export declare class AgentDurableObject {
   private readonly doEnv;
   private readonly services;
   private readonly authorizeAnswer?;
+  private readonly onInputAnnouncement?;
+  private readonly storage;
+  private announceFailures;
   private resolveResources;
   private resolveConnections;
   private ready;
   constructor(state: DurableObjectState, def: DoAgentDef);
   private resolveSession;
+  alarm(): Promise<void>;
+  private armWatchdog;
+  private scheduleAlarm;
+  private deliverHeld;
   turn(input: {
     turnId?: string;
     userText: string;
@@ -100,6 +109,14 @@ export declare class AgentDurableObject {
   }): Promise<{
     turnId: string;
   }>;
+  note(input: {
+    by: string;
+    kind: NoteKind;
+    text: string;
+    session?: string;
+  }): Promise<{
+    noteId: string;
+  }>;
   reset(opts?: {
     session?: string;
   }): Promise<{

package/dist/agent-durable.js

@@ -54,7 +54,7 @@ var DoSessionStore = class {
 	tx(fn) {
 		return this.storage.transactionSync(fn);
 	}
-	reset() {
+	reset(inTx) {
 		return this.storage.transactionSync(() => {
 			const sql = this.sql;
 			sql.exec(`CREATE TABLE IF NOT EXISTS agent_messages_archive (generation INTEGER, seq INTEGER, body TEXT)`);
@@ -67,6 +67,7 @@ var DoSessionStore = class {
 			sql.exec("DELETE FROM agent_steps");
 			this.setStatus("new");
 			sql.exec("INSERT INTO agent_meta (k, v) VALUES ('generation', ?) ON CONFLICT(k) DO UPDATE SET v = ?", String(generation + 1), String(generation + 1));
+			inTx?.();
 			return generation;
 		});
 	}
@@ -108,6 +109,9 @@ var AgentDurableObject = class {
 	doEnv;
 	services;
 	authorizeAnswer;
+	onInputAnnouncement;
+	storage;
+	announceFailures = 0;
 	resolveResources() {
 		return this.resourcesOpened ??= Promise.resolve(typeof this.resourcesInput === "function" ? this.resourcesInput(this.doEnv) : this.resourcesInput ?? {});
 	}
@@ -138,8 +142,13 @@ var AgentDurableObject = class {
 		this.doEnv = def.env;
 		this.services = def.services;
 		this.authorizeAnswer = def.authorizeAnswer;
+		this.onInputAnnouncement = def.onInputAnnouncement;
+		this.storage = state.storage;
 		const name = def.name ?? "agent";
 		const sink = new InProcEventSink();
+		sink.subscribe((e) => {
+			if (e.type === "turn.started") this.armWatchdog();
+		});
 		sink.subscribe((e) => {
 			if (e.type !== "turn.failed") return;
 			const defaultLog = () => console.error(`[june] agent "${name}" turn ${e.turnId} failed${e.step ? ` at ${e.step}` : ""}: ${e.error.stack ?? e.error.message}${e.error.causeChain?.length ? `\ncaused by: ${e.error.causeChain.join(" ← ")}` : ""}`);
@@ -193,8 +202,71 @@ var AgentDurableObject = class {
 		if (key !== void 0 && key !== "self" && stored === void 0) this.store.setSessionKey(key);
 		this.sessionKey = resolved;
 		this.session = new AgentSession(this.name, resolved, this.store, this.sink, this.model, this.tools, crossDoUnsupported, this.channelInstructions);
+		this.session.onDequeue = (heldTurnId, held) => {
+			if (held.hostContext?.deliver && held.event) this.deliverHeld(this.session, heldTurnId, held.event);
+		};
+		const announce = this.onInputAnnouncement;
+		if (announce) {
+			this.session.onAnnounce = async (a) => {
+				await ensureScope();
+				const resources = await this.ready();
+				try {
+					await runInScope({
+						resources,
+						services: this.services
+					}, () => announce(a));
+				} catch (err) {
+					this.scheduleAlarm(Math.min(5e3 * 2 ** this.announceFailures, 3e5));
+					this.announceFailures++;
+					throw err;
+				}
+				this.announceFailures = 0;
+			};
+			this.session.flushAnnouncements();
+		}
 		return this.session;
 	}
+	async alarm() {
+		if (!this.onInputAnnouncement) return;
+		await this.resolveSession().flushAnnouncements();
+	}
+	armWatchdog() {
+		if (this.onInputAnnouncement) this.scheduleAlarm(6e4);
+	}
+	scheduleAlarm(inMs) {
+		const failed = (err) => console.error(`[june] agent "${this.name}": could not schedule the announcement alarm — delivery waits for the next announcement, turn or rebuild:`, err);
+		try {
+			Promise.resolve(this.storage.setAlarm?.(Date.now() + inMs)).catch(failed);
+		} catch (err) {
+			failed(err);
+		}
+	}
+	deliverHeld(session, turnId, event) {
+		const logRenderFailure = (err) => console.error(`[june] agent "${this.name}": delivered render for held turn ${turnId} failed:`, err);
+		try {
+			const channel = this.channels.find((c) => c.name === event.source);
+			if (!channel?.deliver) {
+				logRenderFailure(/* @__PURE__ */ new Error(`no deliver()-capable channel named "${event.source}" is wired into this DO — the held turn runs, but its reply is not rendered`));
+				return;
+			}
+			const it = observeTurnEvents(session, turnId)[Symbol.asyncIterator]();
+			const events = { [Symbol.asyncIterator]: () => it };
+			const target = {
+				channelId: event.channelId,
+				threadId: event.threadId,
+				recipientUserId: event.user?.id,
+				recipientTeamId: event.teamId
+			};
+			this.ready().then((resources) => runInScope({
+				resources,
+				services: this.services
+			}, () => channel.deliver(target, events, { session: this.sessionKey }))).catch(logRenderFailure).finally(() => {
+				it.return?.();
+			});
+		} catch (err) {
+			logRenderFailure(err);
+		}
+	}
 	async turn(input) {
 		await ensureScope();
 		const resources = await this.ready();
@@ -213,8 +285,14 @@ var AgentDurableObject = class {
 			services: this.services
 		}, () => session.start(input));
 	}
+	note(input) {
+		const { session, ...note } = input;
+		return this.resolveSession(session).note(note);
+	}
 	reset(opts) {
-		return this.resolveSession(opts?.session).reset();
+		const session = this.resolveSession(opts?.session);
+		this.armWatchdog();
+		return session.reset();
 	}
 	transcript() {
 		if (this.session) return this.session.transcript();
@@ -225,10 +303,13 @@ var AgentDurableObject = class {
 		const url = new URL(req.url);
 		const key = req.headers.get("x-june-session") ?? void 0;
 		if (req.method === "POST" && url.pathname.endsWith("/turn")) {
-			const { userText, turnId, event, trigger } = await req.json();
+			const { userText, turnId, event, trigger, ifSuspended } = await req.json();
 			await ensureScope();
 			const replace = url.searchParams.get("replace") === "1";
 			const wantsDeliver = url.searchParams.get("deliver") === "1";
+			const detached = url.searchParams.get("detach") === "1";
+			if (ifSuspended === "queue" && !wantsDeliver && !detached) return Response.json({ error: `ifSuspended "queue" needs deliver=1 or detach=1: a held turn runs later, when no one is streaming it` }, { status: 400 });
+			if (ifSuspended === "queue" && replace) return Response.json({ error: `ifSuspended "queue" and replace=1 cannot be combined — replacing would drop held turns that were accepted` }, { status: 400 });
 			let deliverChannel;
 			if (wantsDeliver) {
 				if (!event?.channelId) return Response.json({ error: "deliver=1 needs an inbound event (event.channelId names the reply target)" }, { status: 400 });
@@ -240,6 +321,7 @@ var AgentDurableObject = class {
 			let started;
 			try {
 				session = this.resolveSession(key);
+				this.armWatchdog();
 				started = runInScope({
 					resources,
 					services: this.services
@@ -248,11 +330,17 @@ var AgentDurableObject = class {
 					turnId,
 					event,
 					trigger,
-					replace
+					replace,
+					ifSuspended,
+					hostContext: wantsDeliver ? { deliver: true } : void 0
 				}));
 			} catch (err) {
 				return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
 			}
+			if (started.queued) return Response.json({
+				turnId: started.turnId,
+				queued: true
+			}, { status: 202 });
 			if (wantsDeliver) {
 				const logRenderFailure = (err) => console.error(`[june] agent "${this.name}": delivered render for turn ${started.turnId} failed:`, err);
 				try {
@@ -275,7 +363,7 @@ var AgentDurableObject = class {
 				}
 				return Response.json({ turnId: started.turnId }, { status: 202 });
 			}
-			if (url.searchParams.get("detach") === "1") return Response.json({ turnId: started.turnId }, { status: 202 });
+			if (detached) return Response.json({ turnId: started.turnId }, { status: 202 });
 			return new Response(sseTurnStream(session, started.turnId), { headers: SSE_HEADERS });
 		}
 		if (req.method === "POST" && url.pathname.endsWith("/resume")) {
@@ -310,6 +398,7 @@ var AgentDurableObject = class {
 				console.error(`[june] agent "${this.name}": authorizeAnswer failed for input "${inputId}" of turn ${turnId}:`, err);
 				return Response.json({ error: `authorizeAnswer failed: ${err instanceof Error ? err.message : String(err)} — the answer was NOT applied` }, { status: 500 });
 			}
+			this.armWatchdog();
 			try {
 				runInScope({
 					resources,
@@ -347,12 +436,33 @@ var AgentDurableObject = class {
 			} catch (err) {
 				return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
 			}
+			this.armWatchdog();
 			try {
 				return Response.json(await session.reset());
 			} catch (err) {
 				return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
 			}
 		}
+		if (req.method === "POST" && url.pathname.endsWith("/note")) {
+			let input;
+			try {
+				input = await req.json();
+			} catch {
+				return Response.json({ error: "note: the body must be JSON { by, kind, text }" }, { status: 400 });
+			}
+			let session;
+			try {
+				session = this.resolveSession(key);
+			} catch (err) {
+				return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
+			}
+			try {
+				return Response.json(await session.note(input));
+			} catch (err) {
+				if (err instanceof TypeError) return Response.json({ error: err.message }, { status: 400 });
+				throw err;
+			}
+		}
 		if (url.pathname.endsWith("/transcript")) {
 			if (key !== void 0) try {
 				return Response.json({ transcript: this.resolveSession(key).transcript() });
@@ -361,7 +471,7 @@ var AgentDurableObject = class {
 			}
 			return Response.json({ transcript: this.transcript() });
 		}
-		return new Response("agent DO — POST /turn, POST /resume, POST /reset, or GET /transcript", { status: 404 });
+		return new Response("agent DO — POST /turn, POST /resume, POST /reset, POST /note, or GET /transcript", { status: 404 });
 	}
 };
 const SSE_HEADERS = {
@@ -608,7 +718,8 @@ function serializeTurn(userText, o) {
 		userText,
 		turnId: o?.turnId,
 		event: o?.event,
-		trigger: o?.trigger
+		trigger: o?.trigger,
+		ifSuspended: o?.ifSuspended
 	};
 	try {
 		return JSON.stringify(payload);

package/dist/agent-native.d.ts

@@ -1,12 +1,13 @@
 import { SyncSqlite } from "./sqlite-driver.js";
 import { AgentDefinition, ChannelContext } from "@junejs/core/agent-config";
-import { AgentSession, ChannelPolicy, Model, Runtime, Tool } from "@junejs/core/agent-runtime";
+import { AgentSession, ChannelPolicy, InputAnnouncement, Model, Runtime, Tool } from "@junejs/core/agent-runtime";
 //#region src/agent-native.d.ts
 export type AgentDef = {
   model: Model;
   tools: Tool[];
   instructions?: string;
   channelInstructions?: Record<string, string | ChannelPolicy>;
+  onInputAnnouncement?: (a: InputAnnouncement) => void | Promise<void>;
 };
 export declare function toAgentDef(agent: AgentDefinition, model: Model): AgentDef;
 export type NativeRuntimeOptions = {
@@ -16,11 +17,15 @@ export declare class NativeRuntime implements Runtime {
   private actors;
   private readonly agents;
   private readonly db;
+  private readonly announceRetry;
   private readonly maxSessions;
+  private closing;
   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;
 }
 export declare function createNativeRuntime(agents: Record<string, AgentDef>, path?: string, opts?: NativeRuntimeOptions): Promise<NativeRuntime>;
@@ -28,16 +33,22 @@ export declare class MemoryRuntime implements Runtime {
   private actors;
   private stores;
   private readonly agents;
+  private readonly announceRetry;
+  private closed;
   constructor(agents: Record<string, AgentDef>);
   agentDef(name: string): AgentDef | undefined;
   session(agent: string, id: string): AgentSession;
+  close(): Promise<void>;
 }
 export type AgentBackend = "native" | "memory" | "durable";
+export type InProcessRuntime = Runtime & {
+  close(): Promise<void>;
+};
 export declare function createAgentRuntime(agents: Record<string, AgentDef>, opts?: {
   backend?: AgentBackend;
   path?: string;
   maxSessions?: number;
-}): Promise<Runtime>;
+}): Promise<InProcessRuntime>;
 export declare function mountAgent(agent: AgentDefinition, runtime: Runtime, opts?: {
   chatPath?: string;
   channels?: boolean;

package/dist/agent-native.js

@@ -53,7 +53,7 @@ var SqliteSessionStore = class {
 			throw e;
 		}
 	}
-	reset() {
+	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)`);
@@ -65,6 +65,7 @@ var SqliteSessionStore = class {
 			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;
 		});
 	}
@@ -89,19 +90,74 @@ var InProcEventSink = class {
 		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.channelInstructions ? { channelInstructions: agent.channelInstructions } : {},
+		...agent.onInputAnnouncement ? { onInputAnnouncement: agent.onInputAnnouncement } : {}
 	};
 }
 var NativeRuntime = class {
 	actors = /* @__PURE__ */ new Map();
 	agents;
 	db;
+	announceRetry = new AnnouncementRetry((agent, id) => {
+		this.session(agent, id).flushAnnouncements();
+	});
 	maxSessions;
+	closing;
 	constructor(agents, db, opts = {}) {
 		assertCoreRuntimeVersion("NativeRuntime");
 		this.agents = agents;
@@ -117,6 +173,7 @@ var NativeRuntime = class {
 	session(agent, id) {
 		const key = `${agent}:${id}`;
 		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);
@@ -126,7 +183,7 @@ var NativeRuntime = class {
 		if (!def) throw new Error(`unknown agent: ${agent}`);
 		const model = def.instructions ? withSystem(def.model, def.instructions) : def.model;
 		const sink = new InProcEventSink();
-		const session = new AgentSession(agent, id, new SqliteSessionStore(this.db, key), sink, model, def.tools, this, def.channelInstructions);
+		const session = wireAnnouncements(new AgentSession(agent, id, new SqliteSessionStore(this.db, key), sink, model, def.tools, this, def.channelInstructions), def, this.announceRetry);
 		this.evictIdle();
 		this.actors.set(key, {
 			session,
@@ -137,6 +194,25 @@ var NativeRuntime = class {
 	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) {
@@ -146,7 +222,21 @@ var NativeRuntime = class {
 	}
 };
 async function createNativeRuntime(agents, path = ":memory:", opts = {}) {
-	return new NativeRuntime(agents, await openLocalSqliteSync(path), 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 = [];
@@ -181,7 +271,7 @@ var MemorySessionStore = class {
 	tx(fn) {
 		return fn();
 	}
-	reset() {
+	reset(inTx) {
 		const generation = this.generation++;
 		this.archives.push({
 			generation,
@@ -191,6 +281,7 @@ var MemorySessionStore = class {
 		this.msgs = [];
 		this.steps = /* @__PURE__ */ new Map();
 		this.status = "new";
+		inTx?.();
 		return generation;
 	}
 	unwrap() {}
@@ -199,6 +290,10 @@ var MemoryRuntime = class {
 	actors = /* @__PURE__ */ new Map();
 	stores = /* @__PURE__ */ new Map();
 	agents;
+	announceRetry = new AnnouncementRetry((agent, id) => {
+		this.session(agent, id).flushAnnouncements();
+	});
+	closed = false;
 	constructor(agents) {
 		assertCoreRuntimeVersion("MemoryRuntime");
 		this.agents = agents;
@@ -210,16 +305,23 @@ var MemoryRuntime = class {
 		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);
 			const model = def.instructions ? withSystem(def.model, def.instructions) : def.model;
-			a = new AgentSession(agent, id, store, new InProcEventSink(), model, def.tools, this, def.channelInstructions);
+			a = wireAnnouncements(new AgentSession(agent, id, store, new InProcEventSink(), model, def.tools, this, def.channelInstructions), 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";

package/dist/app.d.ts

@@ -9,6 +9,7 @@ export type JuneApp = {
   warmup(): Promise<void>;
   routePaths(): Promise<string[]>;
   earlyHints(): string[];
+  close(): Promise<void>;
 };
 export declare function createApp({ appDir: appDirInput, config }: CreateAppOptions): JuneApp;
 //#endregion

package/dist/app.js

@@ -1,6 +1,7 @@
 import { discoverAgent } from "./agent-discover.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";
@@ -115,6 +116,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);
@@ -138,6 +140,7 @@ function createApp({ appDir: appDirInput, config = {} }) {
 			const backend = agent.runtime.backend === "durable" ? "native" : agent.runtime.backend;
 			const model = anthropic({ model: def.model });
 			const rt = await createAgentRuntime({ [def.name]: toAgentDef(def, model) }, { backend });
+			agentRuntime = rt;
 			const mounted = mountAgent(def, rt, {
 				chatPath: agent.runtime.chat.path,
 				channels: agent.runtime.channels
@@ -257,6 +260,8 @@ function createApp({ appDir: appDirInput, config = {} }) {
 			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) => {
@@ -264,7 +269,11 @@ function createApp({ appDir: appDirInput, config = {} }) {
 			});
 		},
 		routePaths,
-		earlyHints: () => config.earlyHints ?? []
+		earlyHints: () => config.earlyHints ?? [],
+		async close() {
+			await pipelinePromise?.catch(() => {});
+			await agentRuntime?.close();
+		}
 	};
 }
 //#endregion

package/dist/build.d.ts

@@ -1,7 +1,7 @@
-import { n as scanAppRoutes, r as scanRoutes, t as RouteEntry } from "./route-scan-DMlwoESy.js";
+import { a as scanAppRoutes, o as scanRoutes, t as RouteEntry } from "./route-scan-BMbBzPIB.js";
 import { t as generateContent } from "./content-freeze-CyiW2fRK.js";
-import { i as workerName, n as normalizeBase, r as resolveDeployAdapter, t as freezeConfig } from "./config-freeze-ZWC_Qd4h.js";
-import { n as buildManifest } from "./manifest-DSNX4I-G.js";
+import { i as workerName, n as normalizeBase, r as resolveDeployAdapter, t as freezeConfig } from "./config-freeze-CyXvNqi2.js";
+import { n as buildManifest } from "./manifest-CwTT1zVs.js";
 //#region src/build.d.ts
 export type BuildResult = {
   outFile: string;

package/dist/build.js

@@ -1,6 +1,7 @@
 import { jsxTransform } from "./tsconfig-jsx.js";
 import { generateAgentModule } from "./agent-compile.js";
 import { findMiddlewareFile } from "./router.js";
+import { scanAppRoutes, scanRoutes } from "./route-scan.js";
 import { resolveBoundary } from "./segment.js";
 import { buildModuleCss, registerCssModules, rolldownCssModulesPlugin } from "./css-modules.js";
 import { bundleClientToFile, findClientEntry } from "./client-bundle.js";
@@ -12,7 +13,6 @@ import { loadJuneConfig } from "./config-loader.js";
 import { freezeConfig, normalizeBase, resolveDeployAdapter, workerName } from "./config-freeze.js";
 import { generateContent } from "./content-freeze.js";
 import { createWorker } from "./worker.js";
-import { scanAppRoutes, scanRoutes } from "./route-scan.js";
 import { buildManifest, importLayout } from "./manifest.js";
 import { buildRsc, findRscRoutes } from "./rsc-build.js";
 import { existsSync, lstatSync } from "node:fs";
@@ -154,6 +154,8 @@ async function juneBuild(appRoot, options = {}) {
 		if (r.loading) loadings.push(`    ${JSON.stringify(r.path)}: ${loadingId(r.loading)},`);
 	});
 	const resourceRoutesField = resources.length ? `\n  resourceRoutes: [\n${resources.join("\n")}\n  ],` : "";
+	const generatedPaths = routes.filter((r) => r.generated).map((r) => r.path);
+	const generatedRoutesField = generatedPaths.length ? `\n  generatedRoutes: ${JSON.stringify(generatedPaths)},` : "";
 	const layoutBoundariesField = boundaries.length ? `\n  layoutBoundaries: {\n${boundaries.join("\n")}\n  },` : "";
 	const builtExtraFile = findMiddlewareFile(appDir);
 	if (builtExtraFile) imports.push(`import extra from ${JSON.stringify(importPath(genDir, builtExtraFile))};`);
@@ -208,6 +210,10 @@ export class JuneAgentDO extends DurableObject {
   fetch(req: Request): Promise<Response> {
     return this.#agent.fetch(req);
   }
+  // Delivers input announcements left undelivered — a failed hook's retry, or the watchdog (#260).
+  alarm(): Promise<void> {
+    return this.#agent.alarm();
+  }
 }
 ` : "";
 	const entry = `// AUTO-GENERATED by \`june build\` — do not edit. Regenerate: june build .
@@ -220,7 +226,7 @@ ${statics.join("\n")}
   },
   dynamicRoutes: [
 ${dynamics.join("\n")}
-  ],${resourceRoutesField}
+  ],${resourceRoutesField}${generatedRoutesField}
   layoutChains: {
 ${chains.join("\n")}
   },${layoutBoundariesField}

package/dist/{config-freeze-ZWC_Qd4h.d.ts → config-freeze-CyXvNqi2.d.ts}

@@ -1,5 +1,5 @@
 import { i as JuneAdapter } from "./adapter-DcZ-W1-7.js";
-import { n as WorkerManifest } from "./worker-Dv4l6Ybs.js";
+import { n as WorkerManifest } from "./worker-2qbQjj2c.js";
 import { JuneConfig } from "@junejs/core/config";
 import { DocumentConfig } from "@junejs/core/document";
 //#region src/config-freeze.d.ts

package/dist/config-freeze.d.ts

@@ -1,2 +1,2 @@
-import { i as workerName, n as normalizeBase, r as resolveDeployAdapter, t as freezeConfig } from "./config-freeze-ZWC_Qd4h.js";
+import { i as workerName, n as normalizeBase, r as resolveDeployAdapter, t as freezeConfig } from "./config-freeze-CyXvNqi2.js";
 export { freezeConfig, normalizeBase, resolveDeployAdapter, workerName };