@junejs/server 0.1.0-dev.4 → 0.1.0-dev.7

package/dist/tsconfig-jsx.js

@@ -0,0 +1,35 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+//#region src/tsconfig-jsx.ts
+const stripJsonc = (s) => s.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|\s)\/\/.*$/gm, "$1").replace(/,\s*([}\]])/g, "$1");
+/** 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. */
+async function appJsxImportSource(appRoot) {
+	const read = async (path) => {
+		try {
+			return JSON.parse(stripJsonc(await readFile(path, "utf8")));
+		} catch {
+			return;
+		}
+	};
+	const tc = await read(join(appRoot, "tsconfig.json"));
+	if (!tc) return void 0;
+	if (tc.compilerOptions?.jsxImportSource) return tc.compilerOptions.jsxImportSource;
+	if (tc.extends) {
+		const btc = await read(tc.extends.startsWith(".") ? join(appRoot, tc.extends) : join(appRoot, "node_modules", tc.extends));
+		if (btc?.compilerOptions?.jsxImportSource) return btc.compilerOptions.jsxImportSource;
+	}
+}
+/** 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. */
+async function jsxTransform(appRoot) {
+	return {
+		runtime: "automatic",
+		...await appJsxImportSource(appRoot) === "@junejs/core" ? {} : { importSource: "@junejs/core" }
+	};
+}
+//#endregion
+export { appJsxImportSource, jsxTransform };

package/dist/turso-driver-C1wEigMZ.d.ts

@@ -0,0 +1,22 @@
+import { DbFactory, JuneDb } from "@junejs/core/resources";
+//#region src/turso-driver.d.ts
+interface LibsqlResultSet {
+  rows: unknown[];
+  rowsAffected: number;
+  lastInsertRowid?: bigint | number;
+}
+interface LibsqlClientLike {
+  execute(stmt: {
+    sql: string;
+    args?: unknown[];
+  } | string): Promise<LibsqlResultSet>;
+  executeMultiple?(sql: string): Promise<void>;
+  close(): void | Promise<void>;
+}
+declare function libsqlJuneDb(client: LibsqlClientLike): JuneDb;
+declare function turso(opts?: {
+  url?: string;
+  authToken?: string;
+}): DbFactory;
+//#endregion
+export { turso as i, LibsqlResultSet as n, libsqlJuneDb as r, LibsqlClientLike as t };

package/dist/turso-driver.d.ts

@@ -0,0 +1,2 @@
+import { i as turso, n as LibsqlResultSet, r as libsqlJuneDb, t as LibsqlClientLike } from "./turso-driver-C1wEigMZ.js";
+export { LibsqlClientLike, LibsqlResultSet, libsqlJuneDb, turso };

package/dist/turso-driver.js

@@ -0,0 +1,68 @@
+//#region src/turso-driver.ts
+function libsqlJuneDb(client) {
+	const self = {
+		dialect: "sqlite",
+		async query(sql, params = []) {
+			return (await client.execute({
+				sql,
+				args: params
+			})).rows;
+		},
+		async get(sql, params = []) {
+			return (await client.execute({
+				sql,
+				args: params
+			})).rows[0] ?? void 0;
+		},
+		async run(sql, params = []) {
+			const r = await client.execute({
+				sql,
+				args: params
+			});
+			return {
+				changes: r.rowsAffected ?? 0,
+				lastInsertRowid: Number(r.lastInsertRowid ?? 0)
+			};
+		},
+		async exec(sql) {
+			if (client.executeMultiple) await client.executeMultiple(sql);
+			else await client.execute(sql);
+		},
+		async transaction(fn) {
+			await client.execute("BEGIN");
+			try {
+				const out = await fn(self);
+				await client.execute("COMMIT");
+				return out;
+			} catch (e) {
+				await client.execute("ROLLBACK");
+				throw e;
+			}
+		},
+		async close() {
+			await client.close();
+		}
+	};
+	return self;
+}
+function turso(opts = {}) {
+	return {
+		kind: "turso",
+		open: async () => {
+			const url = opts.url ?? readEnv("TURSO_DATABASE_URL");
+			const authToken = opts.authToken ?? readEnv("TURSO_AUTH_TOKEN");
+			if (!url) throw new Error("turso(): no database url — pass { url } or set TURSO_DATABASE_URL in the environment.");
+			const mod = await import("@libsql/client/web");
+			const createClient = (mod.default ?? mod).createClient;
+			return libsqlJuneDb(createClient({
+				url,
+				authToken
+			}));
+		}
+	};
+}
+function readEnv(name) {
+	return typeof process !== "undefined" && process.env ? process.env[name] : void 0;
+}
+//#endregion
+export { libsqlJuneDb, turso };

