@backtickjs/bundler 0.0.0-stage → 0.1.1

package/dist/print/code.js

@@ -0,0 +1,95 @@
+import semver from "semver";
+// What a bundle is written as, and the one place its conventions live: how a
+// name is written, how a literal escapes, and how an element is written as JSX
+// for the framework's compiler. Everything is code, as a string.
+const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+export function createNames(packageVersions) {
+    return { imports: new Map(), packageVersions };
+}
+// A string, as a literal: `<` escaped, so no `</script>` or `<!--` appears
+// when the bundle is inlined in a page, and the line and paragraph separators,
+// which JSON leaves bare and not every engine reads inside a string.
+export function string(value) {
+    return JSON.stringify(value).replace(/[<\u2028\u2029]/g, (unit) => `\\u${unit.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+export function literal(value) {
+    if (typeof value === "string") {
+        return string(value);
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw new Error(`${value} has no literal`);
+        }
+        return Object.is(value, -0) ? "-0" : String(value);
+    }
+    return String(value);
+}
+export const undefinedValue = "void 0";
+export function call(callee, args) {
+    return `${callee}(${args.join(", ")})`;
+}
+// The body in parentheses, so one that is an object literal is not read as a
+// block.
+export function arrow(params, body) {
+    return `(${params.join(", ")}) => (${body})`;
+}
+export function thunk(body) {
+    return arrow([], body);
+}
+export function array(elements) {
+    return `[${elements.join(", ")}]`;
+}
+/** An object literal, each key bare where it can be and a string where not. */
+export function object(entries) {
+    const members = entries.map(([key, value]) => `${member(key)}: ${value}`);
+    return `{ ${members.join(", ")} }`;
+}
+// A key as an object literal writes it. `__proto__`, bare or quoted, would set
+// the object's prototype instead, so a key a user may have chosen is computed,
+// which makes it the object's own.
+function member(key) {
+    if (key === "__proto__") {
+        return `[${string(key)}]`;
+    }
+    return IDENTIFIER.test(key) ? key : string(key);
+}
+// The package a module is in: its specifier's first segment, or first two
+// when scoped (`solid-js/web` → `solid-js`, `@scope/pkg/x` → `@scope/pkg`).
+function packageOf(from) {
+    const segments = from.split("/");
+    return segments.slice(0, from.startsWith("@") ? 2 : 1).join("/");
+}
+/** An export of a module the client provides, imported by the bundle. */
+export function imported(names, { from, name, version }) {
+    // Where a script's import is written: a plugin's own (a framework's compile
+    // step) are the plugin's, trusted as it is.
+    const pkg = packageOf(from);
+    const provided = names.packageVersions[pkg];
+    if (provided === undefined) {
+        const packages = Object.entries(names.packageVersions).map(([provided, at]) => `${provided}@${at}`);
+        throw new Error(`Can't import \`${name}\` from "${from}": the client provides ` +
+            `${packages.join(", ") || "no packages"}.`);
+    }
+    if (!semver.satisfies(provided, version)) {
+        throw new Error(`Can't import \`${name}\` from "${from}": it needs ${pkg}@${version}, ` +
+            `and the client provides ${pkg}@${provided}.`);
+    }
+    const key = `${from}\0${name}`;
+    let entry = names.imports.get(key);
+    if (entry === undefined) {
+        entry = { from, name, local: `$i${names.imports.size}` };
+        names.imports.set(key, entry);
+    }
+    return entry.local;
+}
+/** An import declaration of one export under its local name. */
+export function importDeclaration(from, name, local) {
+    const exported = IDENTIFIER.test(name) ? name : string(name);
+    return `import { ${exported} as ${local} } from ${string(from)};`;
+}
+// The same import as CommonJS writes it: `const { name: local } = require(…);`.
+export function requireDeclaration(from, name, local) {
+    const exported = IDENTIFIER.test(name) ? name : string(name);
+    return `const { ${exported}: ${local} } = require(${string(from)});`;
+}
+//# sourceMappingURL=code.js.map

