@akanjs/cli 3.0.0-beta.22 → 3.0.0-beta.24

package/{index-aadpbnt2.js → index-ne50hc2m.js}

@@ -866,6 +866,7 @@ function createUseClientBundlePlugin(options = {}) {
 import path6 from "path";
 class PagesEntrySourceGenerator {
   #pageEntries;
+  #asyncDefaults = new Map;
   constructor(pageEntries) {
     this.#pageEntries = pageEntries;
   }
@@ -883,16 +884,16 @@ ${lines.join(`
 };
 `;
   }
-  static async generateStatic(pageEntries) {
-    return await new PagesEntrySourceGenerator(pageEntries).generateStatic();
+  static async generateStatic(pageEntries, { fromDir } = {}) {
+    return await new PagesEntrySourceGenerator(pageEntries).generateStatic({ fromDir });
   }
-  async generateStatic() {
+  async generateStatic({ fromDir } = {}) {
     const imports = this.#pageEntries.map(({ moduleAbsPath }, index) => {
-      const specifier = PagesEntrySourceGenerator.#toImportSpecifier(moduleAbsPath);
+      const specifier = fromDir ? PagesEntrySourceGenerator.#toRelativeSpecifier(fromDir, moduleAbsPath) : PagesEntrySourceGenerator.#toImportSpecifier(moduleAbsPath);
       return `import * as page${index} from ${JSON.stringify(specifier)};`;
     });
     const entries = await Promise.all(this.#pageEntries.map(async ({ key, moduleAbsPath }, index) => {
-      const isAsyncDefault = await AsyncDefaultExportDetector.detect(moduleAbsPath);
+      const isAsyncDefault = await this.#isAsyncDefault(moduleAbsPath);
       return `  ${JSON.stringify(key)}: { loader: async () => page${index}, isAsyncDefault: ${isAsyncDefault} },`;
     }));
     return `${imports.join(`
@@ -903,9 +904,40 @@ ${entries.join(`
 };
 `;
   }
+  async generateHotReplace({
+    fromDir,
+    ownerId,
+    moduleIds
+  }) {
+    const entries = await Promise.all(this.#pageEntries.map(async ({ key, moduleAbsPath }) => {
+      const specifier = PagesEntrySourceGenerator.#toRelativeSpecifier(fromDir, moduleAbsPath);
+      const isAsyncDefault = await this.#isAsyncDefault(moduleAbsPath);
+      return `    ${JSON.stringify(key)}: { loader: async () => require(${JSON.stringify(specifier)}), isAsyncDefault: ${isAsyncDefault} },`;
+    }));
+    return `__akan.accept(${JSON.stringify(ownerId)}, ${JSON.stringify(moduleIds)}, async () => {
+  const replaced = await akanWebkit.replacePages({
+${entries.join(`
+`)}
+  });
+  if (!replaced) throw new Error("the route table no longer matches the pages it was built from");
+});
+`;
+  }
+  #isAsyncDefault(moduleAbsPath) {
+    const known = this.#asyncDefaults.get(moduleAbsPath);
+    if (known)
+      return known;
+    const detected = AsyncDefaultExportDetector.detect(moduleAbsPath);
+    this.#asyncDefaults.set(moduleAbsPath, detected);
+    return detected;
+  }
   static #toImportSpecifier(moduleAbsPath) {
     return path6.resolve(moduleAbsPath).split(path6.sep).join("/");
   }
+  static #toRelativeSpecifier(fromDir, moduleAbsPath) {
+    const relative = path6.relative(fromDir, path6.resolve(moduleAbsPath)).split(path6.sep).join("/");
+    return relative.startsWith(".") ? relative : `./${relative}`;
+  }
 }
 
 // pkgs/@akanjs/devkit/frontendBuild/pagesBundleBuilder.ts
@@ -1244,9 +1276,774 @@ ${CsrArtifactBuilder.escapeInlineScript(await loadScript(src))}
   }
 }
 
-// pkgs/@akanjs/devkit/frontendBuild/fontOptimizer.ts
-import { mkdir as mkdir2, stat as stat2 } from "fs/promises";
+// pkgs/@akanjs/devkit/frontendBuild/csrDevBundler.ts
+import fs3 from "fs";
+import { mkdir as mkdir3 } from "fs/promises";
+import path13 from "path";
+import { CSR_DEV_DIRNAME, CSR_DEV_MANIFEST_FILE as CSR_DEV_MANIFEST_FILE2 } from "akanjs/server/hmr/csrDevManifest";
+import { isAkanRuntimeMetadataFile } from "akanjs/server/hmr/runtimeMetadataFile";
+
+// pkgs/@akanjs/devkit/frontendBuild/csrDevArtifactWriter.ts
+import { mkdir as mkdir2, readdir, rename, rm as rm2 } from "fs/promises";
+import path10 from "path";
+import {
+  CSR_DEV_APP_FILE,
+  CSR_DEV_MANIFEST_FILE,
+  CSR_DEV_ROUTE_PREFIX,
+  csrDevModuleFile
+} from "akanjs/server/hmr/csrDevManifest";
+
+// pkgs/@akanjs/devkit/frontendBuild/csrDevPaths.ts
+import fs from "fs";
 import path9 from "path";
