npm - @akanjs/devkit - Versions diffs - 3.1.0-rc.4 → 3.1.0-rc.6 - Mend

@akanjs/devkit 3.1.0-rc.4 → 3.1.0-rc.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (81) hide show

package/abstractDoc.ts +1 -1
package/agentsIndex.test.ts +4 -1
package/akanConfig/akanConfig.ts +2 -2
package/akanContext.ts +4 -4
package/akanMcpContract.ts +1 -1
package/applicationBuildRunner.test.ts +24 -1
package/applicationBuildRunner.ts +11 -1
package/biome.base.json +0 -10
package/cloud/configLock.ts +2 -1
package/cloud/globalConfig.ts +3 -2
package/codeAgent/agent/CodeAgentProxy.ts +2 -2
package/codeAgent/agent/akanCodeModel.ts +1 -1
package/codeAgent/agent/akanContextFiles.test.ts +3 -1
package/codeAgent/tools/WebToolPack.ts +4 -4
package/codeAgent/tools/akanCodePlugins.test.ts +20 -16
package/commandDecorators/command.ts +5 -4
package/createTunnel.test.ts +14 -0
package/createTunnel.ts +3 -1
package/dependencyScanner.ts +1 -1
package/devkitUtils.test.ts +1 -1
package/executors.test.ts +62 -3
package/executors.ts +26 -9
package/frontendBuild/autoImportSync.test.ts +3 -1
package/frontendBuild/clientEntryDiscovery.ts +1 -1
package/frontendBuild/csrArtifactBuilder.test.ts +30 -0
package/frontendBuild/csrArtifactBuilder.ts +5 -3
package/frontendBuild/csrDevPatcher.test.ts +4 -1
package/frontendBuild/cssBlockParser.test.ts +123 -0
package/frontendBuild/cssBlockParser.ts +132 -0
package/frontendBuild/cssCompiler.test.ts +53 -0
package/frontendBuild/cssCompiler.ts +8 -4
package/frontendBuild/fontOptimizer.ts +2 -1
package/frontendBuild/frontendBuild.test.ts +14 -0
package/frontendBuild/hmrWatcher.ts +1 -1
package/frontendBuild/pagesBundleBuilder.test.ts +98 -0
package/frontendBuild/pagesBundleBuilder.ts +64 -9
package/frontendBuild/routeClientBuilder.ts +1 -1
package/frontendBuild/sourceMtimeIndex.test.ts +1 -1
package/frontendBuild/themeValidator.test.ts +83 -2
package/frontendBuild/themeValidator.ts +37 -15
package/getRelatedCnsts.ts +2 -1
package/integration/devStabilityHarness.ts +5 -3
package/lint/__fixtures__/no-deep-internal-import/bad.tsx +1 -0
package/lint/__fixtures__/no-deep-internal-import/good.tsx +1 -0
package/lint/__fixtures__/no-import-client-functions/bad.tsx +1 -0
package/lint/__fixtures__/no-import-client-functions/good.tsx +1 -0
package/lint/__fixtures__/no-import-client-in-server/bad.tsx +1 -0
package/lint/__fixtures__/no-import-client-in-server/good.tsx +1 -0
package/lint/__fixtures__/no-import-external-library/bad.tsx +1 -0
package/lint/__fixtures__/no-import-external-library/good.tsx +1 -0
package/lint/__fixtures__/no-import-external-library-in-test/bad.tsx +1 -0
package/lint/__fixtures__/no-import-external-library-in-test/good.tsx +1 -0
package/lint/__fixtures__/no-import-server-in-client/bad.tsx +1 -0
package/lint/__fixtures__/no-import-server-in-client/good.tsx +1 -0
package/lint/__fixtures__/no-init-fetch-in-client/store-file/bad.ts +1 -1
package/lint/__fixtures__/no-static-in-object-light-model/bad.ts +2 -2
package/mobile/mobileTarget.ts +1 -2
package/mobile/nativeConfig.test.ts +3 -0
package/mobile/nativeConfig.ts +3 -2
package/mobile/nativeWebDir.ts +3 -2
package/mobile/updateUploader.test.ts +1 -0
package/mobile/updateUploader.ts +3 -3
package/package.json +2 -2
package/platformTest/LinuxDockerTarget.ts +2 -1
package/platformTest/PlatformTestTarget.ts +7 -5
package/platformTest/WindowsSshTarget.ts +2 -1
package/qualityScanner.ts +1 -1
package/recipeScanner.test.ts +9 -3
package/scanInfo.ts +1 -1
package/subspaceClone.ts +5 -4
package/testHelpers.ts +2 -0
package/transforms/barrelImportsPlugin.ts +1 -1
package/transforms/browserDirnamePlugin.test.ts +88 -0
package/transforms/browserDirnamePlugin.ts +25 -0
package/transforms/rscUseClientTransform.ts +2 -2
package/transforms/transforms.test.ts +18 -2
package/transforms/tsconfigPackageResolver.test.ts +9 -0
package/types.ts +1 -0
package/workflow/artifacts.ts +1 -1
package/workflow/rolloutGate.test.ts +5 -1
package/workflow/source.ts +2 -2

