@junejs/server 0.0.9 → 0.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junejs/server",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "June host adapters + dev server. Host-coupled; depends on the pure @junejs/core contract layer.",
   "type": "module",
   "license": "MIT",
@@ -11,6 +11,7 @@
     "./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",
@@ -29,9 +30,13 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@junejs/core": "0.0.9",
+    "@junejs/core": "0.0.11",
+    "@junejs/db": "0.0.11",
     "marked": "^18.0.5",
-    "rolldown": "^1.1.0"
+    "rolldown": "^1.1.0",
+    "postcss": "^8.4.0",
+    "postcss-modules": "^6.0.0",
+    "lightningcss": "^1.27.0"
   },
   "peerDependencies": {
     "react": "^19.2.0",

package/src/adapter.ts

@@ -0,0 +1,226 @@
+// Deploy adapters — the seam between June's portable `fetch(Request) → Response`
+// build and a deploy target. June's core artifact (createWorker(manifest)) is
+// already runtime-portable (the cake demo runs the SAME bundle on Workers AND
+// Vercel Edge), so an adapter does PACKAGING + BINDINGS + entry glue, never a
+// re-bundle. See docs/adapter-interface-spec.md.
+//
+// `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 { basename, join } from "node:path";
+
+import type { JuneConfig } from "@junejs/core/config";
+
+export type AdapterCapabilities = {
+  runtime: "edge" | "node" | "serverless" | "native" | "static";
+  // SSE/WebSocket → live-RSC push & server-push HMR. The framework degrades
+  // features that need it (with a build notice) when false. (Not yet consumed —
+  // the foundation for it.)
+  persistentConnections: boolean;
+  // Who serves prerendered static files: the platform CDN, the server, or none.
+  assets: "platform" | "server" | "none";
+};
+
+// What the adapter contributes to the generated worker entry: extra imports and
+// the `export default` that wraps the portable pipeline.
+export type AdapterEntry = {
+  imports: string[];
+  wrap(pipelineVar: string): string;
+};
+
+// What the app's declared resources need from the platform. Derived from
+// config.resources at build time; the adapter turns it into platform bindings
+// (workers() → wrangler `d1_databases` etc.). Target-neutral so a future
+// vercel()/node() adapter maps the SAME plan to its own provisioning.
+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 };
+};
+
+export type AdapterEmitContext = {
+  appRoot: string;
+  outDir: string;
+  hasAssets: boolean;
+  linkHeader: string | null;
+  config: JuneConfig;
+  // Platform bindings the declared resources need (empty object = none).
+  plan: ResourcePlan;
+  // package.json name (or sanitized dir name) — the fallback worker/app name.
+  defaultName: string;
+};
+
+export interface JuneAdapter {
+  readonly name: string;
+  readonly capabilities: AdapterCapabilities;
+  // Rolldown export conditions BAKED into the bundle at build time (the target
+  // runtime has none). Target-specific: workers → "workerd", vercel → "edge-light".
+  // The same portable graph, resolved for the platform's module surface.
+  readonly conditions: string[];
+  // Reject a config this target can't honor, BEFORE the expensive build — e.g.
+  // Vercel has no D1, so a declared db fails fast with a clear message instead of
+  // a cryptic prerender/runtime error. Optional; default is "accept everything".
+  validate?(ctx: { plan: ResourcePlan; config: JuneConfig }): void;
+  // Wrap the portable pipeline into the platform's entry source.
+  entry(opts: { linkHeader: string | null }): AdapterEntry;
+  // Write the deploy structure (config files, asset placement, server entry).
+  emit(ctx: AdapterEmitContext): Promise<void>;
+}
+
+// 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" },
+    conditions: ["workerd", "edge", "import", "default"],
+
+    entry({ linkHeader }) {
+      return {
+        imports: [`import { withAssets } from "@junejs/server/worker";`],
+        wrap: (pipelineVar) =>
+          `export default withAssets(${pipelineVar}, { link: ${JSON.stringify(linkHeader)} });`,
+      };
+    },
+
+    async emit({ appRoot, outDir, hasAssets, config, plan, defaultName }) {
+      // An app that manages its own wrangler config wins — don't overwrite it.
+      if (existsSync(join(appRoot, "wrangler.toml")) || existsSync(join(appRoot, "wrangler.jsonc"))) {
+        return;
+      }
+      const deployCfg = config.deploy;
+      await writeFile(
+        join(outDir, "wrangler.jsonc"),
+        JSON.stringify(
+          {
+            name: opts?.name ?? deployCfg?.name ?? defaultName,
+            main: "./worker.js",
+            compatibility_date: "2025-01-01",
+            compatibility_flags: ["nodejs_compat"],
+            // run_worker_first: the worker wraps asset serving (withAssets) so
+            // prerendered pages still get Link headers + Accept:markdown
+            // negotiation. The ASSETS binding lets the worker serve assets.
+            ...(hasAssets
+              ? { assets: { directory: "./assets", binding: "ASSETS", run_worker_first: true } }
+              : {}),
+            // A declared `db` resource → a D1 binding. database_id is per-account
+            // (run `wrangler d1 create <name>` and paste it); emitted empty so
+            // the binding is wired and the one missing value is obvious. With it,
+            // the same `sqlite()` declaration runs on D1 at the edge.
+            ...(plan.db
+              ? {
+                  d1_databases: [
+                    {
+                      binding: plan.db.binding,
+                      database_name: plan.db.databaseName,
+                      database_id: "",
+                    },
+                  ],
+                }
+              : {}),
+            // config deploy.domain → a Workers custom domain; without it the
+            // regenerated file would silently drop a hand-attached domain.
+            ...(opts?.domain ?? deployCfg?.domain
+              ? { routes: [{ pattern: opts?.domain ?? deployCfg?.domain, custom_domain: true }] }
+              : {}),
+          },
+          null,
+          2,
+        ) + "\n",
+      );
+    },
+  };
+}
+
+// Vercel target — emits the Build Output API v3 tree (.vercel/output/). June's
+// worker is already a Web-standard fetch handler, so this is packaging, not a
+// re-bundle: the same portable graph, built with edge-light conditions, becomes a
+// Vercel Edge Function. v1 scope: SSR + static + the full agent surface. No db
+// (D1 is Cloudflare-only) — declaring one fails fast; an HTTP-driver db backend
+// for Vercel is a planned follow-up.
+//
+// Routing: only the hashed framework assets (/_june/*) are served statically by
+// the CDN (their exact-path URLs match June's scheme); every page + projection
+// (.md/.json/mcp/llms.txt) renders through the one edge function, so the
+// dual-audience surface is identical to Workers.
+const VERCEL_FUNCTION = "__june"; // → /__june, the catch-all SSR function
+
+export function vercel(opts?: { regions?: string[] }): JuneAdapter {
+  return {
+    name: "vercel",
+    capabilities: { runtime: "edge", persistentConnections: false, assets: "platform" },
+    conditions: ["edge-light", "worker", "browser", "import", "default"],
+
+    validate({ plan }) {
+      if (plan.db) {
+        throw new Error(
+          "vercel(): the Vercel adapter has no db backend yet (D1 is Cloudflare-only).\n" +
+            "  Remove the `db` resource from june.config.ts, or deploy to Workers.\n" +
+            "  An HTTP-driver db (Neon/Turso) for Vercel is planned.",
+        );
+      }
+    },
+
+    entry() {
+      // No withAssets: the CDN serves /_june/*; this function renders everything
+      // else. Resources arrive via process.env (Vercel injects env vars into the
+      // edge runtime); there are no platform bindings.
+      return {
+        imports: [],
+        wrap: (pipelineVar) =>
+          `const __env = typeof process !== "undefined" && process.env ? process.env : {};\n` +
+          `export default (request) => ${pipelineVar}.fetch(request, __env);`,
+      };
+    },
+
+    async emit({ appRoot, outDir, hasAssets }) {
+      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
+      await mkdir(fnDir, { recursive: true });
+
+      // the edge function = June's portable worker bundle. Rolldown code-splits
+      // (worker.js imports ./cache-*.js, ./instrumentation-*.js, …), so copy EVERY
+      // top-level .js — the chunks must sit beside the entry or Vercel rejects the
+      // function ("referencing unsupported modules"). assets/ is handled below.
+      const jsFiles = (await readdir(outDir)).filter((f) => f.endsWith(".js"));
+      for (const f of jsFiles) await copyFile(join(outDir, f), join(fnDir, f));
+      await writeFile(
+        join(fnDir, ".vc-config.json"),
+        JSON.stringify(
+          { runtime: "edge", entrypoint: "worker.js", ...(opts?.regions ? { regions: opts.regions } : {}) },
+          null,
+          2,
+        ) + "\n",
+      );
+
+      // static: only 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 });
+      }
+
+      await writeFile(
+        join(out, "config.json"),
+        JSON.stringify(
+          {
+            version: 3,
+            routes: [
+              {
+                src: "^/_june/(.*)$",
+                headers: { "cache-control": "public, max-age=31536000, immutable" },
+                continue: true,
+              },
+              { handle: "filesystem" }, // serve any static file by exact path
+              { src: "^/.*$", dest: `/${VERCEL_FUNCTION}` }, // everything else → SSR
+            ],
+          },
+          null,
+          2,
+        ) + "\n",
+      );
+    },
+  };
+}

