@junejs/server 0.1.3 → 0.2.1

package/dist/worker.d.ts

@@ -1,57 +1,2 @@
-import { l as ResourceHandler, n as LayoutComponent, r as LoadingComponent, t as ExtraHandler } from "./pipeline-CCp9idQ4.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;
-  }>;
-  generatedRoutes?: string[];
-  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;
-  services?: (env?: unknown) => unknown;
-};
-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 };
+import { a as withDenoAssets, i as withAssets, n as WorkerManifest, r as createWorker, t as WorkerExecutionContext } from "./worker-2qbQjj2c.js";
+export { WorkerExecutionContext, WorkerManifest, createWorker, withAssets, withDenoAssets };

package/dist/worker.js

@@ -1,7 +1,9 @@
-import { durableAgentSurface } from "./agent-durable.js";
+import { durableAgentSurface, durableChannelSurface } from "./agent-durable.js";
 import { compareRoutePatterns, parseSegment } from "./route-rank.js";
+import { acceptTarget } from "./negotiate.js";
 import { createPipeline } from "./pipeline.js";
 import { RESERVED_PREFIX, contentTypeFor, safeRelativePath } from "./static-files.js";
+import { blobFileStore } from "@junejs/core/agent-files";
 //#region src/worker.ts
 function compilePattern(pattern) {
 	const names = [];
@@ -28,7 +30,7 @@ function compilePattern(pattern) {
 		names
 	};
 }