package/frontendBuild/csrArtifactBuilder.ts CHANGED Viewed

@@ -3,6 +3,7 @@ import path from "node:path";
 import type { BaseBuildArtifact } from "akanjs/server";
 import { type PageEntry, resolveSsrPageEntriesForApp } from "../artifact/implicitRootLayout";
 import type { App } from "../commandDecorators";
+import { createBrowserDirnamePlugin } from "../transforms/browserDirnamePlugin";
 import { bundleDefine } from "./bundleDefine";
 import { CsrEntryFiles } from "./csrEntryFiles";
 import { PagesBundleBuilder } from "./pagesBundleBuilder";
@@ -90,7 +91,7 @@ export class CsrArtifactBuilder {
       define: bundleDefine(app, command, "csr"),
       optimizeImports,
       // A raw `.css` in the route graph is Tailwind source; the base artifact's compiled sheet is the only stylesheet.
-      plugins: [PagesBundleBuilder.createCssStubPlugin()],
+      plugins: [PagesBundleBuilder.createCssStubPlugin(), createBrowserDirnamePlugin()],
     };
   }
@@ -234,7 +235,7 @@ void bootCsr(pages);
     for await (const filePath of glob.scan({ cwd: this.#outputDir, absolute: true })) {
       if (predicate(filePath)) files.push(filePath);
     }
-    return files.sort();
+    return files.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
   }
   // Bun hoists the module script into <head> and a React bundle contains "</head>" as text, so positions come from a
@@ -248,9 +249,10 @@ void bootCsr(pages);
     return `${html}\n${snippet}`;
   }
+  // An unclosed body runs to EOF, as the HTML tokenizer reads it; that also keeps the scan linear.
   static blankEmbeddedContent(html: string): string {
     return html.replace(
-      /<script\b[^>]*>[\s\S]*?<\/script\s*>|<style\b[^>]*>[\s\S]*?<\/style\s*>|<!--[\s\S]*?-->/gi,
+      /<script\b[^>]*>[\s\S]*?(?:<\/script(?:[\s/][^<>]*)?>|$)|<style\b[^>]*>[\s\S]*?(?:<\/style(?:[\s/][^<>]*)?>|$)|<!--[\s\S]*?(?:--!?>|$)/gi,
       (match) => " ".repeat(match.length),
     );
   }

package/frontendBuild/csrDevPatcher.test.ts CHANGED Viewed

