@akanjs/cli 3.1.0-rc.20 → 3.1.0-rc.22

package/{index-86jt2a0e.js → index-3xhak9e0.js}

@@ -2,7 +2,7 @@
 import {
   runner,
   script
-} from "./index-jw1zm273.js";
+} from "./index-g5px5pxd.js";
 
 // pkgs/@akanjs/cli/page/page.runner.ts
 class PageRunner extends runner("page") {

package/{index-tamvyvj3.js → index-4fe4qqgn.js}

@@ -2,7 +2,7 @@
 import {
   runner,
   script
-} from "./index-jw1zm273.js";
+} from "./index-g5px5pxd.js";
 import {
   AGENT_BLOCK_START,
   AGENT_BLOCK_END,
@@ -13,14 +13,14 @@ import {
   CLAUDE_COMMENT_RULE,
   AppExecutor,
   LibExecutor
-} from "./index-va06nr10.js";
+} from "./index-gxqvev8w.js";
 import {
   collectRecipeSources2,
   scanRecipes2
 } from "./index-hj6w4ka1.js";
 import {
   AkanContextAnalyzer
-} from "./index-5edzv8fn.js";
+} from "./index-tbmtmkhx.js";
 import {
   Prompter2
 } from "./index-zzvvc845.js";

package/{index-g1mbppa9.js → index-551gh8h2.js}

@@ -4,17 +4,17 @@ import {
   ServerEnvProfile,
   Executor,
   WorkspaceExecutor
-} from "./index-va06nr10.js";
+} from "./index-gxqvev8w.js";
 import {
   resolveAppId,
   targetHtmlFilename
 } from "./index-m9jj544v.js";
-import {
-  ExitCodeError
-} from "./index-jw1zm273.js";
 import {
   CsrArtifactBuilder
-} from "./index-665zp9rs.js";
+} from "./index-6mprvdt8.js";
+import {
+  ExitCodeError
+} from "./index-g5px5pxd.js";
 
 // pkgs/@akanjs/devkit/mobile/desktopBin.ts
 import { chmod, mkdir, rename, rm, writeFile } from "fs/promises";

package/{index-trpasv9q.js → index-5m0s0gdv.js}

@@ -2,7 +2,7 @@
 import {
   AppExecutor,
   LibExecutor
-} from "./index-va06nr10.js";
+} from "./index-gxqvev8w.js";
 
 // pkgs/@akanjs/devkit/workflow/artifacts.ts
 import { capitalize } from "akanjs/common";

package/index-6mprvdt8.js

