@junejs/server 1.0.0-dev.19 → 1.0.0-dev.24

package/dist/manifest.js

@@ -0,0 +1,111 @@
+import { findMiddlewareFile } from "./router.js";
+import { resolveBoundary } from "./segment.js";
+import { freezeConfig } from "./config-freeze.js";
+import { scanAppRoutes } from "./route-scan.js";
+import { existsSync } from "node:fs";
+import { basename, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { routeFromModule } from "@junejs/core/route";
+//#region src/manifest.ts
+async function importLayout(file) {
+	const mod = await import(pathToFileURL(file).href);
+	return typeof mod.default === "function" ? {
+		component: mod.default,
+		boundary: mod.segmentBoundary === true
+	} : null;
+}
+async function buildManifest(appRoot) {
+	const appDir = join(appRoot, "app");
+	const frozen = await freezeConfig(appRoot);
+	const scanned = await scanAppRoutes(appRoot);
+	const layoutCache = /* @__PURE__ */ new Map();
+	const loadCached = async (f) => {
+		if (!layoutCache.has(f)) layoutCache.set(f, await importLayout(f));
+		return layoutCache.get(f) ?? null;
+	};
+	const componentsFor = async (files) => {
+		const items = [];
+		for (const f of files) {
+			const c = await loadCached(f);
+			items.push({
+				file: f,
+				entry: c?.component ?? null,
+				boundary: !!c?.boundary
+			});
+		}
+		return resolveBoundary(items);
+	};
+	const loadingCache = /* @__PURE__ */ new Map();
+	const loadingFor = async (file) => {
+		if (!file) return void 0;
+		if (!loadingCache.has(file)) {
+			const loaded = await importLayout(file);
+			loadingCache.set(file, loaded ? loaded.component : null);
+		}
+		return loadingCache.get(file) ?? void 0;
+	};
+	const routes = {};
+	const dynamicRoutes = [];
+	const resourceRoutes = [];
+	const layoutChains = {};
+	const layoutBoundaries = {};
+	const loadings = {};
+	for (const r of scanned) {
+		const mod = await import(pathToFileURL(r.file).href);
+		if (r.resource) {
+			const handler = mod.default;
+			if (typeof handler === "function") resourceRoutes.push({
+				pattern: r.path,
+				handler
+			});
+			continue;
+		}
+		const def = routeFromModule(mod);
+		if (!def) continue;
+		const { chain, boundaryIndex, key } = await componentsFor(r.layouts);
+		const loading = await loadingFor(r.loading);
+		if (r.dynamic) {
+			dynamicRoutes.push({
+				pattern: r.path,
+				def
+			});
+			layoutChains[r.path] = chain;
+		} else {
+			routes[r.path] = def;
+			layoutChains[r.path] = chain;
+		}
+		if (boundaryIndex !== null && key !== null) layoutBoundaries[r.path] = {
+			index: boundaryIndex,
+			key
+		};
+		if (loading) loadings[r.path] = loading;
+	}
+	let extra;
+	const extraFile = findMiddlewareFile(appDir);
+	if (extraFile) {
+		const mod = await import(pathToFileURL(extraFile).href);
+		if (typeof mod.default === "function") extra = mod.default;
+	}
+	let agentName;
+	const agentDir = join(appDir, frozen.agent.runtime.dir);
+	if (frozen.agent.runtime.enabled && existsSync(agentDir)) {
+		const cfgFile = join(agentDir, "agent.ts");
+		agentName = (existsSync(cfgFile) ? (await import(pathToFileURL(cfgFile).href)).default : void 0)?.name ?? basename(agentDir);
+	}
+	return {
+		routes,
+		dynamicRoutes,
+		resourceRoutes,
+		layoutChains,
+		layoutBoundaries,
+		loadings,
+		document: frozen.document,
+		agent: frozen.agent,
+		agentName,
+		i18n: frozen.i18n,
+		earlyHints: frozen.earlyHints,
+		extra
+	};
+}
+//#endregion
+export { buildManifest, importLayout };

package/dist/route-scan-DMlwoESy.d.ts

@@ -0,0 +1,13 @@
+//#region src/route-scan.d.ts
+type RouteEntry = {
+  path: string;
+  file: string;
+  dynamic: boolean;
+  resource?: boolean;
+  layouts: string[];
+  loading?: string;
+};
+declare function scanRoutes(appDir: string, dir?: string, layouts?: string[], out?: RouteEntry[], loading?: string): Promise<RouteEntry[]>;
+declare function scanAppRoutes(appRoot: string): Promise<RouteEntry[]>;
+//#endregion
+export { scanAppRoutes as n, scanRoutes as r, RouteEntry as t };

package/dist/route-scan.d.ts

@@ -0,0 +1,2 @@
+import { n as scanAppRoutes, r as scanRoutes, t as RouteEntry } from "./route-scan-DMlwoESy.js";
+export { RouteEntry, scanAppRoutes, scanRoutes };

package/dist/route-scan.js

@@ -0,0 +1,55 @@
+import { existsSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { basename, join, relative, sep } from "node:path";
+//#region src/route-scan.ts
+const PAGE_BASENAMES = /* @__PURE__ */ new Set(["page", "index"]);
+const ROUTE_EXTS = [
+	".tsx",
+	".jsx",
+	".ts",
+	".js"
+];
+const isRouteGroup = (name) => /^\(.+\)$/.test(name);
+function segmentFile(dir, base) {
+	return ROUTE_EXTS.map((e) => join(dir, `${base}${e}`)).find(existsSync);
+}
+async function scanRoutes(appDir, dir = appDir, layouts = [], out = [], loading) {
+	const ownLayout = segmentFile(dir, "layout");
+	const chain = ownLayout ? [...layouts, ownLayout] : layouts;
+	const nearestLoading = segmentFile(dir, "loading") ?? loading;
+	const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+	for (const e of entries) {
+		if (e.name.startsWith("_") || e.name.startsWith(".")) continue;
+		const full = join(dir, e.name);
+		if (e.isDirectory()) {
+			await scanRoutes(appDir, full, chain, out, nearestLoading);
+			continue;
+		}
+		const ext = e.name.match(/\.[^.]+$/)?.[0] ?? "";
+		if (!ROUTE_EXTS.includes(ext)) continue;
+		const base = basename(e.name, ext);
+		const resource = base === "route";
+		if (!PAGE_BASENAMES.has(base) && !resource) continue;
+		const relDir = relative(appDir, dir);
+		const path = "/" + (relDir === "" ? [] : relDir.split(sep).filter((s) => !isRouteGroup(s))).join("/");
+		out.push({
+			path: path === "/" ? "/" : path,
+			file: full,
+			dynamic: /\[.+\]/.test(path),
+			resource,
+			layouts: chain,
+			loading: nearestLoading
+		});
+	}
+	return out;
+}
+async function scanAppRoutes(appRoot) {
+	const appDir = join(appRoot, "app");
+	const juneRoutesDir = join(appRoot, ".june", "routes");
+	const appRoutes = await scanRoutes(appDir);
+	const frameworkRoutes = existsSync(juneRoutesDir) ? await scanRoutes(juneRoutesDir) : [];
+	const appPaths = new Set(appRoutes.map((r) => r.path));
+	return [...appRoutes, ...frameworkRoutes.filter((r) => !appPaths.has(r.path))].sort((a, b) => a.path.localeCompare(b.path));
+}
+//#endregion
+export { scanAppRoutes, scanRoutes };

package/dist/turn-events.d.ts

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

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/worker-BkFHGtxp.d.ts

@@ -0,0 +1,61 @@
+import { l as ResourceHandler, n as LayoutComponent, r as LoadingComponent, t as ExtraHandler } from "./pipeline-cCR6MGNK.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;
+  }>;
+  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): {
+  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 };

