@junejs/server 0.0.9 → 0.0.11

package/src/css-modules.ts

@@ -0,0 +1,185 @@
+// CSS Modules — `import styles from "./X.module.css"` gives a map of local class
+// names → scoped names, and the scoped CSS is collected into one stylesheet.
+//
+// The hard constraint: the scoped names must be byte-identical in dev SSR
+// (un-bundled import), the worker build, and the client build (hydration must
+// match SSR). We guarantee that by NEVER deriving the name from a bundler
+// internal — `scopedName(stableKey, class)` is a pure hash of an app-relative
+// path + the class. One main-thread pass globs + transforms every .module.css
+// into a maps dict; the Bun plugin / Node loader / rolldown plugin are then dumb
+// lookups into it, and the served/emitted CSS comes from the SAME pass — so the
+// JS maps and the CSS agree by construction.
+//
+// Transforms go through postcss-modules, so the full CSS-Modules surface works:
+// local scoping (the default), `:global(...)`, and cross-file `composes`. The one
+// thing we override is generateScopedName — it's our deterministic hash, not a
+// bundler internal, which is what makes dev/build/client/Node agree.
+
+import { createHash } from "node:crypto";
+import { readFile, readdir } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+import type { AcceptedPlugin, ChildNode } from "postcss";
+
+export const MODULE_STYLES_URL = "/_june/modules.css";
+
+export const isModuleCss = (id: string) => id.endsWith(".module.css");
+
+// App-relative POSIX path — the stable scoping key (machine/cwd independent).
+export function stableKey(appRoot: string, file: string): string {
+  return relative(appRoot, file).split(sep).join("/");
+}
+
+function scopedName(key: string, cls: string): string {
+  const h = createHash("sha256").update(`${key}|${cls}`).digest("hex").slice(0, 8);
+  return `${cls}_${h}`;
+}
+
+// Transform one .module.css via postcss-modules — correct scoping, `:global`,
+// `composes` (cross-file), and url()/string safety — but with OUR deterministic
+// generateScopedName, so dev SSR / worker build / client build / Node all produce
+// identical names. postcss is imported lazily and only runs at build/dev time, so
+// it never enters the worker graph.
+export async function transformCssModule(
+  file: string,
+  appRoot: string,
+): Promise<{ map: Record<string, string>; css: string }> {
+  const postcss = (await import("postcss")).default;
+  const postcssModules = (await import("postcss-modules")).default as (opts: {
+    generateScopedName(name: string, filename: string): string;
+    getJSON(file: string, json: Record<string, string>): void;
+  }) => AcceptedPlugin;
+  let map: Record<string, string> = {};
+  const result = await postcss([
+    postcssModules({
+      generateScopedName: (name, filename) => scopedName(stableKey(appRoot, filename), name),
+      getJSON: (_f, json) => {
+        map = json;
+      },
+    }),
+  ]).process(await readFile(file, "utf8"), { from: file });
+  return { map, css: result.css };
+}
+
+// The JS a .module.css import resolves to.
+export const moduleJs = (map: Record<string, string>): string =>
+  `export default ${JSON.stringify(map)};`;
+
+export type ModuleMaps = Record<string, Record<string, string>>; // absPath → class map
+
+async function findModuleCss(dir: string): Promise<string[]> {
+  const out: string[] = [];
+  const walk = async (d: string) => {
+    let entries;
+    try {
+      entries = await readdir(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = join(d, e.name);
+      if (e.isDirectory()) await walk(full);
+      else if (e.name.endsWith(".module.css")) out.push(full);
+    }
+  };
+  await walk(dir);
+  return out.sort();
+}
+
+// Drop byte-identical top-level rules. postcss-modules has no module graph, so
+// `composes: x from "./y"` INLINES y's rule into this file's output — and we also
+// emit y directly, so a composed rule lands N+1 times. Vite never duplicates
+// (composes is a graph edge there); we get the same one-copy result by deduping.
+//
+// Two safety points:
+//  - Exact-string match only. Our scoped names are deterministic, so the copies
+//    are byte-identical; we never collapse two genuinely different rules.
+//  - Keep the LAST occurrence, not the first. With :global, two files can write
+//    the same raw selector with different bodies, so the cascade can interleave
+//    (red, blue, red). The winner is the last declaration; dropping the EARLIER
+//    identical copies leaves the last one in place, so the computed result is
+//    unchanged. Keeping the first instead would change which rule wins.
+async function dedupeRules(css: string): Promise<string> {
+  const postcss = (await import("postcss")).default;
+  const root = postcss.parse(css);
+  const last = new Map<string, ChildNode>();
+  root.each((node) => {
+    if (node.type === "rule" || node.type === "atrule") last.set(node.toString(), node);
+  });
+  root.each((node) => {
+    if ((node.type === "rule" || node.type === "atrule") && last.get(node.toString()) !== node) {
+      node.remove();
+    }
+  });
+  return root.toString();
+}
+
+// One pass over app/**/*.module.css → the per-file class maps AND the combined
+// scoped stylesheet. null css when there are none. Deterministic, so the maps the
+// loaders hand out match the CSS that's served/emitted.
+export async function buildModuleCss(
+  appDir: string,
+  appRoot: string,
+): Promise<{ maps: ModuleMaps; css: string | null }> {
+  const files = await findModuleCss(appDir);
+  const maps: ModuleMaps = {};
+  const parts: string[] = [];
+  for (const file of files) {
+    const { map, css } = await transformCssModule(file, appRoot);
+    maps[file] = map;
+    parts.push(css);
+  }
+  return { maps, css: parts.length ? await dedupeRules(parts.join("\n")) : null };
+}
+
+// --- the three dumb interception points (all lookups into `maps`) ------------
+
+// BUILD: a rolldown plugin. rolldown removed CSS support and infers type from
+// the .css extension, so `moduleType: "js"` forces it to treat our map as JS.
+// Added to BOTH the worker bundle and the client bundle.
+export function rolldownCssModulesPlugin(maps: ModuleMaps): {
+  name: string;
+  load(id: string): { code: string; moduleType: "js" } | null;
+} {
+  return {
+    name: "june-css-modules",
+    load(id) {
+      if (!isModuleCss(id)) return null;
+      return { code: moduleJs(maps[id] ?? {}), moduleType: "js" };
+    },
+  };
+}
+
+// RUNTIME (in-process imports — dev SSR + build prerender): register an
+// interceptor so `import "x.module.css"` returns the scoped map. The maps are a
+// module-level reference the Bun plugin reads LIVE (one process can serve several
+// apps across tests/build); the Node loader gets a snapshot at register time.
+let activeMaps: ModuleMaps = {};
+let runtimeRegistered = false;
+
+function registerBunCssModules(): void {
+  const B = (globalThis as { Bun?: { plugin(p: unknown): void } }).Bun!;
+  B.plugin({
+    name: "june-css-modules",
+    setup(build: { onLoad(opts: { filter: RegExp }, cb: (a: { path: string }) => unknown): void }) {
+      build.onLoad({ filter: /\.module\.css$/ }, (args) => ({
+        loader: "js",
+        contents: moduleJs(activeMaps[args.path] ?? {}),
+      }));
+    },
+  });
+}
+
+async function registerNodeCssModules(maps: ModuleMaps): Promise<void> {
+  const { register } = await import("node:module");
+  register(new URL("./css-modules-loader.mjs", import.meta.url), { data: { maps } });
+}
+
+// Point the runtime interceptor at THIS app's maps (and register it once, the
+// first time there's anything to intercept). No-op until an app has module CSS.
+export async function registerCssModules(maps: ModuleMaps): Promise<void> {
+  activeMaps = maps;
+  if (runtimeRegistered || !Object.keys(maps).length) return;
+  runtimeRegistered = true;
+  if (typeof (globalThis as { Bun?: unknown }).Bun !== "undefined") registerBunCssModules();
+  else await registerNodeCssModules(maps);
+}

package/src/css.ts

@@ -0,0 +1,118 @@
+// CSS — the human surface's styling. Convention over import: if `app/global.css`
+// exists, June auto-links it (no `import "./global.css"`). Dev serves it at the
+// stable /_june/global.css; build content-hashes it to /_june/global.<hash>.css
+// (served immutable). Only the asset HREF diverges dev↔built, never the rendered
+// structure — so dev/built parity (the agent surface) holds.
+//
+// Floor: plain CSS, zero deps. Blessed: if global.css opts into Tailwind
+// (`@import "tailwindcss"`), June compiles it via the app's own Tailwind v4
+// (resolved from the app, not bundled into June) — Tailwind auto-detects the
+// content it scans. CSS never touches the agent projections (.md/.json/mcp).
+
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// 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.
+export const STYLES_URL = "/_june/global.css";
+const GLOBAL_CSS = "global.css";
+
+// app/global.css, or null when the app declares no stylesheet.
+export function findGlobalCss(appDir: string): string | null {
+  const p = join(appDir, GLOBAL_CSS);
+  return existsSync(p) ? p : null;
+}
+
+const usesTailwind = (css: string) => /@import\s+["']tailwindcss["']|@tailwind\b/.test(css);
+
+// Resolve a tool from the APP's node_modules (Tailwind/postcss are the app's
+// deps, not June's). Returns null when absent.
+function resolveFromApp(specifier: string, appDir: string): string | null {
+  try {
+    return createRequire(pathToFileURL(join(appDir, "package.json"))).resolve(specifier);
+  } catch {
+    return null;
+  }
+}
+
+async function compileTailwind(
+  css: string,
+  file: string,
+  appDir: string,
+  minify: boolean,
+): Promise<string | null> {
+  const postcssPath = resolveFromApp("postcss", appDir);
+  const tailwindPath = resolveFromApp("@tailwindcss/postcss", appDir);
+  if (!postcssPath || !tailwindPath) return null;
+  const postcss = ((await import(postcssPath)) as { default: (p: unknown[]) => { process(css: string, opts: { from: string }): Promise<{ css: string }> } }).default;
+  const tailwind = ((await import(tailwindPath)) as { default: (opts?: unknown) => unknown }).default;
+  // Tailwind v4 only emits the classes the project actually uses (content
+  // detection = tree-shaking). For build we ALSO minify via its Lightning CSS
+  // optimizer; dev stays unminified for readability.
+  const plugin = minify ? tailwind({ optimize: { minify: true } }) : tailwind();
+  const result = await postcss([plugin]).process(css, { from: file });
+  return result.css;
+}
+
+// Dev-only memo. The dev server re-fetches /global.css on EVERY navigation, but
+// the CSS only changes on edit — so compiling each time wastes ~18ms a nav (and
+// ~145ms the first time, Tailwind's design-system build). Cache it; the .css
+// watcher calls invalidateCss() on edit, and a .tsx class change restarts the
+// whole dev process (cache starts empty there), so the cache never goes stale.
+let devCache: { appDir: string; css: string | null } | null = null;
+
+export async function processCssCached(appDir: string): Promise<string | null> {
+  if (devCache?.appDir === appDir) return devCache.css;
+  const css = await processCss(appDir);
+  devCache = { appDir, css };
+  return css;
+}
+
+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> {
+  try {
+    const { transform } = await import("lightningcss");
+    const { code } = transform({ filename, code: Buffer.from(css), minify: true });
+    return code.toString();
+  } catch (e) {
+    console.warn("[june] CSS minify failed; emitting unminified:", e);
+    return css;
+  }
+}
+
+// Read + process app/global.css → the CSS to serve/emit. null when absent.
+// build passes { minify: true } (optimized, deployable); dev leaves it readable.
+export async function processCss(
+  appDir: string,
+  opts: { minify?: boolean } = {},
+): Promise<string | null> {
+  const file = findGlobalCss(appDir);
+  if (!file) return null;
+  const css = await readFile(file, "utf8");
+  if (usesTailwind(css)) {
+    const compiled = await compileTailwind(css, file, appDir, !!opts.minify).catch((e) => {
+      console.warn("[june] Tailwind compile failed; serving raw CSS:", e);
+      return null;
+    });
+    if (compiled !== null) return compiled; // Tailwind already minified when asked
+    console.warn(
+      "[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;
+}

package/src/d1-migrate.ts

@@ -0,0 +1,209 @@
+// Apply June migrations to a REMOTE D1 at deploy time.
+//
+// The dev `db` opens locally (sqlite().open()); D1's binding only exists inside
+// workerd at request time, so the deploy host can't `factory.open()` it. Instead
+// we reach D1 out-of-band through `wrangler d1 execute --remote`, wrapped as a
+// JuneDb — so the SAME migrate() (same ledger, same destructive classifier the
+// dev path uses) runs against production unchanged. dev and prod converge on one
+// ordered ledger; the only difference is the transport.
+//
+// HOST-ONLY: spawns wrangler + writes temp files (node:*). Imported by deploy.ts,
+// which is never in the worker graph — keep it that way.
+
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+
+import type { JuneDb, RunResult } from "@junejs/core/resources";
+
+import { migrate, type MigrateResult } from "./migrate";
+
+// One `wrangler d1 execute` invocation. `mode:"command"` passes SQL inline (with
+// --json so we can read results/meta); `mode:"file"` writes a temp .sql and uses
+// --file (right for DDL + multi-statement migration bodies). Injectable so tests
+// drive the adapter without spawning wrangler or touching the network.
+export type D1Exec = (req: {
+  sql: string;
+  mode: "command" | "file";
+  json: boolean;
+}) => Promise<{ stdout: string; stderr: string; exitCode: number }>;
+
+// `?`-placeholder binding isn't available over `d1 execute --command`, so inline
+// the params ourselves. Only used for the framework's own ledger ops (controlled
+// values), but escape properly regardless.
+export function inlineParams(sql: string, params: readonly unknown[]): string {
+  let i = 0;
+  return sql.replace(/\?/g, () => {
+    const p = params[i++];
+    if (p === null || p === undefined) return "null";
+    if (typeof p === "number" || typeof p === "bigint") return String(p);
+    if (typeof p === "boolean") return p ? "1" : "0";
+    return `'${String(p).replace(/'/g, "''")}'`;
+  });
+}
+
+// wrangler --json prints a `[{ results, success, meta }]` array on stdout (one
+// element per statement; we read the first, since our --command calls are always
+// single-statement ledger ops). The clean case is pure JSON, but wrangler can
+// emit a banner/notice first — so fall back to parsing from the last line that
+// opens an array (the JSON is the last top-level value).
+function parseD1Json(stdout: string): { results: unknown[]; meta: Record<string, number> } {
+  type Row = { results?: unknown[]; meta?: Record<string, number> };
+  const pick = (arr: Row[]) => {
+    const f = arr[0] ?? {};
+    return { results: f.results ?? [], meta: f.meta ?? {} };
+  };
+  const trimmed = stdout.trim();
+  try {
+    return pick(JSON.parse(trimmed) as Row[]); // common case: pure JSON
+  } catch {
+    const lines = trimmed.split("\n");
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (lines[i]!.trimStart().startsWith("[")) {
+        try {
+          return pick(JSON.parse(lines.slice(i).join("\n")) as Row[]);
+        } catch {
+          /* a nested array opener — keep scanning upward for the real one */
+        }
+      }
+    }
+    throw new Error(`wrangler d1 execute: no JSON array in output:\n${stdout}`);
+  }
+}
+
+// The default transport: build the real argv and spawn wrangler. database is the
+// D1 `database_name`; configPath pins which wrangler config (and thus account)
+// the binding resolves against.
+function defaultExec(opts: {
+  database: string;
+  configPath: string;
+  cwd: string;
+  wranglerVersion: string;
+}): D1Exec {
+  return async ({ sql, mode, json }) => {
+    const base = [
+      "bunx",
+      `wrangler@${opts.wranglerVersion}`,
+      "d1",
+      "execute",
+      opts.database,
+      "--remote",
+      "--config",
+      opts.configPath,
+    ];
+    let tmpDir: string | undefined;
+    if (mode === "file") {
+      tmpDir = await mkdtemp(join(tmpdir(), "june-d1-"));
+      const tmp = join(tmpDir, "migration.sql");
+      await writeFile(tmp, sql);
+      base.push("--file", tmp);
+    } else {
+      base.push("--command", sql);
+    }
+    if (json) base.push("--json");
+    try {
+      const proc = Bun.spawn(base, { cwd: opts.cwd, stdout: "pipe", stderr: "pipe" });
+      const [stdout, stderr, exitCode] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+        proc.exited,
+      ]);
+      return { stdout, stderr, exitCode };
+    } finally {
+      if (tmpDir) await rm(tmpDir, { recursive: true, force: true });
+    }
+  };
+}
+
+// A JuneDb backed by `wrangler d1 execute`. query/get/run go through --command
+// (+ --json); exec (DDL, migration bodies) goes through --file.
+export function wranglerD1(opts: {
+  database: string;
+  configPath: string;
+  cwd: string;
+  wranglerVersion?: string;
+  exec?: D1Exec;
+}): JuneDb {
+  const exec = opts.exec ?? defaultExec({ ...opts, wranglerVersion: opts.wranglerVersion ?? "4.99.0" });
+  const fail = (r: { stderr: string; stdout: string; exitCode: number }) => {
+    throw new Error(`wrangler d1 execute failed (exit ${r.exitCode})\n${r.stderr || r.stdout}`.trim());
+  };
+  const db: JuneDb = {
+    async query<T>(sql: string, params: unknown[] = []) {
+      const r = await exec({ sql: inlineParams(sql, params), mode: "command", json: true });
+      if (r.exitCode !== 0) fail(r);
+      return parseD1Json(r.stdout).results as T[];
+    },
+    async get<T>(sql: string, params: unknown[] = []) {
+      return ((await db.query<T>(sql, params))[0] ?? undefined) as T | undefined;
+    },
+    async run(sql: string, params: unknown[] = []): Promise<RunResult> {
+      const r = await exec({ sql: inlineParams(sql, params), mode: "command", json: true });
+      if (r.exitCode !== 0) fail(r);
+      const { meta } = parseD1Json(r.stdout);
+      return { changes: meta.changes ?? 0, lastInsertRowid: meta.last_row_id ?? 0 };
+    },
+    async exec(sql: string) {
+      const r = await exec({ sql, mode: "file", json: false });
+      if (r.exitCode !== 0) fail(r);
+    },
+    // D1 has no interactive transactions; run inline (same as the edge d1()
+    // adapter). Migrations are one-statement-script-per-file anyway.
+    async transaction<T>(fn: (tx: JuneDb) => Promise<T>) {
+      return fn(db);
+    },
+    async close() {
+      /* nothing to close — each call is its own wrangler invocation */
+    },
+  };
+  return db;
+}
+
+// Resolve which D1 database `june deploy` should migrate. The wrangler config that
+// will be deployed is the source of truth; fall back to the name `june build`
+// derives (`<app>-db`) when the config is TOML or has no d1 binding declared.
+export async function resolveD1Database(appRoot: string, configPath: string): Promise<string | null> {
+  try {
+    const raw = await Bun.file(configPath).text();
+    if (/\.jsonc?$/.test(configPath)) {
+      const json = raw.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+      const cfg = JSON.parse(json) as { d1_databases?: Array<{ database_name?: string }> };
+      const name = cfg.d1_databases?.[0]?.database_name;
+      if (name) return name;
+    }
+  } catch {
+    /* fall through to the derived default */
+  }
+  const pkgPath = join(appRoot, "package.json");
+  let pkgName: string | undefined;
+  try {
+    pkgName = (JSON.parse(await Bun.file(pkgPath).text()) as { name?: string }).name;
+  } catch {
+    /* no package.json — use the directory name */
+  }
+  const defaultName = (pkgName ?? basename(appRoot)).replace(/[^a-z0-9-]/gi, "-").toLowerCase();
+  return `${defaultName}-db`;
+}
+
+// Open the remote D1 as a JuneDb and run the app's db/migrations against it —
+// the same migrate() the dev path uses, so the destructive gate behaves
+// identically (blocked → returned, not applied).
+export async function migrateD1(opts: {
+  appRoot: string;
+  database: string;
+  configPath: string;
+  allowDestructive?: boolean;
+  exec?: D1Exec;
+  now?: string;
+}): Promise<MigrateResult> {
+  const db = wranglerD1({
+    database: opts.database,
+    configPath: opts.configPath,
+    cwd: opts.appRoot,
+    exec: opts.exec,
+  });
+  return migrate(db, join(opts.appRoot, "db", "migrations"), {
+    allowDestructive: opts.allowDestructive,
+    now: opts.now,
+  });
+}

package/src/d1.ts

@@ -0,0 +1,53 @@
+// D1 (Cloudflare) `db` adapter — the EDGE half of the db resource. It adapts
+// D1's prepare().bind().all()/first()/run() to the @junejs/core JuneDb contract.
+//
+// PURE / EDGE-SAFE: this module has NO host imports (no node:*, no ./host), so
+// the generated worker can import it (via bindWorkerResources) without dragging
+// the dev server into the workerd bundle. The local sqlite() adapter — which is
+// host-coupled — lives in db.ts and stays out of the worker graph. D1 *is*
+// SQLite, so the same SQL and Juno tables that run on the dev file run here.
+
+import type { DbFactory, JuneDb, RunResult } from "@junejs/core/resources";
+
+type D1Result<T> = { results: T[] };
+type D1Meta = { changes?: number; last_row_id?: number };
+interface D1PreparedStatement {
+  bind(...values: unknown[]): D1PreparedStatement;
+  all<T = unknown>(): Promise<D1Result<T>>;
+  first<T = unknown>(): Promise<T | null>;
+  run(): Promise<{ meta: D1Meta }>;
+}
+export interface D1Database {
+  prepare(sql: string): D1PreparedStatement;
+  exec(sql: string): Promise<unknown>;
+}
+
+// The binding comes from the worker's env at request time, so d1() takes the
+// already-bound D1Database.
+export function d1(binding: D1Database): DbFactory {
+  const db: JuneDb = {
+    async query<T>(sql: string, params: unknown[] = []) {
+      return (await binding.prepare(sql).bind(...params).all<T>()).results;
+    },
+    async get<T>(sql: string, params: unknown[] = []) {
+      return (await binding.prepare(sql).bind(...params).first<T>()) ?? undefined;
+    },
+    async run(sql: string, params: unknown[] = []): Promise<RunResult> {
+      const { meta } = await binding.prepare(sql).bind(...params).run();
+      return { changes: meta.changes ?? 0, lastInsertRowid: meta.last_row_id ?? 0 };
+    },
+    async exec(sql: string) {
+      await binding.exec(sql);
+    },
+    // D1 has no INTERACTIVE transactions (only batch()); run the fn inline. For
+    // true atomicity, group writes through batch() at the call site. Documented
+    // limitation of the edge backend — the contract stays uniform.
+    async transaction<T>(fn: (tx: JuneDb) => Promise<T>) {
+      return fn(db);
+    },
+    async close() {
+      /* the binding outlives the request; nothing to close */
+    },
+  };
+  return { kind: "d1", open: async () => db };
+}

package/src/db.ts

@@ -2,14 +2,21 @@
 // Declared in june.config.ts (`resources.db: sqlite(...)` / `d1(...)`), opened
 // by the host, injected onto RouteContext as `ctx.db`. The framework depends on
 // the JuneDb contract; these adapters (and Juno on top) are swappable.
+//
+// sqlite() is host-coupled (node:fs + ./host) and DEV-only. The edge-safe d1()
+// adapter lives in ./d1 so the generated worker can import it without dragging
+// this module's host imports into the workerd bundle; it is re-exported here so
+// `@junejs/server/db` stays the one place both db adapters are named.
 
 import { mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 
-import type { DbFactory, JuneDb, RunResult } from "@junejs/core/resources";
+import type { DbFactory } from "@junejs/core/resources";
 
 import { host } from "./host";
 
+export { d1, type D1Database } from "./d1";
+
 // Local SQLite — the zero-config dev default. A persistent FILE, not :memory:,
 // on purpose: `june dev` restarts the process on every save (the watch
 // supervisor), so an in-memory default would evaporate your dev data at each
@@ -26,49 +33,3 @@ export function sqlite(opts: { path?: string } = {}): DbFactory {
     },
   };
 }