package/dist/worker.d.ts

@@ -0,0 +1,55 @@
+import { l as ResourceHandler, n as LayoutComponent, r as LoadingComponent, t as ExtraHandler } from "./pipeline-B2V6tKfO.js";
+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 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;
+  i18n?: I18nConfig;
+  earlyHints?: string[];
+  htmlCacheControl?: string;
+  notFound?: React.ComponentType<{
+    pathname: string;
+  }>;
+  extra?: ExtraHandler;
+  resources?: (env?: unknown) => Promise<Resources> | Resources;
+};
+declare function createWorker(manifest: WorkerManifest): {
+  fetch(request: Request, env?: unknown): Promise<Response>;
+};
+type AssetEnv = {
+  ASSETS?: {
+    fetch(request: Request): Promise<Response>;
+  };
+};
+type FetchPipeline = {
+  fetch(request: Request, env?: unknown): Promise<Response>;
+};
+declare function withAssets(pipeline: FetchPipeline, opts?: {
+  link?: string | null;
+}): {
+  fetch(request: Request, env?: AssetEnv): Promise<Response>;
+};
+declare function withDenoAssets(pipeline: FetchPipeline): (request: Request) => Promise<Response>;
+//#endregion
+export { WorkerManifest, createWorker, withAssets, withDenoAssets };

package/dist/worker.js