package/dist/worker.d.ts

@@ -1,61 +1,2 @@
-import { l as ResourceHandler, n as LayoutComponent, r as LoadingComponent, t as ExtraHandler } from "./pipeline-cCR6MGNK.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;
-  }>;
-  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): {
-  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
+import { a as withDenoAssets, i as withAssets, n as WorkerManifest, r as createWorker, t as WorkerExecutionContext } from "./worker-BkFHGtxp.js";
 export { WorkerExecutionContext, WorkerManifest, createWorker, withAssets, withDenoAssets };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junejs/server",
-  "version": "1.0.0-dev.19",
+  "version": "1.0.0-dev.24",
   "description": "June host adapters + dev server. Host-coupled; depends on the pure @junejs/core contract layer.",
   "type": "module",
   "license": "MIT",
@@ -138,7 +138,7 @@
     "rolldown": "^1.1.0"
   },
   "peerDependencies": {
-    "@junejs/core": ">=0.2.0-dev.36",
+    "@junejs/core": ">=0.2.0-dev.44",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
     "react-server-dom-webpack": "19.2.7",

package/src/agent-discover.ts

@@ -6,7 +6,9 @@
 //     agent.ts                  → default-exports a plain config { name, model?, surfaces? }
 //     instructions.md           → base system prompt
 //     instructions.<source>.md  → per-surface instruction variant (#149)
-//     tools/*.ts                → each default-exports a defineAction (a tool)
+//     tools/*.ts                → each default-exports a defineAction (a tool),
+//                                 OR an array of defineActions (an integration
+//                                 shipping several tools, e.g. googleDriveTools())
 //     skills/*.md               → each a procedure, loaded on demand (progressive disclosure)
 //     channels/*.ts             → each default-exports a Channel (an inbound edge — pure transport)
 //     channels/*.md             → DEPRECATED overlay location (warned; use instructions.<source>.md)
@@ -24,8 +26,7 @@ import { readdir, readFile } from "node:fs/promises";
 import { basename, extname, join } from "node:path";
 import { pathToFileURL } from "node:url";
 
-import type { AnyAction } from "@junejs/core/agent";
-import { assembleAgent, parseSkill, type AgentConfigFile, type AgentDefinition, type AgentModule, type Channel, type ChannelFactory, type Skill } from "@junejs/core/agent-config";
+import { assembleAgent, parseSkill, type AgentConfigFile, type AgentDefinition, type AgentModule, type Channel, type ChannelFactory, type Skill, type ToolEntry } from "@junejs/core/agent-config";
 import type { Connection } from "@junejs/core/connections";
 
 // `_`-prefixed files are private by convention (mirrors the app/ router) — most
@@ -72,10 +73,12 @@ export async function discoverAgentModule(dir: string): Promise<AgentModule> {
     }
   }
 
