@junejs/server 0.0.19 → 0.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junejs/server",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "description": "June host adapters + dev server. Host-coupled; depends on the pure @junejs/core contract layer.",
   "type": "module",
   "license": "MIT",
@@ -30,8 +30,8 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@junejs/core": "0.0.19",
-    "@junejs/db": "0.0.19",
+    "@junejs/core": "0.0.21",
+    "@junejs/db": "0.0.21",
     "marked": "^18.0.5",
     "rolldown": "^1.1.0",
     "lightningcss": "^1.27.0"

package/src/adapter.ts

@@ -268,3 +268,69 @@ export function vercel(opts?: { runtime?: "node" | "edge"; regions?: string[] })
     },
   };
 }
+
+// Deno Deploy target. The SAME portable bundle as workers/vercel (edge-light →
+// react-dom server.edge.js, which Deno's web-standard runtime runs); the entry
+// wraps the pipeline in `Deno.serve(withDenoAssets(...))`. Deno Deploy has no CDN,
+// so the handler serves /_june/* from the co-located assets/ dir itself (like
+// vercel()'s split, but in-process). `june build` produces dist/{worker.js,assets}
+// and `deployctl deploy` ships the dir — no Build Output tree to construct.
+//
+// db: turso() works (libsql over HTTPS, env-driven). sqlite()/d1() are
+// Cloudflare-only; validate() rejects them.
+export function deno(opts?: { org?: string; app?: string }): JuneAdapter {
+  return {
+    name: "deno",
+    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"],
+
+    validate({ config }) {
+      const kind = config.resources?.db?.kind;
+      if (kind && kind !== "turso") {
+        throw new Error(
+          `deno(): the '${kind}' db isn't supported on Deno Deploy (D1 is Cloudflare-only).\n` +
+            "  Use turso() (libsql over HTTPS) for a Deno db, or deploy to Workers.",
+        );
+      }
+    },
+
+    entry() {
+      // The `export default { fetch }` Web Standard export — what `deno serve` (and
+      // Deno Deploy's runtime) invokes, and the same shape vercel()'s Node runtime
+      // uses. (A top-level `Deno.serve()` only works under `deno run`, not the
+      // platform.) No env glue: withDenoAssets reads Deno.env itself.
+      return {
+        imports: [`import { withDenoAssets } from "@junejs/server/worker";`],
+        wrap: (pipelineVar) => `export default { fetch: withDenoAssets(${pipelineVar}) };`,
+      };
+    },
+
+    async emit({ outDir }) {
+      // The bundle (worker.js + chunks) and assets/ already sit in outDir. The
+      // deno.json declares the Deno Deploy target (org/app) + the runtime block.
+      // `type: "dynamic"` is REQUIRED — it's the tag that tells EA "run this
+      // entrypoint as a server" (the `{ fetch }` export `deno serve` runs). Omit
+      // it and EA falls back to framework auto-detection ("internally optimized"),
+      // finds nothing, and the revision dies with "No runtime entrypoint provided".
+      // (The other arm is `type: "static"` + cwd/spa for a prebuilt SPA.) Source
+      // config takes precedence over the dashboard, so the deploy is reproducible.
+      // org/app come from deno({ org, app }) — without them, `deno deploy` prompts.
+      await writeFile(
+        join(outDir, "deno.json"),
+        JSON.stringify(
+          {
+            deploy: {
+              ...(opts?.org ? { org: opts.org } : {}),
+              ...(opts?.app ? { app: opts.app } : {}),
+              runtime: { type: "dynamic", entrypoint: "worker.js" },
+            },
+          },
+          null,
+          2,
+        ) + "\n",
+      );
+    },
+  };
+}

package/src/build.ts

@@ -34,7 +34,7 @@ import { createWorker, type WorkerManifest } from "./worker";
 import { findExtraFile } from "./router";
 import type { ExtraHandler, LayoutComponent, LoadingComponent } from "./pipeline";
 import { findClientEntry, bundleClientToFile, CLIENT_SCRIPT_URL } from "./client-bundle";