-function createWorker(manifest) {
+function createWorker(manifest, opts = {}) {
 	const generated = new Set(manifest.generatedRoutes ?? []);
 	const row = (pattern) => ({
 		...compilePattern(pattern),
@@ -66,15 +68,35 @@ function createWorker(manifest) {
 		};
 	};
 	let currentEnv;
+	const requestLocals = /* @__PURE__ */ new WeakMap();
 	const provider = manifest.resources;
 	const servicesProvider = manifest.services;
 	let servicesCache;
 	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);
+		const agentName = manifest.agentName;
+		const wantChannels = manifest.agent.runtime.channels !== false && (manifest.agentChannels?.length ?? 0) > 0;
+		return async (req) => {
+			const locals = requestLocals.get(req);
+			const ns = () => (locals?.env)?.AGENT;
+			const chatRes = await durableAgentSurface(ns, {
+				agentName,
+				chatPath: manifest.agent.runtime.chat.path
+			})(req);
+			if (chatRes) return chatRes;
+			if (!wantChannels) return null;
+			return durableChannelSurface(ns, {
+				agentName,
+				channels: manifest.agentChannels,
+				env: locals?.env,
+				services: servicesProvider,
+				waitUntil: locals?.ctx?.waitUntil?.bind(locals.ctx),
+				files: provider ? blobFileStore(async () => {
+					const blob = (await provider(locals?.env)).blob;
+					if (!blob) throw new Error(`agent "${agentName}": no blob resource bound in this isolate — attached files can't be read`);
+					return blob;
+				}) : void 0
+			})(req);
+		};
 	})() : void 0;
 	const pipeline = createPipeline({
 		docConfig: manifest.document,
@@ -82,6 +104,7 @@ function createWorker(manifest) {
 		agentSurface,
 		i18n: manifest.i18n,
 		routeList: () => routeList,
+		staticBuild: opts.staticBuild,
 		earlyHints: manifest.earlyHints,
 		htmlCacheControl: manifest.htmlCacheControl,
 		notFoundComponent: manifest.notFound,
@@ -106,34 +129,51 @@ function createWorker(manifest) {
 			return null;
 		}
 	});
-	return { fetch(request, env) {
+	return { fetch(request, env, ctx) {
 		currentEnv = env;
+		requestLocals.set(request, {
+			env,
+			ctx
+		});
 		return pipeline.fetch(request);
 	} };
 }
 const estimateTokens = (s) => String(Math.ceil(s.length / 4));
+function varyAccept(headers) {
+	const vary = headers.get("vary");
+	if (!vary) headers.set("vary", "accept");
+	else if (vary.trim() !== "*" && !vary.split(",").some((v) => v.trim().toLowerCase() === "accept")) headers.set("vary", `${vary}, accept`);
+}
 function withAssets(pipeline, opts = {}) {
-	return { async fetch(request, env) {
+	return { async fetch(request, env, ctx) {
 		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
-				});
+		const target = isPagePath ? acceptTarget(request.headers.get("accept") ?? "") : null;
+		if (target && (request.method === "GET" || request.method === "HEAD")) {
+			if (assets && request.method === "GET" && (target === "md" || target === "json")) {
+				const base = url.pathname === "/" ? "/index" : url.pathname.replace(/\/+$/, "");
+				const assetUrl = new URL(url);
+				assetUrl.pathname = `${base}.${target}`;
+				const a = await assets.fetch(new Request(assetUrl.toString(), { headers: request.headers }));
+				if (a.ok) {
+					const headers = new Headers(a.headers);
+					if (opts.link) headers.set("link", opts.link);
+					varyAccept(headers);
+					if (target === "json") return new Response(a.body, {
+						status: 200,
+						headers
+					});
+					const body = await a.text();
+					headers.set("content-type", "text/markdown; charset=utf-8");
+					headers.set("x-markdown-tokens", estimateTokens(body));
+					return new Response(body, {
+						status: 200,
+						headers
+					});
+				}
 			}
+			return pipeline.fetch(request, env, ctx);
 		}
 		if (assets && (request.method === "GET" || request.method === "HEAD")) {
 			const a = await assets.fetch(request);
@@ -141,10 +181,12 @@ function withAssets(pipeline, opts = {}) {
 				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 negotiated = isPagePath && ct.includes("text/html");
+				if (addLink || immutable || negotiated) {
 					const headers = new Headers(a.headers);
 					if (addLink) headers.set("link", opts.link);
 					if (immutable) headers.set("cache-control", "public, max-age=31536000, immutable");
+					if (negotiated) varyAccept(headers);
 					return new Response(a.body, {
 						status: a.status,
 						headers
@@ -153,7 +195,7 @@ function withAssets(pipeline, opts = {}) {
 				return a;
 			}
 		}
-		return pipeline.fetch(request, env);
+		return pipeline.fetch(request, env, ctx);
 	} };
 }
 function withDenoAssets(pipeline) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junejs/server",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "June host adapters + dev server. Host-coupled; depends on the pure @junejs/core contract layer.",
   "type": "module",
   "license": "MIT",
@@ -36,6 +36,12 @@
       "types": "./dist/agent-discover.d.ts",
       "default": "./dist/agent-discover.js"
     },
+    "./agent-compile": {
+      "source": "./src/agent-compile.ts",
+      "bun": "./src/agent-compile.ts",
+      "types": "./dist/agent-compile.d.ts",
+      "default": "./dist/agent-compile.js"
+    },
     "./db": {
       "source": "./src/db.ts",
       "bun": "./src/db.ts",
@@ -54,6 +60,12 @@
       "types": "./dist/blob.d.ts",
       "default": "./dist/blob.js"
     },
+    "./assets": {
+      "source": "./src/assets.ts",
+      "bun": "./src/assets.ts",
+      "types": "./dist/assets.d.ts",
+      "default": "./dist/assets.js"
+    },
     "./resources": {
       "source": "./src/resources.ts",
       "bun": "./src/resources.ts",
@@ -117,7 +129,8 @@
   },
   "files": [
     "src",
-    "dist"
+    "dist",
+    "assets"
   ],
   "scripts": {
     "test": "bun test",
@@ -125,20 +138,22 @@
     "build": "tsdown"
   },
   "dependencies": {
-    "@junejs/core": ">=0.1.0",
-    "@junejs/db": ">=0.0.33",
+    "@junejs/db": "^0.2.1",
     "@momiji-rs/sparkdown": "^0.0.4",
+    "@resvg/resvg-wasm": "^2.6.2",
     "lightningcss": "^1.27.0",
-    "oxc-parser": "^0.137.0",
+    "oxc-parser": "^0.152.0",
     "rolldown": "^1.1.0"
   },
   "peerDependencies": {
+    "@junejs/core": "^0.2.1",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
-    "react-server-dom-webpack": "19.2.7",
+    "react-server-dom-webpack": "19.3.0",
     "pg": "^8.0.0",
     "mysql2": "^3.0.0",
-    "@libsql/client": "^0.14.0 || ^0.15.0 || ^0.16.0 || ^0.17.0"
+    "@libsql/client": "^0.14.0 || ^0.15.0 || ^0.16.0 || ^0.17.0",
+    "@anthropic-ai/sdk": ">=0.60.0"
   },
   "peerDependenciesMeta": {
     "react-server-dom-webpack": {
@@ -152,17 +167,21 @@
     },
     "@libsql/client": {
       "optional": true
+    },
+    "@anthropic-ai/sdk": {
+      "optional": true
     }
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/junebuild/june"
+    "url": "git+https://github.com/junebuild/june.git",
+    "directory": "packages/june"
   },
   "devDependencies": {
     "@libsql/client": "^0.17.3",
     "@types/pg": "^8.20.0",
     "mysql2": "^3.22.5",
     "pg": "^8.21.0",
-    "react-server-dom-webpack": "19.2.7"
+    "react-server-dom-webpack": "19.3.0"
   }
 }

package/src/adapter.ts

@@ -7,10 +7,11 @@
 // `workers()` is the zero-config default (this file, no import). Other targets
 // 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 { cp, copyFile, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
 
 import type { JuneConfig } from "@junejs/core/config";
+import { stripJsonc } from "./tsconfig-jsx";
 
 export type AdapterCapabilities = {
   runtime: "edge" | "node" | "serverless" | "native" | "static";
@@ -20,6 +21,9 @@ export type AdapterCapabilities = {
   persistentConnections: boolean;
   // Who serves prerendered static files: the platform CDN, the server, or none.
   assets: "platform" | "server" | "none";
+  // Durable Objects (the per-session agent actor). Only workers() today; the
+  // build skips the durable-agent mount (with a notice) when absent.
+  durableObjects?: boolean;
 };
 
 // What the adapter contributes to the generated worker entry: extra imports and
@@ -37,6 +41,11 @@ export type ResourcePlan = {
   // A declared `db` → a D1 binding named `binding`. The runtime provider
   // (bindWorkerResources) reads env[binding]; keep in sync (default "DB").
   db?: { binding: string; databaseName: string };
+  // A durable agent (an app/agent directory on a DO-capable target) → the DO
+  // namespace binding createWorker reads (env.AGENT) and the class the
+  // generated entry exports. workers() emits durable_objects + the SQLite-class
+  // migration from it.
+  agent?: { binding: string; className: string };
 };
 
 export type AdapterEmitContext = {
@@ -53,6 +62,9 @@ export type AdapterEmitContext = {
   // 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[];
+  // Extensions (lowercase, no dot: "wasm", "otf") of the binary files the worker bundle
+  // imports and leaves external for the platform's bundler to load.
+  binaryImports?: string[];
 };
 
 export interface JuneAdapter {
@@ -77,13 +89,97 @@ export interface JuneAdapter {
   emit(ctx: AdapterEmitContext): Promise<void>;
 }
 
+// Whether an app-owned wrangler config actually BINDS the generated DO class
+// under the binding name createWorker reads (env.AGENT) — not merely mentions
+// the class (a migrations entry does that too, and a binding under another
+// name never reaches the chat route). JSONC is parsed for the real
+// durable_objects.bindings entry; TOML is scanned per
+// [[durable_objects.bindings]] table with comments stripped, so a
+// commented-out binding never counts. The TOML scan covers wrangler's
+// canonical table form; an exotic inline-table config may draw a spurious
+// (advisory) warning, never a suppressed one. Pure — unit-tested directly.
+export function hasDurableBinding(text: string, file: string, binding: string, className: string): boolean {
+  if (file.endsWith(".toml")) {
+    const lines = stripTomlComments(text).split("\n");
+    let inBindings = false;
+    let name: string | undefined;
+    let cls: string | undefined;
+    const matches = () => name === binding && cls === className;
+    for (const line of lines) {
+      const t = line.trim();
+      if (t.startsWith("[")) {
+        if (inBindings && matches()) return true; // the table that just ended bound it
+        inBindings = /^\[\[\s*durable_objects\.bindings\s*\]\]$/.test(t);
+        name = cls = undefined;
+        continue;
+      }
+      if (!inBindings) continue;
+      const kv = t.match(/^(name|class_name)\s*=\s*"([^"]*)"/);
+      if (kv) kv[1] === "name" ? (name = kv[2]) : (cls = kv[2]);
+    }
+    return inBindings && matches();
+  }
+  try {
+    const parsed = JSON.parse(stripJsonc(text)) as { durable_objects?: { bindings?: { name?: string; class_name?: string }[] } };
+    return (parsed.durable_objects?.bindings ?? []).some((b) => b.name === binding && b.class_name === className);
+  } catch {
+    return text.includes(className); // unparsable — loose fallback, never crash the build
+  }
+}
+
+// Does an app-owned wrangler config give `.ext` files a loader? Any rule with a glob ending in
+// the extension (`**/*.otf`, `**/*.{otf,ttf}`) counts, whatever its type. The warning this
+// feeds is advisory, so a glob it can't read may draw a spurious warning, never suppress one;
+// comments are stripped first, so a commented-out rule doesn't count. undefined: the JSONC
+// couldn't be parsed, so the answer is unknown. Pure — unit-tested.
+export function hasLoaderRule(text: string, file: string, ext: string): boolean | undefined {
+  const names = (glob: string) => new RegExp(`\\.(${ext}|\\{[^}]*\\b${ext}\\b[^}]*\\})$`, "i").test(glob);
+  if (file.endsWith(".toml")) {
+    // The globs = [...] arrays of [[rules]] tables, with '#' comments removed.
+    const body = stripTomlComments(text);
+    let inRules = false;
+    for (const line of body.split("\n")) {
+      const t = line.trim();
+      if (t.startsWith("[")) {
+        inRules = /^\[\[\s*rules\s*\]\]$/.test(t);
+        continue;
+      }
+      const globs = inRules ? t.match(/^globs\s*=\s*\[(.*)\]/) : null;
+      if (globs && [...globs[1]!.matchAll(/"([^"]*)"/g)].some((m) => names(m[1]!))) return true;
+    }
+    return false;
+  }
+  try {
+    const parsed = JSON.parse(stripJsonc(text)) as { rules?: { globs?: string[] }[] };
+    return (parsed.rules ?? []).some((r) => (r.globs ?? []).some(names));
+  } catch {
+    return undefined; // unparsable — the caller warns that it couldn't check, never crashes the build
+  }
+}
+
+// '#' to end of line, unless inside a double-quoted string.
+function stripTomlComments(text: string): string {
+  return text
+    .split("\n")
+    .map((line) => {
+      let inString = false;
+      for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (ch === '"' && line[i - 1] !== "\\") inString = !inString;
+        else if (ch === "#" && !inString) return line.slice(0, i);
+      }
+      return line;
+    })
+    .join("\n");
+}
+
 // The built-in default. Reproduces exactly what build.ts emitted inline:
 // withAssets(pipeline) as the entry, and a wrangler.jsonc with the assets
 // binding (run_worker_first) + optional custom domain.
 export function workers(opts?: { name?: string; domain?: string }): JuneAdapter {
   return {
     name: "workers",
-    capabilities: { runtime: "edge", persistentConnections: true, assets: "platform" },
+    capabilities: { runtime: "edge", persistentConnections: true, assets: "platform", durableObjects: true },
     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
@@ -98,9 +194,46 @@ export function workers(opts?: { name?: string; domain?: string }): JuneAdapter
       };
     },
 
-    async emit({ appRoot, outDir, hasAssets, config, plan, defaultName }) {
+    async emit({ appRoot, outDir, hasAssets, config, plan, defaultName, binaryImports }) {
+      // Wrangler loads .wasm by default (CompiledWasm) and has no loader for the other
+      // binaries build.ts leaves external, so a font package's .otf failed the deploy with
+      // "No loader is configured" (#379). Each one the bundle imports gets a Data rule: the
+      // module is the file's bytes, which is what a font or image package's workerd entry
+      // expects.
+      const dataExts = (binaryImports ?? []).filter((e) => e !== "wasm");
       // An app that manages its own wrangler config wins — don't overwrite it.
-      if (existsSync(join(appRoot, "wrangler.toml")) || existsSync(join(appRoot, "wrangler.jsonc"))) {
+      // But a durable agent NEEDS its DO binding: warn when the app-owned config
+      // doesn't BIND the generated class under the name createWorker reads
+      // (hasDurableBinding above — a migrations-only mention, a binding under
+      // another name, or a commented-out table must all still warn), instead of
+      // silently shipping a worker whose chat surface 404s.
+      const own = ["wrangler.toml", "wrangler.jsonc"].map((f) => join(appRoot, f)).find(existsSync);
+      if (own) {
+        if (plan.agent) {
+          const cls = plan.agent.className;
+          const bound = hasDurableBinding(await readFile(own, "utf8"), own, plan.agent.binding, cls);
+          if (!bound) {
+            const snippet = own.endsWith(".toml")
+              ? `[[durable_objects.bindings]]\nname = "${plan.agent.binding}"\nclass_name = "${cls}"\n\n[[migrations]]\ntag = "v1"\nnew_sqlite_classes = ["${cls}"]`
+              : `"durable_objects": { "bindings": [{ "name": "${plan.agent.binding}", "class_name": "${cls}" }] },\n"migrations": [{ "tag": "v1", "new_sqlite_classes": ["${cls}"] }]`;
+            console.warn(`[june build] durable agent built, but ${basename(own)} doesn't bind it — add:\n${snippet}`);
+          }
+        }
+        const text = dataExts.length ? await readFile(own, "utf8") : "";
+        const found = dataExts.map((ext) => [ext, hasLoaderRule(text, own, ext)] as const);
+        const unloaded = found.filter(([, has]) => has === false).map(([ext]) => ext);
+        const unknown = found.filter(([, has]) => has === undefined).map(([ext]) => ext);
+        if (unknown.length) {
+          const globs = unknown.map((e) => `"**/*.${e}"`).join(", ");
+          console.warn(`[june build] the worker imports ${unknown.map((e) => `.${e}`).join(", ")} files, and ${basename(own)} couldn't be parsed to check for a rule that loads them — make sure it has one, or the deploy fails with "No loader is configured":\n"rules": [{ "type": "Data", "globs": [${globs}], "fallthrough": true }]`);
+        }
+        if (unloaded.length) {
+          const globs = unloaded.map((e) => `"**/*.${e}"`).join(", ");
+          const snippet = own.endsWith(".toml")
+            ? `[[rules]]\ntype = "Data"\nglobs = [${globs}]\nfallthrough = true`
+            : `"rules": [{ "type": "Data", "globs": [${globs}], "fallthrough": true }]`;
+          console.warn(`[june build] the worker imports ${unloaded.map((e) => `.${e}`).join(", ")} files, but ${basename(own)} has no rule to load them (the deploy will fail with "No loader is configured") — add:\n${snippet}`);
+        }
         return;
       }
       const deployCfg = config.deploy;
@@ -133,6 +266,18 @@ export function workers(opts?: { name?: string; domain?: string }): JuneAdapter
                   ],
                 }
               : {}),
+            // The durable agent: one SQLite-backed DO class = the per-session
+            // AgentSession actor (its ctx.storage.sql is the durable loop's
+            // synchronous store). The binding name is what createWorker reads.
+            ...(plan.agent
+              ? {
+                  durable_objects: { bindings: [{ name: plan.agent.binding, class_name: plan.agent.className }] },
+                  migrations: [{ tag: "v1", new_sqlite_classes: [plan.agent.className] }],
+                }
+              : {}),
+            // Binary files the bundle imports that wrangler has no default loader for.
+            // fallthrough: without it wrangler drops its own default Data rule (**/*.bin).
+            ...(dataExts.length ? { rules: [{ type: "Data", globs: dataExts.map((e) => `**/*.${e}`), fallthrough: true }] } : {}),
             // config deploy.domain → a Workers custom domain; without it the
             // regenerated file would silently drop a hand-attached domain.
             ...(opts?.domain ?? deployCfg?.domain