-  const tools: AnyAction[] = [];
+  // A tool file default-exports one tool OR an array of tools (an integration
+  // like googleDriveTools()); assembly flattens arrays.
+  const tools: ToolEntry[] = [];
   for (const f of await scan(join(dir, "tools"), ".ts")) {
     const mod = await import(pathToFileURL(f).href);
-    if (mod.default) tools.push(mod.default as AnyAction);
+    if (mod.default) tools.push(mod.default as ToolEntry);
   }
 
   const skills: Skill[] = [];
@@ -117,8 +120,8 @@ export async function discoverAgentModule(dir: string): Promise<AgentModule> {
 
 // Discover an agent from its directory, returning the assembled AgentDefinition
 // (tools already adapted from defineActions; read_skill added if any skills
-// exist). Mount it on a runtime with createNativeRuntime({ [agent.name]: { model,
-// tools: agent.tools } }).
+// exist). Mount it on a runtime with createNativeRuntime({ [agent.name]:
+// toAgentDef(agent, model) }).
 export async function discoverAgent(dir: string): Promise<AgentDefinition> {
   return assembleAgent(await discoverAgentModule(dir), process.env);
 }

package/src/agent-durable.ts

@@ -33,6 +33,7 @@ import {
   type TurnFailurePhase,
 } from "@junejs/core/agent-runtime";
 import type { Resources } from "@junejs/core/resources";
+import { observeTurnEvents } from "./turn-events";
 import {
   channelDispatch,
   DeliverUnsupportedError,
@@ -692,45 +693,6 @@ function sseTurnStream(session: AgentSession, turnId: string): ReadableStream<Ui
   });
 }
 
-// The IN-PROCESS sibling of sseTurnStream: one turn's TurnEvents as an AsyncIterable, for a
-// consumer living in the SAME isolate as the session (a delivered render). Subscribes eagerly
-// at call time — not at first iteration — so the sseTurnStream timing guarantee carries over
-// (call this synchronously after start(), before any event can emit); events landing before
-// the consumer catches up are buffered. Ends after the turn's terminal event (completed,
-// failed, or input.requested — a park ends this stream; a later /resume is a new one), and an
-// early consumer exit (for-await break/return) unsubscribes rather than buffering forever.
-function observeTurnEvents(session: AgentSession, turnId: string): AsyncIterable<TurnEvent> {
-  const queue: TurnEvent[] = [];
-  let terminal = false;
-  let notify: (() => void) | undefined;
-  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(): Promise<IteratorResult<TurnEvent>> {
-          for (;;) {
-            const e = queue.shift();
-            if (e) return { value: e, done: false };
-            if (terminal) { unsub(); return { value: undefined, done: true }; }
-            await new Promise<void>((resolve) => { notify = resolve; });
-            notify = undefined;
-          }
-        },
-        async return(): Promise<IteratorResult<TurnEvent>> {
-          unsub();
-          terminal = true;
-          queue.length = 0;
-          return { value: undefined, done: true };
-        },
-      };
-    },
-  };
-}
-
 // Consume an SSE turn stream to its terminal state: the final text, or throw on failure.
 // The non-streaming path (channels, a JSON chat response) uses this. Guards a non-SSE /
 // body-less upstream response (a misroute or an error) into a clear error, not a TypeError.