@@ -0,0 +1,211 @@
+import { durableAgentSurface } from "./agent-durable.js";
+import { createPipeline } from "./pipeline.js";
+import { RESERVED_PREFIX, contentTypeFor, safeRelativePath } from "./static-files.js";
+//#region src/worker.ts
+function compilePattern(pattern) {
+	const names = [];
+	let source = "";
+	let allOptional = true;
+	for (const seg of pattern.split("/").filter(Boolean)) {
+		const oca = seg.match(/^\[\[\.\.\.(\w+)\]\]$/);
+		if (oca) {
+			names.push(oca[1]);
+			source += "(?:/(.+))?";
+			continue;
+		}
+		const ca = seg.match(/^\[\.\.\.(\w+)\]$/);
+		if (ca) {
+			names.push(ca[1]);
+			source += "/(.+)";
+			allOptional = false;
+			continue;
+		}
+		const op = seg.match(/^\[\[(\w+)\]\]$/);
+		if (op) {
+			names.push(op[1]);
+			source += "(?:/([^/]+))?";
+			continue;
+		}
+		const p = seg.match(/^\[(\w+)\]$/);
+		if (p) {
+			names.push(p[1]);
+			source += "/([^/]+)";
+			allOptional = false;
+			continue;
+		}
+		source += "/" + seg.replace(/[.*+?^${}()|\\]/g, "\\$&");
+		allOptional = false;
+	}
+	if (source === "") return {
+		regex: /^\/$/,
+		names
+	};
+	return {
+		regex: new RegExp(allOptional ? `^(?:${source}|/)$` : `^${source}$`),
+		names
+	};
+}
+function createWorker(manifest) {
+	const dynamic = (manifest.dynamicRoutes ?? []).map((d) => ({
+		...compilePattern(d.pattern),
+		def: d.def,
+		pattern: d.pattern
+	}));
+	const resources = (manifest.resourceRoutes ?? []).map((r) => ({
+		...compilePattern(r.pattern),
+		handler: r.handler,
+		pattern: r.pattern
+	}));
+	const routeList = [...Object.keys(manifest.routes), ...(manifest.dynamicRoutes ?? []).map((d) => d.pattern)].sort();
+	const chainFor = (key) => manifest.layoutChains?.[key] ?? [];
+	const loadingFor = (key) => manifest.loadings?.[key];
+	const boundaryFor = (key) => manifest.layoutBoundaries?.[key] ?? null;
+	let currentEnv;
+	const provider = manifest.resources;
+	const agentSurface = manifest.agent.runtime.enabled && manifest.agentName ? (() => {
+		const route = durableAgentSurface(() => currentEnv?.AGENT, {
+			agentName: manifest.agentName,
+			chatPath: manifest.agent.runtime.chat.path
+		});
+		return (req) => route(req);
+	})() : void 0;
+	const pipeline = createPipeline({
+		docConfig: manifest.document,
+		agent: manifest.agent,
+		agentSurface,
+		i18n: manifest.i18n,
+		routeList: () => routeList,
+		earlyHints: manifest.earlyHints,
+		htmlCacheControl: manifest.htmlCacheControl,
+		notFoundComponent: manifest.notFound,
+		extra: manifest.extra,
+		resources: provider ? () => provider(currentEnv) : void 0,
+		resolve: async (pathname) => {
+			const staticDef = manifest.routes[pathname];
+			if (staticDef) {
+				const b = boundaryFor(pathname);
+				return {
+					def: staticDef,
+					params: {},
+					chain: chainFor(pathname),
+					boundaryIndex: b?.index ?? null,
+					boundaryKey: b?.key ?? null,
+					loading: loadingFor(pathname)
+				};
+			}
+			for (const d of dynamic) {
+				const m = pathname.match(d.regex);
+				if (m) {
+					const params = Object.fromEntries(d.names.flatMap((n, i) => {
+						const v = m[i + 1];
+						return v === void 0 ? [] : [[n, decodeURIComponent(v)]];
+					}));
+					const b = boundaryFor(d.pattern);
+					return {
+						def: d.def,
+						params,
+						chain: chainFor(d.pattern),
+						boundaryIndex: b?.index ?? null,
+						boundaryKey: b?.key ?? null,
+						loading: loadingFor(d.pattern)
+					};
+				}
+			}
+			for (const r of resources) {
+				const m = pathname.match(r.regex);
+				if (m) {
+					const params = Object.fromEntries(r.names.flatMap((n, i) => {
+						const v = m[i + 1];
+						return v === void 0 ? [] : [[n, decodeURIComponent(v)]];
+					}));
+					return {
+						handler: r.handler,
+						params
+					};
+				}
+			}
+			return null;
+		}
+	});
+	return { fetch(request, env) {
+		currentEnv = env;
+		return pipeline.fetch(request);
+	} };
+}
+const estimateTokens = (s) => String(Math.ceil(s.length / 4));
+function withAssets(pipeline, opts = {}) {
+	return { async fetch(request, env) {
+		const assets = env?.ASSETS;
+		const url = new URL(request.url);
+		const isPagePath = !/\.[a-z0-9]+$/i.test(url.pathname);
+		const accept = request.headers.get("accept") ?? "";
+		if (assets && request.method === "GET" && isPagePath && /text\/markdown/.test(accept)) {
+			const base = url.pathname === "/" ? "/index" : url.pathname.replace(/\/+$/, "");
+			const mdUrl = new URL(url);
+			mdUrl.pathname = `${base}.md`;
+			const a = await assets.fetch(new Request(mdUrl.toString(), { headers: request.headers }));
+			if (a.ok) {
+				const body = await a.text();
+				const headers = new Headers(a.headers);
+				headers.set("content-type", "text/markdown; charset=utf-8");
+				headers.set("x-markdown-tokens", estimateTokens(body));
+				if (opts.link) headers.set("link", opts.link);
+				return new Response(body, {
+					status: 200,
+					headers
+				});
+			}
+		}
+		if (assets) {
+			const a = await assets.fetch(request);
+			if (a.status !== 404) {
+				const ct = a.headers.get("content-type") ?? "";
+				const addLink = !!opts.link && ct.includes("text/html") && !a.headers.has("link");
+				const immutable = /\.[a-f0-9]{8,}\.(css|js)$/.test(url.pathname);
+				if (addLink || immutable) {
+					const headers = new Headers(a.headers);
+					if (addLink) headers.set("link", opts.link);
+					if (immutable) headers.set("cache-control", "public, max-age=31536000, immutable");
+					return new Response(a.body, {
+						status: a.status,
+						headers
+					});
+				}
+				return a;
+			}
+		}
+		return pipeline.fetch(request, env);
+	} };
+}
+function withDenoAssets(pipeline) {
+	return async (request) => {
+		const method = request.method;
+		if (method === "GET" || method === "HEAD") {
+			const url = new URL(request.url);
+			{
+				const rel = safeRelativePath(url.pathname);
+				if (rel !== null) try {
+					const assetUrl = new URL(`./assets/${rel.split("/").map(encodeURIComponent).join("/")}`, import.meta.url);
+					const immutable = rel.startsWith(`${RESERVED_PREFIX}/`);
+					const headers = {
+						"content-type": contentTypeFor(rel),
+						"cache-control": immutable ? "public, max-age=31536000, immutable" : "public, max-age=0, must-revalidate"
+					};
+					if (method === "HEAD") {
+						const info = await Deno.stat(assetUrl);
+						if (!info.isFile) throw new Error("not a file");
+						return new Response(null, { headers: {
+							...headers,
+							"content-length": String(info.size)
+						} });
+					}
+					const file = await Deno.readFile(assetUrl);
+					return new Response(file, { headers });
+				} catch {}
+			}
+		}
+		return pipeline.fetch(request);
+	};
+}
+//#endregion
+export { createWorker, withAssets, withDenoAssets };

