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

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,209 @@
+import { durableAgentSurface } from "./agent-durable.js";
+import { createPipeline } from "./pipeline.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);
+	} };
+}
+const ASSET_CONTENT_TYPES = {
+	css: "text/css; charset=utf-8",
+	js: "text/javascript; charset=utf-8",
+	json: "application/json; charset=utf-8",
+	map: "application/json; charset=utf-8",
+	svg: "image/svg+xml",
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	webp: "image/webp",
+	avif: "image/avif",
+	ico: "image/x-icon",
+	woff2: "font/woff2",
+	woff: "font/woff"
+};
+function withDenoAssets(pipeline) {
+	return async (request) => {
+		const url = new URL(request.url);
+		if (request.method === "GET" && url.pathname.startsWith("/_june/")) try {
+			const file = await Deno.readFile(new URL(`./assets${url.pathname}`, import.meta.url));
+			const ext = url.pathname.split(".").pop()?.toLowerCase() ?? "";
+			return new Response(file, { headers: {
+				"content-type": ASSET_CONTENT_TYPES[ext] ?? "application/octet-stream",
+				"cache-control": "public, max-age=31536000, immutable"
+			} });
+		} 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.5",
   "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.4",
+    "@junejs/db": ">=0.0.33-dev.1",
     "@momiji-rs/sparkdown": "^0.0.4",
     "lightningcss": "^1.27.0",
     "oxc-parser": "^0.137.0",

package/src/adapter.ts

@@ -80,7 +80,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 +183,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
@@ -293,7 +293,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 +365,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/client-bundle.ts

@@ -68,7 +68,9 @@ async function bundleClient(entryFile: string, cwd: string, mode: BundleMode, ma
       // CONFIGURATION_FIELD_CONFLICT, value-independent). See tsconfig-jsx.ts.
       jsx: await jsxTransform(cwd),
     },
-    resolve: { conditionNames: ["browser", "import", "default"] },
+    // "source" first so @junejs/* resolves to its src/*.ts (never a pre-built
+    // dist) — the client graph bundles June's own runtime (e.g. islands-client).
+    resolve: { conditionNames: ["source", "browser", "import", "default"] },
     onLog(level, log, handler) {
       if (isExpectedClientLog(log)) return;
       handler(level, log);

package/src/rsc-bundle.ts

@@ -19,8 +19,9 @@ import { rscClientReferencesPlugin } from "./rsc-manifest";
 export type RscGraph = "server" | "ssr";
 
 // edge-first conditions shared by both graphs; the server graph prepends
-// "react-server" so React resolves to the server build.
-const EDGE_CONDITIONS = ["workerd", "edge-light", "import", "default"];
+// "react-server" so React resolves to the server build. "source" leads so
+// @junejs/* resolves to its src/*.ts (never a pre-built dist).
+const EDGE_CONDITIONS = ["source", "workerd", "edge-light", "import", "default"];
 
 // Generic-entry virtuals the build resolves to real app modules (so one runtime
 // entry serves any app): "june:app" (the app root), "june:rsc-client" (the