-import { findGlobalCss, minifyCss, processCss, STYLES_URL } from "./css";
+import { cssTargets, findGlobalCss, minifyCss, processCss, STYLES_URL } from "./css";
 import { buildModuleCss, rolldownCssModulesPlugin, registerCssModules } from "./css-modules";
 
 export type BuildResult = {
@@ -290,7 +290,8 @@ export async function juneBuild(
   const { maps: cssModuleMaps, css: rawModuleCss } = await buildModuleCss(appDir, appRoot);
   // Minify for build (dev serves it readable). Scoped class names are untouched,
   // so the hashed sheet still matches the maps the bundlers/loaders hand out.
-  const moduleCss = rawModuleCss === null ? null : await minifyCss(rawModuleCss, "modules.css");
+  const moduleCss =
+    rawModuleCss === null ? null : await minifyCss(rawModuleCss, "modules.css", await cssTargets(appDir));
   let moduleCssAsset: string | null = null;
   if (moduleCss !== null) {
     const hash = createHash("sha256").update(moduleCss).digest("hex").slice(0, 8);

package/src/css.ts

@@ -15,6 +15,8 @@ import { createRequire } from "node:module";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 
+import type { Targets } from "lightningcss"; // type-only — never enters the graph
+
 // Framework-emitted assets live under the reserved /_june/ prefix so they never
 // collide with — or squat on — a user's own paths (cf. Next /_next/, Astro
 // /_astro/). Build content-hashes the file under here; this is the dev URL.
@@ -39,6 +41,32 @@ function resolveFromApp(specifier: string, appDir: string): string | null {
   }
 }
 
+// Browser targets for autoprefix + syntax lowering (CSS nesting, :is(), oklch,
+// logical properties, …). June adds NO dep here: if the app installs `browserslist`
+// its config (or the browserslist defaults) drives the targets; otherwise a baked,
+// broadly-supported baseline. Override per app the standard way — a `browserslist`
+// field in package.json or a .browserslistrc.
+const v = (major: number, minor = 0): number => (major << 16) | (minor << 8);
+const DEFAULT_TARGETS: Targets = { chrome: v(107), edge: v(107), firefox: v(104), safari: v(16) };
+
+let targetsCache: { appDir: string; targets: Targets } | null = null;
+export async function cssTargets(appDir: string): Promise<Targets> {
+  if (targetsCache?.appDir === appDir) return targetsCache.targets;
+  let targets: Targets = DEFAULT_TARGETS;
+  const blPath = resolveFromApp("browserslist", appDir);
+  if (blPath) {
+    try {
+      const browserslist = ((await import(blPath)) as { default: (q?: unknown, o?: unknown) => string[] }).default;
+      const { browserslistToTargets } = await import("lightningcss");
+      targets = browserslistToTargets(browserslist(undefined, { path: appDir }));
+    } catch {
+      /* malformed config / resolution race → keep the baked default */
+    }
+  }
+  targetsCache = { appDir, targets };
+  return targets;
+}
+
 async function compileTailwind(
   css: string,
   file: string,
@@ -76,16 +104,17 @@ export function invalidateCss(): void {
   devCache = null;
 }
 
-// Minify a finished stylesheet with Lightning CSS — the same engine Tailwind v4
-// optimizes with, so all of June's build-time CSS comes out consistently. It only
-// touches whitespace/comments/redundancy, never identifiers, so scoped CSS-module
-// class names survive intact (hydration stays byte-identical to SSR). Lazy import:
-// build/dev-time only, never in the worker graph. Falls back to the input if
-// Lightning CSS can't parse it, so minification can never break a build.
-export async function minifyCss(css: string, filename = "input.css"): Promise<string> {
+// Minify a finished stylesheet with Lightning CSS — and, given `targets`, ALSO
+// autoprefix + lower modern syntax (nesting, :is(), oklch, logical props) for the
+// target browsers. The same engine Tailwind v4 optimizes with, so all of June's
+// build-time CSS comes out consistently. It never touches identifiers, so scoped
+// CSS-module class names survive intact (hydration stays byte-identical to SSR).
+// Lazy import: build/dev-time only, never in the worker graph. Falls back to the
+// input if Lightning CSS can't parse it, so it can never break a build.
+export async function minifyCss(css: string, filename = "input.css", targets?: Targets): Promise<string> {
   try {
     const { transform } = await import("lightningcss");
-    const { code } = transform({ filename, code: Buffer.from(css), minify: true });
+    const { code } = transform({ filename, code: Buffer.from(css), minify: true, targets });
     return code.toString();
   } catch (e) {
     console.warn("[june] CSS minify failed; emitting unminified:", e);
@@ -112,7 +141,8 @@ export async function processCss(
       "[june] global.css uses Tailwind but @tailwindcss/postcss isn't installed — serving raw CSS.",
     );
   }
-  // Plain CSS (or the Tailwind fallback): minify here so the non-Tailwind path
-  // is optimized too, matching the Tailwind path.
-  return opts.minify ? await minifyCss(css, file) : css;
+  // Plain CSS (or the Tailwind fallback): minify + autoprefix/lower for the app's
+  // browser targets, so the non-Tailwind path is optimized too. (Tailwind v4 owns
+  // its own targeting; dev stays readable and untargeted.)
+  return opts.minify ? await minifyCss(css, file, await cssTargets(appDir)) : css;
 }

package/src/deploy.ts

@@ -52,7 +52,7 @@ export async function juneDeploy(appRoot: string, options: DeployOptions = {}):
   // fallback. workers() is the default when neither names one.
   const adapterName = (cfg.deploy?.adapter as { name?: string } | undefined)?.name;
   const target = adapterName ?? cfg.deploy?.target ?? "workers";
-  if (target !== "workers" && target !== "vercel") {
+  if (target !== "workers" && target !== "vercel" && target !== "deno") {
     throw new Error(`unknown deploy target: ${target}`);
   }
 
@@ -62,9 +62,75 @@ export async function juneDeploy(appRoot: string, options: DeployOptions = {}):
   }
 
   const run = options.runCli ?? spawnCli;
-  return target === "vercel"
-    ? deployVercel(appRoot, options, run)
-    : deployWorkers(appRoot, cfg, options, run);
+  if (target === "vercel") return deployVercel(appRoot, options, run);
+  if (target === "deno") return deployDeno(appRoot, cfg, options, run);
+  return deployWorkers(appRoot, cfg, options, run);
+}
+
+// --- Deno Deploy: `deno deploy` ships the built dir (worker.js + assets/) -------
+// ONE-TIME app provisioning (the trap): the app must be created in DYNAMIC mode
+// with worker.js as the entrypoint, or Deno Deploy auto-detects a framework
+// ("internally optimized"), finds none, and every build dies with "No runtime
+// entrypoint provided". The emitted deno.json's deploy.runtime.type="dynamic"
+// only takes precedence AFTER a successful source-config build — a chicken-and-egg
+// the first build can't satisfy. So provision once with the config forced:
+//   deno deploy create --org=<org> --app=<app> --source=local \
+//     --do-not-use-detected-build-config --runtime-mode=dynamic --entrypoint=worker.js
+// After that, plain `deno deploy` re-uses the stuck-free config on every ship.
+const DENO_CREATE_HINT =
+  "first deploy? provision the app in dynamic mode (auto-detect won't find an entrypoint):\n" +
+  "  deno deploy create --org=<org> --app=<app> --source=local \\\n" +
+  "    --do-not-use-detected-build-config --runtime-mode=dynamic --entrypoint=worker.js";
+
+async function deployDeno(
+  appRoot: string,
+  cfg: Awaited<ReturnType<typeof loadJuneConfig>>,
+  options: DeployOptions,
+  run: CliRun,
+): Promise<DeployResult> {
+  const dist = join(appRoot, "dist");
+  if (!existsSync(join(dist, "worker.js"))) {
+    throw new Error(`no built bundle (expected ${join(dist, "worker.js")}) — run june build first`);
+  }
+  if (options.dryRun) {
+    console.log(`dry-run: built ${dist} (skipping deno deploy)`);
+    return { url: null, dryRun: true, configPath: dist, migrated: [] };
+  }
+  if (!process.env.DENO_DEPLOY_TOKEN) {
+    console.log(
+      "note: DENO_DEPLOY_TOKEN not set — `deno deploy` will use its own login\n" +
+        "      (run `deno deploy login` once, or export the token).",
+    );
+  }
+  // Deno Deploy (the current platform; Classic + deployctl retire 2026-07-20). The
+  // emitted deno.json carries deploy.{org,app,runtime}, so `deno deploy` ships dist/
+  // (worker.js + chunks + assets/) with no extra flags onto an already-provisioned
+  // app. --prod targets production (default is a preview). Auth from DENO_DEPLOY_TOKEN.
+  const args = ["deno", "deploy"];
+  if (options.prod) args.push("--prod");
+
+  const { stdout, stderr, exitCode } = await run(args, dist);
+  if (stdout.trim()) console.log(stdout.trimEnd());
+  if (exitCode !== 0) {
+    const out = stderr + stdout;
+    if (/token|login|unauthorized|forbidden|organization was not found|app.*not found/i.test(out)) {
+      throw new Error(
+        "Deno Deploy auth/org failed — set DENO_DEPLOY_TOKEN (or `deno deploy login`) and the\n" +
+          "  org/app in deno({ org, app }).\n  " +
+          DENO_CREATE_HINT +
+          "\n" +
+          stderr.trim(),
+      );
+    }
+    if (/no runtime entrypoint|build config/i.test(out)) {
+      throw new Error("Deno Deploy build failed — " + DENO_CREATE_HINT + "\n" + stderr.trim());
+    }
+    throw new Error(`deno deploy failed (exit ${exitCode})\n${stderr.trim()}`);
+  }
+  // EA serves on *.deno.net (the prod alias <app>.<org>.deno.net + the per-revision
+  // preview); Classic used *.deno.dev. Match both so the URL is always surfaced.
+  const url = stdout.match(/https:\/\/\S+\.deno\.(net|dev)\S*/)?.[0] ?? null;
+  return { url, dryRun: false, configPath: dist, migrated: [] };
 }
 
 // --- Vercel: upload the prebuilt Build Output (.vercel/output/) ---------------

package/src/host.ts

@@ -49,7 +49,7 @@ export interface JuneHost {
   // this with the in-isolate dual-graph loader; the seam stays for the fallback.
   spawnModule(entry: string, args: string[], opts: { conditions?: string[] }): SpawnedModule;
   // Open a LOCAL SQLite database — the internal primitive the `sqlite()` db
-  // adapter builds on (docs/data-layer.md: openDb is demoted from the
+  // adapter builds on (docs/data-layer-boundary.md: openDb is demoted from the
   // user-facing API to a host primitive; apps declare `resources.db` instead).
   openDb(path: string): Promise<JuneDb>;
 }

package/src/index.ts

@@ -4,6 +4,7 @@
 export {
   workers,
   vercel,
+  deno,
   type JuneAdapter,
   type AdapterCapabilities,
   type ResourcePlan,

package/src/kv.ts

@@ -1,4 +1,4 @@
-// `kv` resource adapters. The kv resource IS the cache (docs/data-layer
+// `kv` resource adapters. The kv resource IS the cache (docs/data-layer-boundary
 // .md: "reframe cache as the kv resource — it already is one"): these wrap
 // @junejs/core/cache's CacheStore (memory / redis) as the simpler JuneKv contract,
 // so there is ONE key-value system, surfaced both as cache() and as ambient kv.

package/src/worker.ts

@@ -215,3 +215,54 @@ export function withAssets(
     },
   };
 }
+
+// The Deno-target twin of withAssets. Deno Deploy has NO CDN / asset binding, so
+// the handler serves the hashed framework assets (/_june/*) from the bundle's
+// co-located assets/ dir and falls through to the pipeline for everything else —
+// the same split vercel() gets from the CDN, but in-process. The deno() adapter
+// bakes `export default { fetch: withDenoAssets(pipeline) }` into the entry (the
+// Web Standard handler `deno serve` / Deno Deploy runs). Deno globals are
+// referenced only inside the body, so non-Deno bundles tree-shake this out.
+declare const Deno: {
+  readFile(path: string | URL): Promise<Uint8Array>;
+};
+
+const ASSET_CONTENT_TYPES: Record<string, string> = {
+  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",
+};
+
+export function withDenoAssets(pipeline: FetchPipeline): (request: Request) => Promise<Response> {
+  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 as BodyInit, {
+          headers: {
+            "content-type": ASSET_CONTENT_TYPES[ext] ?? "application/octet-stream",
+            "cache-control": "public, max-age=31536000, immutable",
+          },
+        });
+      } catch {
+        /* not on disk → fall through (the pipeline 404s) */
+      }
+    }
+    // No env arg: Deno has no platform bindings (unlike D1/KV on workers); env-
+    // driven resources (turso) read process.env / Deno.env themselves. Keeps the
+    // function off the --allow-env permission too.
+    return pipeline.fetch(request);
+  };
+}