@pylonsync/functions 0.22.58 → 0.22.60

package/dist/ssr-client-bundler.d.ts

@@ -213,4 +213,31 @@ export declare function getManifest(): Promise<PylonBundleManifest>;
  * right tree).
  */
 export declare function handleBundleClient(msg: BundleClientMessage, send: Send): Promise<void>;
+/**
+ * Assets JavaScript imports (a `.wasm`, an image) as absolute URLs under the
+ * build prefix. Bun's `file` loader exports a RELATIVE path ("assets/x.wasm"),
+ * and code that fetches it resolves it against the page: loro-crdt's browser
+ * build fetched /dashboard/orgs/acme/assets/loro_wasm_bg-….wasm and 404'd.
+ * Bun's `publicPath` would make it absolute, but it also rewrites imports
+ * between split chunks and drops their `chunks/` directory (Bun 1.3.14), so
+ * this plugin writes the file itself, named by its content hash, and exports
+ * the absolute URL. A stylesheet's `url(...)` is left to Bun: CSS cannot
+ * import a JavaScript module.
+ */
+/**
+ * The outdir-relative chunks a built entry reaches through STATIC imports,
+ * nearest first. Specifiers are relative to the importing file: an entry
+ * imports `./chunks/<file>.js`, a chunk imports its siblings as
+ * `./<file>.js`. Following only the first form dropped every chunk-to-chunk
+ * import, so those chunks were missing from the route's modulepreload set
+ * and loaded in a second wave (3 of 28 files on the Veritas home page).
+ *
+ * DYNAMIC `import("Y")` is deliberately not followed. This list becomes the
+ * route's modulepreload set, and a chunk the author deferred behind
+ * `import()` must not be downloaded eagerly: that would ship every byte the
+ * split was meant to defer. The trailing `(` tells the forms apart; Bun's
+ * minified output quotes specifiers plainly, so one pattern covers
+ * `import X from "Y"`, `import{a}from"Y"` and bare `import "Y"`.
+ */
+export declare function staticImportGraph(fs: any, path: any, outdir: string, entryAbsPath: string, chunkRelPaths: Set<string>): Set<string>;
 export {};

package/dist/ssr-client-nav.d.ts

@@ -20,6 +20,13 @@ type MatchRoute = (manifest: any, pathname: string) => ClientRouteMatch | null;
  * A static scan: the bundler reads the page file without running it.
  */
 export declare function declaresClientNavigation(source: string): boolean;
+/**
+ * `source` with `//` and `/* *\/` comments replaced by spaces, so a static
+ * scan sees code only (a commented-out export is not an export). Strings
+ * and template literals are skipped over intact, so a `//` inside one is
+ * not taken for a comment.
+ */
+export declare function stripComments(source: string): string;
 /** Whether `pathname` is one of the app's offline routes. */
 export declare function isOfflinePath(manifest: ClientNavManifest | null, pathname: string, matchRoute: MatchRoute): boolean;
 /**

package/dist/ssr-route-assets.d.ts

@@ -16,7 +16,8 @@ export interface RouteAssetManifest {
 export interface RouteAssetFiles {
     /** `<link rel="stylesheet">` (or inlined `<style>`) in the head. */
     styles: string[];
-    /** `<link rel="modulepreload">` in the head. */
+    /** `<link rel="modulepreload">` in the head: the route entry, then its
+     *  static import graph (see `modulepreloadFiles`). */
     preloads: string[];
     /** `<link rel="preload" as="font">` in the head. */
     fonts: string[];
@@ -24,6 +25,24 @@ export interface RouteAssetFiles {
      *  route entry. */
     scripts: string[];
 }