package/dist/print/code.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code.js","sourceRoot":"","sources":["../../src/print/code.ts"],"names":[],"mappings":"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"}

package/dist/print/printBundle.d.ts

@@ -0,0 +1,19 @@
+import type { BundleTree } from "../bundle/buildBundle.js";
+/**
+ * A bundle tree as a module whose default export is the tree's root: the value
+ * bundled, as its scripts wrote it.
+ *
+ * The module is its imports, a module table of its scripts, each compiled for
+ * its framework when its host was built, and the root. Its imports are the
+ * client's to resolve. As an ES module (`"es"`), a page resolves them through
+ * an import map; as CommonJS (`"cjs"`), whatever runs it hands it `require`,
+ * as a React Native app does for the packages it was built with.
+ *
+ * Its map leads into the host files its scripts were written in: an index
+ * map, each script's own map a section where the script stands. What the
+ * bundler wrote around the scripts maps to nothing, since no source wrote it.
+ */
+export declare function printBundle(tree: BundleTree, format: "es" | "cjs"): {
+    code: string;
+    map: string;
+};

package/dist/print/printBundle.js

@@ -0,0 +1,106 @@
+import { importDeclaration, requireDeclaration, string } from "./code.js";
+const MODULE_ID = "bundle.js";
+// A module table's `require`: a module's exports, its entry run the first time
+// it is asked for.
+const RUNTIME = `const $require = (id) => {
+  if (!(id in $exports)) {
+    const module = { exports: {} };
+    $exports[id] = module.exports;
+    $modules[id](module, module.exports, $require);
+    $exports[id] = module.exports;
+  }
+  return $exports[id];
+};`;
+/**
+ * A bundle tree as a module whose default export is the tree's root: the value
+ * bundled, as its scripts wrote it.
+ *
+ * The module is its imports, a module table of its scripts, each compiled for
+ * its framework when its host was built, and the root. Its imports are the
+ * client's to resolve. As an ES module (`"es"`), a page resolves them through
+ * an import map; as CommonJS (`"cjs"`), whatever runs it hands it `require`,
+ * as a React Native app does for the packages it was built with.
+ *
+ * Its map leads into the host files its scripts were written in: an index
+ * map, each script's own map a section where the script stands. What the
+ * bundler wrote around the scripts maps to nothing, since no source wrote it.
+ */
+export function printBundle(tree, format) {
+    const { names } = tree;
+    const module = new ModuleWriter();
+    if (format === "cjs") {
+        // An ES module is strict code, and so are the scripts; CommonJS isn't.
+        module.line('"use strict";');
+    }
+    const declaration = format === "es" ? importDeclaration : requireDeclaration;
+    for (const { from, name, local } of names.imports.values()) {
+        module.line(declaration(from, name, local));
+    }
+    // Each script a module table's entry, as webpack's and Metro's are: its body
+    // under its id, run once by `$require`. The modules they require are the
+    // client's, each imported whole, once.
+    const modules = new Map(tree.modules.map(([, entry]) => [entry.id, entry]));
+    const dependencies = [
+        ...new Set([...modules.values()].flatMap((entry) => entry.dependencies)),
+    ];
+    dependencies.forEach((specifier, index) => module.line(format === "es"
+        ? `import * as $module${index} from ${string(specifier)};`
+        : `const $module${index} = require(${string(specifier)});`));
+    module.line("const $modules = {");
+    for (const [id, entry] of modules) {
+        module.write(`${string(id)}: `);
+        module.script(entry);
+        module.line(",");
+    }
+    module.line("};");
+    module.line("const $exports = {");
+    dependencies.forEach((specifier, index) => module.line(`${string(specifier)}: $module${index},`));
+    module.line("};");
+    module.line(RUNTIME);
+    for (const [label, entry] of tree.modules) {
+        module.line(`const ${label} = $require(${string(entry.id)}).default;`);
+    }
+    // Parenthesized, so a root that is a function isn't a declaration.
+    module.write(format === "es"
+        ? `export default (${tree.root});`
+        : `module.exports = (${tree.root});`);
+    return { code: module.code, map: module.map() };
+}
+// The module's code as it is written, and a map of the scripts in it.
+class ModuleWriter {
+    code = "";
+    #line = 0;
+    #column = 0;
+    #sections = [];
+    write(text) {
+        this.code += text;
+        const lines = text.split("\n");
+        if (lines.length > 1) {
+            this.#line += lines.length - 1;
+            this.#column = lines[lines.length - 1].length;
+        }
+        else {
+            this.#column += text.length;
+        }
+    }
+    line(text) {
+        this.write(`${text}\n`);
+    }
+    // A script's code, its map a section of the module's where it starts.
+    script({ code, map }) {
+        this.#sections.push({
+            offset: { line: this.#line, column: this.#column },
+            map: JSON.parse(map),
+        });
+        this.write(code);
+    }
+    // An index map: each script's own map, at its offset, decoded by no one here.
+    map() {
+        return JSON.stringify({
+            version: 3,
+            file: MODULE_ID,
+            sections: this.#sections,
+        });
+    }
+}
+//# sourceMappingURL=printBundle.js.map