@@ -379,7 +379,10 @@ describe("CsrDevPatcher", () => {
     await expect(patcher.update([], { roots: [file("ui/E1.tsx")], onlyRoots: true })).rejects.toThrow();
     await expect(patcher.update([], { roots: [file("ui/E4.tsx")], onlyRoots: true })).rejects.toThrow();
     const graph = (await bundler.writer.readJson<CsrDevGraph>("graph.json")) as CsrDevGraph;
-    expect(graph.pending.sort()).toEqual(["apps/demo/ui/E1.tsx", "apps/demo/ui/E4.tsx"]);
+    expect(graph.pending.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))).toEqual([
+      "apps/demo/ui/E1.tsx",
+      "apps/demo/ui/E4.tsx",
+    ]);
   });
   test("a route's check that adds its own root leaves another route's failed root pending", async () => {

package/frontendBuild/cssBlockParser.test.ts ADDED Viewed

@@ -0,0 +1,123 @@
+import { describe, expect, test } from "bun:test";
+import { type CssBlock, CssBlockParser, type CssNode } from "./cssBlockParser";
+const blocksOf = (block: CssBlock) => block.nodes.filter((node): node is CssBlock => node.kind === "block");
+const declarationsOf = (block: CssBlock) =>
+  block.nodes.flatMap((node) => (node.kind === "declaration" ? [[node.property, node.value]] : []));
+const expectLinear = (run: () => unknown) => {
+  const started = performance.now();
+  run();
+  expect(performance.now() - started).toBeLessThan(1000);
+};
+describe("CssBlockParser.parse", () => {
+  test("reads consecutive blocks with their preludes and declarations", () => {
+    const root = CssBlockParser.parse(`a { --x: 1; } b { --y: 2 } c{--z:3}`);
+    expect(blocksOf(root).map((block) => block.prelude)).toEqual(["a", "b", "c"]);
+    expect(blocksOf(root).map(declarationsOf)).toEqual([[["--x", "1"]], [["--y", "2"]], [["--z", "3"]]]);
+  });
+  test("nests at-rules and nested rules, keeping a block's own declarations apart from its children's", () => {
+    const root = CssBlockParser.parse(
+      `@media (min-width: 1px) { :root { --a: 1; } } .card { color: red; &:hover { color: blue; } --b: 2; }`,
+    );
+    const [media, card] = blocksOf(root);
+    expect(media.atRule).toBe("@media");
+    expect(media.prelude).toBe("@media (min-width: 1px)");
+    expect(declarationsOf(blocksOf(media)[0])).toEqual([["--a", "1"]]);
+    expect(card.atRule).toBeNull();
+    expect(declarationsOf(card)).toEqual([
+      ["color", "red"],
+      ["--b", "2"],
+    ]);
+    expect(blocksOf(card).map((block) => block.prelude)).toEqual(["&:hover"]);
+  });
+  test("treats at-rule statements as neither blocks nor declarations", () => {
+    const root = CssBlockParser.parse(
+      `@source "./**/*";\n@import "tailwindcss";\n@custom-variant dark (&:where([data-theme="dark"], [data-theme="dark"] *));\n:root { --a: 1; }`,
+    );
+    expect(root.nodes).toEqual([
+      { kind: "block", prelude: ":root", atRule: null, nodes: [{ kind: "declaration", property: "--a", value: "1" }] },
+    ]);
+  });
+  test("ignores braces, semicolons and comment markers inside strings, comments and escapes", () => {
+    const root = CssBlockParser.parse(
+      [
+        `/* :root { --commented: 1; } */`,
+        `.a::before { content: "} ; /* {"; --q: 'x;y'; }`,
+        `.w-\\[10px\\]\\{ { --escaped: 1; }`,
+        `.b { background: url(data:image/png;base64,AAAA); --after: 2; }`,
+      ].join("\n"),
+    );
+    expect(blocksOf(root).map((block) => block.prelude)).toEqual([".a::before", ".w-\\[10px\\]\\{", ".b"]);
+    expect(blocksOf(root).map(declarationsOf)).toEqual([
+      [
+        ["content", `"} ; /* {"`],
+        ["--q", "'x;y'"],
+      ],
+      [["--escaped", "1"]],
+      [
+        ["background", "url(data:image/png;base64,AAAA)"],
+        ["--after", "2"],
+      ],
+    ]);
+  });
+  test("drops comments from preludes and values", () => {
+    const root = CssBlockParser.parse(`/* lead */ :root /* mid */ , [data-theme="dark"] { --a: /* x */ #fff; }`);
+    const [block] = blocksOf(root);
+    expect(block.prelude).toBe(`:root  , [data-theme="dark"]`);
+    expect(declarationsOf(block)).toEqual([["--a", "#fff"]]);
+  });
+  test("closes what the input leaves open and tolerates a stray closing brace", () => {
+    const root = CssBlockParser.parse(`} :root { --a: 1; .x { --b: 2`);
+    const [rootBlock] = blocksOf(root);
+    expect(declarationsOf(rootBlock)).toEqual([["--a", "1"]]);
+    expect(declarationsOf(blocksOf(rootBlock)[0])).toEqual([["--b", "2"]]);
+    expect(CssBlockParser.parse(`.a { content: "unterminated\n--b: 2; }`).nodes).toHaveLength(1);
+    expect(CssBlockParser.parse(`.a { --b: 1 } /* unterminated`).nodes).toHaveLength(1);
+  });
+});
+describe("CssBlockParser.walk", () => {
+  test("visits in source order, passing each block's context to its children", () => {
+    const root = CssBlockParser.parse(
+      `.a { --x: 1; @media m { --y: 2; } --z: 3; } @theme { --skipped: 1; } .b { --w: 4 }`,
+    );
+    const visited: string[] = [];
+    CssBlockParser.walk(root, "", (node: CssNode, path: string) => {
+      if (node.kind === "declaration") {
+        visited.push(`${path}${node.property}`);
+        return null;
+      }
+      return node.atRule === "@theme" ? null : `${path}${node.prelude}>`;
+    });
+    expect(visited).toEqual([".a>--x", ".a>@media m>--y", ".a>--z", ".b>--w"]);
+  });
+  test("walks a deeply nested tree without recursion", () => {
+    const root = CssBlockParser.parse(`${"@media x{".repeat(100_000)}:root{--deep:1}`);
+    let found = "";
+    CssBlockParser.walk(root, true, (node) => {
+      if (node.kind === "declaration") found = node.property;
+      return true;
+    });
+    expect(found).toBe("--deep");
+  });
+});
+describe("CssBlockParser linear time", () => {
+  test("adversarial runs finish well under a second", () => {
+    expectLinear(() => CssBlockParser.parse(`}${" ".repeat(100_000)}`));
+    expectLinear(() => CssBlockParser.parse(`:root{${"--".repeat(100_000)}`));
+    expectLinear(() => CssBlockParser.parse("@theme".repeat(100_000)));
+    expectLinear(() => CssBlockParser.parse("/*".repeat(100_000)));
+    expectLinear(() => CssBlockParser.parse(`"${"\\".repeat(100_000)}`));
+    expectLinear(() => CssBlockParser.parse("(".repeat(100_000)));
+    expectLinear(() => CssBlockParser.parse(":root{--a:#fff}".repeat(100_000)));
+  });
+});

package/frontendBuild/cssBlockParser.ts ADDED Viewed

@@ -0,0 +1,132 @@
+export interface CssDeclaration {
+  kind: "declaration";
+  property: string;
+  value: string;
+}
+export interface CssBlock {
+  kind: "block";
+  prelude: string;
+  atRule: string | null;
+  nodes: CssNode[];
+}
+export type CssNode = CssDeclaration | CssBlock;
+export class CssBlockParser {
+  readonly #css: string;
+  readonly #stack: CssBlock[] = [{ kind: "block", prelude: "", atRule: null, nodes: [] }];
+  #pendingParts: string[] = [];
+  #segmentStart = 0;
+  #parenDepth = 0;
+  constructor(css: string) {
+    this.#css = css;
+  }
+  static parse(css: string): CssBlock {
+    return new CssBlockParser(css).#run();
+  }
+  static walk<T>(root: CssBlock, context: T, visit: (node: CssNode, context: T) => T | null) {
+    const stack = [{ nodes: root.nodes, idx: 0, context }];
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      const node = frame.nodes[frame.idx];
+      if (!node) {
+        stack.pop();
+        continue;
+      }
+      frame.idx += 1;
+      const childContext = visit(node, frame.context);
+      if (node.kind === "block" && childContext !== null)
+        stack.push({ nodes: node.nodes, idx: 0, context: childContext });
+    }
+  }
+  #run(): CssBlock {
+    const css = this.#css;
+    let idx = 0;
+    while (idx < css.length) {
+      const char = css[idx];
+      if (char === "/" && css[idx + 1] === "*") {
+        this.#pendingParts.push(css.slice(this.#segmentStart, idx));
+        const end = css.indexOf("*/", idx + 2);
+        idx = end === -1 ? css.length : end + 2;
+        this.#segmentStart = idx;
+        continue;
+      }
+      if (char === "\\") {
+        idx += 2;
+        continue;
+      }
+      if (char === '"' || char === "'") {
+        idx = this.#skipString(idx);
+        continue;
+      }
+      if (char === "(") this.#parenDepth += 1;
+      else if (char === ")") this.#parenDepth = Math.max(0, this.#parenDepth - 1);
+      else if (char === "{") this.#openBlock(idx);
+      else if (char === "}") this.#closeBlock(idx);
+      //? A `;` inside parentheses belongs to the value, as in an unquoted `url(data:image/png;base64,…)`.
+      else if (char === ";" && this.#parenDepth === 0) this.#endStatement(idx);
+      idx += 1;
+    }
+    this.#endStatement(css.length);
+    return this.#stack[0];
+  }
+  get #current(): CssBlock {
+    return this.#stack[this.#stack.length - 1];
+  }
+  // An unterminated string ends at the newline, as the CSS tokenizer's bad-string does.
+  #skipString(start: number): number {
+    const css = this.#css;
+    const quote = css[start];
+    let idx = start + 1;
+    while (idx < css.length) {
+      const char = css[idx];
+      if (char === "\\") idx += 2;
+      else if (char === quote) return idx + 1;
+      else if (char === "\n") return idx;
+      else idx += 1;
+    }
+    return css.length;
+  }
+  #takeSegment(end: number): string {
+    const text = this.#pendingParts.join("") + this.#css.slice(this.#segmentStart, end);
+    this.#pendingParts = [];
+    this.#segmentStart = end + 1;
+    return text.trim();
+  }
+  #openBlock(idx: number) {
+    const prelude = this.#takeSegment(idx);
+    const block: CssBlock = { kind: "block", prelude, atRule: CssBlockParser.#atRuleOf(prelude), nodes: [] };
+    this.#current.nodes.push(block);
+    this.#stack.push(block);
+    this.#parenDepth = 0;
+  }
+  #closeBlock(idx: number) {
+    this.#endStatement(idx);
+    if (this.#stack.length > 1) this.#stack.pop();
+    this.#parenDepth = 0;
+  }
+  #endStatement(idx: number) {
+    const text = this.#takeSegment(idx);
+    if (!text || text.startsWith("@")) return;
+    const colon = text.indexOf(":");
+    if (colon <= 0) return;
+    const property = text.slice(0, colon).trim();
+    if (!/^[\w-]+$/.test(property)) return;
+    this.#current.nodes.push({ kind: "declaration", property, value: text.slice(colon + 1).trim() });
+  }
+  static #atRuleOf(prelude: string): string | null {
+    return prelude.match(/^@[\w-]+/)?.[0].toLowerCase() ?? null;
+  }
+}