+/**
+ * The most `<link rel="modulepreload">` tags a page's head carries. Every
+ * file in the route's static graph is needed before hydration, so the list
+ * is complete for any real route; the cap keeps a pathological graph from
+ * bloating the head. Past it, the browser finds the rest by import.
+ */
+export declare const MAX_MODULEPRELOADS = 64;
+/**
+ * The files to modulepreload for a route: its entry first, then its static
+ * import graph (the manifest's `imports`, nearest first), capped at
+ * `MAX_MODULEPRELOADS`. The entry's `<script>` sits at the end of the body,
+ * after a streamed page's Suspense boundaries, so without its preload the
+ * page's own code started last.
+ */
+export declare function modulepreloadFiles(route: {
+    file: string;
+    imports?: string[];
+}): string[];
 /** The scripts the hydration tail loads for a route entry. */
 export declare function routeScriptFiles(route: {
     file: string;

package/dist/types.d.ts

@@ -240,6 +240,24 @@ export interface DbWriter extends DbReader {
     insert(entity: string, data: Record<string, unknown>): Promise<string>;
     /** Update a row by ID. Returns true if the row existed. */
     update(entity: string, id: string, data: Record<string, unknown>): Promise<boolean>;
+    /**
+     * Insert many rows of one entity. Returns their IDs, in order. Same
+     * result as calling `insert` per row, with fewer database round trips:
+     * use it for imports and other loops that write many rows. When a row
+     * fails, the call throws; let the error end the mutation so it rolls
+     * back.
+     */
+    insertMany(entity: string, rows: Record<string, unknown>[]): Promise<string[]>;
+    /**
+     * Update many rows of one entity. Returns, per row and in order, true if
+     * the row existed. Same result as calling `update` per row, with fewer
+     * database round trips. When a row fails, the call throws; let the error
+     * end the mutation so it rolls back.
+     */
+    updateMany(entity: string, rows: {
+        id: string;
+        data: Record<string, unknown>;
+    }[]): Promise<boolean[]>;
     /** Delete a row by ID. Returns true if the row existed. */
     delete(entity: string, id: string): Promise<boolean>;
     /** Link two entities via a relation. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pylonsync/functions",
-  "version": "0.22.58",
+  "version": "0.22.60",
   "description": "TypeScript function runtime for pylon — defines server-side queries, mutations, and actions.",
   "type": "module",
   "main": "src/index.ts",
@@ -58,7 +58,7 @@
     "@types/react-dom": "^19.0.0",
     "browserslist": "^4.29.1",
     "core-js": "^3.50.0",
-    "happy-dom": "^20.8.9",
+    "happy-dom": "^21.0.4",
     "lightningcss": "~1.32.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"

package/src/runtime-db.test.ts

@@ -42,6 +42,11 @@ reader.get("Todo", "r1").catch(() => {});
 reader.unsafe.get("Todo", "r2").catch(() => {});
 writer.update("Todo", "w1", { a: 1 }).catch(() => {});
 writer.unsafe.update("Todo", "w2", { a: 2 }).catch(() => {});
+writer.insertMany("Many", [{ a: 3 }, { a: 4 }]).catch(() => {});
+writer.unsafe.updateMany("Many", [{ id: "m1", data: { a: 5 } }]).catch(() => {});
+// An empty batch sends nothing.
+writer.insertMany("Empty", []).catch(() => {});
+writer.updateMany("Empty", []).catch(() => {});
 
 setTimeout(() => process.exit(0), 300);
 `;
@@ -83,4 +88,11 @@ test("db builders: required unsafe surface, no chaining, unsafe_op flag routing"
   expect(byId("r2")).toMatchObject({ op: "get", unsafe_op: true });
   expect(byId("w1")).toMatchObject({ op: "update", unsafe_op: false });
   expect(byId("w2")).toMatchObject({ op: "update", unsafe_op: true });
+
+  const many = frames.filter((f) => f.entity === "Many");
+  expect(many).toEqual([
+    expect.objectContaining({ op: "insert_many", data: [{ a: 3 }, { a: 4 }], unsafe_op: false }),
+    expect.objectContaining({ op: "update_many", data: [{ id: "m1", data: { a: 5 } }], unsafe_op: true }),
+  ]);
+  expect(frames.some((f) => f.entity === "Empty")).toBe(false);
 });

package/src/runtime.ts

@@ -886,6 +886,28 @@ function buildWriterOps(callId: string, unsafeOp: boolean): Omit<DbWriter, "unsa
       })) as { updated: boolean };
       return r.updated;
     },
+    async insertMany(entity, rows) {
+      if (rows.length === 0) return [];
+      const r = (await rpcDb(callId, {
+        type: "db",
+        op: "insert_many",
+        entity,
+        data: rows,
+        unsafe_op: unsafeOp,
+      })) as { ids: string[] };
+      return r.ids;
+    },
+    async updateMany(entity, rows) {
+      if (rows.length === 0) return [];
+      const r = (await rpcDb(callId, {
+        type: "db",
+        op: "update_many",
+        entity,
+        data: rows,
+        unsafe_op: unsafeOp,
+      })) as { updated: boolean[] };
+      return r.updated;
+    },
     async delete(entity, id) {
       const r = (await rpcDb(callId, {
         type: "db",

package/src/ssr-client-bundler.ts

@@ -42,7 +42,7 @@ import {
   type ManifestBuildConfig,
 } from "./build-compat";
 import { serverBundle } from "./server-bundle";
-import { declaresClientNavigation } from "./ssr-client-nav";
+import { declaresClientNavigation, stripComments } from "./ssr-client-nav";
 import { precompressBuild } from "./ssr-precompress";
 import { parseNamespaceBarrel, rewriteBarrelImports } from "./ssr-barrel-imports";
 import { buildOfflineWorker, readManifestOffline, type BundleOffline } from "./ssr-offline";
@@ -1375,9 +1375,10 @@ function readComponentSource(fs: any, path: any, cwd: string, component: string)
  *  it to the runtime, which takes the title from it on a navigation with no
  *  page fetch. A static scan, so a page without one imports nothing extra. */
 export function exportsStaticMetadata(source: string): boolean {
+  const code = stripComments(source);
   return (
-    /\bexport\s+(?:const|let|var)\s+metadata\b/.test(source) ||
-    /\bexport\s*\{[^}]*\bmetadata\b[^}]*\}/.test(source)
+    /\bexport\s+(?:const|let|var)\s+metadata\b/.test(code) ||
+    /\bexport\s*\{[^}]*\bmetadata\b[^}]*\}/.test(code)
   );
 }
 