-
-// --- D1 (Cloudflare) — the third openDb impl (rebuild-plan Phase 5) ----------
-// The binding comes from the worker's env at request time, so d1() takes the
-// already-bound D1Database. Adapts D1's prepare().bind().all()/first()/run() to
-// the JuneDb contract.
-
-type D1Result<T> = { results: T[] };
-type D1Meta = { changes?: number; last_row_id?: number };
-interface D1PreparedStatement {
-  bind(...values: unknown[]): D1PreparedStatement;
-  all<T = unknown>(): Promise<D1Result<T>>;
-  first<T = unknown>(): Promise<T | null>;
-  run(): Promise<{ meta: D1Meta }>;
-}
-export interface D1Database {
-  prepare(sql: string): D1PreparedStatement;
-  exec(sql: string): Promise<unknown>;
-}
-
-export function d1(binding: D1Database): DbFactory {
-  const db: JuneDb = {
-    async query<T>(sql: string, params: unknown[] = []) {
-      return (await binding.prepare(sql).bind(...params).all<T>()).results;
-    },
-    async get<T>(sql: string, params: unknown[] = []) {
-      return (await binding.prepare(sql).bind(...params).first<T>()) ?? undefined;
-    },
-    async run(sql: string, params: unknown[] = []): Promise<RunResult> {
-      const { meta } = await binding.prepare(sql).bind(...params).run();
-      return { changes: meta.changes ?? 0, lastInsertRowid: meta.last_row_id ?? 0 };
-    },
-    async exec(sql: string) {
-      await binding.exec(sql);
-    },
-    // D1 has no INTERACTIVE transactions (only batch()); run the fn inline. For
-    // true atomicity, group writes through batch() at the call site. Documented
-    // limitation of the edge backend — the contract stays uniform.
-    async transaction<T>(fn: (tx: JuneDb) => Promise<T>) {
-      return fn(db);
-    },
-    async close() {
-      /* the binding outlives the request; nothing to close */
-    },
-  };
-  return { kind: "d1", open: async () => db };
-}