@pylonsync/functions 0.22.50 → 0.22.59

package/src/runtime.ts

@@ -23,6 +23,7 @@ import type {
   EmailOptions,
   EmailSender,
   Files,
+  FileInfo,
   ActionFiles,
   Crdt,
   StoredFile,
@@ -622,8 +623,8 @@ function buildShards(callId: string): Shards {
   };
 }
 
-/** `ctx.files` — signed download URLs, minted host-side. */
-function buildFiles(callId: string): Files {
+/** `ctx.files` — signed download URLs, minted host-side, and what the host knows of a file. */
+export function buildFiles(callId: string): Files {
   return {
     async signedUrl(fileId, opts) {
       return rpc(callId, {
@@ -632,11 +633,14 @@ function buildFiles(callId: string): Files {
         ttl_secs: opts?.ttlSecs,
       }) as Promise<string>;
     },
+    async info(fileId) {
+      return rpc(callId, { type: "files_op", op: "info", file_id: fileId }) as Promise<FileInfo | null>;
+    },
   };
 }
 
-/** `ctx.files` in an action: {@link buildFiles} plus store and delete. */
-function buildActionFiles(callId: string): ActionFiles {
+/** `ctx.files` in an action: {@link buildFiles} plus store, read and delete. */
+export function buildActionFiles(callId: string): ActionFiles {
   return {
     ...buildFiles(callId),
     async store(data, opts) {
@@ -667,6 +671,15 @@ function buildActionFiles(callId: string): ActionFiles {
         file_id: fileId,
       }) as Promise<{ deleted: boolean }>;
     },
+    async read(fileId) {
+      const out = (await rpc(callId, { type: "files_op", op: "read", file_id: fileId })) as {
+        id: string;
+        contentType: string | null;
+        size: number;
+        data_base64: string;
+      };
+      return { id: out.id, contentType: out.contentType ?? null, size: out.size, data: fromBase64(out.data_base64) };
+    },
   };
 }
 

package/src/ssr-barrel-imports.test.ts

@@ -0,0 +1,70 @@
+// Namespace barrels (`radix-ui`): parsing the entry, and rewriting named
+// imports of it into imports of the packages it re-exports.
+
+import { describe, expect, test } from "bun:test";
+import { parseNamespaceBarrel, rewriteBarrelImports } from "./ssr-barrel-imports";
+
+const RADIX = `// src/index.ts
+"use client";
+import * as AlertDialog from "@radix-ui/react-alert-dialog";
+import * as Dialog from "@radix-ui/react-dialog";
+import * as unstable_PasswordToggleField from "@radix-ui/react-password-toggle-field";
+export {
+  AlertDialog,
+  Dialog,
+  unstable_PasswordToggleField
+};
+//# sourceMappingURL=index.mjs.map
+`;
+
+describe("parseNamespaceBarrel", () => {
+  test("maps each exported namespace to its package", () => {
+    expect(Object.fromEntries(parseNamespaceBarrel(RADIX)!)).toEqual({
+      AlertDialog: "@radix-ui/react-alert-dialog",
+      Dialog: "@radix-ui/react-dialog",
+      unstable_PasswordToggleField: "@radix-ui/react-password-toggle-field",
+    });
+  });
+
+  test("anything else is not a barrel", () => {
+    expect(parseNamespaceBarrel(`export const x = 1;`)).toBeNull();
+    expect(parseNamespaceBarrel(`import * as A from "a"; export { A }; console.log(1);`)).toBeNull();
+    expect(parseNamespaceBarrel(`import { a } from "a"; export { a };`)).toBeNull();
+    expect(parseNamespaceBarrel(`import * as A from "a"; export { A, B };`)).toBeNull();
+    expect(parseNamespaceBarrel(``)).toBeNull();
+  });
+});
+
+describe("rewriteBarrelImports", () => {
+  const map = parseNamespaceBarrel(RADIX)!;
+  const barrels = (spec: string) => (spec === "radix-ui" ? map : null);
+  const same = (_barrel: string, spec: string) => spec;
+
+  test("one namespace import per name, keeping local names", () => {
+    expect(
+      rewriteBarrelImports(`import { Dialog as SheetPrimitive } from "radix-ui";`, barrels, same),
+    ).toBe(`import * as SheetPrimitive from "@radix-ui/react-dialog";`);
+    expect(
+      rewriteBarrelImports(`import {\n  AlertDialog,\n  Dialog,\n} from 'radix-ui'`, barrels, same),
+    ).toBe(`import * as AlertDialog from '@radix-ui/react-alert-dialog'; import * as Dialog from '@radix-ui/react-dialog';`);
+  });
+
+  test("type imports, unknown names and other packages stay", () => {
+    expect(rewriteBarrelImports(`import type { Dialog } from "radix-ui";`, barrels, same)).toBe(
+      `import type { Dialog } from "radix-ui";`,
+    );
+    expect(
+      rewriteBarrelImports(`import { Dialog, type Foo, Missing } from "radix-ui";`, barrels, same),
+    ).toBe(
+      `import { type Foo, Missing } from "radix-ui"; import * as Dialog from "@radix-ui/react-dialog";`,
+    );
+    const other = `import { useState } from "react";`;
+    expect(rewriteBarrelImports(other, barrels, same)).toBe(other);
+  });
+
+  test("the target specifier comes from the resolver", () => {
+    expect(
+      rewriteBarrelImports(`import { Dialog } from "radix-ui";`, barrels, () => "/abs/react-dialog/index.mjs"),
+    ).toBe(`import * as Dialog from "/abs/react-dialog/index.mjs";`);
+  });
+});

package/src/ssr-barrel-imports.ts

@@ -0,0 +1,104 @@
+// Per-route vendor code for "barrel" packages.
+//
+// A barrel is a package whose entry only re-exports other packages as
+// namespaces, like `radix-ui`:
+//
+//   import * as Dialog from "@radix-ui/react-dialog";
+//   import * as Select from "@radix-ui/react-select";
+//   export { Dialog, Select };
+//
+// With code splitting, every route that imports anything from the barrel
+// reaches every package it re-exports, so the bundler puts all of them in
+// one shared chunk that loads on every such route (55 KB gzip of Radix on
+// the Veritas home screen, which uses one Radix component). Rewriting
+//
+//   import { Dialog as SheetPrimitive } from "radix-ui";
+//
+// in app source to
+//
+//   import * as SheetPrimitive from "@radix-ui/react-dialog";
+//
+// lets each route reach only the packages it uses, so the splitter keeps
+// the rest out of its chunks. The client bundler applies this to app files
+// (not node_modules) for every bare import whose entry is a barrel.
+
+/**
+ * The namespaces a barrel entry re-exports (exported name → module
+ * specifier), or null when `source` is not a pure namespace barrel: any
+ * statement other than `import * as X from "..."` and `export { ... }` of
+ * those names makes it null.
+ */
+export function parseNamespaceBarrel(source: string): Map<string, string> | null {
+  const code = source
+    .replace(/\/\*[\s\S]*?\*\//g, "")
+    .replace(/^\s*\/\/.*$/gm, "")
+    .replace(/["']use client["'];?/g, "");
+  const imports = new Map<string, string>();
+  let rest = code.replace(
+    /import\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\s+(["'])([^"']+)\2\s*;?/g,
+    (_m, local: string, _q: string, spec: string) => {
+      imports.set(local, spec);
+      return "";
+    },
+  );
+  const exported = new Map<string, string>();
+  let ok = true;
+  rest = rest.replace(/export\s*\{([^}]*)\}\s*;?/g, (_m, list: string) => {
+    for (const item of list.split(",")) {
+      const part = item.trim();
+      if (!part) continue;
+      const m = part.match(/^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+      const spec = m ? imports.get(m[1]!) : undefined;
+      if (!m || !spec) {
+        ok = false;
+        continue;
+      }
+      exported.set(m[2] ?? m[1]!, spec);
+    }
+    return "";
+  });
+  if (!ok || rest.trim() !== "" || exported.size === 0) return null;
+  return exported;
+}
+
+/**
+ * Rewrite `import { A, B as C } from "<barrel>"` in `source` to one
+ * namespace import per name, from `resolveTarget(spec)` (the specifier the
+ * importing file should use for the re-exported module). Type-only imports
+ * and names the barrel does not re-export stay on the barrel import.
+ * `barrels` maps a bare specifier to its parsed barrel. Returns the source
+ * unchanged when nothing applies.
+ */
+export function rewriteBarrelImports(
+  source: string,
+  barrels: (specifier: string) => Map<string, string> | null,
+  resolveTarget: (barrel: string, spec: string) => string,
+): string {
+  return source.replace(
+    /import\s+(type\s+)?\{([^}]*)\}\s*from\s*(["'])([^"'./][^"']*)\3\s*;?/g,
+    (whole, typeOnly: string | undefined, list: string, quote: string, specifier: string) => {
+      if (typeOnly) return whole;
+      const map = barrels(specifier);
+      if (!map) return whole;
+      const kept: string[] = [];
+      const lines: string[] = [];
+      for (const item of list.split(",")) {
+        const part = item.trim();
+        if (!part) continue;
+        const m = part.match(/^(type\s+)?([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+        const target = m && !m[1] ? map.get(m[2]!) : undefined;
+        if (!m || !target) {
+          kept.push(part);
+          continue;
+        }
+        const local = m[3] ?? m[2]!;
+        lines.push(`import * as ${local} from ${quote}${resolveTarget(specifier, target)}${quote};`);
+      }
+      if (lines.length === 0) return whole;
+      if (kept.length > 0) {
+        lines.unshift(`import { ${kept.join(", ")} } from ${quote}${specifier}${quote};`);
+      }
+      return lines.join(" ");
+    },
+  );
+}

package/src/ssr-bucket-serverdata.test.ts

@@ -0,0 +1,167 @@
+// A page with `cache = "auth-bucketed"` is stored as ONE shared entry for
+// every signed-in visitor, so its render must not depend on who rendered it.
+// Safe serverData reads apply the caller's read policies on the host, so their
+// rows depend on the caller: a signed-in render that reads serverData is
+// identity-specific and must not carry the `x-pylon-bucket` proof. Before
+// this check, Alice's render of a page listing "my notes" was stored in the
+// signed-in bucket and served to Bob.
+//
+// Each render runs in a child process (ssr-runtime.ts imports runtime.ts,
+// whose main() owns stdin/stdout). The test plays the host: it answers the
+// child's `db` requests over stdin with the rows the policy would give the
+// render's auth.
+
+import { expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const SSR_RUNTIME = join(import.meta.dir, "ssr-runtime.ts");
+const PKG_NODE_MODULES = join(import.meta.dir, "..", "node_modules");
+
+interface Frame {
+  type: string;
+  status?: number;
+  headers?: Record<string, string>;
+  data?: string;
+}
+
+function makeApp(page: string): string {
+  const dir = mkdtempSync(join(tmpdir(), "pylon-bucket-sd-"));
+  mkdirSync(join(dir, "app"), { recursive: true });
+  mkdirSync(join(dir, ".pylon", "client-build"), { recursive: true });
+  symlinkSync(PKG_NODE_MODULES, join(dir, "node_modules"), "dir");
+  writeFileSync(
+    join(dir, "app", "layout.tsx"),
+    `export default function Layout({ children }: any) {
+  return <html><head><title>t</title></head><body>{children}</body></html>;
+}
+`,
+  );
+  writeFileSync(join(dir, "app", "page.tsx"), page);
+  writeFileSync(join(dir, ".pylon", "client-build", "entry.js"), "");
+  writeFileSync(
+    join(dir, ".pylon", "client-build", "manifest.json"),
+    JSON.stringify({
+      outdir: ".pylon/client-build",
+      public_prefix: "/_pylon/build/",
+      routes: { "app/page": { file: "entry.js", imports: [], css: [] } },
+    }),
+  );
+  return dir;
+}
+
+const NOTES_PAGE = `export const cache = "auth-bucketed";
+export const revalidate = 300;
+export default async function Page({ serverData }: any) {
+  const notes = await serverData.list("Note");
+  return <ul>{notes.map((n: any) => <li key={n.id}>{"NOTE:" + n.body}</li>)}</ul>;
+}
+`;
+
+const UNSAFE_NOTES_PAGE = NOTES_PAGE.replace("serverData.list", "serverData.unsafe.list");
+
+/** Rows a `Note` read returns: the caller's own notes (owner policy) for a
+ *  safe read, every note for `serverData.unsafe`. */
+function notesFor(userId: string | null, unsafe: boolean) {
+  const all = [
+    { id: "n1", userId: "alice", body: "alice-secret" },
+    { id: "n2", userId: "bob", body: "bob-secret" },
+  ];
+  return unsafe ? all : all.filter((n) => n.userId === userId);
+}
+
+async function render(dir: string, userId: string | null) {
+  const msg = {
+    type: "render_route",
+    call_id: "c1",
+    component: "app/page",
+    layouts: ["app/layout"],
+    route_path: "/",
+    url: "/",
+    params: {},
+    search_params: {},
+    headers: { host: "app.test" },
+    cookies: {},
+    host: "app.test",
+    session_present: userId != null,
+    auth: { user_id: userId, is_admin: false, tenant_id: null, roles: [] },
+  };
+  const probe = `
+import { handleRenderRoute } from ${JSON.stringify(SSR_RUNTIME)};
+const frames = [];
+await handleRenderRoute(${JSON.stringify(msg)}, (m) => frames.push(m));
+console.error("FRAMES " + JSON.stringify(frames));
+setTimeout(() => process.exit(0), 50);
+`;
+  const probePath = join(dir, `probe-${Math.random().toString(36).slice(2)}.ts`);
+  writeFileSync(probePath, probe);
+  const proc = Bun.spawn(["bun", "run", probePath], {
+    cwd: dir,
+    env: { ...process.env, PYLON_DEV_MODE: "0" },
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  // Answer the child's db requests the way the host would.
+  const answerDb = (async () => {
+    const decoder = new TextDecoder();
+    let buf = "";
+    for await (const chunk of proc.stdout) {
+      buf += decoder.decode(chunk);
+      let nl: number;
+      while ((nl = buf.indexOf("\n")) >= 0) {
+        const line = buf.slice(0, nl);
+        buf = buf.slice(nl + 1);
+        let m: any;
+        try {
+          m = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (m.type !== "db") continue;
+        const data = m.entity === "Note" ? notesFor(userId, m.unsafe_op === true) : [];
+        proc.stdin.write(
+          JSON.stringify({ type: "result", call_id: m.call_id, op_id: m.op_id, data }) + "\n",
+        );
+        proc.stdin.flush();
+      }
+    }
+  })();
+  const err = await new Response(proc.stderr).text();
+  const code = await proc.exited;
+  await answerDb;
+  const line = err.split("\n").find((l) => l.includes("FRAMES "));
+  if (code !== 0 || !line) throw new Error(`probe failed (exit ${code})\nstderr: ${err}`);
+  const frames = JSON.parse(line.slice(line.indexOf("FRAMES ") + "FRAMES ".length)) as Frame[];
+  const html = frames
+    .filter((f) => f.type === "render_chunk")
+    .map((f) => Buffer.from(f.data!, "base64").toString("utf8"))
+    .join("");
+  const start = frames.find((f) => f.type === "response_start");
+  return { html, headers: start?.headers ?? {} };
+}
+
+test("a signed-in render that reads serverData is not stored in the shared bucket", async () => {
+  const dir = makeApp(NOTES_PAGE);
+  const alice = await render(dir, "alice");
+  expect(alice.html).toContain("NOTE:alice-secret");
+  // The proof the host needs to store this render under the signed-in
+  // bucket, where Bob's request would read it.
+  expect(alice.headers["x-pylon-bucket"]).toBeUndefined();
+});
+
+test("an anonymous render that reads serverData stays bucketable", async () => {
+  // Every anonymous visitor gets the same rows, so the signed-out entry is safe.
+  const dir = makeApp(NOTES_PAGE);
+  const anon = await render(dir, null);
+  expect(anon.html).not.toContain("NOTE:");
+  expect(anon.headers["x-pylon-bucket"]).toBe("300");
+});
+
+test("serverData.unsafe reads do not depend on the caller and stay bucketable", async () => {
+  const dir = makeApp(UNSAFE_NOTES_PAGE);
+  const signedIn = await render(dir, "alice");
+  expect(signedIn.html).toContain("NOTE:bob-secret");
+  expect(signedIn.headers["x-pylon-bucket"]).toBe("300");
+});

package/src/ssr-client-bundler.test.ts

@@ -956,12 +956,72 @@ describe("offline service worker (buildManifest({ offline }))", () => {
     expect(config.precache).not.toContain(prefix + manifest.routes["app/settings/page"].file);
     expect(config.precache).toContain("/icons/192.png");
 
+    // `/_pylon/version` serves this file.
+    const versionFile = JSON.parse(fs.readFileSync(path.join(outdir, "pylon-version.json"), "utf8"));
+    expect(versionFile.version).toBe(manifest.offline!.version);
+    expect(versionFile.builtAt).toBe(manifest.offline!.builtAt);
+    expect(Number.isNaN(Date.parse(versionFile.builtAt))).toBe(false);
+    expect(versionFile.install).toMatch(/^[0-9a-f]{16}$/);
+
     // The same build gives the same version: no reinstall per boot.
     const again = await buildClientBundle();
     const second = JSON.parse(fs.readFileSync(again.manifestPath, "utf8")) as PylonBundleManifest;
     expect(second.offline?.version).toBe(manifest.offline!.version);
   });
 
+  test("a change to the app's name or icon changes the version and the install identity", async () => {
+    const dir = makeFixture(
+      { "page.tsx": PAGE_BODY("Home"), "leads/page.tsx": PAGE_BODY("Leads") },
+      { "layout.tsx": LAYOUT_BODY },
+    );
+    tempDir = dir;
+    const offline = {
+      name: "Field Sales",
+      icons: [{ src: "/icons/192.png", sizes: "192x192" }],
+      startUrl: "/leads",
+      display: "standalone",
+      routes: ["/leads"],
+    };
+    const writeManifest = (o: object) =>
+      fs.writeFileSync(path.join(dir, "pylon.manifest.json"), JSON.stringify({ offline: o }));
+    fs.mkdirSync(path.join(dir, "public", "icons"), { recursive: true });
+    fs.writeFileSync(path.join(dir, "public", "icons", "192.png"), "icon-a");
+    writeManifest(offline);
+    originalCwd = process.cwd();
+    process.chdir(dir);
+
+    const read = async () => {
+      const { outdir } = await buildClientBundle();
+      return JSON.parse(fs.readFileSync(path.join(outdir, "pylon-version.json"), "utf8"));
+    };
+    const base = await read();
+
+    // New icon bytes at the same URL.
+    fs.writeFileSync(path.join(dir, "public", "icons", "192.png"), "icon-b");
+    const icon = await read();
+    expect(icon.install).not.toBe(base.install);
+    expect(icon.version).not.toBe(base.version);
+
+    // A new name.
+    writeManifest({ ...offline, name: "Veritas" });
+    const named = await read();
+    expect(named.install).not.toBe(icon.install);
+
+    // The app's own manifest file wins over the config.
+    fs.writeFileSync(
+      path.join(dir, "public", "manifest.webmanifest"),
+      JSON.stringify({ name: "Own", display: "standalone", icons: [] }),
+    );
+    const own = await read();
+    expect(own.install).not.toBe(named.install);
+    // A field iOS does not read at install (theme color) changes nothing.
+    fs.writeFileSync(
+      path.join(dir, "public", "manifest.webmanifest"),
+      JSON.stringify({ name: "Own", display: "standalone", icons: [], theme_color: "#000" }),
+    );
+    expect((await read()).install).toBe(own.install);
+  });
+
   test("an app without offline gets no worker", async () => {
     tempDir = makeFixture({ "page.tsx": PAGE_BODY("Home") }, { "layout.tsx": LAYOUT_BODY });
     originalCwd = process.cwd();
@@ -972,3 +1032,103 @@ describe("offline service worker (buildManifest({ offline }))", () => {
     expect(fs.existsSync(path.join(outdir, "pylon-sw.js"))).toBe(false);
   });
 });
+
+describe("instant navigation (export const navigation = \"client\")", () => {
+  test("the manifest marks the page, and its entry passes the static metadata", async () => {
+    const dir = makeFixture(
+      {
+        "page.tsx": PAGE_BODY("Home"),
+        "leads/page.tsx":
+          `export const navigation = "client";\nexport const metadata = { title: "Leads" };\n` +
+          PAGE_BODY("Leads"),
+        "reports/page.tsx": PAGE_BODY("Reports"),
+      },
+      { "layout.tsx": LAYOUT_BODY },
+    );
+    tempDir = dir;
+    originalCwd = process.cwd();
+    process.chdir(dir);
+
+    const { manifestPath, outdir } = await buildClientBundle();
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8")) as PylonBundleManifest;
+    expect(manifest.routes["app/leads/page"].navigation).toBe("client");
+    expect(manifest.routes["app/reports/page"].navigation).toBeUndefined();
+    expect(manifest.routes["app/page"].navigation).toBeUndefined();
+
+    // The built client code carries the title for the runtime; a page without
+    // static metadata imports none.
+    const code = (component: string) => {
+      const r = manifest.routes[component];
+      return [r.file, ...r.imports]
+        .map((f) => fs.readFileSync(path.join(outdir, f), "utf8"))
+        .join("\n");
+    };
+    expect(code("app/leads/page")).toMatch(/title:\s*"Leads"/);
+  });
+});
+
+describe("precompressed build files", () => {
+  test("a production build writes .br and .gz copies of its chunks; precompress: false does not", async () => {
+    const dir = makeFixture({ "page.tsx": PAGE_BODY("Home") }, { "layout.tsx": LAYOUT_BODY });
+    tempDir = dir;
+    originalCwd = process.cwd();
+    process.chdir(dir);
+
+    const { manifestPath, outdir } = await _doBuildInner(fs, path, dir, "app", { precompress: true });
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8")) as PylonBundleManifest;
+    const route = manifest.routes["app/page"];
+    // The shared chunk holds React: large, and compressed.
+    const shared = route.imports
+      .map((f) => path.join(outdir, f))
+      .sort((a, b) => fs.statSync(b).size - fs.statSync(a).size)[0];
+    expect(fs.existsSync(shared + ".br")).toBe(true);
+    expect(fs.existsSync(shared + ".gz")).toBe(true);
+    expect(fs.statSync(shared + ".br").size).toBeLessThan(fs.statSync(shared).size / 2);
+
+    const again = await _doBuildInner(fs, path, dir, "app", { precompress: false });
+    const files = fs.readdirSync(again.outdir, { recursive: true }) as string[];
+    expect(files.filter((f) => f.endsWith(".br") || f.endsWith(".gz"))).toEqual([]);
+  });
+});
+
+describe("namespace barrels (radix-ui)", () => {
+  test("a route bundles only the barrel packages it imports", async () => {
+    const dir = makeFixture(
+      {
+        "alpha/page.tsx": `import { Alpha } from "fake-ui";\nexport default function P() { return <div>{Alpha.name}</div>; }\n`,
+        "beta/page.tsx": `import { Beta as B } from "fake-ui";\nexport default function P() { return <div>{B.name}</div>; }\n`,
+      },
+      { "layout.tsx": LAYOUT_BODY },
+    );
+    tempDir = dir;
+    // A barrel and the two packages it re-exports, resolvable from app/.
+    const nm = path.join(dir, "app", "node_modules");
+    const pkg = (name: string, files: Record<string, string>) => {
+      fs.mkdirSync(path.join(nm, name), { recursive: true });
+      for (const [f, body] of Object.entries(files)) fs.writeFileSync(path.join(nm, name, f), body);
+    };
+    pkg("fake-ui", {
+      "package.json": JSON.stringify({ name: "fake-ui", module: "index.mjs", main: "index.mjs", sideEffects: false }),
+      "index.mjs": `import * as Alpha from "@fake/alpha";\nimport * as Beta from "@fake/beta";\nexport { Alpha, Beta };\n`,
+    });
+    for (const [name, marker] of [["alpha", "ALPHA_ONLY_CODE"], ["beta", "BETA_ONLY_CODE"]]) {
+      pkg(`@fake/${name}`, {
+        "package.json": JSON.stringify({ name: `@fake/${name}`, module: "index.mjs", main: "index.mjs", sideEffects: false }),
+        "index.mjs": `export const name = ${JSON.stringify(marker + " " + "x".repeat(2000))};\n`,
+      });
+    }
+    originalCwd = process.cwd();
+    process.chdir(dir);
+
+    const { manifestPath, outdir } = await _doBuildInner(fs, path, dir, "app", { precompress: false });
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8")) as PylonBundleManifest;
+    const code = (component: string) => {
+      const r = manifest.routes[component];
+      return [r.file, ...r.imports].map((f) => fs.readFileSync(path.join(outdir, f), "utf8")).join("\n");
+    };
+    expect(code("app/alpha/page")).toContain("ALPHA_ONLY_CODE");
+    expect(code("app/alpha/page")).not.toContain("BETA_ONLY_CODE");
+    expect(code("app/beta/page")).toContain("BETA_ONLY_CODE");
+    expect(code("app/beta/page")).not.toContain("ALPHA_ONLY_CODE");
+  });
+});