package/dist/print/printBundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"printBundle.js","sourceRoot":"","sources":["../../src/print/printBundle.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAE1E,MAAM,SAAS,GAAG,WAAW,CAAC;AAE9B,+EAA+E;AAC/E,mBAAmB;AACnB,MAAM,OAAO,GAAG;;;;;;;;GAQb,CAAC;AAEJ;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,WAAW,CACzB,IAAgB,EAChB,MAAoB;IAEpB,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC;IACvB,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;IAClC,IAAI,MAAM,KAAK,KAAK,EAAE,CAAC;QACrB,uEAAuE;QACvE,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;IAC/B,CAAC;IACD,MAAM,WAAW,GAAG,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,kBAAkB,CAAC;IAC7E,KAAK,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;QAC3D,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;IAC9C,CAAC;IACD,6EAA6E;IAC7E,yEAAyE;IACzE,uCAAuC;IACvC,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IAC5E,MAAM,YAAY,GAAG;QACnB,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;KACzE,CAAC;IACF,YAAY,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,KAAK,EAAE,EAAE,CACxC,MAAM,CAAC,IAAI,CACT,MAAM,KAAK,IAAI;QACb,CAAC,CAAC,sBAAsB,KAAK,SAAS,MAAM,CAAC,SAAS,CAAC,GAAG;QAC1D,CAAC,CAAC,gBAAgB,KAAK,cAAc,MAAM,CAAC,SAAS,CAAC,IAAI,CAC7D,CACF,CAAC;IACF,MAAM,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;IAClC,KAAK,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,IAAI,OAAO,EAAE,CAAC;QAClC,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;QAChC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACrB,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACnB,CAAC;IACD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAClB,MAAM,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;IAClC,YAAY,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,KAAK,EAAE,EAAE,CACxC,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,SAAS,CAAC,YAAY,KAAK,GAAG,CAAC,CACtD,CAAC;IACF,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAClB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACrB,KAAK,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;QAC1C,MAAM,CAAC,IAAI,CAAC,SAAS,KAAK,eAAe,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,CAAC;IACzE,CAAC;IACD,mEAAmE;IACnE,MAAM,CAAC,KAAK,CACV,MAAM,KAAK,IAAI;QACb,CAAC,CAAC,mBAAmB,IAAI,CAAC,IAAI,IAAI;QAClC,CAAC,CAAC,qBAAqB,IAAI,CAAC,IAAI,IAAI,CACvC,CAAC;IAEF,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,EAAE,CAAC;AAClD,CAAC;AAED,sEAAsE;AACtE,MAAM,YAAY;IAChB,IAAI,GAAG,EAAE,CAAC;IACV,KAAK,GAAG,CAAC,CAAC;IACV,OAAO,GAAG,CAAC,CAAC;IACZ,SAAS,GAAgE,EAAE,CAAC;IAE5E,KAAK,CAAC,IAAY;QAChB,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC;QAClB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC/B,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACrB,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;YAC/B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAE,CAAC,MAAM,CAAC;QACjD,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,MAAM,CAAC;QAC9B,CAAC;IACH,CAAC;IAED,IAAI,CAAC,IAAY;QACf,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC;IAC1B,CAAC;IAED,sEAAsE;IACtE,MAAM,CAAC,EAAE,IAAI,EAAE,GAAG,EAAgB;QAChC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;YAClB,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE;YAClD,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAW;SAC/B,CAAC,CAAC;QACH,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACnB,CAAC;IAED,8EAA8E;IAC9E,GAAG;QACD,OAAO,IAAI,CAAC,SAAS,CAAC;YACpB,OAAO,EAAE,CAAC;YACV,IAAI,EAAE,SAAS;YACf,QAAQ,EAAE,IAAI,CAAC,SAAS;SACzB,CAAC,CAAC;IACL,CAAC;CACF"}

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "@backtickjs/bundler",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "Runs Backtick server components and bundles a screen per request: one JavaScript file for the client",
+  "keywords": [
+    "backtick",
+    "react-native",
+    "server-driven-ui",
+    "server-components",
+    "bundler",
+    "bundle",
+    "jsx"
+  ],
+  "homepage": "https://backtickjs.com",
+  "bugs": {
+    "url": "https://github.com/backtickjs/backtick/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/backtickjs/backtick.git",
+    "directory": "packages/bundler"
+  },
+  "license": "MIT",
+  "author": "Jean-François Bisson <jf@backtickjs.com>",
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/._cache",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "semver": "^7.8.1",
+    "@backtickjs/core": "0.1.1"
+  },
+  "devDependencies": {
+    "@types/semver": "^7.8.0",
+    "prettier": "^3.6.2",
+    "typescript": "^6.0.3"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "dev": "tsc -b --watch",
+    "format": "prettier --write --ignore-unknown .",
+    "format:check": "prettier --check --ignore-unknown .",
+    "test": "node --test \"test/**/*.test.ts\"",
+    "clean": "rm -rf node_modules dist .turbo"
+  }
 }