+
+class CsrDevPaths {
+  static modulePrefix = "akan-module:";
+  static stubPrefix = "stub:";
+  root;
+  constructor(workspaceRoot) {
+    this.root = CsrDevPaths.realpath(workspaceRoot);
+  }
+  idOf(file) {
+    const real = CsrDevPaths.realpath(file);
+    const relative = path9.relative(this.root, real);
+    const id = relative.startsWith("..") || path9.isAbsolute(relative) ? real : relative;
+    return id.split(path9.sep).join("/");
+  }
+  fileOf(id) {
+    return path9.isAbsolute(id) ? id : path9.join(this.root, id);
+  }
+  static isStub(target) {
+    return target.startsWith(CsrDevPaths.stubPrefix);
+  }
+  static isVendorFile(file) {
+    return file.includes(`${path9.sep}node_modules${path9.sep}`);
+  }
+  static isScript(file) {
+    return /\.[cm]?[jt]sx?$/.test(file);
+  }
+  static mtimeOf(file) {
+    return fs.statSync(file, { throwIfNoEntry: false })?.mtimeMs ?? -1;
+  }
+  static async hashOf(file) {
+    const source = Bun.file(file);
+    return await source.exists() ? Bun.hash(await source.arrayBuffer()).toString(36) : "";
+  }
+  static realpath(file) {
+    return fs.existsSync(file) ? fs.realpathSync(file) : path9.resolve(file);
+  }
+  static tryResolve(specifier, from) {
+    try {
+      return Bun.resolveSync(specifier, from);
+    } catch {
+      return null;
+    }
+  }
+  static lineCount(text) {
+    let count = 0;
+    for (let index = text.indexOf(`
+`);index !== -1; index = text.indexOf(`
+`, index + 1))
+      count += 1;
+    return count;
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/csrDevArtifactWriter.ts
+class CsrDevArtifactWriter {
+  static #keptPatches = 40;
+  static #keptVendors = 3;
+  #outDir;
+  constructor(outDir) {
+    this.#outDir = outDir;
+  }
+  async reset() {
+    await rm2(this.#outDir, { recursive: true, force: true });
+    await mkdir2(path10.join(this.#outDir, "modules"), { recursive: true });
+  }
+  async readJson(name) {
+    const file = Bun.file(path10.join(this.#outDir, name));
+    if (!await file.exists())
+      return null;
+    return await file.json().catch(() => null);
+  }
+  async writeJson(name, value) {
+    await this.#writeAtomic(name, JSON.stringify(value));
+  }
+  async writeModules(compiled) {
+    await mkdir2(path10.join(this.#outDir, "modules"), { recursive: true });
+    const helpers = new Map(compiled.flatMap((module) => module.helpers ? [[module.helpers.hash, module.helpers]] : []));
+    await Promise.all([
+      ...compiled.flatMap((module) => [
+        Bun.write(this.#modulePath(module.id, ".js"), module.factory),
+        ...module.sourceMap ? [Bun.write(this.#modulePath(module.id, ".js.map"), module.sourceMap)] : []
+      ]),
+      ...[...helpers.values()].map((shared) => Bun.write(this.#helpersPath(shared.hash), shared.definition))
+    ]);
+  }
+  async forgetModules(ids) {
+    await Promise.all(ids.flatMap((id) => [
+      rm2(this.#modulePath(id, ".js"), { force: true }),
+      rm2(this.#modulePath(id, ".js.map"), { force: true })
+    ]));
+  }
+  async writeVendor(graph) {
+    const ids = Object.keys(graph.modules).filter((id) => graph.modules[id]?.vendor).sort();
+    const stubs = new Set(Object.values(graph.modules).flatMap((module) => module.deps.filter(CsrDevPaths.isStub)));
+    const lines = [await this.#helperDefinitions(graph, ids), ...await this.#defineLines(ids)];
+    for (const stub of [...stubs].sort()) {
+      const message = `[akan-csr] ${stub.slice(CsrDevPaths.stubPrefix.length)} is a Node built-in the browser does not have`;
+      lines.push(`__akan.define(${JSON.stringify(stub)}, function () {
+  throw new Error(${JSON.stringify(message)});
+});
+`);
+    }
+    const code = lines.join("");
+    const vendorFile = `vendor-${Bun.hash(code).toString(36)}.js`;
+    await this.#writeAtomic(vendorFile, code);
+    return vendorFile;
+  }
+  async writeApp(graph, generation) {
+    const ids = Object.keys(graph.modules).filter((id) => !graph.modules[id]?.vendor).sort();
+    const lines = await this.#defineLines(ids);
+    const blocks = ids.map((id, index) => [id, lines[index] ?? ""]);
+    const start = `__akan.start(${JSON.stringify({ generation, refresh: graph.refresh })});
+`;
+    await this.#writeWithSourceMap(CSR_DEV_APP_FILE, await this.#helperDefinitions(graph, ids), blocks, start);
+  }
+  async writePatch(generation, modules) {
+    const patchFile = `patch-${generation}.js`;
+    const blocks = modules.map((module, index) => [module.id, `${JSON.stringify(module.id)}: ${module.factory}${index < modules.length - 1 ? `,
+` : `
+`}`]);
+    const helpers = new Map(modules.flatMap((module) => module.helpers ? [[module.helpers.hash, module.helpers]] : []));
+    const header = `${[...helpers.values()].map((shared) => shared.definition).join("")}__akan.update(${generation}, {
+`;
+    await this.#writeWithSourceMap(patchFile, header, blocks, `});
+`);
+    return `${CSR_DEV_ROUTE_PREFIX}${patchFile}`;
+  }
+  async writeState(graph, manifest) {
+    await this.writeJson("graph.json", graph);
+    await this.writeJson(CSR_DEV_MANIFEST_FILE, manifest);
+  }
+  async prune(vendorFile, generation) {
+    const names = await readdir(this.#outDir);
+    const stale = names.filter((name) => {
+      const patch = /^patch-(\d+)\.js(?:\.layout\.json)?$/.exec(name);
+      return patch ? Number(patch[1]) <= generation - CsrDevArtifactWriter.#keptPatches : false;
+    });
+    const vendors = names.filter((name) => /^vendor-[\w-]+\.js$/.test(name) && name !== vendorFile).map((name) => ({ name, mtimeMs: CsrDevPaths.mtimeOf(path10.join(this.#outDir, name)) })).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(CsrDevArtifactWriter.#keptVendors - 1).map(({ name }) => name);
+    await Promise.all([...stale, ...vendors].map((name) => rm2(path10.join(this.#outDir, name), { force: true })));
+  }
+  async#helperDefinitions(graph, ids) {
+    const hashes = [...new Set(ids.flatMap((id) => graph.modules[id]?.helpers ?? []))].sort();
+    return (await Promise.all(hashes.map((hash) => Bun.file(this.#helpersPath(hash)).text()))).join("");
+  }
+  async#defineLines(ids) {
+    return await Promise.all(ids.map(async (id) => `__akan.define(${JSON.stringify(id)}, ${await Bun.file(this.#modulePath(id, ".js")).text()});
+`));
+  }
+  async#writeWithSourceMap(name, header, blocks, footer) {
+    const layout = { lineCount: 0, modules: [] };
+    let line = CsrDevPaths.lineCount(header);
+    for (const [id, text] of blocks) {
+      layout.modules.push([id, line + 1]);
+      line += CsrDevPaths.lineCount(text);
+    }
+    const code = `${header}${blocks.map(([, text]) => text).join("")}${footer}//# sourceMappingURL=${name}.map
+`;
+    layout.lineCount = CsrDevPaths.lineCount(code);
+    await this.writeJson(`${name}.layout.json`, layout);
+    await this.#writeAtomic(name, code);
+  }
+  async#writeAtomic(name, content) {
+    const target = path10.join(this.#outDir, name);
+    const temp = `${target}.${process.pid}.tmp`;
+    await Bun.write(temp, content);
+    await rename(temp, target);
+  }
+  #modulePath(id, extension) {
+    return path10.join(this.#outDir, csrDevModuleFile(id, extension));
+  }
+  #helpersPath(hash) {
+    return path10.join(this.#outDir, "modules", `helpers-${hash}.js`);
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/csrDevModuleCompiler.ts
+import path12 from "path";
+import { CSR_DEV_ROUTE_PREFIX as CSR_DEV_ROUTE_PREFIX2 } from "akanjs/server/hmr/csrDevManifest";
+
+// pkgs/@akanjs/devkit/frontendBuild/csrDevResolver.ts
+import fs2 from "fs";
+import path11 from "path";
+class CsrDevResolver {
+  static inline = "inline";
+  #paths;
+  #context;
+  #entryFiles;
+  #resolution = new Map;
+  #fallbacks = new Set;
+  #prepassDone = false;
+  constructor({ paths, context, entryFiles, resolution = {} }) {
+    this.#paths = paths;
+    this.#context = context;
+    this.#entryFiles = entryFiles;
+    for (const [importer, bySpecifier] of Object.entries(resolution))
+      this.#resolution.set(paths.fileOf(importer), new Map(Object.entries(bySpecifier).map(([specifier, target]) => [
+        specifier,
+        CsrDevPaths.isStub(target) ? target : paths.fileOf(target)
+      ])));
+  }
+  get prepassDone() {
+    return this.#prepassDone;
+  }
+  get fallbacks() {
+    return this.#fallbacks;
+  }
+  async prepass() {
+    const result = await Bun.build({
+      entrypoints: [...this.#entryFiles, this.#context.refreshFile],
+      target: "browser",
+      metafile: true,
+      env: "AKAN_PUBLIC_*",
+      define: this.#context.define,
+      optimizeImports: this.#context.optimizeImports,
+      plugins: [PagesBundleBuilder.createCssStubPlugin()]
+    });
+    const { inputs } = result.metafile;
+    for (const [input, { imports }] of Object.entries(inputs)) {
+      const importer = CsrDevPaths.realpath(path11.resolve(input));
+      for (const record of imports) {
+        if (!record.original)
+          continue;
+        if (record.external) {
+          if (record.original.startsWith("node:"))
+            this.#remember(importer, record.original, `${CsrDevPaths.stubPrefix}${record.original}`);
+          continue;
+        }
+        const target = path11.resolve(record.path);
+        if (fs2.existsSync(target))
+          this.#remember(importer, record.original, CsrDevPaths.realpath(target));
+      }
+    }
+    this.#prepassDone = true;
+  }
+  resolve(importer, specifier) {
+    if (this.#isInlineSpecifier(specifier))
+      return CsrDevResolver.inline;
+    const known = this.#resolution.get(importer)?.get(specifier);
+    const usable = known && (CsrDevPaths.isStub(known) || fs2.existsSync(known)) ? known : null;
+    const target = usable ?? this.#resolveUnknown(importer, specifier);
+    if (target === null || CsrDevPaths.isStub(target))
+      return target;
+    if (!CsrDevPaths.isScript(target))
+      return CsrDevResolver.inline;
+    if (!usable)
+      this.#remember(importer, specifier, target);
+    return target;
+  }
+  isRegistryModule(file) {
+    if (!CsrDevPaths.isScript(file))
+      return false;
+    const packageName = CsrDevResolver.#packageNameOf(file);
+    if (packageName === null)
+      return true;
+    return !this.#context.optimizeImports.some((pattern) => {
+      const base = CsrDevResolver.#patternBase(pattern);
+      return base === packageName || base.startsWith(`${packageName}/`);
+    });
+  }
+  serialize() {
+    return Object.fromEntries([...this.#resolution].map(([importer, bySpecifier]) => [
+      this.#paths.idOf(importer),
+      Object.fromEntries([...bySpecifier].map(([specifier, target]) => [
+        specifier,
+        CsrDevPaths.isStub(target) ? target : this.#paths.idOf(target)
+      ]))
+    ]));
+  }
+  #resolveUnknown(importer, specifier) {
+    if (specifier.startsWith("node:"))
+      return `${CsrDevPaths.stubPrefix}${specifier}`;
+    const relative = specifier.startsWith(".") || path11.isAbsolute(specifier);
+    if (!relative && !this.#prepassDone)
+      return null;
+    if (!relative) {
+      const sibling = this.#resolvedBySibling(importer, specifier);
+      if (sibling)
+        return sibling;
+    }
+    const resolved = CsrDevPaths.tryResolve(specifier, path11.dirname(importer));
+    if (!resolved)
+      throw new Error(`[csr-dev] cannot resolve "${specifier}" from ${this.#paths.idOf(importer)}`);
+    if (!path11.isAbsolute(resolved))
+      return `${CsrDevPaths.stubPrefix}${specifier}`;
+    if (!relative)
+      this.#fallbacks.add(specifier);
+    return CsrDevPaths.realpath(resolved);
+  }
+  #resolvedBySibling(importer, specifier) {
+    const scope = CsrDevResolver.#packageScopeOf(importer);
+    for (const [other, bySpecifier] of this.#resolution) {
+      const target = bySpecifier.get(specifier);
+      if (target && CsrDevResolver.#packageScopeOf(other) === scope)
+        return target;
+    }
+    return null;
+  }
+  #remember(importer, specifier, target) {
+    const byImporter = this.#resolution.get(importer) ?? new Map;
+    this.#resolution.set(importer, byImporter.set(specifier, target));
+  }
+  #isInlineSpecifier(specifier) {
+    if (specifier.startsWith(".") || path11.isAbsolute(specifier) || specifier.startsWith("node:"))
+      return false;
+    return this.#context.optimizeImports.some((pattern) => {
+      const base = CsrDevResolver.#patternBase(pattern);
+      return specifier === base || specifier.startsWith(`${base}/`);
+    });
+  }
+  static #patternBase(pattern) {
+    return pattern.endsWith("/*") ? pattern.slice(0, -2) : pattern;
+  }
+  static #packageNameOf(file) {
+    const marker = `${path11.sep}node_modules${path11.sep}`;
+    const index = file.lastIndexOf(marker);
+    if (index < 0)
+      return null;
+    const [scope, name] = file.slice(index + marker.length).split(path11.sep);
+    return (scope?.startsWith("@") ? `${scope}/${name}` : scope) || null;
+  }
+  static #packageScopeOf(file) {
+    const marker = `${path11.sep}node_modules${path11.sep}`;
+    const index = file.lastIndexOf(marker);
+    if (index < 0)
+      return "";
+    const [scope, name] = file.slice(index + marker.length).split(path11.sep);
+    return file.slice(0, index + marker.length) + (scope?.startsWith("@") ? `${scope}${path11.sep}${name}` : scope);
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/csrDevModuleCompiler.ts
+class CsrDevModuleCompiler {
+  static #storeRoot = /(?:^|\/)lib\/st\.ts$/;
+  static #factoryArgument = /(?<![\w$.])(?:require|module|exports|__akanImport|\$RefreshReg\$|\$RefreshSig\$)(?![\w$]|\s*:)/;
+  static #helperPatches = [
+    ["__toESM", "(mod, isNodeMode, target)", "toESM"],
+    ["__reExport", "(target, mod, secondTarget)", "reExport"]
+  ];
+  #app;
+  #paths;
+  #resolver;
+  #context;
+  #outDir;
+  constructor({ app, paths, resolver, context, outDir }) {
+    this.#app = app;
+    this.#paths = paths;
+    this.#resolver = resolver;
+    this.#context = context;
+    this.#outDir = outDir;
+  }
+  async compile(startFiles, known) {
+    const compiled = new Map;
+    const seen = new Set([...known, ...startFiles]);
+    let frontier = [...new Set(startFiles)];
+    while (frontier.length > 0) {
+      const round = await this.#compileRound(frontier);
+      if (round.misses.length > 0 && !this.#resolver.prepassDone) {
+        this.#app.verbose(`[csr-dev] ${round.misses.length} unresolved import(s); rerunning the resolution build`);
+        await this.#resolver.prepass();
+        continue;
+      }
+      const next = [];
+      for (const module of round.modules) {
+        compiled.set(module.file, module);
+        for (const dep of module.deps) {
+          if (CsrDevPaths.isStub(dep) || seen.has(dep))
+            continue;
+          seen.add(dep);
+          next.push(dep);
+        }
+      }
+      frontier = next;
+    }
+    const { fallbacks } = this.#resolver;
+    if (fallbacks.size > 0)
+      this.#app.verbose(`[csr-dev] ${fallbacks.size} import(s) outside the browser build's graph resolved with Bun's runtime resolver: ${[...fallbacks].slice(0, 5).join(", ")}${fallbacks.size > 5 ? ", ..." : ""}`);
+    return [...compiled.values()];
+  }
+  async#compileRound(files) {
+    const appFiles = files.filter((file) => !CsrDevPaths.isVendorFile(file));
+    const vendorFiles = files.filter((file) => CsrDevPaths.isVendorFile(file));
+    const rounds = await Promise.all([
+      appFiles.length > 0 ? this.#bunBuild(appFiles, false) : null,
+      vendorFiles.length > 0 ? this.#bunBuild(vendorFiles, true) : null
+    ]);
+    const modules = rounds.flatMap((round) => round?.modules ?? []);
+    const misses = rounds.flatMap((round) => round?.misses ?? []);
+    for (const file of rounds.flatMap((round) => round?.tangled ?? [])) {
+      const single = await this.#bunBuild([file], CsrDevPaths.isVendorFile(file));
+      if (single.tangled.length > 0)
+        throw new Error(`[csr-dev] ${this.#paths.idOf(file)} kept inlining another module`);
+      modules.push(...single.modules);
+      misses.push(...single.misses);
+    }
+    return { modules, misses };
+  }
+  async#bunBuild(files, vendor) {
+    const mtimes = new Map(files.map((file) => [file, CsrDevPaths.mtimeOf(file)]));
+    const hashes = new Map(await Promise.all(files.map(async (file) => [file, vendor ? "" : await CsrDevPaths.hashOf(file)])));
+    const misses = [];
+    const result = await Bun.build({
+      entrypoints: files,
+      root: this.#paths.root,
+      target: "browser",
+      format: "cjs",
+      reactFastRefresh: !vendor,
+      sourcemap: vendor ? "none" : "external",
+      naming: { entry: "[dir]/[name].[ext]", asset: "assets/[name]-[hash].[ext]" },
+      publicPath: CSR_DEV_ROUTE_PREFIX2,
+      metafile: true,
+      env: "AKAN_PUBLIC_*",
+      define: this.#context.define,
+      optimizeImports: this.#context.optimizeImports,
+      plugins: [this.#registryPlugin(vendor, misses)]
+    });
+    const { outputs } = result.metafile;
+    const sourceMaps = new Map(result.outputs.filter((artifact) => artifact.kind === "sourcemap").map((artifact) => [artifact.path, artifact]));
+    const modules = [];
+    const tangled = [];
+    for (const artifact of result.outputs) {
+      if (artifact.kind === "asset") {
+        await Bun.write(path12.join(this.#outDir, artifact.path), artifact);
+        continue;
+      }
+      if (artifact.kind !== "entry-point")
+        continue;
+      const meta = outputs[artifact.path];
+      if (!meta?.entryPoint)
+        throw new Error(`[csr-dev] no entry point recorded for ${artifact.path}`);
+      const file = CsrDevPaths.realpath(path12.resolve(meta.entryPoint));
+      const inputs = Object.keys(meta.inputs).map((input) => CsrDevPaths.realpath(path12.resolve(input)));
+      if (inputs.some((input) => input !== file && this.#resolver.isRegistryModule(input))) {
+        tangled.push(file);
+        continue;
+      }
+      const code = await artifact.text();
+      const id = this.#paths.idOf(file);
+      const sourceMap = sourceMaps.get(`${artifact.path}.map`);
+      modules.push({
+        id,
+        file,
+        vendor,
+        ...CsrDevModuleCompiler.#factory(id, code),
+        sourceMap: sourceMap ? this.#rebaseSourceMap(await sourceMap.text()) : undefined,
+        deps: this.#emittedDeps(code),
+        mtimeMs: mtimes.get(file) ?? CsrDevPaths.mtimeOf(file),
+        hash: hashes.get(file) ?? ""
+      });
+    }
+    return { modules, misses, tangled };
+  }
+  #registryPlugin(vendor, misses) {
+    return {
+      name: "akan-csr-registry",
+      setup: (build) => {
+        build.onLoad({ filter: /\.css$/ }, () => ({ contents: "", loader: "js" }));
+        if (!vendor)
+          build.onLoad({ filter: /\.tsx$/ }, async (args) => {
+            if (CsrDevPaths.isVendorFile(args.path))
+              return;
+            const normalized = RouteClientBuilder.normalizeNamedDefaultFunctionForFastRefresh(await Bun.file(args.path).text());
+            return normalized ? { contents: normalized, loader: "tsx" } : undefined;
+          });
+        build.onResolve({ filter: /.*/ }, (args) => {
+          if (args.kind === "entry-point-build" || !args.importer)
+            return;
+          const importer = CsrDevPaths.realpath(args.importer);
+          const target = this.#resolver.resolve(importer, args.path);
+          if (target === CsrDevResolver.inline)
+            return;
+          if (target === null) {
+            misses.push(`${args.path} from ${this.#paths.idOf(importer)}`);
+            return { path: `akan-miss:${args.path}`, external: true };
+          }
+          const external = CsrDevPaths.isStub(target) ? target : `${CsrDevPaths.modulePrefix}${this.#paths.idOf(target)}`;
+          return { path: external, external: true };
+        });
+      }
+    };
+  }
+  #rebaseSourceMap(text) {
+    const map = JSON.parse(text);
+    const files = map.sources.map((source) => path12.resolve(source));
+    map.sources = files.map((file) => `/${this.#paths.idOf(file)}`);
+    map.sourcesContent = files.map((file, index) => CsrDevPaths.isVendorFile(file) ? null : map.sourcesContent?.[index] ?? null);
+    return JSON.stringify(map);
+  }
+  #emittedDeps(code) {
+    const deps = new Set;
+    const references = /\b(?:require|import|__akanImport)\("((?:akan-module|stub):[^"]+)"\)/g;
+    for (const [, reference] of code.matchAll(references)) {
+      if (!reference)
+        continue;
+      deps.add(CsrDevPaths.isStub(reference) ? reference : this.#paths.fileOf(reference.slice(CsrDevPaths.modulePrefix.length)));
+    }
+    return [...deps];
+  }
+  static #factory(id, code) {
+    const prefix = CsrDevPaths.modulePrefix;
+    let patched = code.replaceAll(`import("${prefix}`, `__akanImport("${prefix}`).replace(/^\/\/# debugId=.*$/m, "");
+    for (const [name, params, method] of CsrDevModuleCompiler.#helperPatches) {
+      const definition = `var ${name} = ${params} => {`;
+      if (patched.includes(definition))
+        patched = patched.replace(definition, `var ${name} = __akan.${method}, __bun${name} = ${params} => {`);
+      else if (patched.includes(`${name}(`))
+        throw new Error(`[csr-dev] ${id}: Bun's ${name} helper no longer reads "${definition}"; CsrDevModuleCompiler must follow`);
+    }
+    if (CsrDevModuleCompiler.#storeRoot.test(id))
+      patched += `
+module.hot.accept();`;
+    const shared = CsrDevModuleCompiler.#shareHelpers(patched);
+    return {
+      factory: `function (require, module, exports, $RefreshReg$, $RefreshSig$, __akanImport) {
+${shared?.code ?? patched}
+}`,
+      helpers: shared?.helpers ?? null
+    };
+  }
+  static #shareHelpers(code) {
+    const marker = code.search(/^\/\/ /m);
+    if (marker <= 0)
+      return null;
+    const preamble = code.slice(0, marker);
+    const names = [...preamble.matchAll(/^(?:var|let|const|function)\s+([\w$]+)/gm)].map(([, name]) => name).filter((name) => !!name);
+    if (names.length === 0 || CsrDevModuleCompiler.#factoryArgument.test(preamble))
+      return null;
+    const hash = Bun.hash(preamble).toString(36);
+    const binding = `var { ${names.join(", ")} } = __akan.helpers(${JSON.stringify(hash)});`;
+    return {
+      code: `${binding}${`
+`.repeat(CsrDevPaths.lineCount(preamble))}${code.slice(marker)}`,
+      helpers: {
+        hash,
+        definition: `__akan.defineHelpers(${JSON.stringify(hash)}, function () {
+${preamble}return { ${names.join(", ")} };
+});
+`
+      }
+    };
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/csrDevBundler.ts
+class CsrDevBundler {
+  static #formatVersion = 3;
+  #app;
+  #paths;
+  #outDir;
+  #entryDir;
+  #writer;
+  constructor(app) {
+    this.#app = app;
+    this.#paths = new CsrDevPaths(app.workspace.workspaceRoot);
+    this.#outDir = path13.join(app.cwdPath, ".akan/artifact", CSR_DEV_DIRNAME);
+    this.#entryDir = path13.join(app.cwdPath, ".akan/generated", CSR_DEV_DIRNAME);
+    this.#writer = new CsrDevArtifactWriter(this.#outDir);
+  }
+  async update(changedFiles = []) {
+    const context = await this.#context();
+    if (context.pageEntries.length === 0)
+      return null;
+    const manifest = await this.#writer.readJson(CSR_DEV_MANIFEST_FILE2);
+    const graph = await this.#writer.readJson("graph.json");
+    const generation = (manifest?.generation ?? 0) + 1;
+    if (!manifest || !graph || graph.version !== 1 || graph.configKey !== context.configKey)
+      return await this.#fullBuild(context, generation, manifest ? "the dev bundle config changed" : "first build");
+    const metadataFile = changedFiles.find(isAkanRuntimeMetadataFile);
+    if (metadataFile)
+      return await this.#fullBuild(context, generation, `${path13.basename(metadataFile)} changed`);
+    return await this.#incrementalBuild(context, graph, manifest, changedFiles, generation);
+  }
+  async#context() {
+    const akanConfig = await this.#app.getConfig();
+    const pageEntries = await resolveSsrPageEntriesForApp(this.#app, await this.#app.getPageKeys());
+    const basePaths = [...akanConfig.basePaths];
+    const htmlBasePaths = basePaths.length > 0 ? basePaths : [""];
+    const define = bundleDefine(this.#app, "start", "csr");
+    const optimizeImports = [...akanConfig.optimizeImports];
+    const configKey = Bun.hash(JSON.stringify([CsrDevBundler.#formatVersion, Bun.version, define, optimizeImports, htmlBasePaths])).toString(36);
+    return {
+      pageEntries,
+      basePaths,
+      htmlBasePaths,
+      define,
+      optimizeImports,
+      configKey,
+      refreshFile: this.#resolveRefreshRuntime()
+    };
+  }
+  #resolveRefreshRuntime() {
+    const akanWebkit = CsrDevPaths.tryResolve("akanjs/webkit", this.#app.cwdPath);
+    const bases = [
+      this.#app.cwdPath,
+      this.#paths.root,
+      ...akanWebkit ? [path13.dirname(path13.dirname(akanWebkit))] : []
+    ];
+    for (const base of bases) {
+      const resolved = CsrDevPaths.tryResolve("react-refresh/runtime", base);
+      if (resolved)
+        return CsrDevPaths.realpath(resolved);
+    }
+    throw new Error(`[csr-dev] react-refresh/runtime is not resolvable from ${bases.join(", ")}`);
+  }
+  async#fullBuild(context, generation, reason) {
+    await this.#writer.reset();
+    const entries = await this.#writeEntries(context);
+    const entryFiles = Object.values(entries.files);
+    const resolver = new CsrDevResolver({ paths: this.#paths, context, entryFiles });
+    await resolver.prepass();
+    const compiled = await this.#compiler(context, resolver).compile([...entryFiles, context.refreshFile], new Set);
+    const graph = {
+      version: 1,
+      configKey: context.configKey,
+      refresh: this.#paths.idOf(context.refreshFile),
+      entries: this.#entryIds(entries.files),
+      modules: {},
+      resolution: {},
+      pending: []
+    };
+    this.#merge(graph, resolver, compiled);
+    await this.#writer.writeModules(compiled);
+    const vendorFile = await this.#writer.writeVendor(graph);
+    await this.#writer.writeApp(graph, generation);
+    await this.#writer.writeState(graph, { version: 1, generation, vendorFile, entries: graph.entries });
+    await this.#writer.prune(vendorFile, generation);
+    return { generation, reload: true, reason, changedIds: [], moduleCount: Object.keys(graph.modules).length };
+  }
+  async#incrementalBuild(context, graph, manifest, changedFiles, generation) {
+    const entries = await this.#writeEntries(context);
+    const entryIds = this.#entryIds(entries.files);
+    await this.#forgetDeletedModules(graph);
+    const changed = await this.#changedModules(graph, changedFiles);
+    for (const file of entries.changed)
+      changed.add(this.#paths.idOf(file));
+    const routesMoved = entries.changed.length > 0 || JSON.stringify(entryIds) !== JSON.stringify(graph.entries);
+    if (changed.size === 0)
+      return null;
+    const resolver = new CsrDevResolver({
+      paths: this.#paths,
+      context,
+      entryFiles: Object.values(entries.files),
+      resolution: graph.resolution
+    });
+    const known = new Set(Object.keys(graph.modules).map((id) => this.#paths.fileOf(id)));
+    let compiled;
+    try {
+      compiled = await this.#compiler(context, resolver).compile([...changed].map((id) => this.#paths.fileOf(id)), known);
+    } catch (error) {
+      graph.pending = [...changed];
+      await this.#writer.writeJson("graph.json", graph);
+      throw error;
+    }
+    const vendorJoined = compiled.some((module) => module.vendor && !graph.modules[module.id]);
+    this.#merge(graph, resolver, compiled);
+    graph.entries = entryIds;
+    await this.#writer.writeModules(compiled);
+    const vendorFile = vendorJoined ? await this.#writer.writeVendor(graph) : manifest.vendorFile;
+    await this.#writer.writeApp(graph, generation);
+    const changedIds = compiled.filter((module) => !module.vendor).map((module) => module.id);
+    const constantId = changedIds.find((id) => id.endsWith(".constant.ts"));
+    const reason = vendorJoined ? "an npm module joined the graph" : routesMoved ? "the route table changed" : constantId ? `${path13.basename(constantId)} changed` : undefined;
+    const patchUrl = reason ? undefined : await this.#writer.writePatch(generation, compiled.filter((module) => !module.vendor));
+    await this.#writer.writeState(graph, { ...manifest, generation, vendorFile, entries: entryIds });
+    await this.#writer.prune(vendorFile, generation);
+    return {
+      generation,
+      reload: !!reason,
+      reason,
+      patchUrl,
+      changedIds,
+      moduleCount: Object.keys(graph.modules).length
+    };
+  }
+  async#changedModules(graph, changedFiles) {
+    const changed = new Set(graph.pending.filter((id) => graph.modules[id]));
+    for (const file of changedFiles) {
+      const id = this.#paths.idOf(file);
+      if (graph.modules[id])
+        changed.add(id);
+    }
+    for (const [id, module] of Object.entries(graph.modules)) {
+      if (module.vendor || changed.has(id))
+        continue;
+      const file = this.#paths.fileOf(id);
+      if (CsrDevPaths.mtimeOf(file) === module.mtimeMs)
+        continue;
+      if (await CsrDevPaths.hashOf(file) !== module.hash)
+        changed.add(id);
+    }
+    return changed;
+  }
+  async#forgetDeletedModules(graph) {
+    const deleted = Object.keys(graph.modules).filter((id) => !graph.modules[id]?.vendor && !fs3.existsSync(this.#paths.fileOf(id)));
+    for (const id of deleted)
+      delete graph.modules[id];
+    await this.#writer.forgetModules(deleted);
+  }
+  async#writeEntries(context) {
+    await mkdir3(this.#entryDir, { recursive: true });
+    const files = {};
+    const changed = [];
+    for (const basePath of context.htmlBasePaths) {
+      const file = path13.join(this.#entryDir, CsrArtifactBuilder.entryFilename(basePath));
+      const entryPages = CsrArtifactBuilder.pageEntriesForBasePath(context.pageEntries, basePath, context.basePaths);
+      const generator = new PagesEntrySourceGenerator(entryPages);
+      const pages = await generator.generateStatic({ fromDir: this.#entryDir });
+      const hot = await generator.generateHotReplace({
+        fromDir: this.#entryDir,
+        ownerId: this.#paths.idOf(file),
+        moduleIds: entryPages.map(({ moduleAbsPath }) => this.#paths.idOf(moduleAbsPath))
+      });
+      const source = `import * as akanWebkit from "akanjs/webkit";
+${pages}
+void akanWebkit.bootCsr(pages);
+${hot}`;
+      const unchanged = await Bun.file(file).exists() && await Bun.file(file).text() === source;
+      if (!unchanged)
+        await Bun.write(file, source);
+      const entryFile = CsrDevPaths.realpath(file);
+      files[basePath] = entryFile;
+      if (!unchanged)
+        changed.push(entryFile);
+    }
+    return { files, changed };
+  }
+  #compiler(context, resolver) {
+    return new CsrDevModuleCompiler({ app: this.#app, paths: this.#paths, resolver, context, outDir: this.#outDir });
+  }
+  #merge(graph, resolver, compiled) {
+    for (const module of compiled)
+      graph.modules[module.id] = {
+        vendor: module.vendor,
+        mtimeMs: module.mtimeMs,
+        hash: module.hash,
+        deps: module.deps.map((dep) => CsrDevPaths.isStub(dep) ? dep : this.#paths.idOf(dep)),
+        ...module.helpers ? { helpers: module.helpers.hash } : {}
+      };
+    graph.pending = [];
+    graph.resolution = resolver.serialize();
+  }
+  #entryIds(files) {
+    return Object.fromEntries(Object.entries(files).map(([basePath, file]) => [basePath, this.#paths.idOf(file)]));
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/fontOptimizer.ts
+import { mkdir as mkdir4, stat as stat2 } from "fs/promises";
+import path14 from "path";
 import ts from "typescript";
 var FONT_URL_PREFIX = "/_akan/fonts";
 var DEFAULT_FONT_SUBSETS = ["latin"];
@@ -1263,7 +2060,7 @@ class FontOptimizer {
   constructor(app, command = "start") {
     this.#app = app;
     this.#command = command;
-    this.#artifactRoot = path9.join(command === "build" ? app.dist.cwdPath : app.cwdPath, ".akan/artifact");
+    this.#artifactRoot = path14.join(command === "build" ? app.dist.cwdPath : app.cwdPath, ".akan/artifact");
   }
   async optimize() {
     const fonts = await this.discoverFonts();
@@ -1288,7 +2085,7 @@ class FontOptimizer {
     return result;
   }
   get #cachePath() {
-    return path9.join(this.#artifactRoot, "fontCache.json");
+    return path14.join(this.#artifactRoot, "fontCache.json");
   }
   async#buildCacheKey(fonts) {
     const sources = [];
@@ -1303,7 +2100,7 @@ class FontOptimizer {
         sources.push({ optimizedSrc: face.optimizedSrc, ...stamp });
       }
       for (const filePath of font.subsetFiles ?? []) {
-        const abs = path9.isAbsolute(filePath) ? filePath : path9.join(this.#app.cwdPath, filePath);
+        const abs = path14.isAbsolute(filePath) ? filePath : path14.join(this.#app.cwdPath, filePath);
         const stamp = await this.#fileStamp(abs);
         if (!stamp)
           return null;
@@ -1329,7 +2126,7 @@ class FontOptimizer {
     const cache = await Bun.file(this.#cachePath).json().catch(() => null);
     if (cache?.version !== FontOptimizer.#cacheVersion || cache.key !== key)
       return null;
-    const files = cache.files.map((relativePath) => path9.join(this.#artifactRoot, relativePath));
+    const files = cache.files.map((relativePath) => path14.join(this.#artifactRoot, relativePath));
     for (const filePath of files) {
       if (!await Bun.file(filePath).exists())
         return null;
@@ -1341,7 +2138,7 @@ class FontOptimizer {
       version: FontOptimizer.#cacheVersion,
       key,
       css: result.css,
-      files: result.files.map((filePath) => path9.relative(this.#artifactRoot, filePath))
+      files: result.files.map((filePath) => path14.relative(this.#artifactRoot, filePath))
     };
     await Bun.write(this.#cachePath, JSON.stringify(cache));
   }
@@ -1349,7 +2146,7 @@ class FontOptimizer {
     const pageKeys = await this.#app.getPageKeys();
     const fonts = [];
     await Promise.all(pageKeys.map(async (key) => {
-      const filePath = path9.resolve(this.#app.cwdPath, "page", key);
+      const filePath = path14.resolve(this.#app.cwdPath, "page", key);
       const file = Bun.file(filePath);
       if (!await file.exists())
         return;
@@ -1368,8 +2165,8 @@ class FontOptimizer {
         this.#app.logger.warn(`[font] source not found: ${face.src}`);
         continue;
       }
-      const outputPath = path9.join(this.#artifactRoot, face.optimizedSrc.replace(/^\/_akan\//, ""));
-      await mkdir2(path9.dirname(outputPath), { recursive: true });
+      const outputPath = path14.join(this.#artifactRoot, face.optimizedSrc.replace(/^\/_akan\//, ""));
+      await mkdir4(path14.dirname(outputPath), { recursive: true });
       const sourceBuffer = Buffer.from(await Bun.file(sourcePath).arrayBuffer());
       const outputBuffer = await this.#buildFontBuffer(font, sourceBuffer, sourcePath);
       await Bun.write(outputPath, outputBuffer);
@@ -1391,7 +2188,7 @@ class FontOptimizer {
     const entries = Array.isArray(value) ? value : [];
     const fonts = entries.filter((entry) => this.#isReadableFont(entry));
     if (fonts.length !== entries.length || !Array.isArray(value))
-      this.#app.logger.warn(`[font] ${path9.relative(this.#app.cwdPath, filePath)} declares fonts the build cannot read without evaluating the module \u2014 write the list inline, or nothing is subset for it and every /_akan/fonts request 404s`);
+      this.#app.logger.warn(`[font] ${path14.relative(this.#app.cwdPath, filePath)} declares fonts the build cannot read without evaluating the module \u2014 write the list inline, or nothing is subset for it and every /_akan/fonts request 404s`);
     return fonts.map((font) => ({ ...font, subsets: font.subsets ?? [...DEFAULT_FONT_SUBSETS] }));
   }
   #isReadableFont(value) {
@@ -1549,8 +2346,8 @@ class FontOptimizer {
       return null;
     const rel = src.replace(/^\//, "");
     const candidates = [
-      this.#command === "build" ? path9.join(this.#app.dist.cwdPath, "public", rel) : null,
-      path9.join(this.#app.cwdPath, "public", rel),
+      this.#command === "build" ? path14.join(this.#app.dist.cwdPath, "public", rel) : null,
+      path14.join(this.#app.cwdPath, "public", rel),
       this.#resolveWorkspacePublicPath(rel)
     ].filter(Boolean);
     for (const candidate of candidates) {
@@ -1582,7 +2379,7 @@ class FontOptimizer {
       return "woff2";
     if (signature === "OTTO")
       return "otf";
-    const ext = path9.extname(sourcePath).slice(1).toLowerCase();
+    const ext = path14.extname(sourcePath).slice(1).toLowerCase();
     if (ext === "otf" || ext === "woff" || ext === "woff2")
       return ext;
     return "ttf";
@@ -1591,7 +2388,7 @@ class FontOptimizer {
     const [root, dep, ...rest] = rel.split("/");
     if (root !== "libs" || !dep || rest.length === 0)
       return null;
-    return path9.join(this.#app.workspace.workspaceRoot, "libs", dep, "public", ...rest);
+    return path14.join(this.#app.workspace.workspaceRoot, "libs", dep, "public", ...rest);
   }
   async#getSubsetText(font) {
     const parts = new Set;
@@ -1601,7 +2398,7 @@ class FontOptimizer {
     if (font.subsetText)
       parts.add(font.subsetText);
     for (const filePath of font.subsetFiles ?? []) {
-      const abs = path9.isAbsolute(filePath) ? filePath : path9.join(this.#app.cwdPath, filePath);
+      const abs = path14.isAbsolute(filePath) ? filePath : path14.join(this.#app.cwdPath, filePath);
       const file = Bun.file(abs);
       if (await file.exists())
         parts.add(await file.text());
@@ -1621,7 +2418,7 @@ class FontOptimizer {
   }
   async#collectAutoSubsetText() {
     const libPageRoots = (await this.#app.getPageRoots()).filter((root) => root.keyPrefix).map((root) => root.dir);
-    const roots = [...["page", "ui", "lib"].map((dir) => path9.join(this.#app.cwdPath, dir)), ...libPageRoots];
+    const roots = [...["page", "ui", "lib"].map((dir) => path14.join(this.#app.cwdPath, dir)), ...libPageRoots];
     const glob = new Bun.Glob("**/*.{ts,tsx,js,jsx,html,md}");
     const parts = [];
     for (const root of [...new Set(roots)].sort()) {
@@ -1734,8 +2531,8 @@ ${declarations.map(([prop, value]) => `  ${prop}: ${value};`).join(`
 }
 
 // pkgs/@akanjs/devkit/frontendBuild/fontPruner.ts
-import { rm as rm2, rmdir, stat as stat3 } from "fs/promises";
-import path10 from "path";
+import { rm as rm3, rmdir, stat as stat3 } from "fs/promises";
+import path15 from "path";
 import { isFontOptimizationEnabled } from "akanjs/client";
 var FONT_GLOB = "**/*.{woff2,woff,ttf,otf,ttc,eot}";
 var REFERRER_GLOB = "**/*.{css,js,mjs,cjs,json,html,htm,svg,xml,webmanifest}";
@@ -1748,8 +2545,8 @@ class FontPruner {
   constructor(app, { keepFonts = [] } = {}) {
     this.#app = app;
     this.#keepGlobs = keepFonts;
-    this.#publicRoot = path10.join(app.dist.cwdPath, "public");
-    this.#artifactRoot = path10.join(app.dist.cwdPath, ".akan/artifact");
+    this.#publicRoot = path15.join(app.dist.cwdPath, "public");
+    this.#artifactRoot = path15.join(app.dist.cwdPath, ".akan/artifact");
   }
   async prune() {
     const empty = { removed: [], kept: [], freedBytes: 0 };
@@ -1764,7 +2561,7 @@ class FontPruner {
     for (const font of fonts) {
       const target = isFontOptimizationEnabled(font) ? optimizedSrcs : unoptimizedSrcs;
       for (const fontPath of font.paths)
-        target.add(path10.posix.basename(fontPath.src));
+        target.add(path15.posix.basename(fontPath.src));
     }
     const result = { removed: [], kept: [], freedBytes: 0 };
     const undecided = [];
@@ -1802,10 +2599,10 @@ class FontPruner {
   async#collectCandidates() {
     const candidates = [];
     for await (const rel of new Bun.Glob(FONT_GLOB).scan({ cwd: this.#publicRoot, dot: false })) {
-      const entry = await stat3(path10.join(this.#publicRoot, rel)).catch(() => null);
+      const entry = await stat3(path15.join(this.#publicRoot, rel)).catch(() => null);
       if (!entry?.isFile())
         continue;
-      candidates.push({ rel: rel.split(path10.sep).join("/"), basename: path10.basename(rel), bytes: entry.size });
+      candidates.push({ rel: rel.split(path15.sep).join("/"), basename: path15.basename(rel), bytes: entry.size });
     }
     return candidates;
   }
@@ -1815,11 +2612,11 @@ class FontPruner {
     const bundled = candidates.filter((candidate) => !optimizedSrcs.has(candidate.basename));
     const roots = [
       { dir: this.#publicRoot, label: "public", needles: authoritative },
-      { dir: path10.join(this.#artifactRoot, "styles"), label: ".akan/artifact/styles", needles: authoritative },
-      { dir: path10.join(this.#artifactRoot, "client"), label: ".akan/artifact/client", needles: bundled },
-      { dir: path10.join(this.#artifactRoot, "client-ssr"), label: ".akan/artifact/client-ssr", needles: bundled },
-      { dir: path10.join(this.#artifactRoot, "server"), label: ".akan/artifact/server", needles: bundled },
-      { dir: path10.join(this.#app.dist.cwdPath, "csr"), label: "csr", needles: bundled }
+      { dir: path15.join(this.#artifactRoot, "styles"), label: ".akan/artifact/styles", needles: authoritative },
+      { dir: path15.join(this.#artifactRoot, "client"), label: ".akan/artifact/client", needles: bundled },
+      { dir: path15.join(this.#artifactRoot, "client-ssr"), label: ".akan/artifact/client-ssr", needles: bundled },
+      { dir: path15.join(this.#artifactRoot, "server"), label: ".akan/artifact/server", needles: bundled },
+      { dir: path15.join(this.#app.dist.cwdPath, "csr"), label: "csr", needles: bundled }
     ];
     for (const root of roots) {
       const pending = root.needles.filter((candidate) => !referrers.has(candidate.rel));
@@ -1838,20 +2635,20 @@ class FontPruner {
       const remaining = needles.filter((needle) => !referrers.has(needle.rel));
       if (!remaining.length)
         return;
-      const text = await Bun.file(path10.join(root.dir, rel)).text().catch(() => "");
+      const text = await Bun.file(path15.join(root.dir, rel)).text().catch(() => "");
       if (!text)
         continue;
       for (const needle of remaining) {
         if (needle.forms.some((form) => text.includes(form)))
-          referrers.set(needle.rel, `${root.label}/${rel.split(path10.sep).join("/")}`);
+          referrers.set(needle.rel, `${root.label}/${rel.split(path15.sep).join("/")}`);
       }
     }
   }
   async#remove(files) {
-    await Promise.all(files.map((file) => rm2(path10.join(this.#publicRoot, file), { force: true })));
-    const dirs = [...new Set(files.map((file) => path10.posix.dirname(file)))].filter((dir) => dir !== "." && dir !== "/").sort((a, b) => b.length - a.length);
+    await Promise.all(files.map((file) => rm3(path15.join(this.#publicRoot, file), { force: true })));
+    const dirs = [...new Set(files.map((file) => path15.posix.dirname(file)))].filter((dir) => dir !== "." && dir !== "/").sort((a, b) => b.length - a.length);
     for (const dir of dirs)
-      await rmdir(path10.join(this.#publicRoot, dir)).catch(() => {
+      await rmdir(path15.join(this.#publicRoot, dir)).catch(() => {
         return;
       });
   }
@@ -1898,8 +2695,8 @@ class FontPruner {
 }
 
 // pkgs/@akanjs/devkit/frontendBuild/precompressArtifacts.ts
-import fs from "fs";
-import path11 from "path";
+import fs4 from "fs";
+import path16 from "path";
 import zlib from "zlib";
 var COMPRESSIBLE_EXTS = new Set([".css", ".html", ".js", ".json", ".svg"]);
 var MIN_COMPRESS_BYTES = 1024;
@@ -1909,8 +2706,8 @@ var GZIP_LEVEL = 9;
 var { formatBytes } = FontPruner;
 async function precompressArtifacts(app) {
   const roots = [
-    path11.join(app.dist.cwdPath, ".akan/artifact/client"),
-    path11.join(app.dist.cwdPath, ".akan/artifact/styles")
+    path16.join(app.dist.cwdPath, ".akan/artifact/client"),
+    path16.join(app.dist.cwdPath, ".akan/artifact/styles")
   ];
   const result = { files: 0, inputBytes: 0, outputBytes: 0, brotliBytes: 0 };
   await Promise.all(roots.map((root) => precompressRoot(root, result)));
@@ -1920,7 +2717,7 @@ async function precompressArtifacts(app) {
   return result;
 }
 async function precompressRoot(root, result) {
-  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory())
+  if (!fs4.existsSync(root) || !fs4.statSync(root).isDirectory())
     return;
   const glob = new Bun.Glob("**/*");
   for await (const filePath of glob.scan({ cwd: root, absolute: true })) {
@@ -1929,7 +2726,7 @@ async function precompressRoot(root, result) {
     const bytes = await Bun.file(filePath).bytes();
     const buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
     const gz = Bun.gzipSync(buffer, { level: GZIP_LEVEL });
-    const br = brotliCompress(buffer, path11.extname(filePath).toLowerCase());
+    const br = brotliCompress(buffer, path16.extname(filePath).toLowerCase());
     await Promise.all([Bun.write(`${filePath}.gz`, gz), Bun.write(`${filePath}.br`, br)]);
     result.files += 1;
     result.inputBytes += bytes.byteLength;
@@ -1949,7 +2746,7 @@ function brotliCompress(buffer, ext) {
 async function shouldPrecompress(filePath) {
   if (filePath.endsWith(".gz") || filePath.endsWith(".br"))
     return false;
-  if (!COMPRESSIBLE_EXTS.has(path11.extname(filePath).toLowerCase()))
+  if (!COMPRESSIBLE_EXTS.has(path16.extname(filePath).toLowerCase()))
     return false;
   const file = Bun.file(filePath);
   if (!await file.exists())
@@ -1958,7 +2755,7 @@ async function shouldPrecompress(filePath) {
 }
 
 // pkgs/@akanjs/devkit/frontendBuild/ssrBaseArtifactBuilder.ts
-import path12 from "path";
+import path17 from "path";
 import { optimize } from "@tailwindcss/node";
 function prepareCssAsset(command, basePath, cssText) {
   return optimize(cssText, { file: `${basePath || "root"}.css`, minify: command === "build" }).code;
@@ -1974,7 +2771,10 @@ class SsrBaseArtifactBuilder {
     this.#app = app;
     this.#command = command;
     this.#artifactDir = `${command === "build" ? app.dist.cwdPath : app.cwdPath}/.akan/artifact`;
-    this.#absArtifactDir = path12.resolve(this.#artifactDir);
+    this.#absArtifactDir = path17.resolve(this.#artifactDir);
+  }
+  static servedWeb(command, web) {
+    return command === "start" ? { ssr: true, csr: true } : web;
   }
   async build() {
     const akanConfig = await this.#app.getConfig();
@@ -1996,7 +2796,7 @@ class SsrBaseArtifactBuilder {
       rscRuntimeSsrManifest,
       vendorMap,
       cssAssets,
-      pagesBundlePath: this.#command === "build" ? path12.relative(this.#absArtifactDir, pagesBundle.bundlePath) : pagesBundle.bundlePath,
+      pagesBundlePath: this.#command === "build" ? path17.relative(this.#absArtifactDir, pagesBundle.bundlePath) : pagesBundle.bundlePath,
       pagesBundleBuildId: pagesBundle.buildId,
       domains: [...akanConfig.domains],
       subRoutes: Object.fromEntries(Array.from(akanConfig.subRoutes.entries()).map(([basePath, domains]) => [basePath, [...domains]])),
@@ -2004,7 +2804,7 @@ class SsrBaseArtifactBuilder {
       branches: [...akanConfig.branches],
       i18n: akanConfig.i18n,
       imageConfig: akanConfig.images,
-      web: akanConfig.web,
+      web: SsrBaseArtifactBuilder.servedWeb(this.#command, akanConfig.web),
       deepLinkAssociations: Object.values(akanConfig.mobile.targets).filter((target) => (target.deepLinks?.domains?.length ?? 0) > 0).map((target) => ({
         targetName: target.name,
         appId: target.appId,
@@ -2013,18 +2813,18 @@ class SsrBaseArtifactBuilder {
         androidSha256CertFingerprints: target.deepLinks?.android?.sha256CertFingerprints
       }))
     };
-    await Bun.write(path12.join(this.#absArtifactDir, "base-artifact.json"), `${JSON.stringify(artifact, null, 2)}
+    await Bun.write(path17.join(this.#absArtifactDir, "base-artifact.json"), `${JSON.stringify(artifact, null, 2)}
 `);
     this.#app.verbose(`[base-artifact] complete in ${Date.now() - this.#started}ms`);
     return { artifact, seedIndex, cssCompiler, optimizedFonts };
   }
   async#buildRuntimeClientEntries() {
     const akanServerPath = await this.#resolveAkanServerPath();
-    const rscClientEntry = path12.resolve(akanServerPath, "rscClient.tsx");
-    const rscSegmentOutletEntry = path12.resolve(akanServerPath, "rscSegmentOutlet.tsx");
+    const rscClientEntry = path17.resolve(akanServerPath, "rscClient.tsx");
+    const rscSegmentOutletEntry = path17.resolve(akanServerPath, "rscSegmentOutlet.tsx");
     const vendorEntries = VENDOR_SPECIFIERS.map((specifier) => ({
       specifier,
-      absPath: path12.resolve(akanServerPath, "vendor", `${specifier.replaceAll("/", "-").replaceAll(".", "-")}.ts`)
+      absPath: path17.resolve(akanServerPath, "vendor", `${specifier.replaceAll("/", "-").replaceAll(".", "-")}.ts`)
     }));
     const entries = [rscClientEntry, rscSegmentOutletEntry, ...vendorEntries.map((v) => v.absPath)];
     const clientBundle = await new ClientEntriesBundler({ app: this.#app, entries, command: this.#command }).bundle();
@@ -2061,15 +2861,15 @@ class SsrBaseArtifactBuilder {
   async#resolveAkanServerPath() {
     const candidates = [];
     try {
-      candidates.push(path12.dirname(Bun.resolveSync("akanjs/server", this.#app.workspace.workspaceRoot)));
+      candidates.push(path17.dirname(Bun.resolveSync("akanjs/server", this.#app.workspace.workspaceRoot)));
     } catch {}
-    candidates.push(path12.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server"), path12.join(this.#app.workspace.workspaceRoot, "node_modules/akanjs/server"));
+    candidates.push(path17.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server"), path17.join(this.#app.workspace.workspaceRoot, "node_modules/akanjs/server"));
     try {
-      candidates.push(path12.dirname(Bun.resolveSync("akanjs/server", path12.dirname(Bun.main))));
+      candidates.push(path17.dirname(Bun.resolveSync("akanjs/server", path17.dirname(Bun.main))));
     } catch {}
-    candidates.push(path12.join(path12.dirname(Bun.main), "node_modules/akanjs/server"), path12.join(path12.dirname(Bun.main), "../../akanjs/server"), path12.resolve(import.meta.dir, "../../server"), path12.resolve(import.meta.dir, "../server"));
+    candidates.push(path17.join(path17.dirname(Bun.main), "node_modules/akanjs/server"), path17.join(path17.dirname(Bun.main), "../../akanjs/server"), path17.resolve(import.meta.dir, "../../server"), path17.resolve(import.meta.dir, "../server"));
     for (const candidate of candidates) {
-      if (await Bun.file(path12.join(candidate, "rscClient.tsx")).exists())
+      if (await Bun.file(path17.join(candidate, "rscClient.tsx")).exists())
         return candidate;
     }
     throw new Error(`[base-artifact] failed to locate akanjs/server; looked in: ${candidates.join(", ")}`);
@@ -2098,7 +2898,7 @@ ${preparedCssText}`).toString(36);
       `styles/${cssAssetName}-${cssHash}.css`,
       `/_akan/styles/${cssAssetName}-${cssHash}.css`
     ];
-    await Bun.write(path12.join(this.#absArtifactDir, cssRelPath), preparedCssText);
+    await Bun.write(path17.join(this.#absArtifactDir, cssRelPath), preparedCssText);
     SsrBaseArtifactBuilder.#warnDroppedImports(this.#app, cssRelPath, preparedCssText, imported);
     this.#app.verbose(`[base-artifact] wrote ${preparedCssText.length} bytes of CSS for ${basePath} -> ${cssRelPath}`);
     return [basePath, { cssUrl, cssRelPath }];
@@ -2111,4 +2911,4 @@ ${preparedCssText}`).toString(36);
     }
   }
 }
-export { computeRouteSeedIndex, saveRouteSeedIndex, AllRoutesBuilder, CssCompiler, PagesBundleBuilder, CsrArtifactBuilder, FontOptimizer, FontPruner, precompressArtifacts, SsrBaseArtifactBuilder };
+export { computeRouteSeedIndex, saveRouteSeedIndex, AllRoutesBuilder, CssCompiler, PagesBundleBuilder, CsrArtifactBuilder, CsrDevBundler, FontOptimizer, FontPruner, precompressArtifacts, SsrBaseArtifactBuilder };