@akanjs/cli 3.1.0-rc.0 → 3.1.0-rc.2

package/index-nq045px5.js

@@ -0,0 +1,1124 @@
+// @bun
+import {
+  FileSys2
+} from "./index-52w0fvh8.js";
+import {
+  AsyncDefaultExportDetector,
+  resolveSsrPageEntriesForApp
+} from "./index-2etqq75t.js";
+
+// pkgs/@akanjs/devkit/frontendBuild/serverGraphFile.ts
+import fs2 from "fs";
+import path3 from "path";
+
+// pkgs/@akanjs/devkit/transforms/rscUseClientTransform.ts
+import path from "path";
+import ts from "typescript";
+
+// pkgs/@akanjs/devkit/transforms/moduleSyntax.ts
+var loaderFor = (absPath) => {
+  if (absPath.endsWith(".tsx"))
+    return "tsx";
+  if (absPath.endsWith(".jsx"))
+    return "jsx";
+  if (absPath.endsWith(".ts"))
+    return "ts";
+  return "js";
+};
+var parseNamedList = (listBody) => {
+  const out = [];
+  for (const raw of listBody.split(",")) {
+    let rest = raw.trim();
+    if (!rest)
+      continue;
+    let isType = false;
+    if (rest.startsWith("type ")) {
+      isType = true;
+      rest = rest.slice(5).trim();
+    }
+    const asMatch = /^(\w+)\s+as\s+(\w+)$/.exec(rest);
+    if (asMatch) {
+      out.push({ imported: asMatch[1] ?? "", local: asMatch[2] ?? "", isType });
+      continue;
+    }
+    if (/^\w+$/.test(rest))
+      out.push({ imported: rest, local: rest, isType });
+  }
+  return out;
+};
+
+// pkgs/@akanjs/devkit/transforms/rscUseClientTransform.ts
+var USE_CLIENT_RE = /^\s*(?:\/\*[\s\S]*?\*\/\s*|\/\/[^\n]*\n\s*)*["']use client["']/;
+var IMPLICIT_ROOT_LAYOUT_RE = /[/\\]\.akan[/\\]generated[/\\](?:implicit-root-layout|root-layouts[/\\].*__root_layout)\.(tsx|ts|jsx|js)$/;
+var STAR_REEXPORT_HINT_RE = /\bexport\s*\*\s*from\b/;
+var hasUseClientDirective = (source) => USE_CLIENT_RE.test(source);
+function toClientReferencePath(absPath, workspaceRoot) {
+  return path.relative(path.resolve(workspaceRoot), path.resolve(absPath)).split(path.sep).join("/");
+}
+var starReexportSpecifiers = (source, filePath) => ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest).statements.filter((statement) => ts.isExportDeclaration(statement) && !statement.exportClause && !statement.isTypeOnly && !!statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)).map((statement) => statement.moduleSpecifier.text);
+var scanUseClientExports = (source, filePath, workspaceRoot) => {
+  const stars = USE_CLIENT_RE.test(source) && STAR_REEXPORT_HINT_RE.test(source) ? starReexportSpecifiers(source, filePath) : [];
+  if (stars.length) {
+    const file = workspaceRoot ? toClientReferencePath(filePath, workspaceRoot) : filePath;
+    const listed = stars.slice(0, 3).map((specifier) => `\`export * from ${JSON.stringify(specifier)}\``);
+    const written = stars.length > 3 ? `${listed.join(", ")} (and ${stars.length - 3} more)` : listed.join(", ");
+    throw new Error(`${file} is a "use client" module, so it cannot ${written}: the server sees only the names a client module ` + `declares, and a star re-export declares none. Re-export them by name \u2014 \`export { \u2026 } from ${JSON.stringify(stars[0])}\`.`);
+  }
+  return new Bun.Transpiler({ loader: loaderFor(filePath) }).scan(source).exports;
+};
+function transformUseClient(source, args) {
+  if (!USE_CLIENT_RE.test(source))
+    return null;
+  if (IMPLICIT_ROOT_LAYOUT_RE.test(args.path))
+    return null;
+  const exports = scanUseClientExports(source, args.path, args.workspaceRoot);
+  if (exports.length === 0)
+    return null;
+  args.onClientModule?.(args.path, exports);
+  const referencePath = args.workspaceRoot ? toClientReferencePath(args.path, args.workspaceRoot) : args.path;
+  const filePathLit = JSON.stringify(referencePath);
+  const lines = [`import { registerClientReference } from "react-server-dom-webpack/server.node";`];
+  for (const name of exports) {
+    const nameLit = JSON.stringify(name);
+    const errMsg = JSON.stringify(`Attempted to call '${name}' from '${referencePath}' on the server, but it is a client-only export.`);
+    const proxy = `() => { throw new Error(${errMsg}); }`;
+    const binding = name === "default" ? `export default registerClientReference(${proxy}, ${filePathLit}, ${nameLit});` : `export const ${name} = registerClientReference(${proxy}, ${filePathLit}, ${nameLit});`;
+    lines.push(binding);
+  }
+  return lines.join(`
+`);
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/csrDevPaths.ts
+import fs from "fs";
+import path2 from "path";
+
+class CsrDevPaths {
+  static modulePrefix = "akan-module:";
+  static stubPrefix = "stub:";
+  static emptyStubPrefix = "stub:empty:";
+  static vendorPrefix = "vendor:";
+  root;
+  constructor(workspaceRoot) {
+    this.root = CsrDevPaths.realpath(workspaceRoot);
+  }
+  idOf(file) {
+    const real = CsrDevPaths.realpath(file);
+    const relative = path2.relative(this.root, real);
+    const id = relative.startsWith("..") || path2.isAbsolute(relative) ? real : relative;
+    return id.split(path2.sep).join("/");
+  }
+  fileOf(id) {
+    return path2.isAbsolute(id) ? id : path2.join(this.root, id);
+  }
+  static isStub(target) {
+    return target.startsWith(CsrDevPaths.stubPrefix);
+  }
+  static isVendorFile(file) {
+    return file.includes(`${path2.sep}node_modules${path2.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.native(file) : path2.resolve(file);
+  }
+  static isNamed(file) {
+    try {
+      return fs.realpathSync.native(file) === file;
+    } catch {
+      return false;
+    }
+  }
+  static #extensions = {
+    import: [".tsx", ".jsx", ".mts", ".ts", ".mjs", ".js", ".cts", ".cjs"],
+    require: [".tsx", ".ts", ".jsx", ".cts", ".cjs", ".js", ".mjs", ".mts"]
+  };
+  static resolveOnDisk(base, kind = "import") {
+    return CsrDevPaths.#asFile(base, kind) ?? CsrDevPaths.#asFolder(base, kind);
+  }
+  static resolveRelative(dir, specifier, kind = "import") {
+    const base = path2.resolve(dir, specifier);
+    const folder = /(^|[\\/])\.\.?$|[\\/]$/.test(specifier);
+    return folder ? CsrDevPaths.#asFolder(base, kind) : CsrDevPaths.resolveOnDisk(base, kind);
+  }
+  static #asFile(base, kind) {
+    const isFile = (candidate) => fs.statSync(candidate, { throwIfNoEntry: false })?.isFile() ?? false;
+    return [base, ...CsrDevPaths.#extensions[kind].map((extension) => `${base}${extension}`)].find(isFile) ?? null;
+  }
+  static #asFolder(dir, kind) {
+    const entry = CsrDevPaths.#packageEntryOf(dir, kind);
+    const named = entry ? CsrDevPaths.#asFile(path2.join(dir, entry), kind) ?? CsrDevPaths.#indexOf(path2.join(dir, entry), kind) : null;
+    return named ?? CsrDevPaths.#indexOf(dir, kind);
+  }
+  static #indexOf(dir, kind) {
+    return CsrDevPaths.#asFile(path2.join(dir, "index"), kind);
+  }
+  static #packageEntryOf(dir, kind) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path2.join(dir, "package.json"), "utf8"));
+      const fields = kind === "require" ? [pkg.browser, pkg.main] : [pkg.browser, pkg.module, pkg.main];
+      const entry = fields.find((field) => typeof field === "string");
+      return typeof entry === "string" ? entry : null;
+    } catch {
+      return null;
+    }
+  }
+  static installedSince(specifier, from, since) {
+    const [first = "", second = ""] = specifier.split("/");
+    const name = first.startsWith("@") ? `${first}/${second}` : first;
+    if (!name || name.startsWith("."))
+      return false;
+    for (let dir = path2.resolve(from);; dir = path2.dirname(dir)) {
+      const pkgDir = path2.join(dir, "node_modules", name);
+      if (fs.existsSync(path2.join(pkgDir, "package.json")))
+        return (fs.statSync(pkgDir, { throwIfNoEntry: false })?.ctimeMs ?? 0) > since;
+      if (path2.dirname(dir) === dir)
+        return false;
+    }
+  }
+  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/serverGraphFile.ts
+class ServerGraphFile {
+  static fileName = "server-graph.json";
+  static #cache = null;
+  static async read(artifactDir) {
+    const file = path3.join(artifactDir, ServerGraphFile.fileName);
+    const stat = fs2.statSync(file, { throwIfNoEntry: false });
+    if (!stat)
+      return null;
+    const stamp = `${stat.ino}:${stat.size}:${stat.mtimeMs}`;
+    const cached = ServerGraphFile.#cache;
+    if (cached?.file === file && cached.stamp === stamp)
+      return cached.graph;
+    const graph = await Bun.file(file).json().catch(() => null);
+    if (graph)
+      ServerGraphFile.#cache = { file, stamp, graph };
+    return graph;
+  }
+  static async write(artifactDir, graph) {
+    const file = path3.join(artifactDir, ServerGraphFile.fileName);
+    const temp = `${file}.${process.pid}.tmp`;
+    await Bun.write(temp, JSON.stringify(graph));
+    await FileSys2.replace(temp, file);
+  }
+  static async carry(artifactDir, files) {
+    const graph = await ServerGraphFile.read(artifactDir);
+    if (!graph || files.length === 0)
+      return;
+    const carried = [...new Set([...graph.carried ?? [], ...files.map((file) => CsrDevPaths.realpath(file))])];
+    await ServerGraphFile.write(artifactDir, { ...graph, carried });
+  }
+  static async touches(graph, files, exportsNow, next) {
+    if (!graph)
+      return true;
+    const inputs = new Set(graph.inputs);
+    const joined = new Set((next?.inputs ?? []).filter((input) => !inputs.has(input)));
+    for (const rawFile of files) {
+      const file = CsrDevPaths.realpath(rawFile);
+      if (joined.has(file))
+        return true;
+      if (!inputs.has(file))
+        continue;
+      const before = graph.clientExports[file];
+      if (!before)
+        return true;
+      const now = await exportsNow(file);
+      if (!now || ServerGraphFile.#names(now) !== ServerGraphFile.#names(before))
+        return true;
+    }
+    return false;
+  }
+  static async clientExportsOf(file) {
+    const source = await Bun.file(file).text().catch(() => null);
+    if (source === null || !hasUseClientDirective(source))
+      return null;
+    try {
+      return scanUseClientExports(source, file);
+    } catch {
+      return null;
+    }
+  }
+  static #names(exports) {
+    return [...exports].sort().join(",");
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/pagesBundleBuilder.ts
+import fs3 from "fs";
+import path8 from "path";
+
+// pkgs/@akanjs/devkit/transforms/barrelImportsPlugin.ts
+import path5 from "path";
+import ts2 from "typescript";
+
+// pkgs/@akanjs/devkit/transforms/barrelAnalyzer.ts
+import path4 from "path";
+import { Logger } from "akanjs/common";
+var REEXPORT_RE = /(?:^|\n)\s*export\s+(?:type\s+)?(?:(\*)(?:\s+as\s+(\w+))?|\{\s*([^}]*?)\s*\})\s+from\s+(["'])([^"']+)\4;?/g;
+var LOCAL_NAMED_RE = /(?:^|\n)\s*export\s+\{\s*([^}]*?)\s*\}(?!\s*from)/g;
+var CANDIDATE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+
+class BarrelAnalyzer {
+  #logger = new Logger("BarrelAnalyzer");
+  #opts;
+  #cache = new Map;
+  #tsTranspiler = new Bun.Transpiler({ loader: "ts" });
+  #tsxTranspiler = new Bun.Transpiler({ loader: "tsx" });
+  constructor(opts) {
+    this.#opts = opts;
+  }
+  analyze(pkgName) {
+    const cached = this.#cache.get(pkgName);
+    if (cached)
+      return cached;
+    const promise = this.#analyzeSafe(pkgName);
+    this.#cache.set(pkgName, promise);
+    return promise;
+  }
+  async#analyzeSafe(pkgName) {
+    try {
+      const pkg = await this.#opts.resolvePackage(pkgName);
+      if (!pkg)
+        return null;
+      const map = new Map;
+      await this.#walk(pkg.entryFile, pkg, map, new Set);
+      return map;
+    } catch (err) {
+      this.#logger.error(`analyze failed for ${pkgName}: ${err.message}`);
+      return null;
+    }
+  }
+  async#walk(absFile, pkg, map, visited) {
+    if (visited.has(absFile))
+      return;
+    visited.add(absFile);
+    const file = Bun.file(absFile);
+    if (!await file.exists())
+      return;
+    const source = await file.text();
+    const currentSubpath = this.#subpathFor(pkg, absFile);
+    if (!currentSubpath)
+      return;
+    const authoritative = this.#scanExports(source, absFile);
+    authoritative.delete("default");
+    const attributed = new Set;
+    const attribute = (listBody, subpath) => {
+      for (const item of parseNamedList(listBody)) {
+        if (item.isType || item.imported === "default" || !authoritative.has(item.local))
+          continue;
+        attributed.add(item.local);
+        if (!map.has(item.local))
+          map.set(item.local, { subpath, originalName: item.imported });
+      }
+    };
+    const starSpecs = [];
+    for (const m of source.matchAll(REEXPORT_RE)) {
+      const star = m[1];
+      const nsAs = m[2];
+      const namedList = m[3];
+      const spec = m[5] ?? "";
+      if (!isRelative(spec))
+        continue;
+      if (star) {
+        if (nsAs)
+          authoritative.delete(nsAs);
+        else
+          starSpecs.push(spec);
+        continue;
+      }
+      if (namedList !== undefined) {
+        const targetAbs = await this.#resolveRel(absFile, spec);
+        if (!targetAbs)
+          continue;
+        const targetSubpath = this.#subpathFor(pkg, targetAbs);
+        if (targetSubpath)
+          attribute(namedList, targetSubpath);
+      }
+    }
+    LOCAL_NAMED_RE.lastIndex = 0;
+    let n = LOCAL_NAMED_RE.exec(source);
+    while (n !== null) {
+      const body = n[1] ?? "";
+      n = LOCAL_NAMED_RE.exec(source);
+      attribute(body, currentSubpath);
+    }
+    for (const name of authoritative) {
+      if (attributed.has(name))
+        continue;
+      if (map.has(name))
+        continue;
+      map.set(name, { subpath: currentSubpath, originalName: name });
+    }
+    for (const spec of starSpecs) {
+      const targetAbs = await this.#resolveRel(absFile, spec);
+      if (targetAbs)
+        await this.#walk(targetAbs, pkg, map, visited);
+    }
+  }
+  #scanExports(source, absFile) {
+    try {
+      const transpiler = [".tsx", ".jsx"].includes(path4.extname(absFile)) ? this.#tsxTranspiler : this.#tsTranspiler;
+      const { exports } = transpiler.scan(source);
+      return new Set(exports);
+    } catch (err) {
+      this.#logger.error(`scan failed: ${err.message}`);
+      return new Set;
+    }
+  }
+  #subpathFor(pkg, absFile) {
+    const rel = path4.relative(pkg.pkgDir, absFile);
+    if (!rel || rel.startsWith("..") || path4.isAbsolute(rel))
+      return null;
+    if (pkg.preserveFilePath)
+      return `${pkg.pkgName}/${rel.split(path4.sep).join("/")}`;
+    const ext = CANDIDATE_EXTS.find((candidate) => rel.endsWith(candidate));
+    const parts = (ext ? rel.slice(0, -ext.length) : rel).split(path4.sep);
+    if (parts[parts.length - 1] === "index")
+      parts.pop();
+    const tail = parts.join("/");
+    return tail === "" ? pkg.pkgName : `${pkg.pkgName}/${tail}`;
+  }
+  async#resolveRel(fromFile, relSpec) {
+    if (this.#opts.resolveRelative)
+      return this.#opts.resolveRelative(fromFile, relSpec);
+    return defaultResolveRelative(fromFile, relSpec);
+  }
+}
+var isRelative = (spec) => {
+  return spec.startsWith("./") || spec.startsWith("../") || spec === "." || spec === "..";
+};
+var defaultResolveRelative = async (fromFile, relSpec) => {
+  const baseDir = path4.dirname(fromFile);
+  const joined = path4.resolve(baseDir, relSpec);
+  if (path4.extname(joined)) {
+    if (await Bun.file(joined).exists())
+      return joined;
+    return null;
+  }
+  for (const ext of CANDIDATE_EXTS) {
+    const cand = joined + ext;
+    if (await Bun.file(cand).exists())
+      return cand;
+  }
+  for (const ext of CANDIDATE_EXTS) {
+    const cand = path4.join(joined, `index${ext}`);
+    if (await Bun.file(cand).exists())
+      return cand;
+  }
+  return null;
+};
+
+// pkgs/@akanjs/devkit/transforms/barrelImportsPlugin.ts
+var createBarrelImportsPlugin = async (app, { skipPath = defaultSkipPath, pipeAfter } = {}) => {
+  const akanConfig = await app.getConfig();
+  const barrels = [...new Set(akanConfig.barrelImports)].filter(Boolean);
+  const analyzer = new BarrelAnalyzer({
+    resolvePackage: await createTsconfigPackageResolver(app)
+  });
+  return {
+    name: "barrel-imports",
+    setup(build) {
+      build.onLoad({
+        filter: /^(?:(?!.*[\\/]node_modules[\\/]).*|.*[\\/]node_modules[\\/]akanjs[\\/].*)\.(tsx|ts|jsx|js)(\?v=\d+)?$/
+      }, async (args) => {
+        const realPath = args.path.replace(/\?v=\d+$/, "");
+        const loader = loaderFor(realPath);
+        let source = await Bun.file(realPath).text();
+        if (skipPath(realPath))
+          return { contents: source, loader };
+        if (!MACRO_ATTR_RE.test(source) && barrels.length > 0) {
+          const rewritten = await rewriteBarrelImports(source, barrels, analyzer);
+          if (rewritten !== null)
+            source = rewritten;
+        }
+        if (pipeAfter) {
+          const piped = await pipeAfter(source, { path: realPath });
+          if (piped !== null)
+            source = piped;
+        }
+        return { contents: source, loader };
+      });
+    }
+  };
+};
+var createTsconfigPackageResolver = async (app) => {
+  const tsconfig = await app.getTsConfig();
+  const tsconfigPaths = tsconfig.compilerOptions.paths ?? {};
+  const wildcardEntries = Object.entries(tsconfigPaths).filter(([k]) => k.endsWith("/*")).map(([k, v]) => ({ prefix: k.slice(0, -1), replacements: v })).sort((a, b) => b.prefix.length - a.prefix.length);
+  return async (pkgName) => {
+    const exact = tsconfigPaths[pkgName];
+    if (exact && exact.length > 0) {
+      const raw = exact[0];
+      if (!raw)
+        return null;
+      const entryFile = path5.resolve(app.workspace.workspaceRoot, raw);
+      if (!await Bun.file(entryFile).exists())
+        return null;
+      const parsed = path5.parse(entryFile);
+      const lastSlash = pkgName.lastIndexOf("/");
+      if (parsed.name !== "index" && lastSlash > 0 && pkgName.slice(lastSlash + 1) === parsed.name)
+        return { pkgName: pkgName.slice(0, lastSlash), entryFile, pkgDir: parsed.dir };
+      return { pkgName, entryFile, pkgDir: path5.dirname(entryFile) };
+    }
+    for (const { prefix, replacements } of wildcardEntries) {
+      if (!pkgName.startsWith(prefix))
+        continue;
+      const suffix = pkgName.slice(prefix.length);
+      for (const repl of replacements) {
+        if (!repl)
+          continue;
+        const replPath = repl.endsWith("/*") ? repl.slice(0, -1) : repl;
+        const candidate = path5.resolve(app.workspace.workspaceRoot, replPath + suffix);
+        for (const ext of CANDIDATE_EXTS2) {
+          const file = `${candidate}${ext}`;
+          if (await Bun.file(file).exists()) {
+            const lastSlash = pkgName.lastIndexOf("/");
+            const parentSpec = lastSlash > 0 ? pkgName.slice(0, lastSlash) : pkgName;
+            return { pkgName: parentSpec, entryFile: file, pkgDir: path5.dirname(file) };
+          }
+        }
+        for (const ext of CANDIDATE_EXTS2) {
+          const file = path5.join(candidate, `index${ext}`);
+          if (await Bun.file(file).exists())
+            return { pkgName, entryFile: file, pkgDir: candidate };
+        }
+      }
+      return null;
+    }
+    const exported = await resolveNodePackageExport(app.workspace.workspaceRoot, pkgName);
+    if (exported)
+      return exported;
+    const pkgJsonPath = path5.join(app.workspace.workspaceRoot, "node_modules", pkgName, "package.json");
+    if (!await Bun.file(pkgJsonPath).exists())
+      return null;
+    try {
+      const pkgJson = JSON.parse(await Bun.file(pkgJsonPath).text());
+      const rel = pkgJson.module ?? pkgJson.main ?? "index.js";
+      const entryFile = path5.resolve(path5.dirname(pkgJsonPath), rel);
+      if (!await Bun.file(entryFile).exists())
+        return null;
+      return { pkgName, entryFile, pkgDir: path5.dirname(pkgJsonPath) };
+    } catch {
+      return null;
+    }
+  };
+};
+var CANDIDATE_EXTS2 = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+var NODE_MODULES_RE = /[\\/]node_modules[\\/]/;
+var AKANJS_NODE_MODULE_RE = /[\\/]node_modules[\\/]akanjs[\\/]/;
+var defaultSkipPath = (absPath) => NODE_MODULES_RE.test(absPath) && !AKANJS_NODE_MODULE_RE.test(absPath);
+var resolveNodePackageExport = async (workspaceRoot, specifier) => {
+  const packageName = getPackageName(specifier);
+  if (!packageName)
+    return null;
+  const pkgJsonPath = path5.join(workspaceRoot, "node_modules", packageName, "package.json");
+  if (!await Bun.file(pkgJsonPath).exists())
+    return null;
+  try {
+    const pkgDir = path5.dirname(pkgJsonPath);
+    const pkgJson = JSON.parse(await Bun.file(pkgJsonPath).text());
+    const subpath = specifier === packageName ? "." : `.${specifier.slice(packageName.length)}`;
+    const exported = resolvePackageExport(pkgJson.exports, subpath);
+    const rel = exported ?? (subpath === "." ? pkgJson.module ?? pkgJson.main ?? "index.js" : null);
+    if (!rel?.startsWith("."))
+      return null;
+    const entryFile = await resolveFileCandidate(path5.resolve(pkgDir, rel));
+    if (!entryFile)
+      return null;
+    return { pkgName: specifier, entryFile, pkgDir: path5.dirname(entryFile), preserveFilePath: true };
+  } catch {
+    return null;
+  }
+};
+var resolveExportValue = (value) => {
+  if (!value)
+    return null;
+  if (typeof value === "string")
+    return value;
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const resolved = resolveExportValue(item);
+      if (resolved)
+        return resolved;
+    }
+    return null;
+  }
+  for (const condition of ["source", "import", "default", "types"]) {
+    const resolved = resolveExportValue(value[condition]);
+    if (resolved)
+      return resolved;
+  }
+  return null;
+};
+var resolvePackageExport = (exportsMap, subpath) => {
+  if (!exportsMap)
+    return null;
+  const exact = resolveExportValue(exportsMap[subpath]);
+  if (exact)
+    return exact;
+  for (const [key, value] of Object.entries(exportsMap)) {
+    const starIdx = key.indexOf("*");
+    if (starIdx === -1)
+      continue;
+    const prefix = key.slice(0, starIdx);
+    const suffix = key.slice(starIdx + 1);
+    if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix))
+      continue;
+    const wildcard = subpath.slice(prefix.length, subpath.length - suffix.length);
+    const resolved = resolveExportValue(value);
+    if (resolved)
+      return resolved.replace("*", wildcard);
+  }
+  return null;
+};
+var getPackageName = (specifier) => {
+  const parts = specifier.split("/");
+  if (!parts[0])
+    return null;
+  if (specifier.startsWith("@"))
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
+  return parts[0];
+};
+var resolveFileCandidate = async (candidate) => {
+  if (await Bun.file(candidate).exists())
+    return candidate;
+  if (path5.extname(candidate))
+    return null;
+  for (const ext of CANDIDATE_EXTS2) {
+    const file = `${candidate}${ext}`;
+    if (await Bun.file(file).exists())
+      return file;
+  }
+  for (const ext of CANDIDATE_EXTS2) {
+    const file = path5.join(candidate, `index${ext}`);
+    if (await Bun.file(file).exists())
+      return file;
+  }
+  return null;
+};
+var MACRO_ATTR_RE = /with\s*\{\s*type\s*:\s*["']macro["']\s*\}/;
+var rewriteBarrelImports = async (source, barrels, analyzer) => {
+  if (!barrels.some((barrel) => source.includes(barrel)))
+    return null;
+  const statements = findImportStatements(source);
+  if (statements.length === 0)
+    return null;
+  let changed = false;
+  let out = source;
+  for (let i = statements.length - 1;i >= 0; i--) {
+    const stmt = statements[i];
+    if (!stmt)
+      continue;
+    if (!barrels.includes(stmt.specifier))
+      continue;
+    const map = await analyzer.analyze(stmt.specifier);
+    if (!map || map.size === 0)
+      continue;
+    const replacement = rewriteSingleStatement(stmt, map);
+    if (replacement === null)
+      continue;
+    out = out.slice(0, stmt.start) + replacement + out.slice(stmt.end);
+    changed = true;
+  }
+  return changed ? out : null;
+};
+var findImportStatements = (source) => {
+  const statements = [];
+  const sourceFile = ts2.createSourceFile("barrel-imports.tsx", source, ts2.ScriptTarget.Latest, false, ts2.ScriptKind.TSX);
+  for (const statement of sourceFile.statements) {
+    if (!ts2.isImportDeclaration(statement))
+      continue;
+    if (!ts2.isStringLiteral(statement.moduleSpecifier))
+      continue;
+    const importClause = statement.importClause;
+    if (!importClause)
+      continue;
+    statements.push({
+      start: statement.getStart(sourceFile),
+      end: statement.end,
+      clause: source.slice(importClause.getStart(sourceFile), importClause.end).trim(),
+      specifier: statement.moduleSpecifier.text
+    });
+  }
+  return statements;
+};
+var parseImportClause = (clause) => {
+  let rest = clause.trim();
+  let typeOnly = false;
+  if (rest.startsWith("type ")) {
+    typeOnly = true;
+    rest = rest.slice(5).trim();
+  }
+  const parsed = { typeOnly };
+  const commaMatch = /^(\w+)\s*,\s*(.+)$/.exec(rest);
+  if (commaMatch) {
+    parsed.defaultImport = commaMatch[1];
+    rest = commaMatch[2] ?? "";
+  } else if (/^\w+$/.test(rest)) {
+    parsed.defaultImport = rest;
+    return parsed;
+  }
+  if (rest.startsWith("*")) {
+    const ns = /^\*\s+as\s+(\w+)$/.exec(rest);
+    if (!ns)
+      return null;
+    parsed.namespaceImport = ns[1];
+    return parsed;
+  }
+  if (rest.startsWith("{")) {
+    const close = rest.indexOf("}");
+    if (close === -1)
+      return null;
+    parsed.named = parseNamedList(rest.slice(1, close));
+  }
+  return parsed;
+};
+var rewriteSingleStatement = (stmt, map) => {
+  const clause = parseImportClause(stmt.clause);
+  if (!clause)
+    return null;
+  if (clause.namespaceImport)
+    return null;
+  if (clause.typeOnly && !clause.defaultImport)
+    return null;
+  if (!clause.named?.length)
+    return null;
+  const remaining = [];
+  const rewrites = new Map;
+  for (const item of clause.named) {
+    if (item.isType) {
+      remaining.push(item);
+      continue;
+    }
+    const target = map.get(item.imported);
+    if (!target) {
+      remaining.push(item);
+      continue;
+    }
+    const list = rewrites.get(target.subpath) ?? [];
+    list.push({ imported: target.originalName, local: item.local, isType: false });
+    rewrites.set(target.subpath, list);
+  }
+  if (rewrites.size === 0)
+    return null;
+  const lines = [];
+  if (shouldPreserveBarrelSideEffects(stmt.specifier))
+    lines.push(`import "${stmt.specifier}";`);
+  if (clause.defaultImport || remaining.length > 0) {
+    const parts = [];
+    if (clause.defaultImport)
+      parts.push(clause.defaultImport);
+    if (remaining.length > 0)
+      parts.push(`{ ${remaining.map(serializeNamedItem).join(", ")} }`);
+    lines.push(`import ${parts.join(", ")} from "${stmt.specifier}";`);
+  }
+  for (const [subpath, items] of rewrites) {
+    lines.push(`import { ${items.map(serializeNamedItem).join(", ")} } from "${subpath}";`);
+  }
+  return lines.join(`
+`);
+};
+var shouldPreserveBarrelSideEffects = (specifier) => /^@(apps|libs)\/[^/]+\/client$/.test(specifier);
+var serializeNamedItem = (item) => {
+  const prefix = item.isType ? "type " : "";
+  if (item.imported === item.local)
+    return `${prefix}${item.imported}`;
+  return `${prefix}${item.imported} as ${item.local}`;
+};
+
+// pkgs/@akanjs/devkit/transforms/externalizeFrameworkPlugin.ts
+import path6 from "path";
+var DEFAULT_INCLUDE = ["akanjs/", "@apps/", "@libs/"];
+var DEFAULT_EXCLUDE_EXACT = new Set(["akanjs/webkit", "@akanjs/cli", "@akanjs/devkit"]);
+var DEFAULT_EXCLUDE_PREFIX = ["@akanjs/cli/", "@akanjs/devkit/"];
+var OPTIONAL_BACKEND_EXTERNAL_EXACT = new Set(["bullmq", "ioredis", "postgres", "protobufjs"]);
+var RUNTIME_EXTERNAL_EXACT = new Set([
+  "react",
+  "react-dom",
+  "react/jsx-runtime",
+  "react/jsx-dev-runtime",
+  "react-server-dom-webpack",
+  "react-server-dom-webpack/server.node",
+  "react-server-dom-webpack/client.node",
+  "react-server-dom-webpack/client.browser"
+]);
+var RUNTIME_EXTERNAL_PREFIX = ["react-dom/", "react-server-dom-webpack/"];
+var CANDIDATE_EXTS3 = [".tsx", ".ts", ".jsx", ".js", ".mjs", ".cjs"];
+async function createExternalizeFrameworkPlugin(options) {
+  const tsconfig = await options.app.getTsConfig();
+  const includePrefixes = options.include ?? DEFAULT_INCLUDE;
+  const extraExact = new Set(options.extra ?? []);
+  const workspaceRoot = options.app.workspace.workspaceRoot;
+  const tsconfigPaths = tsconfig.compilerOptions.paths ?? {};
+  const rootEntries = Object.entries(tsconfigPaths).filter(([k]) => !k.endsWith("/*")).map(([k, v]) => ({ pkg: k, entryFile: v[0] ?? null })).filter((e) => e.entryFile !== null);
+  const wildcardEntries = Object.entries(tsconfigPaths).filter(([k]) => k.endsWith("/*")).map(([k, v]) => ({ prefix: k.slice(0, -1), replacements: v })).sort((a, b) => b.prefix.length - a.prefix.length);
+  async function resolveWorkspaceSubpath(spec) {
+    if (!workspaceRoot)
+      return null;
+    for (const { prefix, replacements } of wildcardEntries) {
+      if (!spec.startsWith(prefix))
+        continue;
+      const suffix = spec.slice(prefix.length);
+      for (const repl of replacements) {
+        const replPath = repl?.endsWith("/*") ? repl.slice(0, -1) : repl ?? "";
+        if (!replPath)
+          continue;
+        const candidate = path6.resolve(workspaceRoot, replPath + suffix);
+        const hit = await firstExisting(candidate);
+        if (hit)
+          return hit;
+      }
+    }
+    for (const { pkg, entryFile } of rootEntries) {
+      if (!spec.startsWith(`${pkg}/`))
+        continue;
+      const suffix = spec.slice(pkg.length + 1);
+      const pkgDir = path6.dirname(path6.resolve(workspaceRoot, entryFile));
+      const candidate = path6.join(pkgDir, suffix);
+      const hit = await firstExisting(candidate);
+      if (hit)
+        return hit;
+    }
+    return null;
+  }
+  return {
+    name: "akan-externalize-framework",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, async (args) => {
+        const spec = args.path;
+        if (spec === "." || spec === ".." || spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/"))
+          return;
+        if (extraExact.has(spec) || DEFAULT_EXCLUDE_EXACT.has(spec))
+          return { path: spec, external: true };
+        for (const prefix of DEFAULT_EXCLUDE_PREFIX) {
+          if (spec.startsWith(prefix))
+            return { path: spec, external: true };
+        }
+        if (OPTIONAL_BACKEND_EXTERNAL_EXACT.has(spec))
+          return { path: spec, external: true };
+        if (RUNTIME_EXTERNAL_EXACT.has(spec))
+          return { path: spec, external: true };
+        for (const prefix of RUNTIME_EXTERNAL_PREFIX) {
+          if (spec.startsWith(prefix))
+            return { path: spec, external: true };
+        }
+        if (!includePrefixes.some((prefix) => spec.startsWith(prefix)))
+          return;
+        const resolved = await resolveWorkspaceSubpath(spec);
+        return resolved ? { path: resolved } : undefined;
+      });
+    }
+  };
+}
+async function firstExisting(basePath) {
+  if (await Bun.file(basePath).exists())
+    return basePath;
+  for (const ext of CANDIDATE_EXTS3) {
+    const candidate = `${basePath}${ext}`;
+    if (await Bun.file(candidate).exists())
+      return candidate;
+  }
+  for (const ext of CANDIDATE_EXTS3) {
+    const candidate = path6.join(basePath, `index${ext}`);
+    if (await Bun.file(candidate).exists())
+      return candidate;
+  }
+  return null;
+}
+
+// pkgs/@akanjs/devkit/transforms/useClientBundlePlugin.ts
+function createUseClientBundlePlugin(options = {}) {
+  return {
+    name: "akan-use-client-bundle",
+    setup(build) {
+      build.onLoad({ filter: /\.(tsx|ts|jsx|js)$/ }, async (args) => {
+        if (args.path.includes("/node_modules/"))
+          return;
+        let source;
+        try {
+          source = await Bun.file(args.path).text();
+        } catch {
+          return;
+        }
+        const stubbed = transformUseClient(source, {
+          path: args.path,
+          workspaceRoot: options.workspaceRoot,
+          onClientModule: options.onClientModule
+        });
+        if (stubbed === null)
+          return;
+        return { contents: stubbed, loader: loaderFor(args.path) };
+      });
+    }
+  };
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/bundleDefine.ts
+var bundleDefine = (app, command, renderEnv) => {
+  const nodeEnv = command === "build" ? "production" : "development";
+  return {
+    "process.env.NODE_ENV": JSON.stringify(nodeEnv),
+    "process.env.AKAN_PUBLIC_RENDER_ENV": JSON.stringify(renderEnv),
+    ...Object.fromEntries(Object.entries(app.getPublicEnv()).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, value]) => [`process.env.${key}`, JSON.stringify(value)]))
+  };
+};
+
+// pkgs/@akanjs/devkit/frontendBuild/pagesEntrySourceGenerator.ts
+import path7 from "path";
+class PagesEntrySourceGenerator {
+  #pageEntries;
+  #asyncDefaults = new Map;
+  #detect;
+  constructor(pageEntries, { isAsyncDefault } = {}) {
+    this.#pageEntries = pageEntries;
+    this.#detect = isAsyncDefault ?? ((moduleAbsPath) => AsyncDefaultExportDetector.detect(moduleAbsPath));
+  }
+  static generate(pageEntries) {
+    return new PagesEntrySourceGenerator(pageEntries).generate();
+  }
+  generate() {
+    const lines = this.#pageEntries.map(({ key, moduleAbsPath }) => {
+      const specifier = PagesEntrySourceGenerator.#toImportSpecifier(moduleAbsPath);
+      return `  ${JSON.stringify(key)}: () => import(${JSON.stringify(specifier)}),`;
+    });
+    return `export const pages = {
+${lines.join(`
+`)}
+};
+`;
+  }
+  static async generateStatic(pageEntries, { fromDir } = {}) {
+    return await new PagesEntrySourceGenerator(pageEntries).generateStatic({ fromDir });
+  }
+  async generateStatic({ fromDir } = {}) {
+    const imports = this.#pageEntries.map(({ moduleAbsPath }, index) => {
+      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 this.#isAsyncDefault(moduleAbsPath);
+      return `  ${JSON.stringify(key)}: { loader: async () => page${index}, isAsyncDefault: ${isAsyncDefault} },`;
+    }));
+    return `${imports.join(`
+`)}
+export const pages = {
+${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 = this.#detect(moduleAbsPath);
+    this.#asyncDefaults.set(moduleAbsPath, detected);
+    return detected;
+  }
+  static #toImportSpecifier(moduleAbsPath) {
+    return path7.resolve(moduleAbsPath).split(path7.sep).join("/");
+  }
+  static #toRelativeSpecifier(fromDir, moduleAbsPath) {
+    const relative = path7.relative(fromDir, path7.resolve(moduleAbsPath)).split(path7.sep).join("/");
+    return relative.startsWith(".") ? relative : `./${relative}`;
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/pagesBundleBuilder.ts
+var VIRTUAL_PAGES_ENTRY = "akan-pages-entry";
+
+class PagesBundleBuilder {
+  #app;
+  #command;
+  #pageEntries;
+  #started = Date.now();
+  #serverEnv;
+  constructor(app, command = "start", pageEntries, serverEnv) {
+    this.#app = app;
+    this.#command = command;
+    this.#pageEntries = pageEntries;
+    this.#serverEnv = serverEnv;
+  }
+  async build() {
+    const akanConfig = await this.#app.getConfig();
+    const resolvedEntries = this.#pageEntries ?? await resolveSsrPageEntriesForApp(this.#app, await this.#app.getPageKeys());
+    const entrySource = PagesEntrySourceGenerator.generate(resolvedEntries);
+    const workspaceRoot = this.#app.workspace.workspaceRoot;
+    const dev = this.#command === "start";
+    const clientExports = {};
+    const onClientModule = dev ? (file, exports) => {
+      clientExports[CsrDevPaths.realpath(file)] = exports;
+    } : undefined;
+    const result = await Bun.build({
+      entrypoints: [VIRTUAL_PAGES_ENTRY],
+      outdir: `${this.#artifactDir}/server`,
+      target: "bun",
+      format: "esm",
+      splitting: this.#splitting,
+      minify: this.#command === "build",
+      naming: {
+        entry: "pages-[hash].[ext]",
+        chunk: "chunks/[name]-[hash].[ext]",
+        asset: "assets/[name]-[hash].[ext]"
+      },
+      define: bundleDefine(this.#app, this.#command, "ssr"),
+      metafile: dev,
+      plugins: [
+        ...this.#serverEnv ? [this.#serverEnv] : [],
+        PagesBundleBuilder.createPagesEntryPlugin(entrySource),
+        PagesBundleBuilder.createCssStubPlugin(),
+        PagesBundleBuilder.createServerUseClientFetchPlugin(),
+        await createExternalizeFrameworkPlugin({ app: this.#app, extra: akanConfig.externalLibs }),
+        akanConfig.barrelImports.length > 0 ? await createBarrelImportsPlugin(this.#app, {
+          pipeAfter: (source, args) => transformUseClient(source, {
+            path: args.path,
+            workspaceRoot,
+            onClientModule
+          })
+        }) : createUseClientBundlePlugin({ workspaceRoot, onClientModule })
+      ]
+    });
+    if (!result.success)
+      throw new AggregateError(result.logs, "[PagesBundleBuilder] Bun.build failed");
+    const entryArtifact = result.outputs.find((a) => a.kind === "entry-point");
+    if (!entryArtifact)
+      throw new Error("[PagesBundleBuilder] Bun.build emitted no entry-point artifact");
+    const bundlePath = path8.resolve(entryArtifact.path);
+    const buildId = Date.now();
+    if (dev && result.metafile)
+      await ServerGraphFile.write(this.#artifactDir, this.#serverGraph(result.metafile, clientExports));
+    const outputBytes = result.outputs.reduce((sum, output) => sum + output.size, 0);
+    const chunkCount = result.outputs.filter((output) => output.kind === "chunk").length;
+    this.#app.verbose(`[PagesBundleBuilder] ${path8.basename(bundlePath)} emitted in ${Date.now() - this.#started}ms splitting=${this.#splitting} entry=${entryArtifact.size} bytes outputs=${result.outputs.length} chunks=${chunkCount} total=${outputBytes} bytes`);
+    return {
+      bundlePath,
+      buildId,
+      splitting: this.#splitting,
+      entryBytes: entryArtifact.size,
+      outputBytes,
+      outputCount: result.outputs.length,
+      chunkCount
+    };
+  }
+  #serverGraph(metafile, clientExports) {
+    const inputs = Object.keys(metafile.inputs).filter((input) => !input.includes("node_modules")).map((input) => path8.resolve(input)).filter((input) => fs3.existsSync(input)).map((input) => CsrDevPaths.realpath(input));
+    return { inputs, clientExports };
+  }
+  get #artifactDir() {
+    return `${this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath}/.akan/artifact`;
+  }
+  get #splitting() {
+    return process.env.AKAN_SERVER_PAGES_SPLITTING === "1";
+  }
+  static createPagesEntryPlugin(source) {
+    return {
+      name: "akan-pages-entry",
+      setup(build) {
+        build.onResolve({ filter: /^akan-pages-entry$/ }, () => ({
+          path: VIRTUAL_PAGES_ENTRY,
+          namespace: "akan-virtual"
+        }));
+        build.onLoad({ filter: /^akan-pages-entry$/, namespace: "akan-virtual" }, () => ({
+          contents: source,
+          loader: "tsx"
+        }));
+      }
+    };
+  }
+  static createCssStubPlugin() {
+    return {
+      name: "akan-css-stub",
+      setup(build) {
+        build.onLoad({ filter: /\.css$/ }, () => ({
+          contents: "",
+          loader: "js"
+        }));
+      }
+    };
+  }
+  static createServerUseClientFetchPlugin() {
+    return {
+      name: "akan-server-use-client-fetch",
+      setup(build) {
+        build.onLoad({ filter: /[/\\]lib[/\\]useClient\.(ts|tsx|js|jsx)$/ }, async (args) => {
+          const source = await Bun.file(args.path).text();
+          const transformed = PagesBundleBuilder.transformServerUseClientFetchSource(source);
+          if (transformed === source)
+            return;
+          return { contents: transformed, loader: loaderFor(args.path) };
+        });
+      }
+    };
+  }
+  static transformServerUseClientFetchSource(source) {
+    if (!source.includes(`with { type: "macro" }`) || !source.includes("FetchClient.build"))
+      return source;
+    return source.replace(/import\s+\{\s*getSerializedSignal\s*\}\s+from\s+["']\.\/sig["']\s+with\s+\{\s*type\s*:\s*["']macro["']\s*\};/, `import { fetch as serverFetch } from "./sig";`).replace(/const\s+fetchProto\s*=\s*FetchClient\.build<[^;]+;/, "const fetchProto = FetchClient.build<typeof signal>(cnst, serverFetch.serializedSignal, { Err: pageProto.Err, base: serverFetch });");
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/csrEntryFiles.ts
+import path9 from "path";
+
+class CsrEntryFiles {
+  static entryFilename(basePath) {
+    return `${basePath || "index"}.csr.tsx`;
+  }
+  static pageEntriesForBasePath(pageEntries, basePath, basePaths) {
+    return pageEntries.filter((entry) => {
+      const entryBasePath = CsrEntryFiles.basePathOfPageKey(entry.key, basePaths);
+      return entryBasePath === null || entryBasePath === basePath;
+    });
+  }
+  static basePathOfPageKey(pageKey, basePaths) {
+    const normalized = pageKey.split(path9.sep).join("/").replace(/^\.\//, "");
+    const segments = normalized.split("/");
+    const firstPublicSegment = segments.find((segment) => segment !== "[lang]" && !/^\(.+\)$/.test(segment));
+    return firstPublicSegment && basePaths.includes(firstPublicSegment) ? firstPublicSegment : null;
+  }
+}
+
+export { bundleDefine, CsrEntryFiles, loaderFor, BarrelAnalyzer, createBarrelImportsPlugin, createTsconfigPackageResolver, rewriteBarrelImports, toClientReferencePath, scanUseClientExports, CsrDevPaths, PagesEntrySourceGenerator, ServerGraphFile, PagesBundleBuilder };