package/src/bundle/bindingKey.ts

@@ -0,0 +1,10 @@
+// A binding key as the compiler writes it, `<name>$<fileHash>$<n>`. Shared by
+// the two halves of the bundler because both have to agree on what a key means,
+// and neither owns it.
+
+// The source name a key was written under, with the uniqueness suffix dropped.
+// Printing it is the caller's job: two distinct keys can share a source name,
+// and whether that matters depends on whether they can meet in one scope.
+export function sourceName(key: string): string {
+  return key.replace(/\$[0-9a-z]+\$\d+$/, "");
+}

package/src/bundle/buildBundle.ts

@@ -0,0 +1,353 @@
+import {
+  type ClientModule,
+  type ClientScript,
+  isClientScript,
+  isJsxElement,
+  type JsxElement,
+} from "@backtickjs/core";
+import { isClientImport, type Spliceable } from "@backtickjs/core";
+
+import {
+  type ElementExpansions,
+  expandJsxElement,
+} from "./expandJsxElement.js";
+import { bindingsOf, capturesOf } from "./params.js";
+import { sourceName } from "./bindingKey.js";
+import {
+  array,
+  arrow,
+  call,
+  createNames,
+  imported,
+  literal,
+  object,
+  thunk,
+  undefinedValue,
+} from "../print/code.js";
+import type { Names } from "../print/code.js";
+
+/**
+ * A bundle as it is built, before it is printed: each script's module it
+ * declares under its label, in the order rendering first reached it, and the
+ * root, as code; and what they import.
+ */
+export interface BundleTree {
+  readonly modules: readonly (readonly [string, ClientModule])[];
+  readonly root: string;
+  readonly names: Names;
+}
+
+// Names a binding may not take: what strict code cannot bind. Every name the
+// bundle introduces starts with `$`, which a script cannot bind, so none of
+// those can meet a binding.
+const RESERVED = ["arguments", "await", "eval", "yield"];
+
+// What encloses a value being rendered: the bindings the thunks around it were
+// handed.
+interface Scope {
+  readonly bindings: ReadonlySet<string>;
+}
+
+const rootScope: Scope = { bindings: new Set() };
+
+// Builds the bundle `{ scripts, root }` as code, and documents how it is
+// derived.
+//
+// Each script is declared once, as its compiled code under a label `$cs<n>`,
+// and called wherever it is used. Its code takes a parameter per splice —
+// a hole reads `$splice<i>()` — then per tag and per capture, so it is a function of the
+// script's source alone: every call passes its own splice arguments, as
+// thunks, and nothing from a call site is inlined.
+//
+// A captured variable is threaded, not resolved by name at the splice site: a
+// fragment written in one script but spliced (via host code) into another still
+// refers to the binding it was written under. Each script receives its live
+// captures as parameters, and a call of it passes those captures from the
+// enclosing scope. Because the compiler gives every binding a globally unique
+// name, a capture is threaded under that one name the whole way down — an
+// intermediate script that binds a same-looking variable has a different
+// unique name, so there is nothing to disambiguate and nothing to rename.
+export async function buildBundle(
+  value: Spliceable,
+  packageVersions: Readonly<Record<string, string>>,
+): Promise<BundleTree> {
+  const names = createNames(packageVersions);
+  const elementExpansions: ElementExpansions = new WeakMap();
+  // Each script's number, in the order rendering first reaches it. Two
+  // scripts written at one source location are one declaration, so the first
+  // script with an id stands for all of them, and a reference to a shared
+  // script is a reference to the same object. Keyed by that script so a label
+  // is a lookup rather than a scan, and ordered by insertion, which is the
+  // order the tail declares them in.
+  const numbers = new Map<ClientScript, number>();
+  const scriptById = new Map<string, ClientScript>();
+  const scriptFor = (script: ClientScript): ClientScript => {
+    const existing = scriptById.get(script.module.id);
+    if (existing !== undefined) {
+      return existing;
+    }
+    scriptById.set(script.module.id, script);
+    numbers.set(script, numbers.size);
+    return script;
+  };
+  // A binding key printed under its source name, with a numeric suffix when two
+  // distinct bindings would otherwise print the same.
+  //
+  // Disambiguated at all because these become identifiers, and identifiers nest:
+  // a hole inside a thunk puts one thunk's parameters inside another's, so two
+  // bindings sharing a source name can land in one chain and the inner would
+  // shadow what the outer was handed (`shadowing` nests three).
+  //
+  // One scope, which is the bundle root: what a drawing is written into now
+  // that structure goes where it stands. A declared script's names are the
+  // compiler's, from its own source — nothing out here reads those names,
+  // because a call hands a script its arguments positionally, and its
+  // captures arrive as numbered parameters rather than under a name.
+  const displayed = new Map<string, string>();
+  const used = new Set<string>(RESERVED);
+  const displayName = (key: string): string => {
+    const existing = displayed.get(key);
+    if (existing !== undefined) {
+      return existing;
+    }
+    const base = sourceName(key);
+    let name = base;
+    for (let n = 2; used.has(name); n++) {
+      name = `${base}${n}`;
+    }
+    used.add(name);
+    displayed.set(key, name);
+    return name;
+  };
+
+  // The script-declared bindings a hole feeds its thunk, so a spliced fragment
+  // sees the bindings in scope at its hole even though the thunk is written at
+  // the call site. The body's hole call and every thunk's parameter list read
+  // this, so they agree positionally.
+  //
+  // Read off the script's own source (see `splices` in `resolveBindings`),
+  // not off what the arguments reaching that hole in this bundle happen to
+  // capture. That is what lets a script be compiled from its source alone: a
+  // second call site appearing elsewhere in a render cannot change a thunk a
+  // first one already had.
+  //
+  // It is a superset — the bindings a fragment written there *could* name, not
+  // the ones it does — because which fragment reaches a hole is a host
+  // decision. A carried fragment arrives with its own captures already bound,
+  // so the extra parameters are unused rather than wrong.
+  const passKeys = (target: ClientScript, hole: number): readonly string[] =>
+    bindingsOf(target.module.params[hole]);
+
+  // The scripts the bundle declares: those a reference calls or passes, not
+  // every one looked up on the way.
+  const declared = new Set<ClientScript>();
+
+  // A declared script's label: `$cs` and its number.
+  const labelOf = (target: ClientScript): string =>
+    `$cs${numbers.get(target)!}`;
+
+  const declare = (script: ClientScript): void => {
+    declared.add(script);
+  };
+
+  // A fragment that is one script whose parameters are exactly what this hole
+  // passes, so calling it is what a thunk around it would have done. The lists
+  // are compared rather than assumed: a hole hands over what its own script has,
+  // and a fragment wants what its own script needs, and those coincide often
+  // but not always.
+  const forwarding = (
+    value: Spliceable,
+    passed: readonly string[],
+  ): string | null => {
+    if (
+      !isClientScript(value) ||
+      value.module.params.some((param) => param.kind !== "capture")
+    ) {
+      return null;
+    }
+    const target = scriptFor(value);
+    const wanted = capturesOf(target);
+    if (
+      wanted.length !== passed.length ||
+      wanted.some((key, at) => key !== passed[at])
+    ) {
+      return null;
+    }
+    declare(target);
+    return labelOf(target);
+  };
+
+  // Writes a value as the code it becomes: composition as data, which is what
+  // a bundle is. A script reference is a call naming which script and
+  // what to hand it; everything else is its literal form. Rendered in order,
+  // one value after the other, so the table follows the order rendering first
+  // reached each script.
+  const render = async (
+    value: Spliceable,
+    scope: Scope = rootScope,
+  ): Promise<string> => {
+    if (isClientScript(value)) {
+      const target = scriptFor(value);
+      declare(target);
+      return call(labelOf(target), await exprCallArgs(value, scope));
+    }
+    if (isJsxElement(value)) {
+      return renderJsx(value, scope);
+    }
+    if (isClientImport(value)) {
+      return imported(names, value);
+    }
+    if (value === null) {
+      return literal(null);
+    }
+    // Checked by name, since everything past here reads the value as an object.
+    if (value === undefined) {
+      return undefinedValue;
+    }
+    if (
+      typeof value === "number" ||
+      typeof value === "string" ||
+      typeof value === "boolean"
+    ) {
+      return literal(value);
+    }
+    if (Array.isArray(value)) {
+      const elements: string[] = [];
+      for (const element of value) {
+        elements.push(await render(element, scope));
+      }
+      return array(elements);
+    }
+    // A host function is host code, which never reaches the client: client
+    // code is written in a script, and reaches another as one.
+    // A server component among them, written as a tag: `<$Rule />`.
+    if (typeof value === "function") {
+      const { name } = value as (...args: never) => unknown;
+      throw new Error(
+        (name === ""
+          ? "Can't splice a host function"
+          : `Can't splice the host function \`${name}\``) +
+          ": it's host code, and only runs on the host. Write a client " +
+          "function as a script instead: cs`(n: number) => ...`; a server " +
+          `component is drawn in a braced splice: \`{\${<${name || "Name"} />}}\`.`,
+      );
+    }
+    // Only plain objects cross structurally. A class instance would land here
+    // and half-work — own fields would cross, getters and methods silently
+    // vanish — so fail loudly instead. An object with behaviour is built by a
+    // client function: `state` for what it holds, arrows for what may be done
+    // to it.
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      const name = value.constructor?.name ?? "an unknown class";
+      throw new Error(
+        `Can't splice this \`${name}\` instance: only plain objects cross into ` +
+          "a client script. Build one with a client function instead.",
+      );
+    }
+    const entries: [string, string][] = [];
+    for (const [key, entry] of Object.entries(value)) {
+      entries.push([key, await render(entry, scope)]);
+    }
+    return object(entries);
+  };
+
+  // Renders a capture in JSON position: a parameter of an enclosing thunk
+  // resolves by name; anything else must be a parameter of the enclosing script.
+  // At
+  // the bundle root there is no enclosing instance, so a capture reaching it
+  // can't be threaded from anywhere.
+  const capExpr = (key: string, scope: Scope): string => {
+    if (scope.bindings.has(key)) {
+      return displayName(key);
+    }
+    throw new Error(
+      `Can't thread the capture \`${sourceName(key)}\`: nothing encloses ` +
+        "this reference to supply it. A fragment carries the bindings it was " +
+        "written under, so this is also what happens when one is spliced " +
+        "somewhere another `" +
+        sourceName(key) +
+        "` shadows it: the binding is still there, but no longer reachable by " +
+        "name, and naming it anyway would mean emitting what the source " +
+        "couldn't say.",
+    );
+  };
+
+  // The arguments of a call of a declared script: for
+  // one `#thunk` per splice ahead of the environment.
+  const exprCallArgs = async (
+    ref: ClientScript,
+    scope: Scope,
+  ): Promise<string[]> => {
+    const target = scriptFor(ref);
+    const parts: string[] = [];
+    // The splices lead the parameters, one `arg` each.
+    for (const [index, arg] of ref.args.entries()) {
+      // What the hole hands over, in the order the script fixes: the bindings
+      // bound there, then the captures it forwards on behalf of whatever is
+      // nested inside it.
+      const passed = [...passKeys(target, index), ...capturesOf(target)];
+      // A fragment whose own parameters are exactly that list reads the hole's
+      // arguments as they arrive, so it is passed as it is rather than wrapped
+      // in a thunk that would only pass them along.
+      const forwarded = forwarding(arg, passed);
+      if (forwarded !== null) {
+        parts.push(forwarded);
+        continue;
+      }
+      if (passed.length === 0) {
+        parts.push(thunk(await render(arg, scope)));
+        continue;
+      }
+      // Otherwise a thunk names them and calls the fragment with what it wants.
+      const inner = { bindings: new Set([...scope.bindings, ...passed]) };
+      parts.push(arrow(passed.map(displayName), await render(arg, inner)));
+    }
+    for (const key of capturesOf(target)) {
+      parts.push(capExpr(key, scope));
+    }
+    return parts;
+  };
+
+  // A tag. A component runs on the host and what it drew stands where the tag
+  // stood; an element is its own name, each prop an expression in the
+  // enclosing script's scope.
+  //
+  // A prop that is `undefined` is left out, as JSX and TypeScript's optional
+  // props read it: a component forwarding an optional prop it wasn't given
+  // writes nothing.
+  const renderJsx = async (jsx: JsxElement, scope: Scope): Promise<string> => {
+    const type = jsx.type;
+    if (typeof type === "function" && !isClientImport(type)) {
+      return render(
+        await expandJsxElement(jsx, type, elementExpansions),
+        scope,
+      );
+    }
+    // An element and a client component (an import, or a script answering
+    // one) are client code, so on the host they can't be tags: they are tags
+    // in a script.
+    if (typeof type === "string") {
+      throw new Error(
+        `\`<${type}>\` is drawn by the client, so it belongs in a script: ` +
+          `cs\`<${type}>…</${type}>\`.`,
+      );
+    }
+    const tag = isClientImport(type) ? `\`<${type.name}>\`` : "A script";
+    throw new Error(
+      `${tag} is a client component, so it can't be a tag on the host. ` +
+        "Use it as a tag in a script.",
+    );
+  };
+
+  // Nothing encloses the root, so nothing it holds can capture.
+  const root = await render(value as Spliceable);
+  // In table order, which is the order rendering first reached each script.
+  const modules: (readonly [string, ClientModule])[] = [];
+  for (const script of numbers.keys()) {
+    if (declared.has(script)) {
+      modules.push([labelOf(script), script.module]);
+    }
+  }
+  return { modules, root, names };
+}