package/frontendBuild/cssCompiler.test.ts ADDED Viewed

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "bun:test";
+import { declaredCustomProperties } from "./cssCompiler";
+describe("declaredCustomProperties", () => {
+  test("names what the regex-based version named", () => {
+    expect(declaredCustomProperties(":root { --kakao: #fee500; --naver: #1ec800; }")).toEqual(["--kakao", "--naver"]);
+    expect(declaredCustomProperties("@theme inline {\n  --color-brand: var(--brand);\n}\n")).toEqual([]);
+    expect(declaredCustomProperties("@theme { --color-x: initial; }\n:root { --brand: #111; }")).toEqual(["--brand"]);
+    expect(declaredCustomProperties(".a { color: var(--kakao); }")).toEqual([]);
+    expect(declaredCustomProperties(":root{--a:#111}\n@media (min-width:1px){:root{--a:#222;--b:#333}}")).toEqual([
+      "--a",
+      "--b",
+    ]);
+    expect(declaredCustomProperties(":root { --a : 1; --b:2 }")).toEqual(["--a", "--b"]);
+    expect(declaredCustomProperties(".a{--x:1}.b{--y:2}.c{--z:3}")).toEqual(["--x", "--y", "--z"]);
+    expect(declaredCustomProperties("--top: 1;")).toEqual(["--top"]);
+    expect(declaredCustomProperties("@property --percentage { syntax: '<number>'; inherits: false; }")).toEqual([]);
+  });
+  test("keeps source order across nested rules", () => {
+    expect(declaredCustomProperties(".x { --a: 1; .y { --b: 2; } --c: 3; }")).toEqual(["--a", "--b", "--c"]);
+  });
+  test("skips a whole @theme block, nested blocks included", () => {
+    const css = `@theme { --animate-spin: spin 1s; @keyframes spin { to { --inner: 1; } } --color-after: red; } :root { --kept: 1; }`;
+    expect(declaredCustomProperties(css)).toEqual(["--kept"]);
+  });
+  test("ignores comments and strings, so a comment mentioning @theme hides nothing", () => {
+    const css = [
+      "/* `@theme` extension does not work from a lib, so these are plain variables. */",
+      ":root { --kakao: #fee500; }",
+      "/* :root { --commented: 1; } */",
+      `.a::before { content: "--quoted: 1"; }`,
+    ].join("\n");
+    expect(declaredCustomProperties(css)).toEqual(["--kakao"]);
+  });
+  test("adversarial input finishes well under a second", () => {
+    for (const css of [
+      "@theme".repeat(100_000),
+      "@theme{".repeat(100_000),
+      `@theme ${"x".repeat(100_000)}`,
+      `:root{${"--".repeat(100_000)}`,
+      " --a".repeat(100_000),
+      "@media x{".repeat(100_000),
+    ]) {
+      const started = performance.now();
+      declaredCustomProperties(css);
+      expect(performance.now() - started).toBeLessThan(1000);
+    }
+  });
+});