@@ -0,0 +1,566 @@
+// @bun
+import {
+  resolveSsrPageEntriesForApp
+} from "./index-gxqvev8w.js";
+import {
+  bundleDefine,
+  CsrEntryFiles,
+  PagesEntrySourceGenerator,
+  PagesBundleBuilder
+} from "./index-6nqnqzv1.js";
+
+// pkgs/@akanjs/devkit/frontendBuild/csrArtifactBuilder.ts
+import { mkdir as mkdir2, rm as rm2, unlink as unlink2 } from "fs/promises";
+import path4 from "path";
+
+// pkgs/@akanjs/devkit/transforms/browserDirnamePlugin.ts
+import path from "path";
+var vendorScript = /[\\/]node_modules[\\/].+\.[cm]?js$/;
+var createBrowserDirnamePlugin = () => ({
+  name: "akan-browser-dirname",
+  setup(build) {
+    build.onLoad({ filter: vendorScript }, async (args) => {
+      const source = await Bun.file(args.path).text();
+      if (!source.includes("__dirname") && !source.includes("__filename"))
+        return;
+      const posixPath = args.path.replaceAll("\\", "/");
+      const filename = posixPath.slice(posixPath.indexOf("/node_modules/"));
+      const define = { __dirname: JSON.stringify(path.posix.dirname(filename)), __filename: JSON.stringify(filename) };
+      return {
+        loader: "js",
+        contents: new Bun.Transpiler({ loader: "js", target: "browser", define }).transformSync(source)
+      };
+    });
+  }
+});
+
+// pkgs/@akanjs/devkit/frontendBuild/mcpAppViewBuilder.ts
+import { mkdir, readdir, rename, rm, unlink } from "fs/promises";
+import path3 from "path";
+import { parseRouteModuleKey } from "akanjs/common";
+
+// pkgs/@akanjs/devkit/transforms/mcpAppPageTrimmer.ts
+import { realpathSync } from "fs";
+import path2 from "path";
+import ts2 from "typescript";
+
+// pkgs/@akanjs/devkit/transforms/pureLazyMarker.ts
+import ts from "typescript";
+
+class PureLazyMarker {
+  static plugin() {
+    return {
+      name: "akan-pure-lazy",
+      setup(build) {
+        build.onLoad({ filter: /\.tsx?$/ }, async (args) => {
+          const file = Bun.file(args.path);
+          if (!await file.exists())
+            return;
+          const source = await file.text();
+          const marked = PureLazyMarker.mark(source, args.path);
+          return marked === source ? undefined : { contents: marked, loader: args.path.endsWith(".tsx") ? "tsx" : "ts" };
+        });
+      }
+    };
+  }
+  static mark(source, filePath) {
+    if (!source.includes("lazy("))
+      return source;
+    const kind = filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+    const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, kind);
+    const starts = [];
+    const visit = (node) => {
+      const call = ts.isVariableDeclaration(node) ? node.initializer : undefined;
+      if (call && ts.isCallExpression(call) && ts.isIdentifier(call.expression) && call.expression.text === "lazy")
+        starts.push(call.getStart(sourceFile));
+      ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return starts.sort((a, b) => b - a).reduce((marked, start) => `${marked.slice(0, start)}/* @__PURE__ */ ${marked.slice(start)}`, source);
+  }
+}
+
+// pkgs/@akanjs/devkit/transforms/mcpAppPageTrimmer.ts
+class McpAppPageTrimmer {
+  static #unused = new Set(["render", "head", "loading", "guard"]);
+  static plugin(pagePaths) {
+    return {
+      name: "akan-mcp-app-page",
+      setup(build) {
+        if (!pagePaths.length)
+          return;
+        const loadedPaths = new Set(pagePaths.flatMap((pagePath) => [pagePath, McpAppPageTrimmer.#realPathOf(pagePath)]));
+        const filter = new RegExp(`^(?:${[...loadedPaths].map((pagePath) => RegExp.escape(pagePath)).join("|")})$`);
+        build.onLoad({ filter }, async (args) => ({
+          contents: PureLazyMarker.mark(McpAppPageTrimmer.trim(await Bun.file(args.path).text(), args.path), args.path),
+          loader: path2.extname(args.path).slice(1)
+        }));
+      }
+    };
+  }
+  static trim(source, filePath) {
+    const sourceFile = ts2.createSourceFile(filePath, source, ts2.ScriptTarget.Latest, true, ts2.ScriptKind.TSX);
+    const spans = McpAppPageTrimmer.#stagesOf(sourceFile).flatMap((stage) => {
+      const [first] = stage.arguments;
+      if (!first || !McpAppPageTrimmer.#unused.has(stage.expression.name.text))
+        return [];
+      return [{ start: first.getStart(sourceFile), end: first.getEnd() }];
+    }).sort((a, b) => b.start - a.start);
+    let trimmed = source;
+    for (const { start, end } of spans)
+      trimmed = `${trimmed.slice(0, start)}() => null${trimmed.slice(end)}`;
+    return trimmed;
+  }
+  static #realPathOf(filePath) {
+    try {
+      return realpathSync(filePath);
+    } catch {
+      return filePath;
+    }
+  }
+  static #stagesOf(sourceFile) {
+    const stages = [];
+    for (const statement of sourceFile.statements) {
+      if (!ts2.isExportAssignment(statement) || statement.isExportEquals)
+        continue;
+      let node = statement.expression;
+      while (ts2.isParenthesizedExpression(node) || ts2.isAsExpression(node) || ts2.isSatisfiesExpression(node))
+        node = node.expression;
+      while (ts2.isCallExpression(node) && ts2.isPropertyAccessExpression(node.expression)) {
+        stages.push(node);
+        node = node.expression.expression;
+      }
+    }
+    return stages;
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/mcpAppViewBuilder.ts
+class McpAppViewBuilder {
+  static dirName = "mcp-apps";
+  static #appName = /^[A-Za-z0-9_-]{1,64}$/;
+  #app;
+  #command;
+  constructor(app, command) {
+    this.#app = app;
+    this.#command = command;
+  }
+  get outputDir() {
+    return this.#command === "build" ? path3.join(this.#app.dist.cwdPath, McpAppViewBuilder.dirName) : path3.join(this.#app.cwdPath, ".akan", "artifact", McpAppViewBuilder.dirName);
+  }
+  async build(pageEntries, { basePaths, cssAssets, options }) {
+    const views = await McpAppViewBuilder.discover(pageEntries, basePaths);
+    if (!views.length) {
+      await rm(this.outputDir, { recursive: true, force: true });
+      return views;
+    }
+    const stagingDir = `${this.outputDir}.next`;
+    await rm(stagingDir, { recursive: true, force: true });
+    const generatedDir = path3.join(this.#app.cwdPath, ".akan", "generated", McpAppViewBuilder.dirName);
+    await rm(generatedDir, { recursive: true, force: true });
+    await mkdir(generatedDir, { recursive: true });
+    const files = Object.fromEntries(views.flatMap((view) => [
+      [path3.join(generatedDir, `${view.name}.html`), McpAppViewBuilder.htmlOf(view)],
+      [path3.join(generatedDir, `${view.name}.view.tsx`), McpAppViewBuilder.entryOf(view, generatedDir)]
+    ]));
+    const pagePaths = [...new Set(views.map((view) => view.page.moduleAbsPath))];
+    const result = await Bun.build({
+      ...options,
+      plugins: [...options.plugins, McpAppPageTrimmer.plugin(pagePaths), PureLazyMarker.plugin()],
+      entrypoints: views.map((view) => path3.join(generatedDir, `${view.name}.html`)),
+      files,
+      root: generatedDir,
+      outdir: stagingDir
+    });
+    if (!result.success) {
+      const logs = result.logs.map((log) => log.message).join(`
+`);
+      throw new Error(`[mcp-app-build] failed${logs ? `
+${logs}` : ""}`);
+    }
+    for (const view of views)
+      await this.#inline(view, stagingDir, cssAssets[view.basePath]);
+    await this.#publish(views, stagingDir);
+    return views;
+  }
+  async#publish(views, stagingDir) {
+    const names = new Set(views.map((view) => `${view.name}.html`));
+    await mkdir(this.outputDir, { recursive: true });
+    for (const name of names)
+      await rename(path3.join(stagingDir, name), path3.join(this.outputDir, name));
+    for (const name of await readdir(this.outputDir))
+      if (!names.has(name))
+        await rm(path3.join(this.outputDir, name), { recursive: true, force: true });
+    const strays = await readdir(stagingDir);
+    if (strays.length)
+      this.#app.logger.warn(`[mcp-app-build] ${strays.join(", ")} reached no view; a view loads nothing beside its own file`);
+    await rm(stagingDir, { recursive: true, force: true });
+  }
+  static async discover(pageEntries, basePaths) {
+    const { RouteSourceValidator } = await import("./routeSourceValidator-6jd0q6r6.js");
+    const roots = pageEntries.filter((entry) => parseRouteModuleKey(entry.key).isInternalRootLayout);
+    const overrides = pageEntries.filter((entry) => parseRouteModuleKey(entry.key).kind === "overrides");
+    const layoutNodes = new Set(pageEntries.flatMap((entry) => {
+      const parsed = parseRouteModuleKey(entry.key);
+      return parsed.kind === "layout" && !parsed.isInternalRootLayout ? [parsed.routeSegments.join("/")] : [];
+    }));
+    const owners = new Map;
+    const views = [];
+    for (const page of pageEntries) {
+      if (parseRouteModuleKey(page.key).kind !== "page")
+        continue;
+      const source = await Bun.file(page.moduleAbsPath).text();
+      const apps = RouteSourceValidator.validateRouteSourceExports(source, page.moduleAbsPath, "page").chain?.apps ?? [];
+      for (const name of apps) {
+        if (!McpAppViewBuilder.#appName.test(name))
+          throw new Error(`[route-convention] app name "${name}" in ${page.key} must match ${McpAppViewBuilder.#appName}`);
+        const owner = owners.get(name.toLowerCase());
+        if (owner?.name === name)
+          throw new Error(`[route-convention] app "${name}" is declared by both ${owner.key} and ${page.key}`);
+        if (owner)
+          throw new Error(`[route-convention] apps "${owner.name}" (${owner.key}) and "${name}" (${page.key}) differ only in case; their views would share one file`);
+        owners.set(name.toLowerCase(), { name, key: page.key });
+        const root = await McpAppViewBuilder.#rootOf(page.key, roots);
+        views.push({
+          name,
+          page,
+          root,
+          ...McpAppViewBuilder.#overridesOf(page.key, root, overrides, layoutNodes),
+          basePath: CsrEntryFiles.basePathOfPageKey(page.key, basePaths) ?? ""
+        });
+      }
+    }
+    return views;
+  }
+  static htmlOf(view) {
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>${view.name}</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="./${view.name}.view.tsx"></script>
+  </body>
+</html>
+`;
+  }
+  static entryOf(view, fromDir) {
+    const specifier = (absPath) => {
+      const relative = path3.relative(fromDir, absPath).split(path3.sep).join("/");
+      return JSON.stringify(relative.startsWith(".") ? relative : `./${relative}`);
+    };
+    const importsOf = (entries, name) => entries.map((entry, idx) => `import ${name}${idx} from ${specifier(entry.moduleAbsPath)};
+`).join("");
+    const namesOf = (entries, name) => entries.map((_, idx) => `${name}${idx}`).join(", ");
+    return `import { McpAppBoot } from "akanjs/webkit";
+import * as page from ${specifier(view.page.moduleAbsPath)};
+${view.root ? `import * as root from ${specifier(view.root.moduleAbsPath)};` : "const root = {};"}
+${importsOf(view.rootOverrides, "rootOverride")}${importsOf(view.overrides, "override")}void McpAppBoot.run({
+  app: ${JSON.stringify(view.name)},
+  page,
+  root,
+  rootOverrides: [${namesOf(view.rootOverrides, "rootOverride")}],
+  overrides: [${namesOf(view.overrides, "override")}],
+  basePath: ${JSON.stringify(view.basePath)},
+});
+`;
+  }
+  static #overridesOf(pageKey, root, overrides, layoutNodes) {
+    const pageSegments = parseRouteModuleKey(pageKey).routeSegments;
+    const rootDepth = root ? parseRouteModuleKey(root.key).routeSegments.length : 0;
+    const over = overrides.map((entry) => ({ entry, segments: parseRouteModuleKey(entry.key).routeSegments })).filter(({ segments }) => segments.every((segment, idx) => pageSegments[idx] === segment)).sort((a, b) => a.segments.length - b.segments.length);
+    const onRootNode = (segments) => segments.length === rootDepth || segments.length < rootDepth && !layoutNodes.has(segments.join("/"));
+    return {
+      rootOverrides: over.filter(({ segments }) => onRootNode(segments)).map(({ entry }) => entry),
+      overrides: over.filter(({ segments }) => !onRootNode(segments)).map(({ entry }) => entry)
+    };
+  }
+  static async#rootOf(pageKey, roots) {
+    const dirOf = (key) => key.slice(0, key.lastIndexOf("/") + 1);
+    const pageDir = dirOf(pageKey);
+    const over = roots.filter((root) => pageDir.startsWith(dirOf(root.key))).sort((a, b) => dirOf(a.key).length - dirOf(b.key).length);
+    for (const root of over)
+      if ((await Bun.file(root.moduleAbsPath).text()).includes("export function McpAppRoot"))
+        return root;
+    return null;
+  }
+  async#inline(view, dir, cssAsset) {
+    const htmlPath = path3.join(dir, `${view.name}.html`);
+    let html = await Bun.file(htmlPath).text();
+    if (cssAsset) {
+      const artifactDir = path3.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan", "artifact");
+      const css = await Bun.file(path3.join(artifactDir, cssAsset.cssRelPath)).text();
+      html = CsrArtifactBuilder.injectBeforeHeadEnd(html, CsrArtifactBuilder.createInlineStyle(css));
+    } else
+      this.#app.logger.warn(`[mcp-app-build] no compiled stylesheet for ${view.name}; its view ships without CSS`);
+    const scripts = [];
+    html = await CsrArtifactBuilder.replaceModuleScriptSrc(html, async (src) => {
+      const jsPath = CsrArtifactBuilder.resolveHtmlAssetPath(htmlPath, src);
+      scripts.push(jsPath);
+      return await Bun.file(jsPath).text();
+    });
+    await Bun.write(htmlPath, html);
+    for (const script of scripts)
+      await unlink(script).catch(() => {
+        return;
+      });
+  }
+}
+
+// pkgs/@akanjs/devkit/frontendBuild/csrArtifactBuilder.ts
+class CsrArtifactBuilder {
+  #app;
+  #command;
+  #lang;
+  #cssAssets;
+  constructor(app, command = "start", lang = "en", { cssAssets = null } = {}) {
+    this.#app = app;
+    this.#command = command;
+    this.#lang = lang;
+    this.#cssAssets = cssAssets;
+  }
+  async build() {
+    const pageKeys = await this.#app.getPageKeys();
+    if (pageKeys.length === 0) {
+      this.#app.log(`[cli] no route files under ${this.#app.cwdPath}/page \u2014 skipping CSR build`);
+      return null;
+    }
+    const pageEntries = await resolveSsrPageEntriesForApp(this.#app, pageKeys);
+    const akanConfig = await this.#app.getConfig();
+    const cssAssets = await this.#loadCssAssets();
+    const basePaths = [...akanConfig.basePaths];
+    const htmlBasePaths = basePaths.length > 0 ? basePaths : [""];
+    await rm2(this.#outputDir, { recursive: true, force: true });
+    await mkdir2(this.#generatedDir, { recursive: true });
+    const generatedFiles = Object.fromEntries((await Promise.all(htmlBasePaths.map(async (basePath) => [
+      this.#createHtmlFile(basePath),
+      await this.#createEntryFile(basePath, CsrArtifactBuilder.pageEntriesForBasePath(pageEntries, basePath, basePaths))
+    ]))).flat());
+    const options = CsrArtifactBuilder.bundleOptions(this.#app, this.#command, akanConfig.optimizeImports);
+    const result = await Bun.build({
+      ...options,
+      entrypoints: htmlBasePaths.map((basePath) => this.#generatedPath(CsrArtifactBuilder.htmlFilename(basePath))),
+      files: generatedFiles,
+      root: this.#generatedDir,
+      outdir: this.#outputDir
+    });
+    if (!result.success) {
+      const logs = result.logs.map((log) => log.message).join(`
+`);
+      throw new Error(`[csr-build] failed${logs ? `
+${logs}` : ""}`);
+    }
+    await this.#inlineCsrArtifacts(cssAssets);
+    await this.#buildMcpAppViews(pageEntries, { basePaths, cssAssets, options });
+    if (this.#command === "build")
+      await CsrArtifactBuilder.writePublicEnv(this.#app, options.define);
+    this.#app.verbose(`[csr-build] output -> ${this.#outputDir}`);
+    return { outputDir: this.#outputDir };
+  }
+  async buildMcpAppViews() {
+    const pageKeys = await this.#app.getPageKeys();
+    if (pageKeys.length === 0)
+      return [];
+    const pageEntries = await resolveSsrPageEntriesForApp(this.#app, pageKeys);
+    const akanConfig = await this.#app.getConfig();
+    return await this.#buildMcpAppViews(pageEntries, {
+      basePaths: [...akanConfig.basePaths],
+      cssAssets: await this.#loadCssAssets(),
+      options: CsrArtifactBuilder.bundleOptions(this.#app, this.#command, akanConfig.optimizeImports)
+    });
+  }
+  async#buildMcpAppViews(pageEntries, option) {
+    const views = await new McpAppViewBuilder(this.#app, this.#command).build(pageEntries, option);
+    if (views.length)
+      this.#app.verbose(`[csr-build] ${views.length} MCP App view(s): ${views.map((view) => view.name).join(", ")}`);
+    return views;
+  }
+  static bundleOptions(app, command, optimizeImports = []) {
+    return {
+      target: "browser",
+      splitting: false,
+      minify: true,
+      define: bundleDefine(app, command, "csr"),
+      optimizeImports,
+      plugins: [PagesBundleBuilder.createCssStubPlugin(), createBrowserDirnamePlugin()]
+    };
+  }
+  static publicEnvPath(app) {
+    return path4.join(app.dist.cwdPath, ".akan", "artifact", "csr-public-env.json");
+  }
+  static async writePublicEnv(app, define) {
+    const prefix = "process.env.";
+    const publicEnv = Object.fromEntries(Object.entries(define).filter(([key]) => key.startsWith(`${prefix}AKAN_PUBLIC_`)).map(([key, value]) => [key.slice(prefix.length), JSON.parse(value)]));
+    await Bun.write(CsrArtifactBuilder.publicEnvPath(app), `${JSON.stringify(publicEnv, null, 2)}
+`);
+  }
+  static pageEntriesForBasePath(pageEntries, basePath, basePaths) {
+    return CsrEntryFiles.pageEntriesForBasePath(pageEntries, basePath, basePaths);
+  }
+  static htmlFilename(basePath) {
+    return `${basePath || "index"}.html`;
+  }
+  static entryFilename(basePath) {
+    return CsrEntryFiles.entryFilename(basePath);
+  }
+  static basePathOfHtml(htmlPath) {
+    const name = path4.basename(htmlPath, ".html");
+    return name === "index" ? "" : name;
+  }
+  get #outputDir() {
+    return path4.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, this.#command === "build" ? "csr" : ".akan/artifact/csr");
+  }
+  get #generatedDir() {
+    return path4.join(this.#app.cwdPath, ".akan/generated/csr");
+  }
+  get #artifactDir() {
+    return path4.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact");
+  }
+  #generatedPath(filename) {
+    return path4.join(this.#generatedDir, filename);
+  }
+  async#createEntryFile(basePath, pageEntries) {
+    return [
+      this.#generatedPath(CsrArtifactBuilder.entryFilename(basePath)),
+      `import { bootCsr } from "akanjs/webkit";
+${await PagesEntrySourceGenerator.generateStatic(pageEntries)}
+void bootCsr(pages);
+`
+    ];
+  }
+  #createHtmlFile(basePath) {
+    return [
+      this.#generatedPath(CsrArtifactBuilder.htmlFilename(basePath)),
+      `<!doctype html>
+<html lang="${this.#lang}">
+  <head>
+    <meta charset="utf-8" />
+    <title>${this.#app.name}</title>
+    <base href="/" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="./${CsrArtifactBuilder.entryFilename(basePath)}"></script>
+  </body>
+</html>
+  `
+    ];
+  }
+  async#loadCssAssets() {
+    if (this.#cssAssets)
+      return this.#cssAssets;
+    const artifactFile = Bun.file(path4.join(this.#artifactDir, "base-artifact.json"));
+    if (!await artifactFile.exists())
+      return {};
+    const artifact = await artifactFile.json();
+    return artifact.cssAssets ?? {};
+  }
+  async#inlineCsrArtifacts(cssAssets) {
+    const jsFiles = new Set;
+    for (const htmlPath of await this.#listOutputFiles((filePath) => filePath.endsWith(".html"))) {
+      const htmlFile = Bun.file(htmlPath);
+      if (!await htmlFile.exists())
+        continue;
+      const basePath = CsrArtifactBuilder.basePathOfHtml(htmlPath);
+      const cssAsset = cssAssets[basePath];
+      if (!cssAsset) {
+        this.#app.logger.warn(`[csr-build] base-artifact.json has no compiled stylesheet for ${basePath || "root"}; ${path4.basename(htmlPath)} ships without CSS`);
+      }
+      const inlined = await this.#inlineHtmlAssets(await htmlFile.text(), htmlPath, cssAsset);
+      for (const filePath of inlined.jsFiles)
+        jsFiles.add(filePath);
+      await Bun.write(htmlPath, inlined.html);
+    }
+    for (const filePath of jsFiles)
+      await unlink2(filePath).catch(() => {
+        return;
+      });
+    const remainingAssets = await this.#listOutputFiles((filePath) => filePath.endsWith(".js") || filePath.endsWith(".css"));
+    if (remainingAssets.length > 0) {
+      throw new Error(`[csr-build] expected single-file HTML, but CSR assets remain:
+${remainingAssets.join(`
+`)}`);
+    }
+  }
+  async#inlineHtmlAssets(html, htmlPath, cssAsset) {
+    let next = html;
+    if (cssAsset) {
+      const css = await Bun.file(path4.join(this.#artifactDir, cssAsset.cssRelPath)).text();
+      next = CsrArtifactBuilder.injectBeforeHeadEnd(next, CsrArtifactBuilder.createInlineStyle(css));
+    }
+    const jsFiles = [];
+    next = await CsrArtifactBuilder.replaceModuleScriptSrc(next, async (src) => {
+      const jsPath = CsrArtifactBuilder.resolveHtmlAssetPath(htmlPath, src);
+      jsFiles.push(jsPath);
+      return await Bun.file(jsPath).text();
+    });
+    return { html: next, jsFiles };
+  }
+  async#listOutputFiles(predicate) {
+    const glob = new Bun.Glob("**/*");
+    const files = [];
+    for await (const filePath of glob.scan({ cwd: this.#outputDir, absolute: true })) {
+      if (predicate(filePath))
+        files.push(filePath);
+    }
+    return files.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  }
+  static injectBeforeHeadEnd(html, snippet) {
+    const scannable = CsrArtifactBuilder.blankEmbeddedContent(html);
+    const headEnd = scannable.search(/<\/head\s*>/i);
+    if (headEnd !== -1)
+      return `${html.slice(0, headEnd)}${snippet}
+${html.slice(headEnd)}`;
+    const bodyStart = scannable.search(/<body(?:\s|>)/i);
+    if (bodyStart !== -1)
+      return `${html.slice(0, bodyStart)}${snippet}
+${html.slice(bodyStart)}`;
+    return `${html}
+${snippet}`;
+  }
+  static blankEmbeddedContent(html) {
+    return html.replace(/<script\b[^>]*>[\s\S]*?(?:<\/script(?:[\s/][^<>]*)?>|$)|<style\b[^>]*>[\s\S]*?(?:<\/style(?:[\s/][^<>]*)?>|$)|<!--[\s\S]*?(?:--!?>|$)/gi, (match) => " ".repeat(match.length));
+  }
+  static createInlineStyle(css) {
+    return `<style data-akan-css="active">
+${css.replace(/<\/style/gi, "<\\/style")}
+</style>`;
+  }
+  static async replaceModuleScriptSrc(html, loadScript) {
+    const scriptRe = /<script\b(?=[^>]*\btype=["']module["'])(?=[^>]*\bsrc=["']([^"']+)["'])[^>]*>\s*<\/script>/gi;
+    let result = "";
+    let lastIndex = 0;
+    let matched = false;
+    for (const match of html.matchAll(scriptRe)) {
+      const full = match[0];
+      const src = match[1];
+      if (match.index === undefined || !src)
+        continue;
+      matched = true;
+      result += html.slice(lastIndex, match.index);
+      result += `<script type="module">
+${CsrArtifactBuilder.escapeInlineScript(await loadScript(src))}
+</script>`;
+      lastIndex = match.index + full.length;
+    }
+    if (!matched)
+      return html;
+    return result + html.slice(lastIndex);
+  }
+  static escapeInlineScript(source) {
+    return source.replace(/<\/script/gi, "<\\/script");
+  }
+  static resolveHtmlAssetPath(htmlPath, src) {
+    if (/^[a-z][a-z0-9+.-]*:/i.test(src) || src.startsWith("//")) {
+      throw new Error(`[csr-build] cannot inline external script: ${src}`);
+    }
+    const normalized = src.startsWith("/") ? src.slice(1) : src;
+    return path4.resolve(path4.dirname(htmlPath), normalized);
+  }
+}
+
+export { CsrArtifactBuilder };

package/{index-192ha4xh.js → index-6nqnqzv1.js}

@@ -2,7 +2,7 @@
 import {
   AsyncDefaultExportDetector,
   resolveSsrPageEntriesForApp
-} from "./index-va06nr10.js";
+} from "./index-gxqvev8w.js";
 import {
   FileSys2
 } from "./index-52w0fvh8.js";

package/{index-dye8pnxx.js → index-73esn3y2.js}

@@ -179,7 +179,7 @@ class SubagentPool2 {
     }
   }
   async#run(id, kind, prompt, signal) {
-    const { CodeAgent } = await import("./CodeAgent-n3tzjm91.js");
+    const { CodeAgent } = await import("./CodeAgent-fee0pnwp.js");
     const budget = this.#options.parent.tools.subagent;
     const child = SubagentPool2.childOf(this.#options.parent, kind);
     const agent = await CodeAgent.create({

package/{index-4mhy6qme.js → index-7xy30jev.js}

@@ -1,16 +1,16 @@
 // @bun
 import {
   jsonText
-} from "./index-trpasv9q.js";
+} from "./index-5m0s0gdv.js";
 import {
   akanMcpInstallTargets
-} from "./index-5edzv8fn.js";
+} from "./index-tbmtmkhx.js";
 import {
   script
-} from "./index-jw1zm273.js";
+} from "./index-g5px5pxd.js";
 import {
   ContextRunner2
-} from "./index-d72hfmdm.js";
+} from "./index-cq5x7a9k.js";
 
 // pkgs/@akanjs/cli/context/context.script.ts
 import { Logger } from "akanjs/common";