package/package.json

@@ -1,40 +1,132 @@
 {
   "name": "@junejs/server",
-  "version": "0.1.0-dev.4",
+  "version": "0.1.0-dev.7",
   "description": "June host adapters + dev server. Host-coupled; depends on the pure @junejs/core contract layer.",
   "type": "module",
   "license": "MIT",
   "homepage": "https://june.build",
   "exports": {
-    ".": "./src/index.ts",
-    "./host": "./src/host.ts",
-    "./agent-native": "./src/agent-native.ts",
-    "./agent-durable": "./src/agent-durable.ts",
-    "./agent-discover": "./src/agent-discover.ts",
-    "./db": "./src/db.ts",
-    "./kv": "./src/kv.ts",
-    "./blob": "./src/blob.ts",
-    "./resources": "./src/resources.ts",
-    "./config": "./src/config-loader.ts",
-    "./content": "./src/content.ts",
-    "./router": "./src/router.ts",
-    "./instrumentation": "./src/instrumentation.ts",
-    "./pipeline": "./src/pipeline.ts",
-    "./worker": "./src/worker.ts",
-    "./build": "./src/build.ts",
-    "./deploy": "./src/deploy.ts",
-    "./dev": "./src/dev.ts"
+    ".": {
+      "source": "./src/index.ts",
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./host": {
+      "source": "./src/host.ts",
+      "bun": "./src/host.ts",
+      "types": "./dist/host.d.ts",
+      "default": "./dist/host.js"
+    },
+    "./agent-native": {
+      "source": "./src/agent-native.ts",
+      "bun": "./src/agent-native.ts",
+      "types": "./dist/agent-native.d.ts",
+      "default": "./dist/agent-native.js"
+    },
+    "./agent-durable": {
+      "source": "./src/agent-durable.ts",
+      "bun": "./src/agent-durable.ts",
+      "types": "./dist/agent-durable.d.ts",
+      "default": "./dist/agent-durable.js"
+    },
+    "./agent-discover": {
+      "source": "./src/agent-discover.ts",
+      "bun": "./src/agent-discover.ts",
+      "types": "./dist/agent-discover.d.ts",
+      "default": "./dist/agent-discover.js"
+    },
+    "./db": {
+      "source": "./src/db.ts",
+      "bun": "./src/db.ts",
+      "types": "./dist/db.d.ts",
+      "default": "./dist/db.js"
+    },
+    "./kv": {
+      "source": "./src/kv.ts",
+      "bun": "./src/kv.ts",
+      "types": "./dist/kv.d.ts",
+      "default": "./dist/kv.js"
+    },
+    "./blob": {
+      "source": "./src/blob.ts",
+      "bun": "./src/blob.ts",
+      "types": "./dist/blob.d.ts",
+      "default": "./dist/blob.js"
+    },
+    "./resources": {
+      "source": "./src/resources.ts",
+      "bun": "./src/resources.ts",
+      "types": "./dist/resources.d.ts",
+      "default": "./dist/resources.js"
+    },
+    "./config": {
+      "source": "./src/config-loader.ts",
+      "bun": "./src/config-loader.ts",
+      "types": "./dist/config-loader.d.ts",
+      "default": "./dist/config-loader.js"
+    },
+    "./content": {
+      "source": "./src/content.ts",
+      "bun": "./src/content.ts",
+      "types": "./dist/content.d.ts",
+      "default": "./dist/content.js"
+    },
+    "./router": {
+      "source": "./src/router.ts",
+      "bun": "./src/router.ts",
+      "types": "./dist/router.d.ts",
+      "default": "./dist/router.js"
+    },
+    "./instrumentation": {
+      "source": "./src/instrumentation.ts",
+      "bun": "./src/instrumentation.ts",
+      "types": "./dist/instrumentation.d.ts",
+      "default": "./dist/instrumentation.js"
+    },
+    "./pipeline": {
+      "source": "./src/pipeline.ts",
+      "bun": "./src/pipeline.ts",
+      "types": "./dist/pipeline.d.ts",
+      "default": "./dist/pipeline.js"
+    },
+    "./worker": {
+      "source": "./src/worker.ts",
+      "bun": "./src/worker.ts",
+      "types": "./dist/worker.d.ts",
+      "default": "./dist/worker.js"
+    },
+    "./build": {
+      "source": "./src/build.ts",
+      "bun": "./src/build.ts",
+      "types": "./dist/build.d.ts",
+      "default": "./dist/build.js"
+    },
+    "./deploy": {
+      "source": "./src/deploy.ts",
+      "bun": "./src/deploy.ts",
+      "types": "./dist/deploy.d.ts",
+      "default": "./dist/deploy.js"
+    },
+    "./dev": {
+      "source": "./src/dev.ts",
+      "bun": "./src/dev.ts",
+      "types": "./dist/dev.d.ts",
+      "default": "./dist/dev.js"
+    }
   },
   "files": [
-    "src"
+    "src",
+    "dist"
   ],
   "scripts": {
     "test": "bun test",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "build": "tsdown"
   },
   "dependencies": {
-    "@junejs/core": ">=0.1.0-dev.3",
-    "@junejs/db": ">=0.0.33-dev.0",
+    "@junejs/core": ">=0.1.0-dev.5",
+    "@junejs/db": ">=0.0.33-dev.2",
     "@momiji-rs/sparkdown": "^0.0.4",
     "lightningcss": "^1.27.0",
     "oxc-parser": "^0.137.0",

package/src/adapter.ts

@@ -8,7 +8,7 @@
 // are explicit `deploy: { adapter: vercel() }` from their own package.
 import { existsSync } from "node:fs";
 import { cp, copyFile, mkdir, readdir, rm, writeFile } from "node:fs/promises";
-import { basename, join } from "node:path";
+import { basename, dirname, join } from "node:path";
 
 import type { JuneConfig } from "@junejs/core/config";
 
@@ -49,6 +49,10 @@ export type AdapterEmitContext = {
   plan: ResourcePlan;
   // package.json name (or sanitized dir name) — the fallback worker/app name.
   defaultName: string;
+  // Verbatim public/ files (forward-slash paths relative to assets/), already
+  // copied into outDir/assets. Adapters that build a separate static tier (vercel)
+  // place these there; whole-assets targets (workers/static/deno) ignore it.
+  publicFiles?: string[];
 };
 
 export interface JuneAdapter {
@@ -80,7 +84,7 @@ export function workers(opts?: { name?: string; domain?: string }): JuneAdapter
   return {
     name: "workers",
     capabilities: { runtime: "edge", persistentConnections: true, assets: "platform" },
-    conditions: ["workerd", "edge", "import", "default"],
+    conditions: ["source", "workerd", "edge", "import", "default"],
     // workers-og is a workerd-native WASM package: rolldown cannot bundle its
     // .wasm assets (wrangler's own bundler applies the CompiledWasm rule). Mark
     // it external here so user apps never need `build: { external: ["workers-og"] }`.
@@ -183,7 +187,7 @@ export function vercel(opts?: { runtime?: "node" | "edge"; regions?: string[] })
     // listed BEFORE "edge-light", so requesting "worker" pulls the wrong renderer.
     // "edge-light" → server.edge.js, which uses Web Streams (renderToReadableStream)
     // and runs on workerd AND Node alike. Mirrors workers()'s shape.
-    conditions: ["edge-light", "edge", "import", "default"],
+    conditions: ["source", "edge-light", "edge", "import", "default"],
 
     validate({ config }) {
       // turso() is libsql over HTTPS — it runs on Vercel (the build bundles the web
@@ -214,7 +218,7 @@ export function vercel(opts?: { runtime?: "node" | "edge"; regions?: string[] })
       };
     },
 
-    async emit({ appRoot, outDir, hasAssets }) {
+    async emit({ appRoot, outDir, hasAssets, publicFiles }) {
       const out = join(appRoot, ".vercel", "output");
       const fnDir = join(out, "functions", `${VERCEL_FUNCTION}.func`);
       await rm(out, { recursive: true, force: true }); // clean — no stale outputs
@@ -249,11 +253,20 @@ export function vercel(opts?: { runtime?: "node" | "edge"; regions?: string[] })
         await writeFile(join(fnDir, "package.json"), JSON.stringify({ type: "module" }, null, 2) + "\n");
       }
 
-      // static: only the hashed framework assets under /_june/ (exact-path URLs)
+      // static: the hashed framework assets under /_june/ (exact-path URLs)...
       if (hasAssets) {
         const src = join(outDir, "assets", "_june");
         if (existsSync(src)) await cp(src, join(out, "static", "_june"), { recursive: true });
       }
+      // ...plus verbatim public/ files, served by the `filesystem` route handle
+      // below. Only these — prerendered page HTML stays on the SSR function.
+      for (const rel of publicFiles ?? []) {
+        const from = join(outDir, "assets", rel);
+        if (!existsSync(from)) continue;
+        const to = join(out, "static", rel);
+        await mkdir(dirname(to), { recursive: true });
+        await copyFile(from, to);
+      }
 
       await writeFile(
         join(out, "config.json"),
@@ -293,7 +306,7 @@ export function deno(opts?: { org?: string; app?: string }): JuneAdapter {
     capabilities: { runtime: "edge", persistentConnections: true, assets: "server" },
     // "deno" first (a dep may ship a Deno-specific build); else edge-light →
     // server.edge.js (Web Streams + fetch, which Deno has).
-    conditions: ["deno", "edge-light", "edge", "import", "default"],
+    conditions: ["source", "deno", "edge-light", "edge", "import", "default"],
 
     validate({ config }) {
       const kind = config.resources?.db?.kind;
@@ -365,7 +378,7 @@ export function staticSite(): JuneAdapter {
     capabilities: { runtime: "static", persistentConnections: false, assets: "none" },
     // edge-light → react-dom resolves to server.edge.js (Web Streams), which the
     // build host (Bun/Node) runs during prerender — the same choice as vercel()/deno().
-    conditions: ["edge-light", "edge", "import", "default"],
+    conditions: ["source", "edge-light", "edge", "import", "default"],
     // Defensive: if an OG/image route ever slips into a static build, keep the WASM
     // renderer external so the bundle still builds (Kura drops the OG route on static).
     buildExternal: ["workers-og"],

package/src/agent-discover.ts

@@ -21,7 +21,7 @@ import { basename, extname, join } from "node:path";
 import { pathToFileURL } from "node:url";
 
 import type { AnyAction } from "@junejs/core/agent";
-import { defineAgent, type AgentConfigFile, type AgentDefinition, type Channel, type Skill } from "@junejs/core/agent-config";
+import { defineAgent, resolveChannel, type AgentConfigFile, type AgentDefinition, type Channel, type ChannelFactory, type Skill } from "@junejs/core/agent-config";
 import { connectAll, type Connection } from "@junejs/core/connections";
 
 async function scan(dir: string, ext: string): Promise<string[]> {
@@ -79,10 +79,13 @@ export async function discoverAgent(dir: string): Promise<AgentDefinition> {
     skills.push(parseSkill(basename(f, ".md"), await readFile(f, "utf8")));
   }
 
+  // A channel module default-exports a Channel OR a `(env) => Channel` factory (the
+  // form workerd needs — secrets live in env, not at module scope). On native, env is
+  // process.env (present at load), so resolve here; the plain form stays supported.
   const channels: Channel[] = [];
   for (const f of await scan(join(dir, "channels"), ".ts")) {
     const mod = await import(pathToFileURL(f).href);
-    if (mod.default) channels.push(mod.default as Channel);
+    if (mod.default) channels.push(resolveChannel(mod.default as Channel | ChannelFactory, process.env));
   }
 
   // connections/*.ts — outbound: wire external MCP/OpenAPI servers, turning their