package/frontendBuild/cssCompiler.ts CHANGED Viewed

@@ -6,6 +6,7 @@ import type { App } from "../commandDecorators";
 import { BarrelAnalyzer } from "../transforms/barrelAnalyzer";
 import { createTsconfigPackageResolver, rewriteBarrelImports } from "../transforms/barrelImportsPlugin";
 import { CsrEntryFiles } from "./csrEntryFiles";
+import { CssBlockParser } from "./cssBlockParser";
 import { CssCandidateCache } from "./cssCandidateCache";
 import { CssImportResolver } from "./cssImportResolver";
@@ -387,10 +388,13 @@ export function isIgnoredNodeModuleSource(filePath: string): boolean {
 /** Skips `@theme` blocks: Tailwind emits those variables only when a utility uses one. */
 export function declaredCustomProperties(css: string): string[] {
-  const withoutThemeBlocks = css.replace(/@theme[^{]*\{[^}]*\}/g, "");
-  return [...new Set([...withoutThemeBlocks.matchAll(/(?:^|[\s;{])(--[\w-]+)\s*:/g)].map(([, name]) => name))].filter(
-    (name): name is string => !!name,
-  );
+  const names = new Set<string>();
+  CssBlockParser.walk(CssBlockParser.parse(css), true, (node) => {
+    if (node.kind === "block") return node.atRule === "@theme" ? null : true;
+    if (node.property.startsWith("--")) names.add(node.property);
+    return null;
+  });
+  return [...names];
 }
 export function getPageKeyBasePath(pageKey: string, basePaths: string[]): string | null {

package/frontendBuild/fontOptimizer.ts CHANGED Viewed

@@ -425,7 +425,8 @@ export class FontOptimizer {
       if (!isDir) continue;
       const filePaths: string[] = [];
       for await (const filePath of glob.scan({ cwd: root, absolute: true })) filePaths.push(filePath);
-      for (const filePath of filePaths.sort()) parts.push(await Bun.file(filePath).text());
+      for (const filePath of filePaths.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)))
+        parts.push(await Bun.file(filePath).text());
     }
     return parts.join("");
   }