package/src/app.ts

@@ -22,6 +22,8 @@ import { findExtraFile, listRoutes, matchRouteTree, resolveNotFound, routeFiles,
 import { createPipeline, type ExtraHandler, type LayoutComponent, type Pipeline, type Resolved } from "./pipeline";
 import { memoizeResources } from "./resources";
 import { findClientEntry, bundleClientToString, CLIENT_SCRIPT_URL } from "./client-bundle";
+import { findGlobalCss, processCssCached, STYLES_URL } from "./css";
+import { buildModuleCss, registerCssModules, MODULE_STYLES_URL, type ModuleMaps } from "./css-modules";
 
 export type CreateAppOptions = {
   appDir: string;
@@ -48,6 +50,20 @@ async function loadLayout(file: string): Promise<LayoutComponent | null> {
   return mod.default;
 }
 
+// The nearest loading.tsx up the segment chain (deepest wins) → the streaming
+// Suspense fallback. Memoized like layouts.
+const loadingCache = new Map<string, React.ComponentType>();
+async function nearestLoading(segments: SegmentMatch[]): Promise<React.ComponentType | undefined> {
+  const file = [...segments].reverse().find((s) => s.loading)?.loading;
+  if (!file) return undefined;
+  const cached = loadingCache.get(file);
+  if (cached) return cached;
+  const mod = (await import(pathToFileURL(file).href)) as { default?: React.ComponentType };
+  if (typeof mod.default !== "function") return undefined;
+  loadingCache.set(file, mod.default);
+  return mod.default;
+}
+
 async function loadChain(segments: SegmentMatch[]): Promise<LayoutComponent[]> {
   const chain: LayoutComponent[] = [];
   for (const seg of segments) {
@@ -68,19 +84,29 @@ export function createApp({ appDir: appDirInput, config = {} }: CreateAppOptions
   // (bundled lazily, memoized). Detected the same way the build freezes it, so
   // dev and built surfaces agree.
   const clientEntry = findClientEntry(appDir);
+  const cssEntry = findGlobalCss(appDir);
   const docConfig: DocumentConfig = {
     site: config.site ?? {},
     speculationRules: resolveSpeculationRules(speculation ?? undefined),
     speculationDelivery: speculation ? speculation.delivery ?? "inline" : "inline",
     viewTransitions: config.viewTransitions ?? true,
+    clientRouter: config.clientRouter ?? false,
     clientScript: clientEntry ? CLIENT_SCRIPT_URL : null,
+    styles: cssEntry ? STYLES_URL : null,
   };
 
+  // CSS Modules: glob + transform app/**/*.module.css ONCE (memoized) → the maps
+  // (runtime interceptor + client bundle look these up) + the collected sheet.
+  let moduleCssPromise: Promise<{ maps: ModuleMaps; css: string | null }> | undefined;
+  const getModuleCss = () => (moduleCssPromise ??= buildModuleCss(appDir, dirname(appDir)));
+
   let clientBundle: Promise<string> | undefined;
   const serveClient = (): Promise<string> =>
     // cwd = the app ROOT (appDir's parent) so rolldown resolves node_modules
-    // from the project, exactly like the build does.
-    (clientBundle ??= bundleClientToString(clientEntry!, dirname(appDir)));
+    // from the project, exactly like the build does. Islands may import .module.css.
+    (clientBundle ??= getModuleCss().then(({ maps }) =>
+      bundleClientToString(clientEntry!, dirname(appDir), maps),
+    ));
 
   const routePaths = () => listRoutes(appDir, { pageConvention: true });
 
@@ -92,6 +118,13 @@ export function createApp({ appDir: appDirInput, config = {} }: CreateAppOptions
   let pipelinePromise: Promise<Pipeline> | undefined;
   const getPipeline = (): Promise<Pipeline> => (pipelinePromise ??= buildPipeline());
   async function buildPipeline(): Promise<Pipeline> {
+    // Wire CSS Modules BEFORE any route import: the runtime interceptor must be
+    // active so `import "x.module.css"` in a route resolves to the scoped map,
+    // and the document must link the collected sheet.
+    const { maps, css } = await getModuleCss();
+    await registerCssModules(maps);
+    if (css !== null) docConfig.moduleStyles = MODULE_STYLES_URL;
+
     const { notFound } = await resolveNotFound(appDir, "/");
     let notFoundComponent: ComponentType<{ pathname: string }> | undefined;
     if (notFound) {
@@ -120,7 +153,12 @@ export function createApp({ appDir: appDirInput, config = {} }: CreateAppOptions
         const mod = await import(pathToFileURL(match.file).href);
         const def = routeFromModule(mod);
         if (!def) return null;
-        return { def, params: match.params, chain: await loadChain(match.segments) };
+        return {
+          def,
+          params: match.params,
+          chain: await loadChain(match.segments),
+          loading: await nearestLoading(match.segments),
+        };
       },
     });
   }
@@ -131,6 +169,30 @@ export function createApp({ appDir: appDirInput, config = {} }: CreateAppOptions
 
   return {
     fetch(request) {
+      // Dev serves the global stylesheet (build ships it as a static asset);
+      // re-read+processed each hit so edits show on reload, like /client.js.
+      if (cssEntry && new URL(request.url).pathname === STYLES_URL) {
+        return processCssCached(appDir).then(
+          (css) =>
+            new Response(css ?? "", {
+              headers: { "content-type": "text/css; charset=utf-8" },
+            }),
+          (err: unknown) => {
+            console.error("[june] global.css failed:", err);
+            return new Response(`/* global.css failed: ${err instanceof Error ? err.message : String(err)} */\n`, {
+              status: 500,
+              headers: { "content-type": "text/css; charset=utf-8" },
+            });
+          },
+        );
+      }
+      // Dev serves the collected CSS-Modules stylesheet (build ships it hashed).
+      if (new URL(request.url).pathname === MODULE_STYLES_URL) {
+        return getModuleCss().then(
+          ({ css }) =>
+            new Response(css ?? "", { headers: { "content-type": "text/css; charset=utf-8" } }),
+        );
+      }
       // Dev serves the islands runtime itself (build ships it as a static
       // asset); bundled on first hit, memoized after.
       if (clientEntry && new URL(request.url).pathname === CLIENT_SCRIPT_URL) {

package/src/blob.ts

@@ -1,7 +1,7 @@
 // `blob` resource adapters — the object/file store seam (JuneBlob). The
 // zero-config dev default is a local directory; R2 (and S3-shaped backends) are
 // the deploy adapters. Same binding model as db/kv: declare `resources.blob` in
-// june.config.ts → injected as ctx.blob.
+// june.config.ts → use the ambient `blob` (decoupled from ctx).
 
 import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";