@@ -2021,36 +2022,9 @@ export async function _doBuildInner(
       // against; the build itself is fine.
     }
 
-    // Scan a built JS file for STATIC `import` literals pointing at
-    // `./chunks/<file>.js` and return them resolved to outdir-relative paths.
-    // Bun's minified output uses simple double quotes for module specifiers,
-    // so a `matchAll` covers both `import X from "Y"` and bare `import "Y"`.
-    //
-    // DYNAMIC `import("Y")` is deliberately NOT matched. This list becomes the
-    // route's modulepreload set, and a chunk the author deferred behind
-    // `import()` must not be downloaded eagerly anyway — that would split the
-    // code out of the entry (so it isn't parsed on load) while still shipping
-    // every byte, which is the expensive half of the cost with none of the
-    // saving. The trailing `(` is what distinguishes the two forms.
-    function scanChunkImports(jsAbsPath: string): string[] {
-      let src: string;
-      try {
-        src = fs.readFileSync(jsAbsPath, "utf8");
-      } catch {
-        return [];
-      }
-      const found = new Set<string>();
-      const matches = src.matchAll(/(?:from\s*|import\s*)["']([^"']+)["']/g);
-      for (const m of matches) {
-        const spec = m[1];
-        if (spec.startsWith("./chunks/") || spec.startsWith("chunks/")) {
-          const base = path.basename(spec);
-          const hit = chunksByBasename.get(base);
-          if (hit) found.add(hit.relPath);
-        }
-      }
-      return Array.from(found);
-    }
+    const chunkRelPaths = new Set(
+      Array.from(chunksByBasename.values()).map((c) => c.relPath),
+    );
 
     const manifest: PylonBundleManifest = {
       build_id: makeBuildId(),
@@ -2064,22 +2038,9 @@ export async function _doBuildInner(
       const stem = `client-entry-${slug}`;
       const entry = entriesByStem.get(stem);
       if (!entry) continue;
-      // Walk transitively in case Bun emits chunks that reference
-      // other chunks (rare in the single-level splitting we use,
-      // but free to compute).
-      const seen = new Set<string>();
-      const queue: string[] = scanChunkImports(entry.absPath);
-      for (const q of queue) seen.add(q);
-      while (queue.length > 0) {
-        const relChunk = queue.shift()!;
-        const absChunk = path.join(outdir, relChunk);
-        for (const nested of scanChunkImports(absChunk)) {
-          if (!seen.has(nested)) {
-            seen.add(nested);
-            queue.push(nested);
-          }
-        }
-      }
+      // The SSR head modulepreloads every file in the static graph, so the
+      // browser fetches them in parallel instead of level by level.
+      const seen = staticImportGraph(fs, path, outdir, entry.absPath, chunkRelPaths);
       manifest.routes[r.component] = {
         file: entry.relPath,
         imports: Array.from(seen),
@@ -2372,6 +2333,65 @@ const ASSET_RE = /\.(wasm|png|jpe?g|gif|webp|avif|ico|svg|woff2?|ttf|otf|mp3|mp4
  * the absolute URL. A stylesheet's `url(...)` is left to Bun: CSS cannot
  * import a JavaScript module.
  */
+/**
+ * The outdir-relative chunks a built entry reaches through STATIC imports,
+ * nearest first. Specifiers are relative to the importing file: an entry
+ * imports `./chunks/<file>.js`, a chunk imports its siblings as
+ * `./<file>.js`. Following only the first form dropped every chunk-to-chunk
+ * import, so those chunks were missing from the route's modulepreload set
+ * and loaded in a second wave (3 of 28 files on the Veritas home page).
+ *
+ * DYNAMIC `import("Y")` is deliberately not followed. This list becomes the
+ * route's modulepreload set, and a chunk the author deferred behind
+ * `import()` must not be downloaded eagerly: that would ship every byte the
+ * split was meant to defer. The trailing `(` tells the forms apart; Bun's
+ * minified output quotes specifiers plainly, so one pattern covers
+ * `import X from "Y"`, `import{a}from"Y"` and bare `import "Y"`.
+ */
+export function staticImportGraph(
+  fs: any,
+  path: any,
+  outdir: string,
+  entryAbsPath: string,
+  chunkRelPaths: Set<string>,
+): Set<string> {
+  const toUrlPath = (p: string) => p.replace(/\\/g, "/");
+  const scan = (jsAbsPath: string): string[] => {
+    let src: string;
+    try {
+      src = fs.readFileSync(jsAbsPath, "utf8");
+    } catch {
+      return [];
+    }
+    const found = new Set<string>();
+    const dir = path.dirname(jsAbsPath);
+    for (const m of src.matchAll(/(?:from\s*|import\s*)["']([^"']+)["']/g)) {
+      const spec = m[1]!;
+      if (!spec.startsWith("./") && !spec.startsWith("../") && !spec.startsWith("chunks/")) {
+        continue;
+      }
+      const rel = toUrlPath(
+        path.relative(outdir, path.resolve(spec.startsWith("chunks/") ? outdir : dir, spec)),
+      );
+      if (chunkRelPaths.has(rel)) found.add(rel);
+    }
+    return Array.from(found);
+  };
+  const seen = new Set<string>();
+  const queue = scan(entryAbsPath);
+  for (const q of queue) seen.add(q);
+  while (queue.length > 0) {
+    const rel = queue.shift()!;
+    for (const nested of scan(path.join(outdir, rel))) {
+      if (!seen.has(nested)) {
+        seen.add(nested);
+        queue.push(nested);
+      }
+    }
+  }
+  return seen;
+}
+
 /**
  * Rewrite named imports from namespace barrels (`radix-ui`) in app source
  * into imports of the re-exported packages, so a route bundles only the

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

@@ -35,6 +35,8 @@ describe("declaresClientNavigation", () => {
       `const navigation = "client";`,
       `export const navigationMode = "client";`,
       `// navigation = "client"`,
+      `// export const navigation = "client";`,
+      `/* export const navigation = "client"; */`,
       "",
     ]) {
       expect(declaresClientNavigation(src)).toBe(false);
@@ -42,6 +44,10 @@ describe("declaresClientNavigation", () => {
   });
 });
 
+test("comments are stripped; strings that contain // are not", () => {
+  expect(declaresClientNavigation(`const u = "http://x"; export const navigation = "client";`)).toBe(true);
+});
+
 describe("clientRouteFor", () => {
   test("a page that opted in", () => {
     expect(clientRouteFor(MANIFEST, "/leads", matchRoute)?.component).toBe("app/leads/page");
@@ -74,5 +80,6 @@ describe("exportsStaticMetadata", () => {
     expect(exportsStaticMetadata(`const metadata = {}; export { metadata };`)).toBe(true);
     expect(exportsStaticMetadata(`export async function generateMetadata() {}`)).toBe(false);
     expect(exportsStaticMetadata(`const metadata = {};`)).toBe(false);
+    expect(exportsStaticMetadata(`// export const metadata = { title: "x" };`)).toBe(false);
   });
 });