package/frontendBuild/frontendBuild.test.ts CHANGED Viewed

@@ -195,6 +195,20 @@ describe("CsrArtifactBuilder", () => {
     );
   });
+  test("blanks embedded bodies the way the HTML tokenizer closes them", () => {
+    const blank = (html: string) => CsrArtifactBuilder.blankEmbeddedContent(html).trim();
+    expect(blank("<script>a</script >")).toBe("");
+    expect(blank("<script>a</script\t\n bar>")).toBe("");
+    expect(blank("<SCRIPT>a</SCRIPT>")).toBe("");
+    expect(blank("<style>a</style foo>")).toBe("");
+    expect(blank("<!-- a --!></head>")).toBe("</head>");
+    expect(blank("<script>a</scripts></head>")).toBe("");
+    expect(blank("<!-- a </head>")).toBe("");
+    expect(CsrArtifactBuilder.blankEmbeddedContent(`<!--${"<!--".repeat(50_000)}`)).toHaveLength(200_004);
+    expect(CsrArtifactBuilder.blankEmbeddedContent(`<script>${"</script\t".repeat(50_000)}`)).toHaveLength(450_008);
+  });
   test("gives each basePath its own routes plus the routes outside every basePath", () => {
     const entries = [
       { key: "./_layout.tsx", moduleAbsPath: "/repo/page/_layout.tsx" },

package/frontendBuild/hmrWatcher.ts CHANGED Viewed

@@ -197,7 +197,7 @@ export class HmrWatcher {
     const gaps = this.#index.coverageGaps;
     const key = gaps
       .map((gap) => `${gap.code}:${gap.path}`)
-      .sort()
+      .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
       .join("|");
     if (key === this.#reportedGaps) return;
     this.#reportedGaps = key;

package/frontendBuild/pagesBundleBuilder.test.ts ADDED Viewed

@@ -0,0 +1,98 @@
+import { describe, expect, test } from "bun:test";
+import { PagesBundleBuilder } from "./pagesBundleBuilder";
+const macroImport = `import { getSerializedSignal } from "./sig" with { type: "macro" };`;
+const macroFetchProto =
+  "const fetchProto = FetchClient.build<typeof signal>(cnst, getSerializedSignal(), { Err: pageProto.Err });";
+const serverImport = `import { fetch as serverFetch } from "./sig";`;
+const serverFetchProto =
+  "const fetchProto = FetchClient.build<typeof signal>(cnst, serverFetch.serializedSignal, { Err: pageProto.Err, base: serverFetch });";
+const generatedUseClient = (lines: { importLine?: string; fetchProtoLine?: string } = {}) =>
+  [
+    'import { makePageProto, registerClientRuntime } from "akanjs/client";',
+    'import { FetchClient } from "akanjs/fetch";',
+    'import * as cnst from "./cnst";',
+    'import type * as dict from "./dict";',
+    lines.importLine ?? macroImport,
+    'import type * as signal from "./sig";',
+    "",
+    "// dict.ts is cumulative, so a lib dictionary is a subset of the mounting app's. Translator state is global,",
+    "const dictionary = {};",
+    "const pageProto = makePageProto<typeof dict>(dictionary);",
+    lines.fetchProtoLine ?? macroFetchProto,
+    'export const runtime = registerClientRuntime({ ...pageProto, ...fetchProto }, { scope: "lib" });',
+    "",
+    "export const { msg, Err, usePage, sig, fetch } = runtime;",
+    "",
+  ].join("\n");
+const transform = (source: string) => PagesBundleBuilder.transformServerUseClientFetchSource(source);
+describe("PagesBundleBuilder.transformServerUseClientFetchSource", () => {
+  test("swaps the signal macro for the live server fetch in the generated useClient.ts", () => {
+    expect(transform(generatedUseClient())).toBe(
+      generatedUseClient({ importLine: serverImport, fetchProtoLine: serverFetchProto }),
+    );
+  });
+  test("accepts the spacing and quoting variants the regex-based version accepted", () => {
+    const source = generatedUseClient({
+      importLine: `import   {getSerializedSignal}   from './sig'   with {type : 'macro'};`,
+      fetchProtoLine: [
+        "const fetchProto=FetchClient.build<typeof signal>(",
+        "  cnst,",
+        "  getSerializedSignal(),",
+        "  { Err: pageProto.Err },",
+        ");",
+      ].join("\n"),
+    }).replace("import type * as dict", `import { x } from "./x" with { type: "macro" };\nimport type * as dict`);
+    const transformed = transform(source);
+    expect(transformed).toContain(`\n${serverImport}\n`);
+    expect(transformed).toContain(`\n${serverFetchProto}\nexport const runtime`);
+    expect(transformed).not.toContain("getSerializedSignal");
+  });
+  test("keeps an export modifier in front of the rewritten declaration", () => {
+    const transformed = transform(generatedUseClient({ fetchProtoLine: `export ${macroFetchProto}` }));
+    expect(transformed).toContain(`\nexport ${serverFetchProto}\n`);
+  });
+  test("leaves comments and strings that spell the statements alone", () => {
+    const source = generatedUseClient().replace(
+      "const dictionary = {};",
+      `// ${macroFetchProto}\nconst note = "${macroImport.replaceAll('"', "'")}";\nconst dictionary = {};`,
+    );
+    const transformed = transform(source);
+    expect(transformed).toContain(`// ${macroFetchProto}\n`);
+    expect(transformed).toContain(`const note = "${macroImport.replaceAll('"', "'")}";`);
+    expect(transformed).toContain(`\n${serverImport}\n`);
+    expect(transformed).toContain(`\n${serverFetchProto}\n`);
+  });
+  test("returns sources it does not recognise unchanged", () => {
+    const transformed = generatedUseClient({ importLine: serverImport, fetchProtoLine: serverFetchProto });
+    expect(transform(transformed)).toBe(transformed);
+    const typeOnly = generatedUseClient({ importLine: macroImport.replace("import {", "import type {") });
+    expect(transform(typeOnly)).toContain(`import type { getSerializedSignal } from "./sig" with { type: "macro" };`);
+    const aliased = generatedUseClient({
+      importLine: macroImport.replace("getSerializedSignal", "getSerializedSignal as g"),
+    });
+    expect(transform(aliased)).toContain(`import { getSerializedSignal as g } from "./sig" with { type: "macro" };`);
+    const withoutMacro = 'import { x } from "./y";\n';
+    expect(transform(withoutMacro)).toBe(withoutMacro);
+  });
+  test("adversarial input finishes well under a second", () => {
+    const marker = `${macroImport}\nFetchClient.build\n`;
+    for (const source of [
+      marker + "const fetchProto=FetchClient.build<".repeat(100_000),
+      marker + `import { getSerializedSignal } from "./sig" with { type: `.repeat(100_000),
+      marker + "{".repeat(100_000),
+    ]) {
+      const started = performance.now();
+      transform(source);
+      expect(performance.now() - started).toBeLessThan(1000);
+    }
+  });
+});

package/frontendBuild/pagesBundleBuilder.ts CHANGED Viewed

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import type { BunPlugin } from "bun";
+import ts from "typescript";
 import type { PageEntry } from "../artifact/implicitRootLayout";
 import { resolveSsrPageEntriesForApp } from "../artifact/implicitRootLayout";
 import type { App } from "../commandDecorators";
@@ -25,6 +26,12 @@ export interface BuildPagesBundleResult {
   chunkCount: number;
 }
+interface TextSpan {
+  start: number;
+  end: number;
+  text: string;
+}
 const VIRTUAL_PAGES_ENTRY = "akan-pages-entry";
 export class PagesBundleBuilder {
@@ -174,14 +181,62 @@ export class PagesBundleBuilder {
   static transformServerUseClientFetchSource(source: string): string {
     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 });",
-      );
+    const tokens = PagesBundleBuilder.#tokenize(source);
+    const edits: TextSpan[] = [];
+    const importAt = PagesBundleBuilder.#indexOfTokens(tokens, PagesBundleBuilder.#macroImportTokens);
+    if (importAt !== -1)
+      edits.push({
+        start: tokens[importAt].start,
+        end: tokens[importAt + PagesBundleBuilder.#macroImportTokens.length - 1].end,
+        text: `import { fetch as serverFetch } from "./sig";`,
+      });
+    const fetchProtoAt = PagesBundleBuilder.#indexOfTokens(tokens, PagesBundleBuilder.#fetchProtoTokens);
+    const fetchProtoEnd = fetchProtoAt === -1 ? undefined : tokens.slice(fetchProtoAt).find(({ text }) => text === ";");
+    if (fetchProtoEnd)
+      edits.push({
+        start: tokens[fetchProtoAt].start,
+        end: fetchProtoEnd.end,
+        text: "const fetchProto = FetchClient.build<typeof signal>(cnst, serverFetch.serializedSignal, { Err: pageProto.Err, base: serverFetch });",
+      });
+    let transformed = source;
+    for (const { start, end, text } of edits.sort((a, b) => b.start - a.start))
+      transformed = transformed.slice(0, start) + text + transformed.slice(end);
+    return transformed;
+  }
+  static readonly #macroImportTokens = [
+    "import",
+    "{",
+    "getSerializedSignal",
+    "}",
+    "from",
+    '"./sig"',
+    "with",
+    "{",
+    "type",
+    ":",
+    '"macro"',
+    "}",
+    ";",
+  ] as const;
+  static readonly #fetchProtoTokens = ["const", "fetchProto", "=", "FetchClient", ".", "build", "<"] as const;
+  //? The scanner, not the parser: parsing recurses per nesting level and overflows the stack on a deep `{` run.
+  static #tokenize(source: string): TextSpan[] {
+    const scanner = ts.createScanner(ts.ScriptTarget.Latest, true, ts.LanguageVariant.Standard, source);
+    const tokens: TextSpan[] = [];
+    for (let kind = scanner.scan(); kind !== ts.SyntaxKind.EndOfFileToken; kind = scanner.scan()) {
+      const text =
+        kind === ts.SyntaxKind.StringLiteral ? JSON.stringify(scanner.getTokenValue()) : scanner.getTokenText();
+      tokens.push({ text, start: scanner.getTokenStart(), end: scanner.getTokenEnd() });
+    }
+    return tokens;
+  }
+  static #indexOfTokens(tokens: TextSpan[], pattern: readonly string[]): number {
+    for (let idx = 0; idx + pattern.length <= tokens.length; idx += 1) {
+      if (pattern.every((text, offset) => tokens[idx + offset].text === text)) return idx;
+    }
+    return -1;
   }
 }

package/frontendBuild/routeClientBuilder.ts CHANGED Viewed

@@ -244,7 +244,7 @@ export class RouteClientBuilder {
   //? a probe export and only the ones the parser reports as exports are declarations.
   static #declaredNamedDefaultFunctions(source: string, filePath?: string) {
     const candidates = [
-      ...source.matchAll(/(^|\n)(\s*)export\s+default\s+(async\s+)?function\s+([A-Za-z_$][\w$]*)(?=\s*(?:<|\())/g),
+      ...source.matchAll(/(^|\n)([^\S\n]*)export\s+default\s+(async\s+)?function\s+([A-Za-z_$][\w$]*)(?=\s*(?:<|\())/g),
     ].map((match) => ({
       index: match.index,
       text: match[0],

package/frontendBuild/sourceMtimeIndex.test.ts CHANGED Viewed

@@ -50,7 +50,7 @@ describe("SourceMtimeIndex", () => {
     for (const [i, abs] of files.entries()) await rewrite(abs, `${i}00`);
-    expect((await index.collectChanges()).sort()).toEqual([...files].sort());
+    expect((await index.collectChanges()).sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))).toEqual([...files].sort());
   });
   test("reports a change once, then stops reporting it", async () => {