package/src/ssr-client-nav.ts

@@ -36,7 +36,48 @@ type MatchRoute = (manifest: any, pathname: string) => ClientRouteMatch | null;
  * A static scan: the bundler reads the page file without running it.
  */
 export function declaresClientNavigation(source: string): boolean {
-  return /export\s+const\s+navigation\s*(?::[^=]+)?=\s*(["'`])client\1/.test(source);
+  return /export\s+const\s+navigation\s*(?::[^=]+)?=\s*(["'`])client\1/.test(
+    stripComments(source),
+  );
+}
+
+/**
+ * `source` with `//` and `/* *\/` comments replaced by spaces, so a static
+ * scan sees code only (a commented-out export is not an export). Strings
+ * and template literals are skipped over intact, so a `//` inside one is
+ * not taken for a comment.
+ */
+export function stripComments(source: string): string {
+  let out = "";
+  let i = 0;
+  while (i < source.length) {
+    const c = source[i]!;
+    const next = source[i + 1];
+    if (c === "/" && next === "/") {
+      const end = source.indexOf("\n", i);
+      const stop = end === -1 ? source.length : end;
+      out += " ".repeat(stop - i);
+      i = stop;
+    } else if (c === "/" && next === "*") {
+      const end = source.indexOf("*/", i + 2);
+      const stop = end === -1 ? source.length : end + 2;
+      out += source.slice(i, stop).replace(/[^\n]/g, " ");
+      i = stop;
+    } else if (c === '"' || c === "'" || c === "`") {
+      let j = i + 1;
+      while (j < source.length && source[j] !== c) {
+        if (source[j] === "\\") j++;
+        else if (c !== "`" && source[j] === "\n") break;
+        j++;
+      }
+      out += source.slice(i, j + 1);
+      i = j + 1;
+    } else {
+      out += c;
+      i++;
+    }
+  }
+  return out;
 }
 
 /** Whether `pathname` is one of the app's offline routes. */

package/src/ssr-offline-shell.test.ts

@@ -251,3 +251,29 @@ test("the worker precaches exactly the files the route's HTML loads", async () =
   expect(config.precache).toContain("/icons/512.png");
   expect(config.shells).toEqual(["/"]);
 });
+
+test("the head modulepreloads the route entry and its whole static graph", async () => {
+  const dir = makeApp(SESSION_ONLY_PAGE);
+  const { html } = await render(dir);
+  const head = html.slice(0, html.indexOf("</head>"));
+  const preloaded = [...head.matchAll(/<link rel="modulepreload" href="([^"]+)">/g)].map((m) => m[1]);
+  const route = BUNDLE_MANIFEST.routes["app/page"];
+  expect(preloaded).toEqual([route.file, ...route.imports].map((f) => "/_pylon/build/" + f));
+});
+
+test("modulepreloads are capped for a pathological graph", async () => {
+  const { MAX_MODULEPRELOADS } = await import("./ssr-route-assets");
+  const imports = Array.from({ length: MAX_MODULEPRELOADS + 20 }, (_, i) => `chunks/c${i}-aaaa1111.js`);
+  const manifest = {
+    ...BUNDLE_MANIFEST,
+    routes: { "app/page": { ...BUNDLE_MANIFEST.routes["app/page"], imports } },
+  };
+  const dir = makeApp(SESSION_ONLY_PAGE, manifest);
+  const { html } = await render(dir);
+  const head = html.slice(0, html.indexOf("</head>"));
+  const preloaded = [...head.matchAll(/<link rel="modulepreload" href="([^"]+)">/g)];
+  expect(preloaded.length).toBe(MAX_MODULEPRELOADS);
+  // The entry comes first, then the nearest imports.
+  expect(preloaded[0]![1]).toBe("/_pylon/build/" + BUNDLE_MANIFEST.routes["app/page"].file);
+  expect(preloaded[1]![1]).toBe("/_pylon/build/chunks/c0-aaaa1111.js");
+});

package/src/ssr-route-assets.ts

@@ -21,7 +21,8 @@ export interface RouteAssetManifest {
 export interface RouteAssetFiles {
   /** `<link rel="stylesheet">` (or inlined `<style>`) in the head. */
   styles: string[];
-  /** `<link rel="modulepreload">` in the head. */
+  /** `<link rel="modulepreload">` in the head: the route entry, then its
+   *  static import graph (see `modulepreloadFiles`). */
   preloads: string[];
   /** `<link rel="preload" as="font">` in the head. */
   fonts: string[];
@@ -30,6 +31,25 @@ export interface RouteAssetFiles {
   scripts: string[];
 }
 
+/**
+ * The most `<link rel="modulepreload">` tags a page's head carries. Every
+ * file in the route's static graph is needed before hydration, so the list
+ * is complete for any real route; the cap keeps a pathological graph from
+ * bloating the head. Past it, the browser finds the rest by import.
+ */
+export const MAX_MODULEPRELOADS = 64;
+
+/**
+ * The files to modulepreload for a route: its entry first, then its static
+ * import graph (the manifest's `imports`, nearest first), capped at
+ * `MAX_MODULEPRELOADS`. The entry's `<script>` sits at the end of the body,
+ * after a streamed page's Suspense boundaries, so without its preload the
+ * page's own code started last.
+ */
+export function modulepreloadFiles(route: { file: string; imports?: string[] }): string[] {
+  return [route.file, ...(route.imports ?? [])].slice(0, MAX_MODULEPRELOADS);
+}
+
 /** The scripts the hydration tail loads for a route entry. */
 export function routeScriptFiles(
   route: { file: string },
@@ -48,7 +68,7 @@ export function routeAssetFiles(
   if (!route) return null;
   return {
     styles: route.css ?? [],
-    preloads: route.imports ?? [],
+    preloads: modulepreloadFiles(route),
     fonts: manifest.fonts?.preload ?? [],
     scripts: routeScriptFiles(route, manifest.polyfills),
   };
@@ -62,7 +82,8 @@ export function routeAssetUrls(
   const files = routeAssetFiles(manifest, component);
   if (!files) return [];
   const prefix = manifest.public_prefix || "/_pylon/build/";
-  return [...files.styles, ...files.preloads, ...files.fonts, ...files.scripts].map(
+  // The entry is both preloaded and loaded as a script: list it once.
+  return [...new Set([...files.styles, ...files.preloads, ...files.fonts, ...files.scripts])].map(
     (f) => prefix + f,
   );
 }

package/src/ssr-runtime.ts

@@ -10,6 +10,7 @@
 import { withMetaSlot } from "./ssr-page-tree";
 import { moduleKey, serverBundle } from "./server-bundle";
 import {
+  modulepreloadFiles,
   routeAssetFiles,
   routeScriptFiles,
   type RouteAssetFiles,
@@ -2471,7 +2472,7 @@ async function renderBoundaryToClient(
     for (const css of manifestRoute.css) {
       headBlob += await cssHeadTag(css, publicPrefix);
     }
-    for (const chunk of manifestRoute.imports) {
+    for (const chunk of modulepreloadFiles(manifestRoute)) {
       headBlob += `<link rel="modulepreload"${co} href="${publicPrefix}${chunk}">`;
     }
   } else {

package/src/ssr-static-graph.test.ts

@@ -0,0 +1,35 @@
+// The route's modulepreload set is its whole static import graph, including
+// chunk-to-chunk imports (a chunk imports its siblings as "./x.js").
+
+import { afterEach, expect, test } from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { staticImportGraph } from "./ssr-client-bundler";
+
+let dir = "";
+afterEach(() => {
+  if (dir) fs.rmSync(dir, { recursive: true, force: true });
+});
+
+test("follows chunk-to-chunk imports, not dynamic ones", () => {
+  dir = fs.mkdtempSync(path.join(os.tmpdir(), "pylon-graph-"));
+  fs.mkdirSync(path.join(dir, "chunks"));
+  const write = (f: string, body: string) => fs.writeFileSync(path.join(dir, f), body);
+  write("client-entry-home-aaaa1111.js", `import{a}from"./chunks/a-11111111.js";import"./chunks/b-22222222.js";a();`);
+  write("chunks/a-11111111.js", `import{c as d}from"./c-33333333.js";export const a=()=>d();`);
+  write("chunks/b-22222222.js", `import"./c-33333333.js";`);
+  write("chunks/c-33333333.js", `import"./d-44444444.js";export const c=1;const later=()=>import("./lazy-55555555.js");`);
+  write("chunks/d-44444444.js", `export const d=1;`);
+  write("chunks/lazy-55555555.js", `export const lazy=1;`);
+  const chunks = new Set(
+    ["a-11111111", "b-22222222", "c-33333333", "d-44444444", "lazy-55555555"].map((c) => `chunks/${c}.js`),
+  );
+  const graph = staticImportGraph(fs, path, dir, path.join(dir, "client-entry-home-aaaa1111.js"), chunks);
+  expect([...graph]).toEqual([
+    "chunks/a-11111111.js",
+    "chunks/b-22222222.js",
+    "chunks/c-33333333.js",
+    "chunks/d-44444444.js",
+  ]);
+});

package/src/types.ts

@@ -284,6 +284,26 @@ export interface DbWriter extends DbReader {
     data: Record<string, unknown>
   ): Promise<boolean>;
 
+  /**
+   * Insert many rows of one entity. Returns their IDs, in order. Same
+   * result as calling `insert` per row, with fewer database round trips:
+   * use it for imports and other loops that write many rows. When a row
+   * fails, the call throws; let the error end the mutation so it rolls
+   * back.
+   */
+  insertMany(entity: string, rows: Record<string, unknown>[]): Promise<string[]>;
+
+  /**
+   * Update many rows of one entity. Returns, per row and in order, true if
+   * the row existed. Same result as calling `update` per row, with fewer
+   * database round trips. When a row fails, the call throws; let the error
+   * end the mutation so it rolls back.
+   */
+  updateMany(
+    entity: string,
+    rows: { id: string; data: Record<string, unknown> }[]
+  ): Promise<boolean[]>;
+
   /** Delete a row by ID. Returns true if the row existed. */
   delete(entity: string, id: string): Promise<boolean>;