From d858d840f92d3239710ea2cd90724f001251ee27 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 08:46:44 -0500
Subject: [PATCH 01/67] Accept file URL paths in synchronous fs functions

readFileSync, writeFileSync, appendFileSync, statSync, lstatSync,
readdirSync, mkdirSync, rmSync, rmdirSync, mkdtempSync, accessSync,
unlinkSync, chmodSync, chownSync, lchownSync, truncateSync, copyFileSync,
renameSync, realpathSync, realpathSync.native, openSync and opendirSync
accept a file: URL wherever they accept a path. The URL converts as
fileURLToPath converts it, with Node's errors for other schemes, hosts,
encoded separators and null bytes.

Arguments after a URL path that have side effects are evaluated into
hidden locals before the conversion, so they run even when it throws. A
URL path after a string path, or with options that are not literals,
fails with SC2020, because Node checks those arguments before it converts
the URL. existsSync and the fs.promises functions also fail with SC2020
for URL paths: existsSync answers false for a URL it cannot convert, and
fs.promises reports conversion errors as rejections.

Fixes #1616

Co-authored-by: jlucaso1 <55464917+jlucaso1@users.noreply.github.com>
---
 docs/content/docs/limitations.mdx             |   2 +
 .../builtin-apis/filesystem-url-paths.mdx     |   3 +
 .../ambient/scriptc-node-fallback.d.ts        |  81 +++----
 .../lowering/builtins/filesystem-calls.ts     |  17 +-
 .../frontend/lowering/builtins/filesystem.ts  |   7 +-
 .../frontend/lowering/builtins/fs-paths.ts    | 212 ++++++++++++++++++
 .../lowering/builtins/module-calls.ts         |  12 +-
 .../compiler/src/frontend/lowering/lowerer.ts |  22 +-
 .../tests/corpus/6931-fs-url-paths.ts.json    |   6 +
 .../diagnostics/fs-url-path-fences.ts.json    |   6 +
 .../node-types/fs-url-path-fences.ts.json     |   6 +
 .../fixtures/node-types/fs-url-paths.ts.json  |   6 +
 tests/corpus/6931-fs-url-paths.ts             |  96 ++++++++
 tests/diagnostics/fs-url-path-fences.ts       |  15 ++
 .../fixtures/node-types/fs-url-path-fences.ts |   9 +
 tests/fixtures/node-types/fs-url-paths.ts     |  10 +
 .../__snapshots__/fs-url-path-fences.ts.txt   |  35 +++
 .../corpus-costs/6931-fs-url-paths.ts.json    |   1 +
 tests/harness/project-config.test.ts          |  29 +++
 19 files changed, 522 insertions(+), 53 deletions(-)
 create mode 100644 docs/content/limitations/builtin-apis/filesystem-url-paths.mdx
 create mode 100644 packages/compiler/src/frontend/lowering/builtins/fs-paths.ts
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6931-fs-url-paths.ts.json
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/fs-url-path-fences.ts.json
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fs-url-path-fences.ts.json
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fs-url-paths.ts.json
 create mode 100644 tests/corpus/6931-fs-url-paths.ts
 create mode 100644 tests/diagnostics/fs-url-path-fences.ts
 create mode 100644 tests/fixtures/node-types/fs-url-path-fences.ts
 create mode 100644 tests/fixtures/node-types/fs-url-paths.ts
 create mode 100644 tests/harness/__snapshots__/fs-url-path-fences.ts.txt
 create mode 100644 tests/harness/corpus-costs/6931-fs-url-paths.ts.json

diff --git a/docs/content/docs/limitations.mdx b/docs/content/docs/limitations.mdx
index 05f9d329a..5be38a924 100644
--- a/docs/content/docs/limitations.mdx
+++ b/docs/content/docs/limitations.mdx
@@ -82,6 +82,8 @@ title: "Limitations"
 
 <include>../limitations/builtin-apis/filesystem-flags.mdx</include>
 
+<include>../limitations/builtin-apis/filesystem-url-paths.mdx</include>
+
 <include>../limitations/builtin-apis/copy.mdx</include>
 
 <include>../limitations/builtin-apis/glob.mdx</include>
diff --git a/docs/content/limitations/builtin-apis/filesystem-url-paths.mdx b/docs/content/limitations/builtin-apis/filesystem-url-paths.mdx
new file mode 100644
index 000000000..d5079ed5a
--- /dev/null
+++ b/docs/content/limitations/builtin-apis/filesystem-url-paths.mdx
@@ -0,0 +1,3 @@
+- **Filesystem URL paths:** Synchronous `fs` functions accept `file:` URL paths and convert them as `fileURLToPath` does.
+  `existsSync` and the `fs.promises` functions refuse URL paths; pass `fileURLToPath(url)` instead.
+  A URL path after a string path, or with options that are not literals, is refused, because Node checks those arguments before it converts the URL.
diff --git a/packages/compiler/ambient/scriptc-node-fallback.d.ts b/packages/compiler/ambient/scriptc-node-fallback.d.ts
index fb107ef99..ee7c794f1 100644
--- a/packages/compiler/ambient/scriptc-node-fallback.d.ts
+++ b/packages/compiler/ambient/scriptc-node-fallback.d.ts
@@ -1379,13 +1379,13 @@ interface ImportMeta {
  * `recursive`); empty directories go through `rmdirSync`. */
 declare module "node:fs" {
   import { Readable, Writable } from "stream";
-  export function readFileSync(path: string | number, encoding: BufferEncoding): string;
+  export function readFileSync(path: string | number | URL, encoding: BufferEncoding): string;
   export function readFileSync(
-    path: string | number,
+    path: string | number | URL,
     options: { encoding: BufferEncoding },
   ): string;
-  export function readFileSync(path: string | number): Buffer;
-  export function readFileSync(path: string, options: unknown): string | Buffer;
+  export function readFileSync(path: string | number | URL): Buffer;
+  export function readFileSync(path: string | URL, options: unknown): string | Buffer;
   /* Error-first callbacks select string or Buffer data from their encoding.
    * Unknown options retain that union until the caller validates the value. */
   export function readFile(
@@ -1397,7 +1397,7 @@ declare module "node:fs" {
    * Node — an existing file keeps its permissions) and/or the utf8
    * encoding spelling. */
   export function writeFileSync(
-    path: string,
+    path: string | URL,
     data: string,
     /* The options-record stance (see http.RequestOptions): flag fences
      * by name at the call site; undocumented keys drop like Node. */
@@ -1409,14 +1409,17 @@ declare module "node:fs" {
     },
   ): void;
   /* The bare-encoding spelling — the options record's encoding key alone. */
-  export function writeFileSync(path: string, data: string, encoding: "utf8" | "utf-8"): void;
-  export function writeFileSync(path: string, data: string | Uint8Array): void;
-  export function appendFileSync(path: string, data: string | Uint8Array): void;
+  export function writeFileSync(path: string | URL, data: string, encoding: "utf8" | "utf-8"): void;
+  export function writeFileSync(path: string | URL, data: string | Uint8Array): void;
+  export function appendFileSync(path: string | URL, data: string | Uint8Array): void;
   export function existsSync(path: string): boolean;
-  export function mkdirSync(path: string): void;
-  export function mkdirSync(path: string, options: { recursive?: boolean; mode?: number }): void;
-  export function unlinkSync(path: string): void;
-  export function chmodSync(path: string, mode: number): void;
+  export function mkdirSync(path: string | URL): void;
+  export function mkdirSync(
+    path: string | URL,
+    options: { recursive?: boolean; mode?: number },
+  ): void;
+  export function unlinkSync(path: string | URL): void;
+  export function chmodSync(path: string | URL, mode: number): void;
   export function fchmodSync(fd: number, mode: number): void;
   export function fsyncSync(fd: number): void;
   export function linkSync(
@@ -1514,29 +1517,29 @@ declare module "node:fs" {
     path: string | Uint8Array | URL,
     options: string | { encoding?: string | null } | null,
   ): string | Buffer;
-  export function chownSync(path: string, uid: number, gid: number): void;
-  export function lchownSync(path: string, uid: number, gid: number): void;
+  export function chownSync(path: string | URL, uid: number, gid: number): void;
+  export function lchownSync(path: string | URL, uid: number, gid: number): void;
   export function fchownSync(fd: number, uid: number, gid: number): void;
-  export function truncateSync(path: string, len?: number): void;
+  export function truncateSync(path: string | URL, len?: number): void;
   /* The 2-argument form only (Node's mode flags have no lowering). The
    * destination is created or truncated carrying the SOURCE's mode. */
-  export function copyFileSync(src: string, dest: string): void;
+  export function copyFileSync(src: string | URL, dest: string | URL): void;
   export function rename(
     oldPath: string,
     newPath: string,
     callback: (err: NodeJS.ErrnoException | null) => void,
   ): void;
-  export function renameSync(oldPath: string, newPath: string): void;
-  export function rmSync(path: string): void;
+  export function renameSync(oldPath: string | URL, newPath: string | URL): void;
+  export function rmSync(path: string | URL): void;
   /* maxRetries/retryDelay are accepted no-ops (Node retries around
    * EBUSY-class races; the synchronous lowering has no re-entrancy that
    * needs them). */
   export function rmSync(
-    path: string,
+    path: string | URL,
     options: { recursive?: boolean; force?: boolean; maxRetries?: number; retryDelay?: number },
   ): void;
-  export function rmdirSync(path: string): void;
-  export function readdirSync(path: string): string[];
+  export function rmdirSync(path: string | URL): void;
+  export function readdirSync(path: string | URL): string[];
   /* The withFileTypes form: Dirent rows (name + parentPath + the type
    * probes — the honest subset of Node's Dirent surface). The type is
    * interned explicitly in type-mapper.ts (the record's hidden %dtype field
@@ -1550,7 +1553,7 @@ declare module "node:fs" {
     isSymbolicLink(): boolean;
   }
   export function readdirSync(
-    path: string,
+    path: string | URL,
     /* The options-record stance (see http.RequestOptions): recursive
      * fences by name at the call site; undocumented keys drop like Node. */
     options: { withFileTypes: true; recursive?: boolean; [option: string]: unknown },
@@ -1599,7 +1602,7 @@ declare module "node:fs" {
     encoding?: "utf8" | "utf-8";
     bufferSize?: number;
   }
-  export function opendirSync(path: string, options?: OpenDirOptions): Dir;
+  export function opendirSync(path: string | URL, options?: OpenDirOptions): Dir;
   /* fs.ReadStream / fs.WriteStream: runtime Readable and Writable streams
    * over a file (scr_fs_stream.c). The options are checked at runtime
    * with Node's rules; flags and mode are checked when the file opens, so
@@ -1641,8 +1644,8 @@ declare module "node:fs" {
     path: string | Buffer | URL,
     options?: BufferEncoding | WriteStreamOptions,
   ): WriteStream;
-  export function accessSync(path: string, mode?: number): void;
-  export function mkdtempSync(prefix: string): string;
+  export function accessSync(path: string | URL, mode?: number): void;
+  export function mkdtempSync(prefix: string | URL): string;
   export const constants: {
     readonly F_OK: number;
     readonly R_OK: number;
@@ -1745,34 +1748,34 @@ declare module "node:fs" {
     bigint?: boolean;
     throwIfNoEntry?: boolean;
   }
-  export function statSync(path: string, options?: undefined): Stats;
+  export function statSync(path: string | URL, options?: undefined): Stats;
   export function statSync(
-    path: string,
+    path: string | URL,
     options: StatSyncOptions & { bigint?: false; throwIfNoEntry: false },
   ): Stats | undefined;
   export function statSync(
-    path: string,
+    path: string | URL,
     options: StatSyncOptions & { bigint?: false; throwIfNoEntry?: true },
   ): Stats;
   /* bigint: true type-checks so the lowering can name it as unsupported. */
-  export function statSync(path: string, options: StatSyncOptions & { bigint: true }): Stats;
-  export function statSync(path: string, options: StatSyncOptions): Stats | undefined;
-  export function lstatSync(path: string, options?: undefined): Stats;
+  export function statSync(path: string | URL, options: StatSyncOptions & { bigint: true }): Stats;
+  export function statSync(path: string | URL, options: StatSyncOptions): Stats | undefined;
+  export function lstatSync(path: string | URL, options?: undefined): Stats;
   export function lstatSync(
-    path: string,
+    path: string | URL,
     options: StatSyncOptions & { bigint?: false; throwIfNoEntry: false },
   ): Stats | undefined;
   export function lstatSync(
-    path: string,
+    path: string | URL,
     options: StatSyncOptions & { bigint?: false; throwIfNoEntry?: true },
   ): Stats;
   /* bigint: true type-checks so the lowering can name it as unsupported. */
-  export function lstatSync(path: string, options: StatSyncOptions & { bigint: true }): Stats;
-  export function lstatSync(path: string, options: StatSyncOptions): Stats | undefined;
+  export function lstatSync(path: string | URL, options: StatSyncOptions & { bigint: true }): Stats;
+  export function lstatSync(path: string | URL, options: StatSyncOptions): Stats | undefined;
   /* The fd pair behind spawn's fd-stdio form: openSync(path, flags) →
    * the raw fd. Numeric flags use an inline OR of the O_* constants. */
-  export function openSync(path: string, flags: string): number;
-  export function openSync(path: string, flags: number, mode?: number): number;
+  export function openSync(path: string | URL, flags: string): number;
+  export function openSync(path: string | URL, flags: number, mode?: number): number;
   export function closeSync(fd: number): void;
   export function fdatasyncSync(fd: number): void;
   export function ftruncateSync(fd: number, len?: number): void;
@@ -1853,9 +1856,9 @@ declare module "node:fs" {
   export function fstatSync(fd: number): Stats;
   /* realpath(3) — resolves symlinks, `.`/`..`, throwing Node's fs error
    * shapes for missing paths. */
-  export function realpathSync(path: string): string;
+  export function realpathSync(path: string | URL): string;
   export namespace realpathSync {
-    function native(path: string): string;
+    function native(path: string | URL): string;
   }
   /* statfs(2)/statvfs(3) — the filesystem-capacity snapshot (the fields
    * Node's statfsSync reports; bavail × bsize is the free-space probe). */
diff --git a/packages/compiler/src/frontend/lowering/builtins/filesystem-calls.ts b/packages/compiler/src/frontend/lowering/builtins/filesystem-calls.ts
index 05028e1df..f23dff029 100644
--- a/packages/compiler/src/frontend/lowering/builtins/filesystem-calls.ts
+++ b/packages/compiler/src/frontend/lowering/builtins/filesystem-calls.ts
@@ -1,6 +1,7 @@
 import { dynUndefinedExpr, boolLit, numLit, varRef } from "../../../ir/build.js";
 import * as ts from "../../ts7/adapter.js";
 import { type Lowerer } from "../lowerer.js";
+import { lowerFsPath } from "./fs-paths.js";
 import { locOf } from "../../program.js";
 import {
   type BuiltinModuleFn,
@@ -231,7 +232,7 @@ export function lowerFsNumericOpenCall(
       "use an inline bitwise OR of fs.constants.O_RDONLY/O_WRONLY/O_RDWR/O_CREAT/O_EXCL/O_NOFOLLOW/O_NONBLOCK/O_TRUNC/O_APPEND",
     );
   }
-  const path = lowerer.lowerExprExpecting(expr.arguments.nodes[0]!, STRING);
+  const path = lowerFsPath(lowerer, expr.arguments.nodes[0]!);
   const mode = expr.arguments.nodes[2]
     ? lowerer.lowerExprExpecting(expr.arguments.nodes[2]!, F64)
     : ({ kind: "numLit", value: 0o666, type: F64, loc } satisfies IrExpr);
@@ -640,7 +641,9 @@ export function lowerFsEncodedRead(
       return null;
   }
   const sourceType = descriptor ? F64 : STRING;
-  const source = lowerer.lowerExprExpecting(expr.arguments.nodes[0]!, sourceType);
+  const source = descriptor
+    ? lowerer.lowerExprExpecting(expr.arguments.nodes[0]!, sourceType)
+    : lowerFsPath(lowerer, expr.arguments.nodes[0]!);
   const encoding: IrExpr =
     optionsType.kind === "string"
       ? lowerer.lowerExprExpecting(options, STRING)
@@ -742,7 +745,7 @@ export function lowerFsOpendirCall(
   ) {
     lowerer.noLowering(`${member} with ${expr.arguments.nodes.length} arguments`, expr);
   }
-  const path = lowerer.lowerExprExpecting(expr.arguments.nodes[0]!, STRING);
+  const path = lowerFsPath(lowerer, expr.arguments.nodes[0]!);
   let bufferSize: IrExpr = { kind: "numLit", value: 32, type: F64, loc };
   const optsNode = expr.arguments.nodes[1];
   if (optsNode && !(ts.isIdentifier(optsNode) && optsNode.text === "undefined")) {
@@ -812,7 +815,7 @@ export function lowerFsMkdirSyncCall(
     );
   }
   const { recursive, modeNode } = options;
-  const path = lowerer.lowerExprExpecting(expr.arguments.nodes[0]!, STRING);
+  const path = lowerFsPath(lowerer, expr.arguments.nodes[0]!);
   const mode: IrExpr | null = modeNode ? lowerer.lowerExprExpecting(modeNode, F64) : null;
   if (!recursive) {
     return mode
@@ -884,7 +887,7 @@ export function lowerFsRemoveCall(lowerer: Lowerer, expr: ts.CallExpression, loc
       "the recursive/force flags must be boolean literals; maxRetries/retryDelay are numbers; other options have no lowering",
     );
   }
-  const path = lowerer.lowerExprExpecting(expr.arguments.nodes[0]!, STRING);
+  const path = lowerFsPath(lowerer, expr.arguments.nodes[0]!);
 
   const recursive = boolLit(opts.bools["recursive"] === true, loc);
   const force = boolLit(opts.bools["force"] === true, loc);
@@ -941,7 +944,7 @@ export function lowerFsWriteBytesCall(
         "byte writes take Uint8Array/Buffer data",
       );
     }
-    const path = lowerer.lowerExprExpecting(expr.arguments.nodes[0]!, STRING);
+    const path = lowerFsPath(lowerer, expr.arguments.nodes[0]!);
     const data = lowerer.lowerExprExpecting(expr.arguments.nodes[1]!, BYTES_U8);
     if (bi.module === "fs/promises") {
       return {
@@ -981,7 +984,7 @@ export function lowerFsWriteOptionsCall(
   // values in object-literal order before issuing the write; otherwise a
   // call/getter statically typed as the accepted utf8 literal can vanish.
   const finishWrite = (optionValues: WriteOptionValue[]): IrExpr => {
-    const path = lowerer.lowerExprExpecting(expr.arguments.nodes[0]!, STRING);
+    const path = lowerFsPath(lowerer, expr.arguments.nodes[0]!);
     const data = lowerer.lowerExprExpecting(expr.arguments.nodes[1]!, STRING);
     const pathLocal = lowerer.declareHiddenLocal("%writePath", STRING);
     const dataLocal = lowerer.declareHiddenLocal("%writeData", STRING);
diff --git a/packages/compiler/src/frontend/lowering/builtins/filesystem.ts b/packages/compiler/src/frontend/lowering/builtins/filesystem.ts
index 49875e004..0e1c062c5 100644
--- a/packages/compiler/src/frontend/lowering/builtins/filesystem.ts
+++ b/packages/compiler/src/frontend/lowering/builtins/filesystem.ts
@@ -1,6 +1,7 @@
 import { dynUndefinedExpr, boolLit, numLit, varRef } from "../../../ir/build.js";
 import * as ts from "../../ts7/adapter.js";
 import { type Lowerer, ladderFenceExpr } from "../lowerer.js";
+import { lowerFsPath } from "./fs-paths.js";
 import { isJsSourceFile, locOf } from "../../program.js";
 import {
   builtinModuleFnOf,
@@ -513,7 +514,7 @@ export function lowerStringOrBytesWrite(
     kind: "call",
     callee: helper,
     args: [
-      lowerer.lowerExprExpecting(call.arguments.nodes[0]!, STRING),
+      lowerFsPath(lowerer, call.arguments.nodes[0]!),
       lowerer.lowerExprExpecting(call.arguments.nodes[1]!, dataType),
     ],
     type: VOID,
@@ -1376,7 +1377,7 @@ export function lowerFsReaddirTypesCall(
   ) {
     fence();
   }
-  const path = lowerer.lowerExprExpecting(call.arguments.nodes[0]!, STRING);
+  const path = lowerFsPath(lowerer, call.arguments.nodes[0]!);
   return {
     kind: "libCall",
     fn: promiseForm ? "fsp.readdirTypes" : "fs.readdirTypesSync",
@@ -1405,7 +1406,7 @@ export function lowerFsStatOptionsCall(
   const spelling = noFollow ? "lstatSync" : "statSync";
   const plainFn: IrLibFn = noFollow ? "fs.lstatSync" : "fs.statSync";
   const optsNode = call.arguments.nodes[1]!;
-  const path = lowerer.lowerExprExpecting(call.arguments.nodes[0]!, STRING);
+  const path = lowerFsPath(lowerer, call.arguments.nodes[0]!);
   // The path binds first, then the options' effects, then the stat runs.
   const plainAfter = (effect: IrExpr | null): IrExpr => {
     if (effect === null) return { kind: "libCall", fn: plainFn, args: [path], type: STATS_T, loc };
diff --git a/packages/compiler/src/frontend/lowering/builtins/fs-paths.ts b/packages/compiler/src/frontend/lowering/builtins/fs-paths.ts
new file mode 100644
index 000000000..fb9176b53
--- /dev/null
+++ b/packages/compiler/src/frontend/lowering/builtins/fs-paths.ts
@@ -0,0 +1,212 @@
+/* fs path arguments given as file: URLs. Node converts a URL path with
+ * fileURLToPath inside each function (getValidatedPath), after every
+ * argument has been evaluated, and validates some arguments before the
+ * path and others after it. A URL-typed path lowers to the same
+ * conversion (url.fileURLToPathUrl). Later arguments with side effects are
+ * evaluated into hidden locals before the conversion, so they run even
+ * when it throws. The conversion keeps Node's error order when every
+ * earlier path is a URL too and each argument Node validates before the
+ * path is absent or a literal that passes that validation; other URL
+ * forms fence with SC2020, as do the fs.promises functions, whose
+ * conversion errors are rejections rather than throws, and existsSync,
+ * which answers false for a URL it cannot convert. */
+import * as ts from "../../ts7/adapter.js";
+import { type Lowerer } from "../lowerer.js";
+import { locOf } from "../../program.js";
+import { sideEffectFreeOptionValue } from "../surfaces.js";
+import { type IrExpr, type IrStmt, STRING, URL_T } from "../../../ir/ir.js";
+
+/** The fs functions whose path parameters accept a URL: the path
+ * parameter indexes, and whether Node validates the paths before every
+ * other argument (otherwise the options come first). */
+const FS_URL_PATHS: Readonly<
+  Record<string, { readonly paths: readonly number[]; readonly pathsFirst: boolean }>
+> = {
+  accessSync: { paths: [0], pathsFirst: true },
+  appendFileSync: { paths: [0], pathsFirst: false },
+  chmodSync: { paths: [0], pathsFirst: true },
+  chownSync: { paths: [0], pathsFirst: true },
+  copyFileSync: { paths: [0, 1], pathsFirst: true },
+  lchownSync: { paths: [0], pathsFirst: true },
+  lstatSync: { paths: [0], pathsFirst: true },
+  mkdirSync: { paths: [0], pathsFirst: false },
+  mkdtempSync: { paths: [0], pathsFirst: false },
+  openSync: { paths: [0], pathsFirst: true },
+  opendirSync: { paths: [0], pathsFirst: true },
+  readFileSync: { paths: [0], pathsFirst: false },
+  readdirSync: { paths: [0], pathsFirst: false },
+  realpathSync: { paths: [0], pathsFirst: false },
+  "realpathSync.native": { paths: [0], pathsFirst: false },
+  renameSync: { paths: [0, 1], pathsFirst: true },
+  rmSync: { paths: [0], pathsFirst: false },
+  rmdirSync: { paths: [0], pathsFirst: true },
+  statSync: { paths: [0], pathsFirst: true },
+  truncateSync: { paths: [0], pathsFirst: true },
+  unlinkSync: { paths: [0], pathsFirst: true },
+  writeFileSync: { paths: [0], pathsFirst: false },
+};
+
+/** The fs.promises functions with path parameters, by path indexes. */
+const FSP_PATHS: Readonly<Record<string, readonly number[]>> = {
+  access: [0],
+  appendFile: [0],
+  chmod: [0],
+  chown: [0],
+  copyFile: [0, 1],
+  lchown: [0],
+  lstat: [0],
+  mkdir: [0],
+  mkdtemp: [0],
+  open: [0],
+  opendir: [0],
+  readFile: [0],
+  readdir: [0],
+  realpath: [0],
+  rename: [0, 1],
+  rm: [0],
+  rmdir: [0],
+  stat: [0],
+  truncate: [0],
+  unlink: [0],
+  writeFile: [0],
+};
+
+function isUrlArgument(lowerer: Lowerer, node: ts.Expression | undefined): boolean {
+  return node !== undefined && lowerer.mapTypeOf(lowerer.typeOf(node))?.kind === "url";
+}
+
+/** A literal that Node's option validation accepts before it reads the
+ * path: a string (the checker admits only the declared encodings, flags
+ * and type names), a boolean, an integer in [0, 2^31 - 1] (every numeric
+ * option of these functions accepts that range), undefined or null, or an
+ * object literal of those. */
+function preValidatedLiteral(node: ts.Expression): boolean {
+  let e = node;
+  while (ts.isParenthesizedExpression(e)) e = e.expression;
+  if (ts.isStringLiteralLike(e)) return true;
+  if (
+    e.kind === ts.SyntaxKind.TrueKeyword ||
+    e.kind === ts.SyntaxKind.FalseKeyword ||
+    e.kind === ts.SyntaxKind.NullKeyword
+  )
+    return true;
+  if (ts.isIdentifier(e)) return e.text === "undefined";
+  if (ts.isNumericLiteral(e)) {
+    const value = Number(e.text);
+    return Number.isInteger(value) && value >= 0 && value <= 2147483647;
+  }
+  if (ts.isObjectLiteralExpression(e)) {
+    return e.properties.nodes.every(
+      (p) =>
+        ts.isPropertyAssignment(p) &&
+        !ts.isComputedPropertyName(p.name) &&
+        preValidatedLiteral(p.initializer),
+    );
+  }
+  return false;
+}
+
+/** SC2020 when the call passes a URL path in a form whose conversion
+ * order would differ from Node's (see the file comment). */
+function checkUrlPaths(
+  lowerer: Lowerer,
+  call: ts.CallExpression,
+  module: string,
+  member: string,
+): void {
+  const args = call.arguments.nodes;
+  const name = module === "fs/promises" ? `fs.promises.${member}` : member;
+  const hint = "convert the URL first: fileURLToPath(url) from node:url";
+  if (module === "fs/promises") {
+    if ((FSP_PATHS[member] ?? []).some((i) => isUrlArgument(lowerer, args[i])))
+      lowerer.noLowering(`${name} with a URL path`, call, hint);
+    return;
+  }
+  if (member === "existsSync" && isUrlArgument(lowerer, args[0]))
+    lowerer.noLowering(`${name} with a URL path`, call, hint);
+  const row = FS_URL_PATHS[member];
+  if (!row) return;
+  const first = row.paths.find((i) => isUrlArgument(lowerer, args[i]));
+  if (first === undefined) return;
+  if (args.some(ts.isSpreadElement))
+    lowerer.noLowering(`${name} with spread arguments and a URL path`, call);
+  // The runtime checks a string path after the conversion, so a string
+  // path Node checks first cannot precede the URL.
+  if (row.paths.some((i) => i < first && args[i] !== undefined))
+    lowerer.noLowering(`${name} with a string path before a URL path`, call, hint);
+  const staged: ts.Expression[] = [];
+  for (let i = first + 1; i < args.length; i++) {
+    const arg = args[i]!;
+    if (sideEffectFreeOptionValue(arg)) continue;
+    // Literals are read by their members, so a whole-value slot cannot
+    // hold them.
+    let e = arg;
+    while (ts.isParenthesizedExpression(e)) e = e.expression;
+    if (ts.isObjectLiteralExpression(e) || ts.isArrayLiteralExpression(e))
+      lowerer.noLowering(`${name} with a URL path and a later literal that has effects`, arg, hint);
+    staged.push(e);
+  }
+  if (staged.length > 0) {
+    lowerer.stagedAfterPath.set(args[first]!, staged);
+    for (const e of staged) lowerer.stagedArguments.set(e, null);
+  }
+  if (row.pathsFirst) return;
+  // writeFileSync/appendFileSync's data is checked after the path.
+  const data = member === "writeFileSync" || member === "appendFileSync" ? 1 : -1;
+  for (let i = 0; i < args.length; i++) {
+    if (row.paths.includes(i) || i === data || preValidatedLiteral(args[i]!)) continue;
+    lowerer.noLowering(`${name} with a URL path and options that are not literals`, args[i]!, hint);
+  }
+}
+
+/** Fences URL paths that cannot convert in Node's order: the check every
+ * fs and fs.promises call runs before lowering its arguments. */
+export function checkFsUrlPaths(
+  lowerer: Lowerer,
+  call: ts.CallExpression,
+  bi: { module: string; member: string },
+): void {
+  if (bi.module === "fs" || bi.module === "fs/promises")
+    checkUrlPaths(lowerer, call, bi.module, bi.member);
+}
+
+/** An fs path argument as a string: a URL converts with fileURLToPath's
+ * conversion (url.fileURLToPathUrl), which throws Node's errors for other
+ * schemes, hosts and encoded separators. */
+export function lowerFsPath(lowerer: Lowerer, node: ts.Expression): IrExpr {
+  if (!isUrlArgument(lowerer, node)) return lowerer.lowerExprExpecting(node, STRING);
+  const loc = locOf(node);
+  const url = lowerer.lowerExprExpecting(node, URL_T);
+  const staged = lowerer.stagedAfterPath.get(node);
+  if (staged === undefined)
+    return { kind: "libCall", fn: "url.fileURLToPathUrl", args: [url], type: STRING, loc };
+  // The URL and the later arguments with effects, in source order, then
+  // the conversion.
+  const saved = lowerer.declareHiddenLocal("%fsUrl", URL_T);
+  const stmts: IrStmt[] = [{ kind: "varDecl", localId: saved.id, init: url, loc }];
+  for (const arg of staged) {
+    lowerer.stagedArguments.delete(arg);
+    const value = lowerer.lowerExpr(arg);
+    const slot = lowerer.declareHiddenLocal("%fsArg", value.type);
+    stmts.push({ kind: "varDecl", localId: slot.id, init: value, loc: locOf(arg) });
+    lowerer.stagedArguments.set(arg, { localId: slot.id, type: value.type });
+  }
+  return {
+    kind: "seqExpr",
+    stmts,
+    result: {
+      kind: "libCall",
+      fn: "url.fileURLToPathUrl",
+      args: [{ kind: "varRef", localId: saved.id, type: URL_T, loc }],
+      type: STRING,
+      loc,
+    },
+    type: STRING,
+    loc,
+  };
+}
+
+/** Whether `index` is a path parameter of the fs function `member`. */
+export function isFsPathParam(member: string, index: number): boolean {
+  return FS_URL_PATHS[member]?.paths.includes(index) === true;
+}
diff --git a/packages/compiler/src/frontend/lowering/builtins/module-calls.ts b/packages/compiler/src/frontend/lowering/builtins/module-calls.ts
index c85f2c777..d33585d83 100644
--- a/packages/compiler/src/frontend/lowering/builtins/module-calls.ts
+++ b/packages/compiler/src/frontend/lowering/builtins/module-calls.ts
@@ -25,6 +25,7 @@ import {
   lowerFsWriteOptionsCall,
   lowerFsReadPathCall,
 } from "./filesystem-calls.js";
+import { checkFsUrlPaths, isFsPathParam, lowerFsPath } from "./fs-paths.js";
 import { lowerBufferEncodingCall } from "./text-codecs.js";
 import { lowerUtilTypeCall } from "./util-types.js";
 import { InternalCompilerError } from "../../../errors.js";
@@ -58,6 +59,7 @@ export function lowerBuiltinModuleCall(
   loc: SrcLoc,
 ): IrExpr {
   const name = ts.getTextOfNode(expr.expression);
+  checkFsUrlPaths(lowerer, expr, bi);
   if (bi.module === "util/types") {
     return lowerUtilTypeCall(lowerer, expr, bi, loc, name);
   }
@@ -240,7 +242,7 @@ export function lowerBuiltinModuleCall(
     expr.arguments.nodes.length === 1 &&
     lowerer.mapTypeOf(lowerer.typeOf(expr.arguments.nodes[0]!))?.kind !== "f64"
   ) {
-    const path = lowerer.lowerExprExpecting(expr.arguments.nodes[0]!, STRING);
+    const path = lowerFsPath(lowerer, expr.arguments.nodes[0]!);
     return { kind: "libCall", fn: "fs.readFileSyncBytes", args: [path], type: BYTES_U8, loc };
   }
   if (
@@ -305,7 +307,7 @@ export function lowerBuiltinModuleCall(
     if (expr.arguments.nodes.length < 1 || expr.arguments.nodes.length > 2) {
       lowerer.noLowering(`${bi.member} with ${expr.arguments.nodes.length} arguments`, expr);
     }
-    const path = lowerer.lowerExprExpecting(expr.arguments.nodes[0]!, STRING);
+    const path = lowerFsPath(lowerer, expr.arguments.nodes[0]!);
     const second: IrExpr = expr.arguments.nodes[1]
       ? lowerer.lowerExprExpecting(expr.arguments.nodes[1], F64)
       : { kind: "numLit", value: 0, type: F64, loc };
@@ -467,7 +469,11 @@ export function lowerBuiltinModuleCall(
     );
     args = lowerer.completeArgs(expr.arguments.nodes, shapes, loc, expr);
   } else {
-    args = expr.arguments.nodes.map((a, i) => lowerer.lowerExprExpecting(a, fn.params[i]));
+    args = expr.arguments.nodes.map((a, i) =>
+      bi.module === "fs" && isFsPathParam(bi.member, i)
+        ? lowerFsPath(lowerer, a)
+        : lowerer.lowerExprExpecting(a, fn.params[i]),
+    );
     for (let i = args.length; i < fn.params.length; i++) {
       const dflt = fn.defaults![i - required]!;
       args.push({ kind: "strLit", value: dflt, type: STRING, loc });
diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts
index 543149f83..80b2a5938 100644
--- a/packages/compiler/src/frontend/lowering/lowerer.ts
+++ b/packages/compiler/src/frontend/lowering/lowerer.ts
@@ -2918,6 +2918,12 @@ export class Lowerer {
    * for the duration of that call, the receiver lowers to the Transform of
    * the value held in the named local. */
   readonly hashStreamReceivers = new Map<ts.Expression, { localId: string; type: IrType }>();
+  /** fs call arguments evaluated ahead of a URL path's conversion
+   * (builtins/fs-paths.ts): each lowers to the hidden local that holds its
+   * value, which is null until the path's lowering has saved it. */
+  readonly stagedArguments = new Map<ts.Expression, { localId: string; type: IrType } | null>();
+  /** The staged arguments that follow each such URL path, in order. */
+  readonly stagedAfterPath = new Map<ts.Expression, ts.Expression[]>();
   readonly moduleNsParamOverrides = new Map<
     ts.ParameterDeclaration,
     IrType & { kind: "moduleNs" }
@@ -10003,6 +10009,8 @@ export class Lowerer {
     // retain their own checked conversion and must not be erased here.
     while (ts.isParenthesizedExpression(node) || ts.isSatisfiesExpression(node))
       node = node.expression;
+    const staged = this.stagedArgument(node);
+    if (staged) return expected ? this.coerceInto(node, staged, expected) : staged;
     if (expected) {
       if (ts.isConditionalExpression(node)) return lowerTernary(this, node, expected);
       const escaped = this.neverAssertionInto(node, expected);
@@ -12035,7 +12043,19 @@ export class Lowerer {
   lowerExpr(expr: ts.Expression): IrExpr {
     const hash = this.hashStreamReceivers.get(expr);
     if (hash) return hashStreamOf(varRef(hash.localId, hash.type, locOf(expr)));
-    return lowerExpr(this, expr);
+    return this.stagedArgument(expr) ?? lowerExpr(this, expr);
+  }
+
+  /** The saved value of a staged fs argument (stagedArguments), or null for
+   * every other expression. */
+  private stagedArgument(node: ts.Expression): IrExpr | null {
+    if (this.stagedArguments.size === 0) return null;
+    while (ts.isParenthesizedExpression(node)) node = node.expression;
+    if (!this.stagedArguments.has(node)) return null;
+    const slot = this.stagedArguments.get(node);
+    if (!slot)
+      throw new InternalCompilerError("an fs argument lowered before the URL path it follows");
+    return varRef(slot.localId, slot.type, locOf(node));
   }
 
   lowerIntrinsicProperty(expr: ts.PropertyAccessExpression): IrExpr | null {
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6931-fs-url-paths.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6931-fs-url-paths.ts.json
new file mode 100644
index 000000000..6a1574e04
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6931-fs-url-paths.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6931-fs-url-paths.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/fs-url-path-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/fs-url-path-fences.ts.json
new file mode 100644
index 000000000..c25c78ec0
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/fs-url-path-fences.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/diagnostics/fs-url-path-fences.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fs-url-path-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fs-url-path-fences.ts.json
new file mode 100644
index 000000000..7b63a5564
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fs-url-path-fences.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/fixtures/node-types/fs-url-path-fences.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fs-url-paths.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fs-url-paths.ts.json
new file mode 100644
index 000000000..cdc4ee43f
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fs-url-paths.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/fixtures/node-types/fs-url-paths.ts"
+ ],
+ "diags": []
+}
diff --git a/tests/corpus/6931-fs-url-paths.ts b/tests/corpus/6931-fs-url-paths.ts
new file mode 100644
index 000000000..91a630d1b
--- /dev/null
+++ b/tests/corpus/6931-fs-url-paths.ts
@@ -0,0 +1,96 @@
+// fs functions given file: URL paths: the URL converts as fileURLToPath
+// converts it, so names with spaces and non-ASCII characters reach the same
+// file, and URLs with another scheme, a host or an encoded separator throw
+// Node's errors.
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+
+const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "fs-url-")));
+const at = (name: string): URL => pathToFileURL(path.join(dir, name));
+// Arguments after a URL path are evaluated before the URL converts.
+function logged(name: string): URL {
+  console.log("evaluated", name);
+  return at(name);
+}
+function mode(): number {
+  console.log("evaluated mode");
+  return 0o600;
+}
+
+function clean(text: string): string {
+  return text.split(dir).join("<dir>");
+}
+
+function attempt(label: string, run: () => void): void {
+  try {
+    run();
+    console.log(label, "returned");
+  } catch (error) {
+    if (error instanceof Error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      console.log(label, error.name, code, clean(error.message));
+    }
+  }
+}
+
+const file = at("a b ü.txt");
+fs.writeFileSync(file, "hello");
+console.log(fs.readFileSync(file, "utf8"));
+console.log(fs.readFileSync(file).length);
+console.log(fs.readFileSync(file, { encoding: "utf8" }));
+console.log(fs.readFileSync(file, "base64"));
+fs.appendFileSync(file, " world");
+fs.writeFileSync(at("bytes.bin"), new Uint8Array([1, 2, 3]));
+fs.writeFileSync(at("mode.txt"), "m", { mode: 0o600 });
+console.log(fs.readFileSync(path.join(dir, "a b ü.txt"), "utf8"));
+console.log(fs.statSync(file).size, fs.lstatSync(file).isFile(), fs.statSync(at("bytes.bin")).size);
+console.log(fs.statSync(at("missing"), { throwIfNoEntry: false }) === undefined);
+fs.accessSync(file);
+fs.accessSync(file, fs.constants.R_OK);
+fs.chmodSync(file, 0o644);
+console.log((fs.statSync(file).mode & 0o777).toString(8));
+
+fs.mkdirSync(at("sub/deep"), { recursive: true });
+fs.mkdirSync(at("plain"));
+console.log(fs.readdirSync(at("sub")));
+console.log(fs.readdirSync(at("sub"), { withFileTypes: true }).map((entry) => entry.name));
+fs.copyFileSync(file, at("sub/copy.txt"));
+fs.renameSync(at("sub/copy.txt"), at("sub/moved.txt"));
+console.log(fs.readFileSync(at("sub/moved.txt"), "utf8"));
+fs.truncateSync(at("sub/moved.txt"), 4);
+console.log(fs.readFileSync(at("sub/moved.txt"), "utf8"));
+const fd = fs.openSync(at("sub/moved.txt"), "r");
+console.log(typeof fd);
+fs.closeSync(fd);
+console.log(clean(fs.realpathSync(at("sub/../sub/moved.txt"))));
+console.log(clean(fs.realpathSync.native(at("sub"))));
+const temp = fs.mkdtempSync(at("tmp-"));
+console.log(path.dirname(temp) === dir, path.basename(temp).length);
+fs.rmdirSync(pathToFileURL(temp));
+const opened = fs.opendirSync(at("sub"));
+console.log(opened.path === path.join(dir, "sub"));
+opened.closeSync();
+fs.unlinkSync(at("sub/moved.txt"));
+fs.rmSync(at("sub"), { recursive: true, force: true });
+fs.rmSync(at("plain"), { recursive: true });
+console.log(fs.readdirSync(dir).sort());
+
+attempt("scheme", () => fs.readFileSync(new URL("http://example.com/a.txt"), "utf8"));
+attempt("host", () => fs.statSync(new URL("file://example.com/a.txt")));
+attempt("separator", () => fs.readFileSync(new URL("file:///tmp/a%2Fb"), "utf8"));
+attempt("lowercase separator", () => fs.unlinkSync(new URL("file:///tmp/a%2fb")));
+attempt("null byte", () => fs.readFileSync(new URL("file:///tmp/a%00b")));
+attempt("missing", () => fs.readFileSync(at("missing.txt"), "utf8"));
+attempt("both bad", () => fs.copyFileSync(new URL("http://a/"), new URL("file://b/c")));
+attempt("rename", () => fs.renameSync(at("missing.txt"), at("other.txt")));
+attempt("mkdir", () => {
+  fs.mkdirSync(new URL("ftp://a/b"), { recursive: true });
+});
+attempt("later effects", () => fs.copyFileSync(new URL("http://a/"), logged("dest.txt")));
+attempt("later mode", () => fs.chmodSync(new URL("http://a/"), mode()));
+attempt("chmod", () => fs.chmodSync(new URL("data:text/plain,a"), 0o600));
+
+fs.rmSync(dir, { recursive: true, force: true });
+console.log("done", fs.existsSync(dir));
diff --git a/tests/diagnostics/fs-url-path-fences.ts b/tests/diagnostics/fs-url-path-fences.ts
new file mode 100644
index 000000000..080c561e1
--- /dev/null
+++ b/tests/diagnostics/fs-url-path-fences.ts
@@ -0,0 +1,15 @@
+// URL paths whose conversion would run in a different order than Node's.
+import * as fs from "node:fs";
+
+const url = new URL("file:///tmp/fs-url-path-fences");
+const encoding: BufferEncoding = process.argv.length > 9 ? "latin1" : "utf8";
+const recursive = process.argv.length > 9;
+
+// Node validates the string source before converting the URL destination.
+fs.copyFileSync("/tmp/source", url);
+// Node validates the options before the path.
+console.log(fs.readFileSync(url, encoding));
+fs.mkdirSync(url, { recursive });
+// A literal's members are lowered one by one, so they cannot be evaluated
+// ahead of the conversion as one value.
+console.log(fs.statSync(url, { throwIfNoEntry: process.argv.length > 9 }));
diff --git a/tests/fixtures/node-types/fs-url-path-fences.ts b/tests/fixtures/node-types/fs-url-path-fences.ts
new file mode 100644
index 000000000..4ae142189
--- /dev/null
+++ b/tests/fixtures/node-types/fs-url-path-fences.ts
@@ -0,0 +1,9 @@
+import { existsSync } from "node:fs";
+import { readFile, stat } from "node:fs/promises";
+
+const url = new URL("file:///tmp/node-types-url-fences");
+// existsSync answers false for a URL it cannot convert.
+console.log(existsSync(url));
+// The fs.promises functions reject for a URL they cannot convert.
+void readFile(url, "utf8");
+void stat(url);
diff --git a/tests/fixtures/node-types/fs-url-paths.ts b/tests/fixtures/node-types/fs-url-paths.ts
new file mode 100644
index 000000000..6d33d708d
--- /dev/null
+++ b/tests/fixtures/node-types/fs-url-paths.ts
@@ -0,0 +1,10 @@
+import { mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+const dir = mkdtempSync(join(tmpdir(), "node-types-url-"));
+const file = pathToFileURL(join(dir, "a b.txt"));
+writeFileSync(file, "hello");
+console.log(readFileSync(file, "utf8"), readFileSync(file).length, statSync(file).size);
+rmSync(pathToFileURL(dir), { recursive: true });
diff --git a/tests/harness/__snapshots__/fs-url-path-fences.ts.txt b/tests/harness/__snapshots__/fs-url-path-fences.ts.txt
new file mode 100644
index 000000000..1a53f8df5
--- /dev/null
+++ b/tests/harness/__snapshots__/fs-url-path-fences.ts.txt
@@ -0,0 +1,35 @@
+fs-url-path-fences.ts:9:1 - error SC2020: 'copyFileSync with a string path before a URL path' is part of the standard library types but has no scriptc lowering yet
+
+   8 | // Node validates the string source before converting the URL destination.
+   9 | fs.copyFileSync("/tmp/source", url);
+     | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  10 | // Node validates the options before the path.
+
+  hint: convert the URL first: fileURLToPath(url) from node:url
+
+fs-url-path-fences.ts:11:34 - error SC2020: 'readFileSync with a URL path and options that are not literals' is part of the standard library types but has no scriptc lowering yet
+
+  10 | // Node validates the options before the path.
+  11 | console.log(fs.readFileSync(url, encoding));
+     |                                  ^~~~~~~~
+  12 | fs.mkdirSync(url, { recursive });
+
+  hint: convert the URL first: fileURLToPath(url) from node:url
+
+fs-url-path-fences.ts:12:19 - error SC2020: 'mkdirSync with a URL path and options that are not literals' is part of the standard library types but has no scriptc lowering yet
+
+  11 | console.log(fs.readFileSync(url, encoding));
+  12 | fs.mkdirSync(url, { recursive });
+     |                   ^~~~~~~~~~~~~
+  13 | // A literal's members are lowered one by one, so they cannot be evaluated
+
+  hint: convert the URL first: fileURLToPath(url) from node:url
+
+fs-url-path-fences.ts:15:30 - error SC2020: 'statSync with a URL path and a later literal that has effects' is part of the standard library types but has no scriptc lowering yet
+
+  14 | // ahead of the conversion as one value.
+  15 | console.log(fs.statSync(url, { throwIfNoEntry: process.argv.length > 9 }));
+     |                              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  16 | 
+
+  hint: convert the URL first: fileURLToPath(url) from node:url
\ No newline at end of file
diff --git a/tests/harness/corpus-costs/6931-fs-url-paths.ts.json b/tests/harness/corpus-costs/6931-fs-url-paths.ts.json
new file mode 100644
index 000000000..458abd256
--- /dev/null
+++ b/tests/harness/corpus-costs/6931-fs-url-paths.ts.json
@@ -0,0 +1 @@
+{ "plain": 4139, "san": 50584 }
diff --git a/tests/harness/project-config.test.ts b/tests/harness/project-config.test.ts
index c7a5202f2..dabb9b0bf 100644
--- a/tests/harness/project-config.test.ts
+++ b/tests/harness/project-config.test.ts
@@ -764,6 +764,35 @@ test("node-types: exec's numeric ExecException.code remains a named fence", asyn
   }
 });
 
+test("node-types: fs functions take URL paths under @types/node's PathLike", async () => {
+  const dir = outDirFor("node-fs-url-paths");
+  const result = await compile(join(nodeTypesDir, "fs-url-paths.ts"), {
+    outPath: join(dir, "fs-url-paths"),
+    outDir: dir,
+    sanitize,
+  });
+  expect(result.ok, !result.ok ? JSON.stringify(result.diagnostics, null, 2) : "").toBe(true);
+  if (!result.ok) return;
+  const { stdout } = await execFileAsync(result.binaryPath);
+  expect(stdout).toBe("hello 5 5\n");
+});
+
+test("node-types: existsSync and fs.promises URL paths remain named fences", async () => {
+  const dir = outDirFor("node-fs-url-path-fences");
+  const result = await compile(join(nodeTypesDir, "fs-url-path-fences.ts"), {
+    outPath: join(dir, "fs-url-path-fences"),
+    outDir: dir,
+    sanitize,
+  });
+  expect(result.ok).toBe(false);
+  if (result.ok) return;
+  expect(result.diagnostics.map((diagnostic) => [diagnostic.code, diagnostic.message])).toEqual([
+    ["SC2020", expect.stringContaining("'existsSync with a URL path'")],
+    ["SC2020", expect.stringContaining("'fs.promises.readFile with a URL path'")],
+    ["SC2020", expect.stringContaining("'fs.promises.stat with a URL path'")],
+  ]);
+});
+
 test("node-types: path and os lower statically under @types/node's shapes", async () => {
   const outDir = outDirFor("node-path-os");
   const result = await compile(join(nodeTypesDir, "path-os.ts"), {

From fd8ac00e63ab536e4065ab55cb06932d00c7c7c9 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 08:53:09 -0500
Subject: [PATCH 02/67] Convert global isFinite's argument with ToNumber

Global isFinite now converts any argument with ToNumber before the test,
the same way global isNaN does, and only Number.isFinite stays strict.
Before, an argument that wasn't typed as a number, such as a checker-unknown
or dynamic value, refused with SC2012.

The shared ToNumber conversion for these arguments (isNaN, isFinite, the
Math functions, String.fromCharCode, DataView offsets) now handles every
value kind: strings parse as numeric literals, booleans and null convert
to numbers, undefined is NaN, and dynamic values call valueOf/toString or
throw Node's TypeError for a Symbol or BigInt. Before, a dynamic value
went through a checked number cast and threw a TypeError for a string,
and a string or boolean in a JavaScript file reached a run-time SC1090.

Fixes #1386

Co-authored-by: espetro <26749475+espetro@users.noreply.github.com>
---
 .../src/frontend/lowering/lower-calls.ts      | 84 +++++++------------
 .../src/frontend/lowering/lower-exprs.ts      | 22 +++++
 .../corpus/6905-isfinite-coercion.ts.json     |  6 ++
 .../corpus/6906-tonumber-arguments.mjs.json   |  6 ++
 tests/corpus/6905-isfinite-coercion.ts        | 38 +++++++++
 tests/corpus/6906-tonumber-arguments.mjs      | 32 +++++++
 6 files changed, 135 insertions(+), 53 deletions(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6905-isfinite-coercion.ts.json
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6906-tonumber-arguments.mjs.json
 create mode 100644 tests/corpus/6905-isfinite-coercion.ts
 create mode 100644 tests/corpus/6906-tonumber-arguments.mjs

diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts
index d768cec9b..9d871ca8b 100644
--- a/packages/compiler/src/frontend/lowering/lower-calls.ts
+++ b/packages/compiler/src/frontend/lowering/lower-calls.ts
@@ -166,7 +166,6 @@ import { lowerReflectCall } from "./builtins/reflection.js";
 import {
   lowerAbsenceProbe,
   v8CalleeText,
-  lowerOptionalNumber,
   lowerPromiseAllTupleCall,
   lowerPromiseRejectCall,
   lowerToNumberArgument,
@@ -1008,10 +1007,9 @@ export function lowerCall(lowerer: Lowerer, expr: ts.CallExpression): IrExpr {
     // excludes shadowed names. parseInt's omitted radix completes
     // to 0 — the spec's "undefined" (base 10 with the 0x hex escape);
     // parseFloat lowers the STRING form only (Node would ToString other
-    // values — no static story); isNaN/isFinite's arguments are
-    // checker-pinned (or checked) to number, where the global's ToNumber
-    // coercion is the identity and the tests are Number.isNaN /
-    // Number.isFinite exactly (ms's `isFinite(val)` guard).
+    // values — no static story); isNaN/isFinite apply the global's
+    // ToNumber to any argument, then test like Number.isNaN /
+    // Number.isFinite.
     if (
       (expr.expression.text === "parseInt" ||
         expr.expression.text === "isNaN" ||
@@ -1130,18 +1128,14 @@ export function lowerCall(lowerer: Lowerer, expr: ts.CallExpression): IrExpr {
     }
     if (islFn && expr.arguments.nodes.length === islFn.args.length) {
       // The static forms above already took the exactly-typed argument
-      // (a string for parseFloat, a number for isFinite): name the
-      // argument type that refused the call, so the message states the
-      // condition rather than reading as if the global itself were
-      // unsupported.
+      // (a string for parseFloat): name the argument type that refused
+      // the call, so the message states the condition rather than
+      // reading as if the global itself were unsupported.
       const argText = loweredArgumentText(lowerer, expr.arguments.nodes[0]!);
-      const exact = expr.expression.text === "isFinite" ? "number" : "string";
       lowerer.refuseUnsupportedApi(
         `'${expr.expression.text}' with a '${argText}' argument`,
         expr,
-        exact === "string"
-          ? "only a string argument compiles statically: convert the argument explicitly first (for example String(x), or narrow the union)"
-          : "only a number argument compiles statically: narrow the argument to a number first",
+        "only a string argument compiles statically: convert the argument explicitly first (for example String(x), or narrow the union)",
       );
     }
   }
@@ -10298,7 +10292,7 @@ export function lowerStaticNumberGlobal(
   args: readonly ts.Expression[],
   loc: SrcLoc,
 ): IrExpr | null {
-  if (name === "parseInt" || name === "isNaN") {
+  if (name === "parseInt" || name === "isNaN" || name === "isFinite") {
     const maxArgs = name === "parseInt" ? 2 : 1;
     if (args.length < 1 || args.length > maxArgs) {
       lowerer.noLowering(
@@ -10306,10 +10300,12 @@ export function lowerStaticNumberGlobal(
         call,
       );
     }
-    if (name === "isNaN") {
-      // The global's ToNumber turns a missing value into NaN.
+    if (name === "isNaN" || name === "isFinite") {
+      // The global's ToNumber turns a missing value into NaN, converts
+      // strings, booleans and null, and calls valueOf/toString on objects.
       const x = lowerToNumberArgument(lowerer, args[0]!);
-      return { kind: "libCall", fn: "num.isNaN", args: [x], type: BOOL, loc };
+      const fn = name === "isNaN" ? "num.isNaN" : "number.isFinite";
+      return { kind: "libCall", fn, args: [x], type: BOOL, loc };
     }
     const radix: IrExpr = args[1]
       ? lowerer.lowerExprExpecting(args[1], F64)
@@ -10445,32 +10441,28 @@ export function lowerStaticNumberGlobal(
         : lowerer.lowerExprExpecting(args[0]!, STRING);
     return { kind: "libCall", fn: "num.parseInt", args: [s, radix], type: F64, loc };
   }
-  // STATIC parseFloat/isFinite over exactly-typed arguments —
-  // parseInt's siblings (num.parseFloat is ECMA 19.2.4's decimal-
-  // literal prefix parse in scr_string.c; a number-typed isFinite IS
-  // Number.isFinite — the global's ToNumber coercion is the identity
-  // there, ms's `isFinite(val)` guard). Other argument types retain
-  // their native coercion checks or the SC2012 refusal. The probe never
-  // emits — lowering is IR construction.
-  if ((name === "parseFloat" || name === "isFinite") && args.length === 1) {
-    if (name === "parseFloat") {
-      const optional = optionalCallValue(lowerer, args[0]!);
-      if (optional) {
-        const parsed = lowerOptionalStringNumber(
-          lowerer,
-          optional,
-          loc,
-          "num.parseFloat",
-          "parseFloat",
-        );
-        if (parsed) return parsed;
-      }
+  // STATIC parseFloat over string arguments — parseInt's sibling
+  // (num.parseFloat is ECMA 19.2.4's decimal-literal prefix parse in
+  // scr_string.c). Other argument types retain their native coercion
+  // checks or the SC2012 refusal. The probe never emits — lowering is IR
+  // construction.
+  if (name === "parseFloat" && args.length === 1) {
+    const optional = optionalCallValue(lowerer, args[0]!);
+    if (optional) {
+      const parsed = lowerOptionalStringNumber(
+        lowerer,
+        optional,
+        loc,
+        "num.parseFloat",
+        "parseFloat",
+      );
+      if (parsed) return parsed;
     }
     const probed = tryLowerExpression(lowerer, args[0]!);
-    if (name === "parseFloat" && probed?.type.kind === "string") {
+    if (probed?.type.kind === "string") {
       return { kind: "libCall", fn: "num.parseFloat", args: [probed], type: F64, loc };
     }
-    if (name === "parseFloat" && probed?.type.kind === "dyn") {
+    if (probed?.type.kind === "dyn") {
       return {
         kind: "libCall",
         fn: "num.parseFloat",
@@ -10479,20 +10471,6 @@ export function lowerStaticNumberGlobal(
         loc,
       };
     }
-    if (name === "isFinite" && probed?.type.kind === "f64") {
-      return { kind: "libCall", fn: "number.isFinite", args: [probed], type: BOOL, loc };
-    }
-    // A number the checker trusts but storage may hold missing (an
-    // out-of-range read): the global's ToNumber makes undefined NaN.
-    if (
-      name === "isFinite" &&
-      probed?.type.kind === "union" &&
-      lowerer.armTag(probed.type.unionId, UNDEFINED_T) >= 0 &&
-      lowerer.stripUndefinedArm(probed.type).kind === "f64"
-    ) {
-      const x = lowerOptionalNumber(lowerer, probed, loc, args[0]);
-      return { kind: "libCall", fn: "number.isFinite", args: [x], type: BOOL, loc };
-    }
   }
   return null;
 }
diff --git a/packages/compiler/src/frontend/lowering/lower-exprs.ts b/packages/compiler/src/frontend/lowering/lower-exprs.ts
index 591057cab..4b03e915d 100644
--- a/packages/compiler/src/frontend/lowering/lower-exprs.ts
+++ b/packages/compiler/src/frontend/lowering/lower-exprs.ts
@@ -1438,6 +1438,28 @@ export function lowerToNumberArgument(lowerer: Lowerer, node: ts.Expression): Ir
   if (ts.isConditionalExpression(inner)) return lowerer.lowerExprExpecting(node, F64);
   const value = lowerer.lowerExpr(node);
   if (isOptionalNumber(value)) return lowerOptionalNumber(lowerer, value, loc, inner);
+  // Other values convert with ToNumber: strings parse as numeric literals,
+  // booleans and null are numbers, and checked-dynamic values call
+  // valueOf/toString or throw Node's TypeError for a Symbol or BigInt.
+  const num = (value: number): IrExpr => ({ kind: "numLit", value, type: F64, loc });
+  switch (value.type.kind) {
+    case "string":
+      return { kind: "libCall", fn: "num.fromString", args: [value], type: F64, loc };
+    case "bool":
+      return { kind: "ternary", cond: value, then: num(1), else_: num(0), type: F64, loc };
+    case "nullT":
+      return defaultAfterUndefined(value, num(0));
+    case "undefinedT":
+      return defaultAfterUndefined(value, num(NaN));
+    case "dyn":
+      return { kind: "libCall", fn: "dyn.toNumberCoerce", args: [value], type: F64, loc };
+    case "union":
+      if (lowerer.dynConvertible(value.type)) {
+        const boxed = lowerer.coerceToExpected(value, DYN);
+        return { kind: "libCall", fn: "dyn.toNumberCoerce", args: [boxed], type: F64, loc };
+      }
+      break;
+  }
   return lowerer.coerceInto(node, value, F64);
 }
 
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6905-isfinite-coercion.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6905-isfinite-coercion.ts.json
new file mode 100644
index 000000000..210987798
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6905-isfinite-coercion.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6905-isfinite-coercion.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6906-tonumber-arguments.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6906-tonumber-arguments.mjs.json
new file mode 100644
index 000000000..2fc650f3a
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6906-tonumber-arguments.mjs.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6906-tonumber-arguments.mjs"
+ ],
+ "diags": []
+}
diff --git a/tests/corpus/6905-isfinite-coercion.ts b/tests/corpus/6905-isfinite-coercion.ts
new file mode 100644
index 000000000..57e158c72
--- /dev/null
+++ b/tests/corpus/6905-isfinite-coercion.ts
@@ -0,0 +1,38 @@
+// Global isFinite applies ToNumber to its argument before the test, like
+// global isNaN: strings parse as numeric literals, booleans and null are 0
+// and 1, undefined is NaN, and objects convert through valueOf/toString.
+// Number.isFinite stays strict and answers false for anything not a number.
+const values: unknown[] = ["12", "", " 0x10 ", "abc", "1e400", true, false, null, undefined, {}, [], [7], [1, 2]];
+for (const value of values) {
+  console.log(JSON.stringify(value) ?? "undefined", isFinite(value as any), Number.isFinite(value));
+}
+
+const u: unknown = 12;
+console.log(isFinite(u as any));
+
+let calls = "";
+const boxed: unknown = { valueOf: () => ((calls += "v"), 5) };
+console.log(isFinite(boxed as any), calls);
+const text: unknown = { toString: () => "Infinity" };
+console.log(isFinite(text as any));
+
+class Cache {
+  #maxAge: unknown;
+  constructor(maxAge?: number) {
+    this.#maxAge = maxAge;
+  }
+  expires(): boolean {
+    return isFinite(this.#maxAge as any);
+  }
+}
+console.log(new Cache(1000).expires(), new Cache().expires());
+
+const throwing: unknown[] = [Symbol("s"), 10n];
+for (const value of throwing) {
+  try {
+    isFinite(value as any);
+  } catch (e) {
+    console.log(e instanceof TypeError);
+  }
+}
+console.log(isFinite(1 / 0), isFinite(-1 / 0), isFinite(0 / 0), isFinite(-0));
diff --git a/tests/corpus/6906-tonumber-arguments.mjs b/tests/corpus/6906-tonumber-arguments.mjs
new file mode 100644
index 000000000..23b150eb8
--- /dev/null
+++ b/tests/corpus/6906-tonumber-arguments.mjs
@@ -0,0 +1,32 @@
+// Arguments that the global number functions convert with ToNumber, in a
+// JavaScript file where they arrive as strings, booleans, null, undefined
+// or dynamic values: isNaN, isFinite, Math functions and
+// String.fromCharCode match Node for each.
+console.log(isNaN("12"), isNaN("abc"), isNaN(true), isNaN(null), isNaN(undefined));
+console.log(isFinite("12"), isFinite("abc"), isFinite(true), isFinite(null), isFinite(undefined));
+console.log(Math.floor("3.7"), Math.max("4", 2), Math.abs(false), Math.sqrt(null), String.fromCharCode("65", true));
+
+const parsed = JSON.parse('["12", " 0x10 ", "", "1e400", true, null, {}, [], [7]]');
+for (const value of parsed) console.log(JSON.stringify(value), isNaN(value), isFinite(value), Math.trunc(value));
+
+let calls = "";
+const boxed = { valueOf: () => ((calls += "v"), 4.5), toString: () => ((calls += "s"), "9") };
+console.log(isFinite(boxed), isNaN(boxed), Math.round(boxed), calls);
+
+class LruCache {
+  constructor(config) {
+    this.maxAge = config.maxAge;
+  }
+  hasMaxAge() {
+    return isFinite(this.maxAge);
+  }
+}
+console.log(new LruCache({ maxAge: 1000 }).hasMaxAge(), new LruCache({}).hasMaxAge());
+
+for (const value of [Symbol("s"), 10n]) {
+  try {
+    isFinite(value);
+  } catch (e) {
+    console.log(e instanceof TypeError, e.message);
+  }
+}

From 9b70fb5e7b0fde8a6eeb87bb903e47c7b2d40b88 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 08:58:29 -0500
Subject: [PATCH 03/67] Negotiate ALPN and bound the TLS version in tls.connect
 and tls.createServer

tls.connect and tls.createServer accept ALPNProtocols as an array of
strings, a Buffer or a Uint8Array in the wire format. The server answers
with the first of its own protocols that the client offers, and both
sockets report it as alpnProtocol. A client that offers none of the
server's protocols fails with ERR_SSL_TLSV1_ALERT_NO_APPLICATION_PROTOCOL.

minVersion and maxVersion bound the handshake, and getProtocol() reports
the version it picked. Ranges that do not overlap fail with Node's
ERR_SSL_TLSV1_ALERT_PROTOCOL_VERSION or ERR_SSL_NO_PROTOCOLS_AVAILABLE,
and invalid versions throw Node's TypeError. tls.connect's timeout option
arms the socket's inactivity timeout before it connects.

Refs #1438

Co-authored-by: saboursepideh <25549001+saboursepideh@users.noreply.github.com>
---
 .../src/generated/node-v24-compatibility.json |  12 +-
 .../generated/node-v24-internal.json          |  18 +-
 internal/compatibility/static-support.json    |   2 +
 .../src/frontend/lowering/lower-server.ts     |  30 +-
 .../corpus/6721-tls-alpn-protocols.ts.json    |   6 +
 .../corpus/6722-tls-min-max-version.ts.json   |   6 +
 .../corpus/6723-tls-connect-timeout.ts.json   |   6 +
 packages/runtime/src/scr_error.c              |   5 +
 packages/runtime/src/scr_tls.c                | 443 ++++++++++++++++--
 tests/corpus/6721-tls-alpn-protocols.ts       |  75 +++
 tests/corpus/6722-tls-min-max-version.ts      |  85 ++++
 tests/corpus/6723-tls-connect-timeout.ts      |  51 ++
 .../6721-tls-alpn-protocols.ts.json           |   1 +
 .../6722-tls-min-max-version.ts.json          |   1 +
 .../6723-tls-connect-timeout.ts.json          |   1 +
 15 files changed, 694 insertions(+), 48 deletions(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6721-tls-alpn-protocols.ts.json
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6722-tls-min-max-version.ts.json
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6723-tls-connect-timeout.ts.json
 create mode 100644 tests/corpus/6721-tls-alpn-protocols.ts
 create mode 100644 tests/corpus/6722-tls-min-max-version.ts
 create mode 100644 tests/corpus/6723-tls-connect-timeout.ts
 create mode 100644 tests/harness/corpus-costs/6721-tls-alpn-protocols.ts.json
 create mode 100644 tests/harness/corpus-costs/6722-tls-min-max-version.ts.json
 create mode 100644 tests/harness/corpus-costs/6723-tls-connect-timeout.ts.json

diff --git a/docs/src/generated/node-v24-compatibility.json b/docs/src/generated/node-v24-compatibility.json
index ed717c35e..66b0ba3dd 100644
--- a/docs/src/generated/node-v24-compatibility.json
+++ b/docs/src/generated/node-v24-compatibility.json
@@ -68082,9 +68082,9 @@
         "inherited": true
       },
       "static": {
-        "status": "not-implemented",
-        "detail": "No static compiler lowering is registered for this API yet.",
-        "verification": "registry-gap"
+        "status": "partial",
+        "detail": "Implemented for the documented scriptc module-loader subset.",
+        "verification": "test-backed"
       }
     },
     {
@@ -68289,9 +68289,9 @@
         "inherited": true
       },
       "static": {
-        "status": "not-implemented",
-        "detail": "No static compiler lowering is registered for this API yet.",
-        "verification": "registry-gap"
+        "status": "partial",
+        "detail": "Implemented for the documented scriptc module-loader subset.",
+        "verification": "test-backed"
       }
     },
     {
diff --git a/internal/compatibility/generated/node-v24-internal.json b/internal/compatibility/generated/node-v24-internal.json
index bbf177d52..c6a7a102c 100644
--- a/internal/compatibility/generated/node-v24-internal.json
+++ b/internal/compatibility/generated/node-v24-internal.json
@@ -95364,7 +95364,9 @@
           "tests/corpus/2331-tls-server-options-typed.ts",
           "tests/corpus/2500-net-autosel-timeout.ts",
           "tests/corpus/2557-tls-ca-store.ts",
-          "tests/corpus/2596-net-arg-ladders.cjs"
+          "tests/corpus/2596-net-arg-ladders.cjs",
+          "tests/corpus/6721-tls-alpn-protocols.ts",
+          "tests/corpus/6722-tls-min-max-version.ts"
         ]
       },
       "anchorSource": "chapter"
@@ -96365,8 +96367,11 @@
         "inherited": true
       },
       "static": {
-        "status": "not-implemented",
-        "evidence": "compiler-unmatched:tls"
+        "status": "partial",
+        "evidence": "compiler-feature:tls.tlsSocket.getProtocol",
+        "tests": [
+          "tests/corpus/6722-tls-min-max-version.ts"
+        ]
       },
       "anchorSource": "exact"
     },
@@ -96572,8 +96577,11 @@
         "inherited": true
       },
       "static": {
-        "status": "not-implemented",
-        "evidence": "compiler-unmatched:tls"
+        "status": "partial",
+        "evidence": "compiler-feature:tls.alpnProtocol",
+        "tests": [
+          "tests/corpus/6721-tls-alpn-protocols.ts"
+        ]
       },
       "anchorSource": "ancestor"
     },
diff --git a/internal/compatibility/static-support.json b/internal/compatibility/static-support.json
index 1f713630b..23c7a159b 100644
--- a/internal/compatibility/static-support.json
+++ b/internal/compatibility/static-support.json
@@ -365,6 +365,8 @@
     { "chapter": "stream", "signatures": ["`writable` Type: {boolean}"], "status": "partial", "evidence": ["tests/corpus/2893-child-stdin-duplex.ts", "tests/corpus/2895-child-stdin-write-after-end.ts"] },
     { "chapter": "stream", "signatures": ["Event: `'drain'`"], "status": "partial", "evidence": ["tests/corpus/2894-child-stdin-backpressure.ts"] },
     { "chapter": "console", "signatures": ["Class: `Console`"], "status": "partial", "evidence": ["tests/corpus/4900-console-instances.ts", "tests/corpus/4901-console-instance-errors.ts"] },
+    { "chapter": "tls", "signatures": ["`alpnProtocol` Type: {string|boolean|null}"], "status": "partial", "evidence": ["tests/corpus/6721-tls-alpn-protocols.ts"] },
+    { "chapter": "tls", "signatures": ["`tlsSocket.getProtocol()`"], "status": "partial", "evidence": ["tests/corpus/6722-tls-min-max-version.ts"] },
     { "chapter": "webstreams", "signatures": ["`readableStream.values([options])`"], "status": "partial", "evidence": ["tests/corpus/2862-web-readable-async-iteration.ts"] },
     { "chapter": "webstreams", "signatures": ["`streamConsumers.text(stream)`", "`streamConsumers.json(stream)`", "`streamConsumers.buffer(stream)`"], "status": "partial", "evidence": ["tests/corpus/2629-stream-consumers.ts", "tests/corpus/2630-stream-consumers-errors.ts"] },
     { "chapter": "webstreams", "signatures": ["`streamConsumers.arrayBuffer(stream)`"], "status": "partial", "evidence": ["tests/corpus/4875-stream-consumers-array-buffer.ts"] },
diff --git a/packages/compiler/src/frontend/lowering/lower-server.ts b/packages/compiler/src/frontend/lowering/lower-server.ts
index f0da85bf8..4a7c00d84 100644
--- a/packages/compiler/src/frontend/lowering/lower-server.ts
+++ b/packages/compiler/src/frontend/lowering/lower-server.ts
@@ -4877,12 +4877,14 @@ const TLS_VALIDATED_OPTIONS: ReadonlySet<string> = new Set([
 ]);
 
 /** True when a literal options bag must ride the runtime walker: JS uses
- * it for the typed TLS validation ladders, and HTTPS uses it for
+ * it for the typed TLS validation ladders, HTTPS uses it for
  * keepAliveTimeoutBuffer so the HTTP option is consumed without losing
- * the literal's evaluation order. */
+ * the literal's evaluation order, and `runtimeKeys` names options only the
+ * runtime walk implements (tls.createServer's ALPNProtocols). */
 function tlsLiteralNeedsRuntimeWalk(
   node: ts.ObjectLiteralExpression,
   includeHttpTimeoutOptions = false,
+  runtimeKeys: ReadonlySet<string> = new Set(),
 ): boolean {
   const jsSource = isJsSourceFile(ts.getSourceFileOfNode(node));
   return node.properties.nodes.some(
@@ -4890,19 +4892,29 @@ function tlsLiteralNeedsRuntimeWalk(
       (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
       (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) &&
       ((includeHttpTimeoutOptions && p.name.text === "keepAliveTimeoutBuffer") ||
+        runtimeKeys.has(p.name.text) ||
         (jsSource && TLS_VALIDATED_OPTIONS.has(p.name.text))),
   );
 }
 
+/** tls.createServer options the runtime walk implements and the literal
+ * cert/key lowering does not. */
+const TLS_SERVER_RUNTIME_OPTIONS: ReadonlySet<string> = new Set([
+  "ALPNProtocols",
+  "minVersion",
+  "maxVersion",
+]);
+
 function lowerTlsServerOptionsOrDyn(
   lowerer: Lowerer,
   node: ts.Expression,
   what: string,
   includeHttpTimeoutOptions = false,
+  runtimeKeys: ReadonlySet<string> = new Set(),
 ): { cert: IrExpr; key: IrExpr; dyn?: undefined } | { dyn: IrExpr } {
   if (
     ts.isObjectLiteralExpression(node) &&
-    !tlsLiteralNeedsRuntimeWalk(node, includeHttpTimeoutOptions)
+    !tlsLiteralNeedsRuntimeWalk(node, includeHttpTimeoutOptions, runtimeKeys)
   ) {
     return lowerTlsServerOptions(lowerer, node, what);
   }
@@ -4934,14 +4946,14 @@ function lowerTlsServerOptionsOrDyn(
  * connect(options[, cb]) and connect(port[, host][, options][, cb]) with
  * a RUNTIME options record (the checked-dynamic JS lane's shape — a dyn
  * value, or a record that converts): the runtime walk implements
- * port/host/rejectUnauthorized/ca/servername and throws the catchable
+ * port/host/rejectUnauthorized/ca/servername/ALPNProtocols/minVersion/maxVersion/timeout and throws the catchable
  * fence for other documented members (the divergence-66 stance). The
  * callback (and 'secureConnect'/'connect' listeners) fires
  * post-handshake — Node's secureConnect timing. */
 function lowerTlsConnectCall(lowerer: Lowerer, expr: ts.CallExpression, loc: SrcLoc): IrExpr {
   const args = expr.arguments.nodes;
   const FORMS_HINT =
-    "the supported forms are connect(options[, cb]) and connect(port[, host][, options][, cb]) — options implement port/host/rejectUnauthorized/ca/servername";
+    "the supported forms are connect(options[, cb]) and connect(port[, host][, options][, cb]) — options implement port/host/rejectUnauthorized/ca/servername/ALPNProtocols/minVersion/maxVersion/timeout";
   if (args.length < 1 || args.length > 4 || args.some(ts.isSpreadElement)) {
     lowerer.noLowering(`tls.connect with ${args.length} arguments`, expr, FORMS_HINT);
   }
@@ -5060,7 +5072,13 @@ function lowerTlsModuleCall(
         "the supported form is createServer({ cert, key }, socket => ...)",
       );
     }
-    const opts = lowerTlsServerOptionsOrDyn(lowerer, args[0]!, "tls.createServer");
+    const opts = lowerTlsServerOptionsOrDyn(
+      lowerer,
+      args[0]!,
+      "tls.createServer",
+      false,
+      TLS_SERVER_RUNTIME_OPTIONS,
+    );
     if (args.length === 1) {
       return opts.dyn !== undefined
         ? { kind: "libCall", fn: "tls.createServerDyn", args: [opts.dyn], type: NETSERVER_T, loc }
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6721-tls-alpn-protocols.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6721-tls-alpn-protocols.ts.json
new file mode 100644
index 000000000..b86035ce7
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6721-tls-alpn-protocols.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6721-tls-alpn-protocols.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6722-tls-min-max-version.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6722-tls-min-max-version.ts.json
new file mode 100644
index 000000000..0100ffe8f
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6722-tls-min-max-version.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6722-tls-min-max-version.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6723-tls-connect-timeout.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6723-tls-connect-timeout.ts.json
new file mode 100644
index 000000000..cc239efba
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6723-tls-connect-timeout.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6723-tls-connect-timeout.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/runtime/src/scr_error.c b/packages/runtime/src/scr_error.c
index 4f514681b..94523fc43 100644
--- a/packages/runtime/src/scr_error.c
+++ b/packages/runtime/src/scr_error.c
@@ -422,6 +422,11 @@ const char *scr_error_message_code(const ScrStr *msg) {
     { "self-signed certificate", false, "DEPTH_ZERO_SELF_SIGNED_CERT" },
     { "unable to verify the first certificate", false, "UNABLE_TO_VERIFY_LEAF_SIGNATURE" },
     { "Hostname/IP does not match certificate's altnames", false, "ERR_TLS_CERT_ALTNAME_INVALID" },
+    { "error:0A000460:SSL routines:ssl3_read_bytes:tlsv1 alert no application protocol", true,
+      "ERR_SSL_TLSV1_ALERT_NO_APPLICATION_PROTOCOL" },
+    { "error:0A00042E:SSL routines:ssl3_read_bytes:tlsv1 alert protocol version", true,
+      "ERR_SSL_TLSV1_ALERT_PROTOCOL_VERSION" },
+    { "error:0A0000BF:SSL routines::no protocols available", true, "ERR_SSL_NO_PROTOCOLS_AVAILABLE" },
   };
   for (size_t i = 0; i < sizeof known / sizeof known[0]; i++) {
     size_t n = strlen(known[i].prefix);
diff --git a/packages/runtime/src/scr_tls.c b/packages/runtime/src/scr_tls.c
index 804e51d69..59f3c2c0a 100644
--- a/packages/runtime/src/scr_tls.c
+++ b/packages/runtime/src/scr_tls.c
@@ -255,6 +255,93 @@ void scr_secure_ctx_release_v(void *p) { scr_secure_ctx_release((ScrSecureCtx *)
 
 /* ── the server config (one per created server, rc'd) ────────────────── */
 
+/* An owned ALPN name list (NULL-terminated; NULL frees nothing). */
+static void scr_tls_alpn_free(char **names) {
+  if (names == NULL) return;
+  for (char **n = names; *n != NULL; n++) free(*n);
+  free(names);
+}
+
+static bool scr_tls_alpn_dyn(const ScrDyn *v, char ***out);
+static void scr_tls_opt_fence(const char *api, const char *key, const char *hint);
+static bool scr_tls_dyn_truthy(const ScrDyn *v);
+
+/* Node's toV over a minVersion/maxVersion value: 'TLSv1' through 'TLSv1.3'
+ * as 10 through 13, null or undefined as `def`. Anything else throws
+ * ERR_TLS_INVALID_PROTOCOL_VERSION ("%j is not a valid <which> TLS protocol
+ * version"). False with the exception pending. */
+static bool scr_tls_version_dyn(const ScrDyn *v, const char *which, int def, int *out) {
+  if (v == NULL || v->kind == SCR_DYN_UNDEF || v->kind == SCR_DYN_NULL) {
+    *out = def;
+    return true;
+  }
+  if (v->kind == SCR_DYN_STR) {
+    static const struct { const char *name; int version; } names[] = {
+      { "TLSv1", 10 }, { "TLSv1.1", 11 }, { "TLSv1.2", 12 }, { "TLSv1.3", 13 },
+    };
+    for (size_t i = 0; i < sizeof names / sizeof names[0]; i++) {
+      if (v->v.str->len == strlen(names[i].name) &&
+          memcmp(v->v.str->data, names[i].name, v->v.str->len) == 0) {
+        *out = names[i].version;
+        return true;
+      }
+    }
+  }
+  ScrStr *shown = scr_util_format_j(v);
+  if (shown == NULL) return false;
+  char msg[300];
+  int m = snprintf(msg, sizeof msg, "%.*s is not a valid %s TLS protocol version",
+                   (int)(shown->len < 200 ? shown->len : 200), shown->data, which);
+  scr_str_release(shown);
+  scr_throw_error_msg_code(SCR_ERR_TYPE, msg, (size_t)m, "ERR_TLS_INVALID_PROTOCOL_VERSION");
+  return false;
+}
+
+/* The version range on an mbedTLS config. mbedTLS implements TLS 1.2 and
+ * 1.3, so a minimum of TLSv1 or TLSv1.1 offers from 1.2, the lowest version
+ * Node's default security level allows too. Answers false when no version
+ * in [min, max] is available (a maximum below 1.2, or min above max), which
+ * Node reports as ERR_SSL_NO_PROTOCOLS_AVAILABLE when the handshake starts. */
+static bool scr_tls_conf_versions(mbedtls_ssl_config *conf, int min, int max) {
+  if (min < 12) min = 12;
+  if (max < min) return false;
+  mbedtls_ssl_conf_min_tls_version(conf, min == 13 ? MBEDTLS_SSL_VERSION_TLS1_3 : MBEDTLS_SSL_VERSION_TLS1_2);
+  mbedtls_ssl_conf_max_tls_version(conf, max == 13 ? MBEDTLS_SSL_VERSION_TLS1_3 : MBEDTLS_SSL_VERSION_TLS1_2);
+  return true;
+}
+
+/* Node's SecureContext checks, in its order: secureProtocol conflicts with
+ * an explicit minVersion or maxVersion, then each version. The range lands
+ * in *min / *max (Node's defaults TLSv1.2 and TLSv1.3). False with the
+ * exception pending. */
+static bool scr_tls_versions_dyn(const ScrDyn *opts, int *min, int *max) {
+  const ScrDyn *vmin = opts != NULL && opts->kind == SCR_DYN_OBJ ? scr_dyn_obj_get(opts, "minVersion", 10) : NULL;
+  const ScrDyn *vmax = opts != NULL && opts->kind == SCR_DYN_OBJ ? scr_dyn_obj_get(opts, "maxVersion", 10) : NULL;
+  const ScrDyn *proto = opts != NULL && opts->kind == SCR_DYN_OBJ ? scr_dyn_obj_get(opts, "secureProtocol", 14) : NULL;
+  if (proto != NULL && scr_tls_dyn_truthy(proto)) {
+    const ScrDyn *version = vmin != NULL && vmin->kind != SCR_DYN_UNDEF && vmin->kind != SCR_DYN_NULL ? vmin
+                            : vmax != NULL && vmax->kind != SCR_DYN_UNDEF && vmax->kind != SCR_DYN_NULL ? vmax
+                                                                                                        : NULL;
+    if (version != NULL) {
+      ScrStr *a = scr_util_format_j(version);
+      if (a == NULL) return false;
+      ScrStr *b = scr_util_format_j(proto);
+      if (b == NULL) {
+        scr_str_release(a);
+        return false;
+      }
+      char msg[400];
+      int m = snprintf(msg, sizeof msg, "TLS protocol version %.*s conflicts with secureProtocol %.*s",
+                       (int)(a->len < 150 ? a->len : 150), a->data, (int)(b->len < 150 ? b->len : 150), b->data);
+      scr_str_release(a);
+      scr_str_release(b);
+      scr_throw_error_msg_code(SCR_ERR_TYPE, msg, (size_t)m, "ERR_TLS_PROTOCOL_VERSION_CONFLICT");
+      return false;
+    }
+  }
+  return scr_tls_version_dyn(vmin, "minimum", 12, min) && scr_tls_version_dyn(vmax, "maximum", 13, max);
+}
+
 typedef struct ScrTlsSrv {
   size_t rc;
   mbedtls_ssl_config conf;
@@ -275,6 +362,12 @@ typedef struct ScrTlsSrv {
    * thunk that becomes each minted answer closure's fn */
   ScrClosure *sni_cb;
   void *sni_answer_fn;
+  /* tls.createServer's ALPNProtocols (owned; NULL when none), in the
+   * server's preference order. */
+  char **alpn;
+  /* maxVersion TLSv1.2: the ClientHello is pre-parsed so a hello that
+   * offers only later versions gets OpenSSL's protocol_version alert. */
+  bool max_tls12;
 } ScrTlsSrv;
 
 /* The ALPN answers (static storage — mbedTLS keeps the pointers). Plain
@@ -325,6 +418,7 @@ static void scr_tls_srv_release(ScrTlsSrv *s) {
   mbedtls_ssl_config_free(&s->conf);
   mbedtls_x509_crt_free(&s->cert);
   mbedtls_pk_free(&s->pk);
+  scr_tls_alpn_free(s->alpn);
   free(s);
 }
 
@@ -342,6 +436,13 @@ typedef struct ScrTlsCli {
    * VERIFY_NONE socket (the https client's rejectUnauthorized:false)
    * never verified, so authorized answers false like Node's. */
   bool verify_recorded;
+  /* The ALPNProtocols option's names, NULL-terminated, in the caller's
+   * order (mbedtls_ssl_conf_alpn_protocols keeps the pointer); NULL when
+   * none are offered. */
+  char **alpn;
+  /* No TLS version is in the configured range: the handshake fails as
+   * soon as it starts (Node's ERR_SSL_NO_PROTOCOLS_AVAILABLE). */
+  bool no_protocols;
 } ScrTlsCli;
 
 /* The default trust anchors when no `ca` option is given: the host trust
@@ -490,6 +591,7 @@ static ScrTlsCli *scr_tls_cli_new(ScrStr *host, bool reject_unauthorized, const
 
 static void scr_tls_cli_free(ScrTlsCli *c) {
   mbedtls_ssl_config_free(&c->conf);
+  scr_tls_alpn_free(c->alpn);
   mbedtls_x509_crt_free(&c->ca);
   free(c->hostname);
   free(c->verify_name);
@@ -725,8 +827,13 @@ static int scr_tls_f_sni(void *p, mbedtls_ssl_context *ssl, const unsigned char
  * random, session id, cipher suites, compression, then the extension list
  * — server_name (type 0) holds one host_name (type 0) entry. Answers 1
  * with `out` set, 2 for a well-formed hello without SNI or anything
- * malformed (the real handshake will judge it). */
-static int scr_tls_parse_ch_body(const unsigned char *b, size_t n, char *out, size_t out_cap) {
+ * malformed (the real handshake will judge it). *offers12 answers whether
+ * the hello offers TLS 1.2: true without a supported_versions extension
+ * (type 43), else whether its list holds 0x0303. */
+static int scr_tls_parse_ch_body(const unsigned char *b, size_t n, char *out, size_t out_cap,
+                                 bool *offers12) {
+  *offers12 = true;
+  int found = 2;
   size_t i = 34; /* version(2) + random(32) */
   if (i + 1 > n) return 2;
   i += 1 + b[i]; /* session id: length byte + body */
@@ -744,24 +851,35 @@ static int scr_tls_parse_ch_body(const unsigned char *b, size_t n, char *out, si
     size_t el = ((size_t)b[i + 2] << 8) | b[i + 3];
     i += 4;
     if (i + el > end) return 2;
-    if (et == 0) {
+    if (et == 0 && found == 2) {
       /* server_name: list length(2), then entry type(1) + length(2) + name */
-      if (el < 5 || b[i + 2] != 0) return 2;
-      size_t nl = ((size_t)b[i + 3] << 8) | b[i + 4];
-      if (nl == 0 || nl + 5 > el || nl + 1 > out_cap) return 2;
-      memcpy(out, b + i + 5, nl);
-      out[nl] = 0;
-      return 1;
+      if (el >= 5 && b[i + 2] == 0) {
+        size_t nl = ((size_t)b[i + 3] << 8) | b[i + 4];
+        if (nl > 0 && nl + 5 <= el && nl + 1 <= out_cap) {
+          memcpy(out, b + i + 5, nl);
+          out[nl] = 0;
+          found = 1;
+        }
+      }
+    } else if (et == 43 && el >= 1) {
+      /* supported_versions: list length(1), then 2-byte versions */
+      size_t vl = b[i] < el - 1 ? b[i] : el - 1;
+      *offers12 = false;
+      for (size_t v = 0; v + 1 < vl; v += 2) {
+        if (b[i + 1 + v] == 0x03 && b[i + 2 + v] == 0x03) *offers12 = true;
+      }
     }
     i += el;
   }
-  return 2;
+  return found;
 }
 
 /* Reassemble the handshake stream from the raw record flight and look for
  * the server_name extension. 0 = need more bytes; 1 = found (out set);
  * 2 = no SNI / not parseable (serve the default cert). */
-static int scr_tls_parse_sni(const unsigned char *buf, size_t len, char *out, size_t out_cap) {
+static int scr_tls_parse_sni(const unsigned char *buf, size_t len, char *out, size_t out_cap,
+                             bool *offers12) {
+  *offers12 = true;
   unsigned char *hs = NULL;
   size_t hs_len = 0, hs_cap = 0;
   size_t off = 0;
@@ -785,7 +903,7 @@ static int scr_tls_parse_sni(const unsigned char *buf, size_t len, char *out, si
       size_t chlen = ((size_t)hs[1] << 16) | ((size_t)hs[2] << 8) | hs[3];
       if (chlen > 131072) { free(hs); return 2; }
       if (hs_len >= 4 + chlen) {
-        int r = scr_tls_parse_ch_body(hs + 4, chlen, out, out_cap);
+        int r = scr_tls_parse_ch_body(hs + 4, chlen, out, out_cap, offers12);
         free(hs);
         return r;
       }
@@ -811,8 +929,19 @@ static int scr_tls_sni_collect(ScrTlsSock *t) {
   char servername[256];
   for (;;) {
     if (t->hello_len > 0) {
-      int r = scr_tls_parse_sni(t->hello, t->hello_len, servername, sizeof servername);
-      if (r == 2 || t->hello_len > 65536) {
+      bool offers12;
+      int r = scr_tls_parse_sni(t->hello, t->hello_len, servername, sizeof servername, &offers12);
+      if (r != 0 && t->srv->max_tls12 && !offers12) {
+        /* A TLS 1.2 server and a hello offering only later versions:
+         * OpenSSL answers with a fatal protocol_version alert, which the
+         * client reports as ERR_SSL_TLSV1_ALERT_PROTOCOL_VERSION. */
+        static const unsigned char alert[] = { 0x15, 0x03, 0x03, 0x00, 0x02, 0x02, 0x46 };
+        int fd = scr_net_sock_fd(t->sock);
+        if (fd >= 0) (void)!write(fd, alert, sizeof alert);
+        scr_net_sock_transport_error(t->sock, NULL);
+        return -1;
+      }
+      if (r == 2 || t->hello_len > 65536 || (r == 1 && t->srv->sni_cb == NULL)) {
         /* no SNI (or unparseable): skip the callback, serve the default
          * pair — Node's SNICallback never fires without a server_name */
         t->sni_state = SCR_SNI_DONE;
@@ -899,6 +1028,12 @@ void scr_tls_sni_answer(ScrClosure *self, bool has_err, ScrSecureCtx *ctx /*move
 
 static int scr_tls_handshake(void *tctx) {
   ScrTlsSock *t = (ScrTlsSock *)tctx;
+  if (t->cli != NULL && t->cli->no_protocols) {
+    /* OpenSSL's reason without its per-process prefix (SEMANTICS.md
+     * divergence 55); scr_error_message_code gives Node's code. */
+    scr_net_sock_transport_error(t->sock, "error:0A0000BF:SSL routines::no protocols available");
+    return -1;
+  }
   if (t->sni_state == SCR_SNI_COLLECT) {
     t->in_handshake = true;
     int c = scr_tls_sni_collect(t);
@@ -927,6 +1062,20 @@ static int scr_tls_handshake(void *tctx) {
      * at this level and let the closed hook classify it */
     scr_net_sock_transport_error(t->sock, NULL);
     return -1;
+  } else if (r == MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE &&
+             t->ssl.MBEDTLS_PRIVATE(in_msg) != NULL &&
+             t->ssl.MBEDTLS_PRIVATE(in_msg)[1] == MBEDTLS_SSL_ALERT_MSG_NO_APPLICATION_PROTOCOL) {
+    /* The server shares none of the ALPNProtocols: OpenSSL's reason, which
+     * Node reports as ERR_SSL_TLSV1_ALERT_NO_APPLICATION_PROTOCOL
+     * (scr_error_message_code), without its per-process prefix and source
+     * location (SEMANTICS.md divergence 55). */
+    snprintf(msg, sizeof msg,
+             "error:0A000460:SSL routines:ssl3_read_bytes:tlsv1 alert no application protocol");
+  } else if (r == MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE &&
+             t->ssl.MBEDTLS_PRIVATE(in_msg) != NULL &&
+             t->ssl.MBEDTLS_PRIVATE(in_msg)[1] == MBEDTLS_SSL_ALERT_MSG_PROTOCOL_VERSION) {
+    /* The server accepts none of the offered versions. */
+    snprintf(msg, sizeof msg, "error:0A00042E:SSL routines:ssl3_read_bytes:tlsv1 alert protocol version");
   } else {
     /* non-verify handshake failures: honest but not Node's exact openssl
      * string (SEMANTICS.md divergence 55) */
@@ -1012,19 +1161,44 @@ static void scr_tls_srv_on_conn(void *ctx, ScrNetSocket *sock) {
   if (mbedtls_ssl_setup(&t->ssl, &srv->conf) != 0) scr_tls_oom();
   t->sock = sock;
   t->srv = scr_tls_srv_retain(srv);
-  if (srv->sni_cb != NULL) t->sni_state = SCR_SNI_COLLECT; /* pre-parse the hello */
+  if (srv->sni_cb != NULL || srv->max_tls12) t->sni_state = SCR_SNI_COLLECT; /* pre-parse the hello */
   mbedtls_ssl_set_bio(&t->ssl, t, scr_tls_bio_send, scr_tls_bio_recv, NULL);
   scr_net_sock_set_transport(sock, &SCR_TLS_OPS, t);
 }
 
+static ScrNetServer *scr_tls_create_server_alpn(const char *cert, size_t cert_len,
+                                                const char *key, size_t key_len,
+                                                ScrClosure *handler /*moves, nullable*/,
+                                                ScrNetConnFn fn, char **alpn /*moves, nullable*/,
+                                                int min_version, int max_version) {
+  ScrTlsSrv *srv = scr_tls_srv_new(cert, cert_len, key, key_len, false);
+  srv->max_tls12 = max_version == 12;
+  if (!scr_tls_conf_versions(&srv->conf, min_version, max_version)) {
+    /* Node's server then fails every handshake; nothing here models
+     * that, so it stays a refusal. */
+    scr_tls_srv_release(srv);
+    scr_closure_release(handler);
+    scr_tls_alpn_free(alpn);
+    scr_tls_opt_fence("tls.createServer", "maxVersion",
+                      "a version range with neither TLSv1.2 nor TLSv1.3 has no lowering");
+    return NULL;
+  }
+  if (alpn != NULL) {
+    /* mbedTLS picks the first of these the client offers (Node's server
+     * preference) and sends no_application_protocol when it offers none. */
+    srv->alpn = alpn;
+    mbedtls_ssl_conf_alpn_protocols(&srv->conf, (const char **)srv->alpn);
+  }
+  ScrNetServer *s = scr_net_create_server(handler, fn);
+  scr_net_server_set_native_conn(s, &scr_tls_srv_on_conn, srv, &scr_tls_srv_release_v);
+  scr_net_server_defer_connections(s); /* the handler is 'secureConnection' */
+  return s;
+}
+
 ScrNetServer *scr_tls_create_server(const char *cert, size_t cert_len, const char *key,
                                      size_t key_len, ScrClosure *handler /*moves, nullable*/,
                                      ScrNetConnFn fn) {
-  ScrTlsSrv *srv = scr_tls_srv_new(cert, cert_len, key, key_len, false);
-  ScrNetServer *s = scr_net_create_server(handler, fn);
-  scr_net_server_set_native_conn(s, &scr_tls_srv_on_conn, srv, &scr_tls_srv_release_v);
-  scr_net_server_defer_connections(s); /* the handler is 'secureConnection' */
-  return s;
+  return scr_tls_create_server_alpn(cert, cert_len, key, key_len, handler, fn, NULL, 12, 13);
 }
 
 ScrNetServer *scr_https_create_server(const char *cert, size_t cert_len, const char *key,
@@ -1730,8 +1904,10 @@ static bool scr_tls_opts_validate(const ScrDyn *opts) {
  * dyn options record; false = exception pending (partial results released).
  * Exported runtime-internally: scr_http2.c's createSecureServerDyn rides
  * the same walk (scr_http2.c always links alongside this unit). */
-bool scr_tls_srv_opts_walk(const ScrDyn *opts, const char *api, ScrBytes **cert_out,
-                            ScrBytes **key_out) {
+/* `server_ok`: tls.createServer reads ALPNProtocols, minVersion and
+ * maxVersion itself; the walk's other callers keep their fences. */
+static bool scr_tls_srv_opts_walk_ex(const ScrDyn *opts, const char *api, ScrBytes **cert_out,
+                                     ScrBytes **key_out, bool server_ok) {
   *cert_out = NULL;
   *key_out = NULL;
   if (opts == NULL || opts->kind != SCR_DYN_OBJ) {
@@ -1770,6 +1946,9 @@ bool scr_tls_srv_opts_walk(const ScrDyn *opts, const char *api, ScrBytes **cert_
     if (strcmp(e->key, "rejectUnauthorized") == 0) {
       continue; /* meaningful only with requestCert, which fences */
     }
+    if (server_ok && (strcmp(e->key, "ALPNProtocols") == 0 || strcmp(e->key, "minVersion") == 0 ||
+                      strcmp(e->key, "maxVersion") == 0))
+      continue;
     if (strcmp(e->key, "SNICallback") == 0) {
       scr_tls_opt_fence(api, "SNICallback",
                         "SNICallback lowers only on http2.createSecureServer({ allowHTTP1: true, ... }) with a literal options object");
@@ -1803,6 +1982,11 @@ bool scr_tls_srv_opts_walk(const ScrDyn *opts, const char *api, ScrBytes **cert_
   return ok;
 }
 
+bool scr_tls_srv_opts_walk(const ScrDyn *opts, const char *api, ScrBytes **cert_out,
+                            ScrBytes **key_out) {
+  return scr_tls_srv_opts_walk_ex(opts, api, cert_out, key_out, false);
+}
+
 /* createSecureContext over a RUNTIME options record: Node's typed
  * validations first (scr_tls_opts_validate), then the pem walk — a bag
  * that validates AND carries both cert and key builds the real context;
@@ -1845,13 +2029,29 @@ void scr_tls_ca_certs_chk(const ScrDyn *type, const ScrStr *fence) {
 ScrNetServer *scr_tls_create_server_dyn(const ScrDyn *opts /*borrowed*/,
                                          ScrClosure *handler /*moves, nullable*/,
                                          ScrNetConnFn fn) {
-  ScrBytes *cert, *key;
-  if (!scr_tls_srv_opts_walk(opts, "tls.createServer", &cert, &key)) {
+  int min_version = 12, max_version = 13;
+  if (!scr_tls_versions_dyn(opts, &min_version, &max_version)) {
     scr_closure_release(handler);
     return NULL;
   }
-  ScrNetServer *s = scr_tls_create_server((const char *)cert->data, cert->len,
-                                           (const char *)key->data, key->len, handler, fn);
+  ScrBytes *cert, *key;
+  if (!scr_tls_srv_opts_walk_ex(opts, "tls.createServer", &cert, &key, true)) {
+    scr_closure_release(handler);
+    return NULL;
+  }
+  /* The Server constructor converts ALPNProtocols after the secure
+   * context validates (Node's order). */
+  char **alpn = NULL;
+  const ScrDyn *protocols = scr_dyn_obj_get(opts, "ALPNProtocols", 13);
+  if (protocols != NULL && !scr_tls_alpn_dyn(protocols, &alpn)) {
+    scr_bytes_release(cert);
+    scr_bytes_release(key);
+    scr_closure_release(handler);
+    return NULL;
+  }
+  ScrNetServer *s = scr_tls_create_server_alpn((const char *)cert->data, cert->len,
+                                                (const char *)key->data, key->len, handler, fn,
+                                                alpn, min_version, max_version);
   scr_bytes_release(cert);
   scr_bytes_release(key);
   return s;
@@ -1896,20 +2096,157 @@ ScrNetServer *scr_https_create_server_dyn(const ScrDyn *opts /*borrowed*/,
 
 /* ── tls.connect (the TLS client socket) ──────────────────────────────── */
 
+/* Node's inspect of a Buffer inside ERR_INVALID_ARG_VALUE's message:
+ * "<Buffer 00 01 ...>" with at most 50 bytes, the whole rendering cut at
+ * 128 characters with "...". */
+static void scr_tls_alpn_value_fail(const char *reason, const uint8_t *data, size_t len) {
+  char inspected[400];
+  size_t n = (size_t)snprintf(inspected, sizeof inspected, "<Buffer");
+  size_t shown = len < 50 ? len : 50;
+  for (size_t i = 0; i < shown; i++) n += (size_t)snprintf(inspected + n, sizeof inspected - n, " %02x", data[i]);
+  if (len > shown) n += (size_t)snprintf(inspected + n, sizeof inspected - n, " ... %zu more byte%s", len - shown, len - shown == 1 ? "" : "s");
+  snprintf(inspected + n, sizeof inspected - n, ">");
+  if (strlen(inspected) > 128) strcpy(inspected + 128, "...");
+  char msg[600];
+  int m = snprintf(msg, sizeof msg, "The argument 'ALPNProtocols' %s. Received %s", reason, inspected);
+  scr_throw_error_msg_code(SCR_ERR_TYPE, msg, (size_t)m, "ERR_INVALID_ARG_VALUE");
+}
+
+/* The wire list (<len><name>...) as mbedTLS's NULL-terminated names, after
+ * Node's validateALPNBuffer. An empty list offers nothing (*out stays
+ * NULL). False with the exception pending. */
+static bool scr_tls_alpn_from_wire(const uint8_t *data, size_t len, char ***out) {
+  size_t count = 0;
+  for (size_t at = 0; at < len;) {
+    size_t n = data[at];
+    if (n == 0) {
+      scr_tls_alpn_value_fail("must not contain zero-length protocol", data, len);
+      return false;
+    }
+    if (at + 1 + n > len) {
+      scr_tls_alpn_value_fail("contains truncated protocol", data, len);
+      return false;
+    }
+    at += 1 + n;
+    count++;
+  }
+  if (count == 0) return true;
+  char **names = calloc(count + 1, sizeof *names);
+  if (!names) scr_tls_oom();
+  size_t k = 0;
+  for (size_t at = 0; at < len; at += 1 + data[at]) {
+    names[k] = malloc((size_t)data[at] + 1);
+    if (!names[k]) scr_tls_oom();
+    memcpy(names[k], data + at + 1, data[at]);
+    names[k][data[at]] = '\0';
+    k++;
+  }
+  *out = names;
+  return true;
+}
+
+/* tls.connect's ALPNProtocols (Node's convertALPNProtocols, then
+ * setALPNProtocols): an array of non-empty strings of at most 255 bytes, a
+ * Uint8Array or other ArrayBufferView in the wire format, or a falsy value
+ * (no ALPN). Any other truthy value is the binding's TypeError. False with
+ * the exception pending. */
+static bool scr_tls_alpn_dyn(const ScrDyn *v, char ***out) {
+  *out = NULL;
+  ScrDyn *own = NULL;
+  if (v->kind == SCR_DYN_TYPED_REF) {
+    own = scr_dyn_typed_ref_materialize(v);
+    if (own == NULL) return false;
+    v = own;
+  }
+  bool ok = true;
+  if (v->kind == SCR_DYN_ARR) {
+    /* convertProtocols: Buffer.byteLength of every entry first (strings,
+     * or the ArrayBuffer and view entries byteLength also measures), then
+     * each length's checks, then buff.write, which takes strings only. */
+    size_t count = v->v.arr.len;
+    size_t total = 0;
+    for (size_t i = 0; ok && i < count; i++) {
+      const ScrDyn *e = v->v.arr.items[i];
+      size_t n;
+      if (e->kind == SCR_DYN_STR) {
+        n = e->v.str->len;
+      } else if (e->kind == SCR_DYN_BYTES || scr_buffer_storage_is(e)) {
+        ScrBytes *view = scr_bytes_buffer_source(e);
+        if (view == NULL) {
+          ok = false;
+          break;
+        }
+        n = view->len;
+        scr_bytes_release(view);
+      } else {
+        scr_dyn_arg_type_fail("string", "of type string or an instance of Buffer or ArrayBuffer", e);
+        ok = false;
+        break;
+      }
+      if (n == 0) {
+        char name[32];
+        snprintf(name, sizeof name, "protocols[%zu]", i);
+        scr_dyn_arg_value_fail(name, "must be a non-empty string", e);
+        ok = false;
+        break;
+      }
+      if (n > 255) {
+        char msg[160];
+        int m = snprintf(msg, sizeof msg,
+                         "The byte length of the protocol at index %zu exceeds the maximum length. It must be <= 255. Received %zu",
+                         i, n);
+        scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)m, "ERR_OUT_OF_RANGE");
+        ok = false;
+        break;
+      }
+      total += 1 + n;
+    }
+    uint8_t *wire = ok ? malloc(total + 1) : NULL;
+    if (ok && !wire) scr_tls_oom();
+    size_t at = 0;
+    for (size_t i = 0; ok && i < count; i++) {
+      const ScrDyn *e = v->v.arr.items[i];
+      if (e->kind != SCR_DYN_STR) {
+        static const char msg[] = "argument must be a string";
+        scr_throw_error_msg_code(SCR_ERR_TYPE, msg, sizeof msg - 1, "ERR_INVALID_ARG_TYPE");
+        ok = false;
+        break;
+      }
+      wire[at++] = (uint8_t)e->v.str->len;
+      memcpy(wire + at, e->v.str->data, e->v.str->len);
+      at += e->v.str->len;
+    }
+    if (ok) ok = scr_tls_alpn_from_wire(wire, at, out);
+    free(wire);
+  } else if (v->kind == SCR_DYN_BYTES) {
+    ScrBytes *view = scr_bytes_buffer_source(v);
+    if (view == NULL) ok = false;
+    else {
+      ok = scr_tls_alpn_from_wire(view->data, view->len, out);
+      scr_bytes_release(view);
+    }
+  } else if (scr_tls_dyn_truthy(v)) {
+    static const char msg[] = "Must give a Buffer as first argument";
+    scr_throw_error_msg(SCR_ERR_TYPE, msg, sizeof msg - 1);
+    ok = false;
+  }
+  scr_dyn_release(own);
+  return ok;
+}
+
 /* tls.connect's documented keys outside the implemented set: present
  * throws (the server walk's stance). */
 static const char *const SCR_TLS_CONNECT_FENCED_OPTIONS[] = {
-  "ALPNProtocols", "allowHalfOpen", "autoSelectFamily",
+  "allowHalfOpen", "autoSelectFamily",
   "autoSelectFamilyAttemptTimeout", "cert", "certificateCompression", "checkServerIdentity",
   "ciphers", "clientCertEngine", "crl", "dhparam", "ecdhCurve",
   "enableTrace", "family", "fd", "hints", "highWaterMark",
   "honorCipherOrder", "keepAlive", "keepAliveInitialDelay", "key",
-  "localAddress", "localPort", "lookup", "maxVersion", "minDHSize",
-  "minVersion", "noDelay", "onread", "passphrase", "path", "pfx",
+  "localAddress", "localPort", "lookup", "minDHSize", "noDelay", "onread", "passphrase", "path", "pfx",
   "privateKeyEngine", "privateKeyIdentifier", "pskCallback", "readable",
   "secureContext", "secureOptions", "secureProtocol", "session",
   "sessionIdContext", "sigalgs", "signal", "socket", "ticketKeys",
-  "timeout", "writable", NULL,
+  "writable", NULL,
 };
 
 ScrNetSocket *scr_tls_connect_dyn(double port, ScrStr *host /*borrowed, nullable*/,
@@ -1920,12 +2257,19 @@ ScrNetSocket *scr_tls_connect_dyn(double port, ScrStr *host /*borrowed, nullable
   ScrBytes *ca = NULL;
   const ScrStr *servername = NULL;
   const ScrStr *opt_host = NULL;
+  char **alpn = NULL;
+  const ScrDyn *alpn_value = NULL;
+  const ScrDyn *timeout_value = NULL;
+  int min_version = 12, max_version = 13;
   bool ok = true;
   if (opts != NULL && opts->kind != SCR_DYN_UNDEF && opts->kind != SCR_DYN_NULL) {
     if (opts->kind != SCR_DYN_OBJ) {
       scr_dyn_arg_type_fail("options", "of type object", opts);
       ok = false;
     }
+    /* createSecureContext's version checks come before its other options
+     * (Node's SecureContext constructor). */
+    if (ok && !scr_tls_versions_dyn(opts, &min_version, &max_version)) ok = false;
     for (size_t i = 0; ok && i < opts->v.obj.len; i++) {
       const ScrDynEntry *e = &opts->v.obj.entries[i];
       const ScrDyn *v = e->value;
@@ -1974,6 +2318,16 @@ ScrNetSocket *scr_tls_connect_dyn(double port, ScrStr *host /*borrowed, nullable
         if (ca == NULL) ok = false;
         continue;
       }
+      if (strcmp(e->key, "ALPNProtocols") == 0) {
+        alpn_value = v; /* converted after the context options, as TLSSocket does */
+        continue;
+      }
+      if (strcmp(e->key, "minVersion") == 0 || strcmp(e->key, "maxVersion") == 0) continue;
+      if (strcmp(e->key, "timeout") == 0) {
+        /* `if (options.timeout) tlssock.setTimeout(options.timeout)` */
+        timeout_value = scr_tls_dyn_truthy(v) ? v : NULL;
+        continue;
+      }
       if (strcmp(e->key, "servername") == 0) {
         if (v->kind == SCR_DYN_STR) servername = v->v.str;
         else {
@@ -1985,7 +2339,7 @@ ScrNetSocket *scr_tls_connect_dyn(double port, ScrStr *host /*borrowed, nullable
       for (size_t k = 0; SCR_TLS_CONNECT_FENCED_OPTIONS[k] != NULL; k++) {
         if (strcmp(e->key, SCR_TLS_CONNECT_FENCED_OPTIONS[k]) == 0) {
           scr_tls_opt_fence("tls.connect", e->key,
-                            "port/host/rejectUnauthorized/ca/servername are the honestly-implemented members of a runtime options record");
+                            "port/host/rejectUnauthorized/ca/servername/ALPNProtocols/minVersion/maxVersion/timeout are the implemented members of a runtime options record");
           ok = false;
           break;
         }
@@ -1993,6 +2347,26 @@ ScrNetSocket *scr_tls_connect_dyn(double port, ScrStr *host /*borrowed, nullable
       /* anything else: an undocumented key, dropped like Node drops it */
     }
   }
+  if (ok && alpn_value != NULL && !scr_tls_alpn_dyn(alpn_value, &alpn)) ok = false;
+  /* socket.setTimeout(msecs) runs after the TLSSocket exists and before it
+   * connects: Node's msecs checks, then the inactivity timer below. */
+  double timeout_ms = 0;
+  if (ok && timeout_value != NULL) {
+    if (timeout_value->kind != SCR_DYN_NUM) {
+      scr_dyn_arg_type_fail("msecs", "of type number", timeout_value);
+      ok = false;
+    } else if (!isfinite(timeout_value->v.num) || timeout_value->v.num < 0) {
+      char recv[48], msg[160];
+      scr_num_received(timeout_value->v.num, recv);
+      int m = snprintf(msg, sizeof msg,
+                       "The value of \"msecs\" is out of range. It must be a non-negative finite number. Received %s",
+                       recv);
+      scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)m, "ERR_OUT_OF_RANGE");
+      ok = false;
+    } else {
+      timeout_ms = timeout_value->v.num;
+    }
+  }
   if (ok && port < 0) {
     scr_dyn_arg_type_fail("options.port", "of type number", scr_dyn_undefined());
     ok = false;
@@ -2000,6 +2374,7 @@ ScrNetSocket *scr_tls_connect_dyn(double port, ScrStr *host /*borrowed, nullable
   ScrStr *dial_host = (ScrStr *)(host != NULL && host->len > 0 ? host : opt_host);
   if (ok && !scr_net_host_chk(dial_host)) ok = false;
   if (!ok) {
+    scr_tls_alpn_free(alpn);
     scr_bytes_release(ca);
     scr_closure_release(cb);
     return NULL;
@@ -2022,7 +2397,13 @@ ScrNetSocket *scr_tls_connect_dyn(double port, ScrStr *host /*borrowed, nullable
                                      ca != NULL ? (const char *)ca->data : NULL,
                                      ca != NULL ? ca->len : 0, !reject);
   if (servername != NULL) scr_tls_cli_set_servername(cli, servername);
+  if (alpn != NULL) {
+    cli->alpn = alpn; /* moves */
+    mbedtls_ssl_conf_alpn_protocols(&cli->conf, (const char **)cli->alpn);
+  }
+  cli->no_protocols = !scr_tls_conf_versions(&cli->conf, min_version, max_version);
   scr_tls_cli_wrap(s, cli);
+  if (timeout_ms > 0) scr_net_sock_set_timeout(s, timeout_ms);
   scr_str_release(localhost_fallback);
   scr_bytes_release(ca);
   return s;
diff --git a/tests/corpus/6721-tls-alpn-protocols.ts b/tests/corpus/6721-tls-alpn-protocols.ts
new file mode 100644
index 000000000..f68fb2840
--- /dev/null
+++ b/tests/corpus/6721-tls-alpn-protocols.ts
@@ -0,0 +1,75 @@
+// tls.connect and tls.createServer with ALPNProtocols: the server answers
+// with the first of its own protocols the client offers, both sockets
+// report it as alpnProtocol, and a client that offers none of the
+// server's fails with ERR_SSL_TLSV1_ALERT_NO_APPLICATION_PROTOCOL. An
+// array of strings, a Buffer or a Uint8Array in the wire format, an empty
+// list and a falsy value all work as in Node, and invalid values throw
+// Node's errors from tls.connect.
+import * as tls from "node:tls";
+import { readFileSync } from "node:fs";
+
+const dir = "tests/fixtures/server/certs/";
+const ca = readFileSync(dir + "ca.pem");
+const server = tls.createServer(
+  {
+    cert: readFileSync(dir + "localhost.pem"),
+    key: readFileSync(dir + "localhost-key.pem"),
+    ALPNProtocols: ["h2", "x/1"],
+  },
+  (socket) => {
+    socket.end(`server:${String(socket.alpnProtocol)}`);
+  },
+);
+
+function attempt(port: number, label: string, protocols: unknown): Promise<void> {
+  return new Promise<void>((resolve) => {
+    const socket = tls.connect({ host: "localhost", port, ca, ALPNProtocols: protocols as any }, () => {
+      console.log(label, "client:", JSON.stringify(socket.alpnProtocol));
+    });
+    let data = "";
+    socket.on("data", (chunk: Buffer) => (data += chunk.toString()));
+    socket.on("end", () => {
+      console.log(label, data);
+      resolve();
+    });
+    socket.on("error", (err) => {
+      console.log(label, "error:", (err as NodeJS.ErrnoException).code);
+      resolve();
+    });
+  });
+}
+
+function invalid(label: string, protocols: unknown): void {
+  try {
+    const socket = tls.connect({ host: "127.0.0.1", port: 1, ALPNProtocols: protocols as any });
+    socket.on("error", () => {});
+    socket.destroy();
+    console.log(label, "accepted");
+  } catch (e) {
+    const err = e as NodeJS.ErrnoException;
+    console.log(label, err.name, err.code, err.message);
+  }
+}
+
+server.listen(0, "127.0.0.1", async () => {
+  const port = (server.address() as { port: number }).port;
+  await attempt(port, "strings", ["x/1", "h2"]);
+  await attempt(port, "only-second", ["zz", "x/1"]);
+  await attempt(port, "buffer", Buffer.from([2, 0x68, 0x32]));
+  await attempt(port, "uint8array", new Uint8Array([3, 0x78, 0x2f, 0x31]));
+  await attempt(port, "absent", undefined);
+  await attempt(port, "empty", []);
+  await attempt(port, "falsy", 0);
+  await attempt(port, "no-match", ["zz"]);
+  server.close();
+
+  invalid("string", "h2");
+  invalid("object", {});
+  invalid("buffer-element", [Buffer.from("h2")]);
+  invalid("number-element", [1]);
+  invalid("empty-element", ["h2", ""]);
+  invalid("too-long", ["a".repeat(256)]);
+  invalid("zero-length", Buffer.from([0]));
+  invalid("truncated", Buffer.from([5, 0x68]));
+  invalid("long-zero", Buffer.alloc(60));
+});
diff --git a/tests/corpus/6722-tls-min-max-version.ts b/tests/corpus/6722-tls-min-max-version.ts
new file mode 100644
index 000000000..07d01867d
--- /dev/null
+++ b/tests/corpus/6722-tls-min-max-version.ts
@@ -0,0 +1,85 @@
+// tls.connect and tls.createServer with minVersion and maxVersion: the
+// handshake picks the highest version both ranges allow and getProtocol()
+// reports it. A range the server does not share fails with
+// ERR_SSL_TLSV1_ALERT_PROTOCOL_VERSION, a client range with neither TLSv1.2
+// nor TLSv1.3 fails with ERR_SSL_NO_PROTOCOLS_AVAILABLE once the handshake
+// starts, and an invalid version or a secureProtocol conflict throws Node's
+// TypeError from tls.connect.
+import * as tls from "node:tls";
+import { readFileSync } from "node:fs";
+
+const dir = "tests/fixtures/server/certs/";
+const ca = readFileSync(dir + "ca.pem");
+const cert = readFileSync(dir + "localhost.pem");
+const key = readFileSync(dir + "localhost-key.pem");
+
+const upTo12 = tls.createServer({ cert, key, maxVersion: "TLSv1.2" }, (s) => s.end(`server:${s.getProtocol()}`));
+const from13 = tls.createServer({ cert, key, minVersion: "TLSv1.3" }, (s) => s.end(`server:${s.getProtocol()}`));
+const any = tls.createServer({ cert, key }, (s) => s.end(`server:${s.getProtocol()}`));
+
+function listen(server: tls.Server): Promise<number> {
+  return new Promise<number>((resolve) =>
+    server.listen(0, "127.0.0.1", () => resolve((server.address() as { port: number }).port)),
+  );
+}
+
+interface Versions {
+  minVersion?: unknown;
+  maxVersion?: unknown;
+  secureProtocol?: string;
+}
+
+function attempt(label: string, port: number, versions: Versions): Promise<void> {
+  return new Promise<void>((resolve) => {
+    let socket: tls.TLSSocket;
+    try {
+      const options = {
+        host: "localhost",
+        port,
+        ca,
+        minVersion: versions.minVersion as any,
+        maxVersion: versions.maxVersion as any,
+        secureProtocol: versions.secureProtocol,
+      };
+      socket = tls.connect(options, () => console.log(label, "client:", socket.getProtocol()));
+    } catch (e) {
+      const err = e as NodeJS.ErrnoException;
+      console.log(label, err.name, err.code, err.message);
+      resolve();
+      return;
+    }
+    let data = "";
+    socket.on("data", (chunk: Buffer) => (data += chunk.toString()));
+    socket.on("end", () => {
+      console.log(label, data);
+      resolve();
+    });
+    socket.on("error", (err) => {
+      console.log(label, "error:", (err as NodeJS.ErrnoException).code);
+      resolve();
+    });
+  });
+}
+
+async function main(): Promise<void> {
+  const p12 = await listen(upTo12);
+  const p13 = await listen(from13);
+  const pAny = await listen(any);
+  await attempt("defaults", pAny, {});
+  await attempt("max-1.2", pAny, { maxVersion: "TLSv1.2" });
+  await attempt("min-1.3", pAny, { minVersion: "TLSv1.3" });
+  await attempt("min-1-against-1.2", p12, { minVersion: "TLSv1" });
+  await attempt("min-1.3-against-1.2", p12, { minVersion: "TLSv1.3" });
+  await attempt("max-1.2-against-1.3", p13, { maxVersion: "TLSv1.2" });
+  await attempt("max-1.1", pAny, { maxVersion: "TLSv1.1" });
+  await attempt("min-above-max", pAny, { minVersion: "TLSv1.3", maxVersion: "TLSv1.2" });
+  await attempt("null-min", pAny, { minVersion: null });
+  await attempt("invalid-min", pAny, { minVersion: "TLSv9" });
+  await attempt("invalid-max", pAny, { maxVersion: 3 });
+  await attempt("conflict", pAny, { minVersion: "TLSv1.2", secureProtocol: "TLSv1_2_method" });
+  upTo12.close();
+  from13.close();
+  any.close();
+}
+
+void main();
diff --git a/tests/corpus/6723-tls-connect-timeout.ts b/tests/corpus/6723-tls-connect-timeout.ts
new file mode 100644
index 000000000..68f40ec37
--- /dev/null
+++ b/tests/corpus/6723-tls-connect-timeout.ts
@@ -0,0 +1,51 @@
+// tls.connect's timeout option arms the socket's inactivity timeout
+// before it connects, so a handshake the peer never answers emits
+// 'timeout'. Node applies it only when truthy, so 0 and NaN arm nothing,
+// and setTimeout's msecs checks throw from tls.connect for a value that is
+// not a number, negative, or not finite.
+import * as net from "node:net";
+import * as tls from "node:tls";
+
+// The server reads (and ignores) what arrives, so each connection closes
+// when its client is destroyed.
+const silent = net.createServer((socket) => {
+  socket.resume();
+});
+
+function attempt(port: number, label: string, timeout: unknown): Promise<void> {
+  return new Promise<void>((resolve) => {
+    let socket: tls.TLSSocket;
+    try {
+      socket = tls.connect({ host: "127.0.0.1", port, timeout: timeout as any });
+    } catch (e) {
+      const err = e as NodeJS.ErrnoException;
+      console.log(label, err.name, err.code, err.message);
+      resolve();
+      return;
+    }
+    const fallback = setTimeout(() => {
+      console.log(label, "no timeout event");
+      socket.destroy();
+      resolve();
+    }, 300);
+    socket.on("timeout", () => {
+      console.log(label, "timeout");
+      clearTimeout(fallback);
+      socket.destroy();
+      resolve();
+    });
+    socket.on("error", (err) => console.log(label, "error", (err as NodeJS.ErrnoException).code));
+  });
+}
+
+silent.listen(0, "127.0.0.1", async () => {
+  const port = (silent.address() as net.AddressInfo).port;
+  await attempt(port, "50ms", 50);
+  await attempt(port, "fractional", 30.7);
+  await attempt(port, "zero", 0);
+  await attempt(port, "nan", NaN);
+  await attempt(port, "negative", -1);
+  await attempt(port, "infinite", Infinity);
+  await attempt(port, "string", "x");
+  silent.close();
+});
diff --git a/tests/harness/corpus-costs/6721-tls-alpn-protocols.ts.json b/tests/harness/corpus-costs/6721-tls-alpn-protocols.ts.json
new file mode 100644
index 000000000..ab6ff1c99
--- /dev/null
+++ b/tests/harness/corpus-costs/6721-tls-alpn-protocols.ts.json
@@ -0,0 +1 @@
+{ "plain": 4300, "san": 60600 }
diff --git a/tests/harness/corpus-costs/6722-tls-min-max-version.ts.json b/tests/harness/corpus-costs/6722-tls-min-max-version.ts.json
new file mode 100644
index 000000000..c1b1d2d17
--- /dev/null
+++ b/tests/harness/corpus-costs/6722-tls-min-max-version.ts.json
@@ -0,0 +1 @@
+{ "plain": 3000, "san": 4700 }
diff --git a/tests/harness/corpus-costs/6723-tls-connect-timeout.ts.json b/tests/harness/corpus-costs/6723-tls-connect-timeout.ts.json
new file mode 100644
index 000000000..9ebfb8b9d
--- /dev/null
+++ b/tests/harness/corpus-costs/6723-tls-connect-timeout.ts.json
@@ -0,0 +1 @@
+{ "plain": 6200, "san": 60300 }

From 237a5111745865115764083495978ae58b50e827 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 09:05:05 -0500
Subject: [PATCH 04/67] Resolve conditional member types over literal class
 type arguments

A generic class instance bound its type parameters only to their mapped
IR types, so a literal argument widened (K = "required" became string)
and a member typed by a conditional over it, such as
`get(): Value<T, K>` with `type Value<T, K> = K extends "required" ? T :
T | undefined`, refused with SC2001.

Class instantiation now also keeps the type arguments as checker types
for the members it collects and lowers, as generic functions do. A
literal argument for a type parameter that a conditional type in the
class depends on is part of the instance key, so Field<string,
"required"> and Field<string, "optional"> are separate instances. The
conditional evaluation decides `X extends Y` by assignability when both
sides are primitive or literal types.

Fixes #1240

Co-authored-by: blurname <50226652+blurname@users.noreply.github.com>
---
 .../src/frontend/lowering/lower-classes.ts    | 70 ++++++++++++++++++-
 .../compiler/src/frontend/lowering/lowerer.ts |  6 +-
 packages/compiler/src/frontend/type-mapper.ts | 28 +++++++-
 ...-generic-class-literal-conditional.ts.json |  6 ++
 .../6908-generic-class-literal-conditional.ts | 50 +++++++++++++
 5 files changed, 155 insertions(+), 5 deletions(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6908-generic-class-literal-conditional.ts.json
 create mode 100644 tests/corpus/6908-generic-class-literal-conditional.ts

diff --git a/packages/compiler/src/frontend/lowering/lower-classes.ts b/packages/compiler/src/frontend/lowering/lower-classes.ts
index 371541df8..ae03a748c 100644
--- a/packages/compiler/src/frontend/lowering/lower-classes.ts
+++ b/packages/compiler/src/frontend/lowering/lower-classes.ts
@@ -688,6 +688,9 @@ export interface ClassInfo {
     path: InstantiationPath;
     family: ClassInfo;
     bindings: Map<ts.Symbol, IrType>;
+    /** The type arguments as checker types, for the resolutions that need
+     * literal identity (a conditional type over a literal argument). */
+    tsBindings: Map<ts.Symbol, ts.Type>;
     typeArgsText: string;
     ordinal: number;
   };
@@ -767,6 +770,9 @@ export interface GenericClassInfo {
   typeParams: ts.Symbol[];
   family: ClassInfo;
   instances: Map<string, { name: string; info: ClassInfo | null; poisoned?: boolean }>;
+  /** The type parameters a conditional type in the class depends on
+   * (literalSensitiveTypeParams), computed on first instantiation. */
+  literalSensitive?: Set<ts.Symbol>;
 }
 
 /** The KEY symbol behind a LATE-BOUND (`__@name@id`) property: resolved
@@ -1766,6 +1772,7 @@ export function collectClassShapeInner(
     family: ClassInfo;
     name: string;
     bindings: Map<ts.Symbol, IrType>;
+    tsBindings: Map<ts.Symbol, ts.Type>;
     typeArgsText: string;
     ordinal: number;
   },
@@ -4442,6 +4449,7 @@ export function collectClassShapeInner(
         path: inst.path,
         family: inst.family,
         bindings: inst.bindings,
+        tsBindings: inst.tsBindings,
         typeArgsText: inst.typeArgsText,
         ordinal: inst.ordinal,
       };
@@ -4582,8 +4590,10 @@ export function genericClassInstanceType(
     .getTypeArguments(ref as ts.TypeReference)
     .slice(0, gci.typeParams.length);
   const mapped: IrType[] = [];
+  const tsArgs: ts.Type[] = [];
   if (args.length === gci.typeParams.length) {
     for (const a of args) {
+      tsArgs.push(lowerer.typeParamTsResolver(a) ?? a);
       const m = lowerer.mapTypeOf(a, mapArgument);
       if (!m || m.kind === "void") {
         // An UNBOUND type parameter argument (`Box<T>` outside any
@@ -4602,9 +4612,26 @@ export function genericClassInstanceType(
       const b = lowerer.typeParamBindings?.get(tp);
       if (!b) return null;
       mapped.push(b);
+      const bound = lowerer.typeParamTsBindings?.get(tp);
+      if (bound) tsArgs.push(bound);
     }
   }
-  const key = mapped.map(typeKey).join(",");
+  // A literal argument for a type parameter that a conditional type
+  // depends on (`K extends "required" ? T : T | undefined`) selects the
+  // members' types, so it keys its own instance; mapType alone widens it.
+  gci.literalSensitive ??= literalSensitiveTypeParams(lowerer, gci);
+  const literalKey = (i: number): string | null => {
+    if (!gci.literalSensitive!.has(gci.typeParams[i]!)) return null;
+    const arg = tsArgs[i];
+    if (arg?.isStringLiteralType()) return JSON.stringify(arg.value);
+    if (arg?.isNumberLiteralType()) return String(arg.value);
+    if (arg && arg.flags & ts.TypeFlags.BooleanLiteral) return lowerer.checker.typeToString(arg);
+    return null;
+  };
+  const literals = gci.typeParams.map((_, i) => literalKey(i));
+  const key =
+    mapped.map(typeKey).join(",") +
+    (literals.some((l) => l !== null) ? `@${literals.map((l) => l ?? "*").join(",")}` : "");
   const existing = gci.instances.get(key);
   if (existing) {
     if (existing.info) lowerer.noteGenericClassInstanceDemand(existing.info);
@@ -4626,13 +4653,18 @@ export function genericClassInstanceType(
   gci.instances.set(key, entry);
   const bindings = new Map<ts.Symbol, IrType>();
   gci.typeParams.forEach((tp, i) => bindings.set(tp, mapped[i]!));
-  const rendered = mapped.map((m) => lowerer.fmt(m)).join(", ");
+  const tsBindings = new Map<ts.Symbol, ts.Type>();
+  if (tsArgs.length === gci.typeParams.length)
+    gci.typeParams.forEach((tp, i) => tsBindings.set(tp, tsArgs[i]!));
+  const rendered = mapped.map((m, i) => literals[i] ?? lowerer.fmt(m)).join(", ");
   const typeArgsText = `<${rendered.length > 80 ? rendered.slice(0, 77) + "..." : rendered}>`;
   const prevBindings = lowerer.typeParamBindings;
+  const prevTsBindings = lowerer.typeParamTsBindings;
   const prevContext = lowerer.instantiationContext;
   const previousPath = lowerer.genericInstantiationPath;
   lowerer.genericInstantiationPath = path;
   lowerer.typeParamBindings = bindings;
+  lowerer.typeParamTsBindings = tsBindings;
   lowerer.instantiationContext = `instantiating class '${gci.baseName}' with ${typeArgsText}`;
   try {
     lowerer.collectClassShapeInner(decl, undefined, {
@@ -4640,6 +4672,7 @@ export function genericClassInstanceType(
       family: gci.family,
       name,
       bindings,
+      tsBindings,
       typeArgsText,
       ordinal,
     });
@@ -4651,6 +4684,7 @@ export function genericClassInstanceType(
     return null;
   } finally {
     lowerer.typeParamBindings = prevBindings;
+    lowerer.typeParamTsBindings = prevTsBindings;
     lowerer.instantiationContext = prevContext;
     lowerer.genericInstantiationPath = previousPath;
   }
@@ -4666,6 +4700,35 @@ export function genericClassInstanceType(
   return { kind: "object", className: name };
 }
 
+/** The class's type parameters that a conditional type inside it depends
+ * on: the parameters named within a type node that is a conditional type
+ * or refers to one (`get(): Value<T, K>` with `type Value<T, K> = K
+ * extends "required" ? T : T | undefined`). Their literal arguments pick
+ * the conditional's branch. */
+function literalSensitiveTypeParams(lowerer: Lowerer, gci: GenericClassInfo): Set<ts.Symbol> {
+  const params = new Set(gci.typeParams);
+  const found = new Set<ts.Symbol>();
+  const collect = (node: ts.Node): void => {
+    if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName)) {
+      const symbol = lowerer.checker.getSymbolAtLocation(node.typeName);
+      if (symbol && params.has(symbol)) found.add(symbol);
+    }
+    ts.forEachChild(node, collect);
+  };
+  const visit = (node: ts.Node): void => {
+    if (
+      ts.isConditionalTypeNode(node) ||
+      (ts.isTypeReferenceNode(node) &&
+        lowerer.checker.getTypeFromTypeNode(node).isConditionalType())
+    ) {
+      collect(node);
+    }
+    ts.forEachChild(node, visit);
+  };
+  for (const member of gci.decl.members.nodes) visit(member);
+  return found;
+}
+
 /** Runs a member-lowering thunk under an INSTANTIATION's type-parameter
  * bindings (the generic-fn typeParamResolver mechanism) — the checker
  * keeps reporting the unsubstituted `T`s inside the shared body AST.
@@ -4699,17 +4762,20 @@ function withInstanceBindings<T>(lowerer: Lowerer, info: ClassInfo, fn: () => T)
     }
   }
   const prevBindings = lowerer.typeParamBindings;
+  const prevTsBindings = lowerer.typeParamTsBindings;
   const prevContext = lowerer.instantiationContext;
   const prevSuppress = lowerer.suppressStats;
   const previousPath = lowerer.genericInstantiationPath;
   lowerer.genericInstantiationPath = gi.path;
   lowerer.typeParamBindings = gi.bindings;
+  lowerer.typeParamTsBindings = gi.tsBindings;
   lowerer.instantiationContext = `instantiating class '${gi.family.generic?.baseName ?? info.def.jsName ?? ""}' with ${gi.typeArgsText}`;
   lowerer.suppressStats = prevSuppress || gi.ordinal > 0;
   try {
     return fn();
   } finally {
     lowerer.typeParamBindings = prevBindings;
+    lowerer.typeParamTsBindings = prevTsBindings;
     lowerer.instantiationContext = prevContext;
     lowerer.suppressStats = prevSuppress;
     lowerer.genericInstantiationPath = previousPath;
diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts
index 543149f83..d3ea6aa2d 100644
--- a/packages/compiler/src/frontend/lowering/lowerer.ts
+++ b/packages/compiler/src/frontend/lowering/lowerer.ts
@@ -8644,8 +8644,9 @@ export class Lowerer {
   /** The ts-level twin of typeParamResolver: the bound CHECKER type of a
    * type parameter in the current instantiation (typeParamTsBindings), for
    * the resolutions where mapType's widening already dropped what the body
-   * needs (indexed accesses over literal-bound keys). Inert outside
-   * call-keyed generic instantiation. */
+   * needs (indexed accesses over literal-bound keys, conditional types
+   * over literal arguments). Inert outside generic function and class
+   * instantiation. */
   readonly typeParamTsResolver = (t: ts.Type): ts.Type | null => {
     if (!this.typeParamTsBindings || !(t.flags & ts.TypeFlags.TypeParameter)) return null;
     const sym: ts.Symbol | undefined = t.getSymbol();
@@ -10838,6 +10839,7 @@ export class Lowerer {
       family: ClassInfo;
       name: string;
       bindings: Map<ts.Symbol, IrType>;
+      tsBindings: Map<ts.Symbol, ts.Type>;
       typeArgsText: string;
       ordinal: number;
     },
diff --git a/packages/compiler/src/frontend/type-mapper.ts b/packages/compiler/src/frontend/type-mapper.ts
index ca838cea2..3448545f8 100644
--- a/packages/compiler/src/frontend/type-mapper.ts
+++ b/packages/compiler/src/frontend/type-mapper.ts
@@ -5836,7 +5836,9 @@ function evalMappedTemplate(
     if (!checkType || !extendsType) return null;
     const checked = evalMappedTemplate(checkType, keys, scope, ctx);
     if (!checked) return null;
-    const inferred = matchInferReference(checked, extendsType, ctx);
+    const inferred =
+      primitiveExtendsCheck(checked, extendsType, ctx) ??
+      matchInferReference(checked, extendsType, ctx);
     if (inferred === undefined) return null;
     const branch = inferred ? type.getTrueType() : type.getFalseType();
     const branchScope = inferred ? new Map([...scope, ...inferred]) : scope;
@@ -5845,6 +5847,30 @@ function evalMappedTemplate(
   return mentionsMappedParams(type, keys, aliases) ? null : type;
 }
 
+/** `checked extends X` where X is a primitive or literal type, or a union of
+ * them (`K extends "required" ? ...`), and `checked` is one such type:
+ * X has no infer positions, so assignability decides the branch (an empty
+ * binding map for the true branch). A union `checked` distributes and stays
+ * undecided here (undefined), as do other shapes. */
+function primitiveExtendsCheck(
+  checked: ts.Type,
+  extendsType: ts.Type,
+  ctx: TypeMapperCtx,
+): Map<ts.Symbol, ts.Type> | false | undefined {
+  const primitive =
+    ts.TypeFlags.StringLike |
+    ts.TypeFlags.NumberLike |
+    ts.TypeFlags.BooleanLike |
+    ts.TypeFlags.BigIntLike |
+    ts.TypeFlags.Null |
+    ts.TypeFlags.Undefined;
+  const isPrimitive = (t: ts.Type): boolean =>
+    !t.isUnionType() && (t.flags & primitive) !== 0 && (t.flags & ts.TypeFlags.TypeParameter) === 0;
+  const extendsParts = extendsType.isUnionType() ? ts.constituentTypes(extendsType) : [extendsType];
+  if (!isPrimitive(checked) || !extendsParts.every(isPrimitive)) return undefined;
+  return ctx.checker.isTypeAssignableTo(checked, extendsType) ? new Map() : false;
+}
+
 /** `checked extends G<..., infer T, ...>`: the infer bindings when
  * `checked` is a reference to the same generic `G` (its arguments bind the
  * infer positions; other positions must be the same types), false when it
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6908-generic-class-literal-conditional.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6908-generic-class-literal-conditional.ts.json
new file mode 100644
index 000000000..d0403f33f
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6908-generic-class-literal-conditional.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6908-generic-class-literal-conditional.ts"
+ ],
+ "diags": []
+}
diff --git a/tests/corpus/6908-generic-class-literal-conditional.ts b/tests/corpus/6908-generic-class-literal-conditional.ts
new file mode 100644
index 000000000..d06669be3
--- /dev/null
+++ b/tests/corpus/6908-generic-class-literal-conditional.ts
@@ -0,0 +1,50 @@
+// A generic class whose member types are conditional types over a literal
+// type parameter: each literal argument selects the conditional's branch,
+// so Field<T, "required">.get() returns T and Field<T, "optional">.get()
+// returns T | undefined.
+type Kind = "required" | "optional";
+type Value<T, K extends Kind> = K extends "required" ? T : T | undefined;
+
+class Field<T, K extends Kind> {
+  value: T;
+  kind: K;
+  present: boolean;
+  constructor(value: T, kind: K, present = true) {
+    this.value = value;
+    this.kind = kind;
+    this.present = present;
+  }
+  get(): Value<T, K> {
+    return (this.present ? this.value : undefined) as Value<T, K>;
+  }
+  describe(): string {
+    return `${this.kind}:${String(this.get())}`;
+  }
+}
+
+console.log(new Field("hello", "required").get());
+const name = new Field("ada", "required");
+const nick = new Field("ad", "optional", false);
+const age = new Field(36, "optional");
+console.log(name.get().toUpperCase(), nick.get() ?? "(none)", (age.get() ?? 0) + 1);
+console.log(name.describe(), nick.describe(), age.describe());
+
+function read(field: Field<string, "required">): string {
+  return field.get();
+}
+function readOptional(field: Field<string, "optional">): string {
+  return field.get() ?? "missing";
+}
+console.log(read(name), readOptional(nick), readOptional(new Field("x", "optional")));
+
+type Flag<B extends boolean> = B extends true ? "on" : "off";
+class Switch<B extends boolean> {
+  readonly state: B;
+  constructor(state: B) {
+    this.state = state;
+  }
+  label(): Flag<B> {
+    return (this.state ? "on" : "off") as Flag<B>;
+  }
+}
+console.log(new Switch(true).label(), new Switch(false).label());

From 96c82719b6ae406c1fdf2420d72e4872e2da6891 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 10:07:56 -0500
Subject: [PATCH 05/67] Deliver queued worker messages before immediates, as
 Node does

A thread's event loop delivered one message from its workers or its
parent per loop turn, so timers and setImmediate callbacks ran between
messages that were already queued. Node's MessagePort delivers, in one
callback, the messages queued when it starts and those that arrive
meanwhile until it has taken 1000, with a microtask checkpoint after
each, before the loop goes on to the check phase.

- scr_worker_dispatch starts a batch when it delivers a message: the
  messages queued then, and at least 1000 in all.
- scr_workers_more continues the loop pass while the next event in the
  thread's mailbox is a message and the batch has room; other events
  (online, exit, error, stdio) keep their order and their turns.
- scr_mailbox_head_kind and scr_mailbox_count_kind read the mailbox's
  first event kind and the number of queued events of a kind.
- Corpus 6211 checks the order of messages, nextTick, microtasks and
  setImmediate for worker-to-parent and parent-to-worker messages
  against Node.
---
 .../limitations/native-worker-threads.mdx     |  1 +
 .../6211-worker-message-batches.ts.json       |  6 ++
 packages/runtime/src/scr_mailbox.c            | 15 ++++
 packages/runtime/src/scr_mailbox.h            |  4 +
 packages/runtime/src/scr_worker_events.c      | 30 ++++++-
 tests/corpus/6211-worker-message-batches.ts   | 87 +++++++++++++++++++
 .../6211-worker-message-batches.ts.json       |  1 +
 7 files changed, 142 insertions(+), 2 deletions(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6211-worker-message-batches.ts.json
 create mode 100644 tests/corpus/6211-worker-message-batches.ts
 create mode 100644 tests/harness/corpus-costs/6211-worker-message-batches.ts.json

diff --git a/docs/content/limitations/native-worker-threads.mdx b/docs/content/limitations/native-worker-threads.mdx
index e45d12ad3..5bd259114 100644
--- a/docs/content/limitations/native-worker-threads.mdx
+++ b/docs/content/limitations/native-worker-threads.mdx
@@ -18,6 +18,7 @@ An unhandled rejection whose reason is not error-like arrives as an `UnhandledPr
 A thrown value that does not clone, such as a function, arrives as an `ERR_WORKER_UNSERIALIZABLE_ERROR` Error, where Node sends its `util.inspect` string.
 `new MessageChannel()` from `node:worker_threads` makes two entangled MessagePorts, in one thread or across threads once a port is transferred, with `receiveMessageOnPort`.
 Port messages arrive in Node's order: each port's queued messages as one batch before `setImmediate` callbacks, a port's own `'close'` after the poll phase, and the other port's `'close'` after its queued messages while the loop keeps running.
+A worker's messages to its parent, and the parent's messages in the worker, also arrive as one batch before `setImmediate` callbacks, each followed by its microtasks, as in Node: the messages queued when delivery starts, and those that arrive meanwhile until the batch holds 1000.
 `receiveMessageOnPort(parentPort)` in a worker takes the parent's next message.
 A port's `onmessage` property and `addEventListener` are unsupported.
 `BroadcastChannel` delivers each message to every other open channel with the same name, in any thread, as a `'message'` `MessageEvent` through `onmessage` and `addEventListener`; an open channel keeps the process alive until `close()` or `unref()`.
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6211-worker-message-batches.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6211-worker-message-batches.ts.json
new file mode 100644
index 000000000..a9cc11603
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6211-worker-message-batches.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6211-worker-message-batches.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/runtime/src/scr_mailbox.c b/packages/runtime/src/scr_mailbox.c
index 361a43791..39e7801ed 100644
--- a/packages/runtime/src/scr_mailbox.c
+++ b/packages/runtime/src/scr_mailbox.c
@@ -226,6 +226,21 @@ bool scr_mailbox_pending(ScrMailbox *mailbox) {
   return pending;
 }
 
+unsigned scr_mailbox_head_kind(ScrMailbox *mailbox) {
+  scr_mailbox_lock(mailbox);
+  unsigned kind = mailbox->head ? mailbox->head->kind : 0;
+  scr_mailbox_unlock(mailbox);
+  return kind;
+}
+
+size_t scr_mailbox_count_kind(ScrMailbox *mailbox, unsigned kind) {
+  scr_mailbox_lock(mailbox);
+  size_t count = 0;
+  for (ScrMailEvent *event = mailbox->head; event; event = event->next) count += event->kind == kind;
+  scr_mailbox_unlock(mailbox);
+  return count;
+}
+
 /* A taker that finds the mailbox empty spins this long before it blocks.
  * Replies between threads usually arrive within a few microseconds, and a
  * blocked taker pays a sleep and a wakeup for each one. */
diff --git a/packages/runtime/src/scr_mailbox.h b/packages/runtime/src/scr_mailbox.h
index 678d17723..ac8493057 100644
--- a/packages/runtime/src/scr_mailbox.h
+++ b/packages/runtime/src/scr_mailbox.h
@@ -26,6 +26,10 @@ ScrMailEvent *scr_mailbox_take_kind(ScrMailbox *mailbox, unsigned kind, uint64_t
 void scr_mail_event_free(ScrMailEvent *event);
 void scr_mailbox_close(ScrMailbox *mailbox);
 bool scr_mailbox_pending(ScrMailbox *mailbox);
+/* The kind of the first queued event, or 0 when none is queued. */
+unsigned scr_mailbox_head_kind(ScrMailbox *mailbox);
+/* The number of queued events of this kind. */
+size_t scr_mailbox_count_kind(ScrMailbox *mailbox, unsigned kind);
 void scr_mailbox_wait(ScrMailbox *mailbox, double milliseconds);
 int scr_mailbox_pollfd(const ScrMailbox *mailbox);
 
diff --git a/packages/runtime/src/scr_worker_events.c b/packages/runtime/src/scr_worker_events.c
index b4efa3e0d..f7778f3fa 100644
--- a/packages/runtime/src/scr_worker_events.c
+++ b/packages/runtime/src/scr_worker_events.c
@@ -57,6 +57,15 @@ static SCR_TL uint64_t scr_channel_poll_gen;
 /* the loop pass continues a phase (scr_channel_more answered true) */
 static SCR_TL bool scr_channel_continuing;
 static SCR_TL bool scr_channel_closing_phase;
+/* Messages from the thread's workers and its parent are delivered in
+ * batches, as Node's MessagePort delivers them: one callback takes the
+ * messages queued when it starts, and those that arrive meanwhile until it
+ * has taken SCR_WORKER_BATCH_MIN, with a microtask checkpoint after each,
+ * before the loop goes on to timers and immediates. A delivered message
+ * starts a batch; the loop pass continues it (scr_workers_more) while the
+ * next event is a message and the batch has room. */
+#define SCR_WORKER_BATCH_MIN 1000
+static SCR_TL size_t scr_worker_batch_left;
 static const char *const scr_worker_method_names[] = {
   "ref", "unref", "hasRef", "terminate", "postMessage", "on", "once", "addListener",
   "prependListener", "prependOnceListener", "off", "removeListener", "removeAllListeners",
@@ -700,6 +709,14 @@ static bool scr_channel_more(void) {
   return more;
 }
 
+static bool scr_workers_more(void) {
+  if (scr_channel_more()) return true;
+  if (scr_worker_batch_left == 0) return false;
+  if (scr_worker_events && scr_mailbox_head_kind(scr_worker_events) == SCR_WORKER_MESSAGE) return true;
+  scr_worker_batch_left = 0;
+  return false;
+}
+
 static void scr_worker_dispatch(void) {
   if (scr_channel_dispatch()) return;
   ScrWorkerView *port = scr_worker_port;
@@ -718,7 +735,16 @@ static void scr_worker_dispatch(void) {
     port->queued_head = event->next;
     if (!port->queued_head) port->queued_tail = NULL;
     event->next = NULL;
-  } else event = scr_mailbox_take(scr_worker_events);
+  } else {
+    event = scr_mailbox_take(scr_worker_events);
+    if (event && event->kind == SCR_WORKER_MESSAGE) {
+      if (scr_worker_batch_left == 0) {
+        size_t queued = 1 + scr_mailbox_count_kind(scr_worker_events, SCR_WORKER_MESSAGE);
+        scr_worker_batch_left = queued > SCR_WORKER_BATCH_MIN ? queued : SCR_WORKER_BATCH_MIN;
+      }
+      scr_worker_batch_left--;
+    }
+  }
   if (!event) return;
   if (event->kind == SCR_WORKER_WAKE) { scr_mail_event_free(event); return; }
   if (event->kind == SCR_WORKER_STDIN) {
@@ -869,7 +895,7 @@ static bool scr_worker_events_install(void) {
   if (scr_context_atexit(scr_worker_events_cleanup) != 0) scr_trap("scriptc: out of memory\n");
   scr_loop_set_workers(scr_workers_pending, scr_worker_events_ready, scr_worker_dispatch,
     scr_worker_events_pollfd, scr_worker_events_wait);
-  scr_loop_set_workers_more(scr_channel_more);
+  scr_loop_set_workers_more(scr_workers_more);
   return true;
 }
 
diff --git a/tests/corpus/6211-worker-message-batches.ts b/tests/corpus/6211-worker-message-batches.ts
new file mode 100644
index 000000000..75583c027
--- /dev/null
+++ b/tests/corpus/6211-worker-message-batches.ts
@@ -0,0 +1,87 @@
+import { Worker, isMainThread, parentPort, workerData } from "node:worker_threads";
+
+// Messages queued for a thread while one of its 'message' listeners runs
+// are delivered before the loop goes on to immediates, in both directions:
+// worker to parent, and parent to worker. Microtasks a listener queues run
+// before the next message. The first listener waits on a shared flag until
+// the other thread has posted the rest, so they are queued before it
+// returns.
+type Setup = { role: "sender" | "receiver"; flag: Int32Array };
+
+function waitFor(flag: Int32Array, index: number): void {
+  while (Atomics.load(flag, index) === 0) Atomics.wait(flag, index, 0, 50);
+}
+
+function signal(flag: Int32Array, index: number): void {
+  Atomics.store(flag, index, 1);
+  Atomics.notify(flag, index);
+}
+
+/** Records the order of the batch the first message's listener waits for. */
+function receive(on: (listener: (m: unknown) => void) => void, flag: Int32Array, done: (log: string[]) => void): void {
+  const log: string[] = [];
+  let count = 0;
+  on((m) => {
+    count++;
+    log.push(`message ${String(m)}`);
+    if (count === 1) {
+      signal(flag, 0);
+      waitFor(flag, 1);
+      process.nextTick(() => log.push("tick"));
+      queueMicrotask(() => log.push("microtask"));
+      setImmediate(() => {
+        log.push("immediate");
+        done(log);
+      });
+    }
+    if (count === 4) queueMicrotask(() => log.push(`microtask after ${String(m)}`));
+  });
+}
+
+function send(post: (m: string) => void, flag: Int32Array, prefix: string): void {
+  post(`${prefix}1`);
+  waitFor(flag, 0);
+  for (let i = 2; i <= 6; i++) post(`${prefix}${i}`);
+  signal(flag, 1);
+}
+
+if (isMainThread) {
+  // Worker to parent: the worker sends, this thread receives.
+  const first = new Int32Array(new SharedArrayBuffer(8));
+  const sender = new Worker(new URL(import.meta.url), { workerData: { role: "sender", flag: first } satisfies Setup });
+  receive(
+    (listener) => sender.on("message", listener),
+    first,
+    (log) => {
+      console.log("worker to parent");
+      for (const line of log) console.log(line);
+    },
+  );
+  sender.on("exit", () => {
+    // Parent to worker: this thread sends, the worker receives and reports its log.
+    const second = new Int32Array(new SharedArrayBuffer(8));
+    const receiver = new Worker(new URL(import.meta.url), {
+      workerData: { role: "receiver", flag: second } satisfies Setup,
+    });
+    receiver.on("message", (log: unknown) => {
+      if (!Array.isArray(log)) return;
+      console.log("parent to worker");
+      for (const line of log) console.log(String(line));
+    });
+    receiver.on("online", () => send((m) => receiver.postMessage(m), second, "p"));
+    receiver.on("exit", (code: number) => console.log("exit", code));
+  });
+} else {
+  const setup = workerData as Setup;
+  const port = parentPort!;
+  if (setup.role === "sender") send((m) => port.postMessage(m), setup.flag, "w");
+  else
+    receive(
+      (listener) => port.on("message", listener),
+      setup.flag,
+      (log) => {
+        port.postMessage(log);
+        port.close();
+      },
+    );
+}
diff --git a/tests/harness/corpus-costs/6211-worker-message-batches.ts.json b/tests/harness/corpus-costs/6211-worker-message-batches.ts.json
new file mode 100644
index 000000000..75b17b215
--- /dev/null
+++ b/tests/harness/corpus-costs/6211-worker-message-batches.ts.json
@@ -0,0 +1 @@
+{ "plain": 2507, "san": 20224 }

From 9a73f63b0655b8180c23a86bdbb970b1af69314b Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 12:17:22 -0500
Subject: [PATCH 06/67] Pass undefined as the zlib callback result on errors

Node calls a zlib callback with (err, undefined) when the operation
fails. The callback adapter passed a NULL Buffer in the result's static
Buffer slot instead: member reads crashed and typeof printed "object".
This applied to deflate, inflate, deflateRaw, inflateRaw, gzip, gunzip
and unzip, with and without options, for callback literals and for
function values.

A function shaped (err, out), with err typed Error | null and out a
Buffer that the body reads, now tests out on entry (bytes.isAbsent).
With a Buffer, the body runs as before. With the NULL Buffer, a second
copy of the body runs with out read as any holding undefined, so typeof,
comparisons, templates, optional chains and console.log give Node's
answers and member reads throw Node's TypeError. Passed on into a Buffer
slot, out stays the NULL Buffer, which a callee with the same entry test
reads as undefined. The parameter keeps its static type, so callers and
adapters are unchanged. A copy that has no such lowering throws SC2020
when it runs.

Conditions on the error parameter fold in the error-path copy, and in
the success copy for a literal that only the adapter calls. Inside an
error-path copy, a nested callback lowers once with its result read as
any, so nested callbacks grow linearly in code size.
---
 .../compiler/src/backend/llvm/lib-dispatch.ts |   8 +
 .../frontend/lowering/builtins/arguments.ts   |  45 ++-
 .../src/frontend/lowering/lower-functions.ts  | 377 ++++++++++++++----
 .../compiler/src/frontend/lowering/lowerer.ts |  42 ++
 .../src/frontend/lowering/static-typeof.ts    |  42 +-
 .../compiler/src/ir/builtin-signatures.ts     |   8 +
 .../6920-zlib-callback-error-result.ts.json   |   6 +
 .../corpus/6920-zlib-callback-error-result.ts | 195 +++++++++
 .../6920-zlib-callback-error-result.ts.json   |   1 +
 9 files changed, 634 insertions(+), 90 deletions(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6920-zlib-callback-error-result.ts.json
 create mode 100644 tests/corpus/6920-zlib-callback-error-result.ts
 create mode 100644 tests/harness/corpus-costs/6920-zlib-callback-error-result.ts.json

diff --git a/packages/compiler/src/backend/llvm/lib-dispatch.ts b/packages/compiler/src/backend/llvm/lib-dispatch.ts
index 924027ee2..526d4b7e0 100644
--- a/packages/compiler/src/backend/llvm/lib-dispatch.ts
+++ b/packages/compiler/src/backend/llvm/lib-dispatch.ts
@@ -758,6 +758,14 @@ export function emitLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlValue {
     const inline = emitInlineAtomicsOp(host, e);
     if (inline) return inline;
   }
+  if (e.fn === "bytes.isAbsent") {
+    // A borrowed read: retaining an absent Buffer would dereference NULL.
+    const value = host.emitReadReceiver(e.args[0]!);
+    const t = host.B.tmp();
+    host.B.line(`${t} = icmp eq ptr ${value.name}, null`);
+    return { name: t, type: e.type };
+  }
+  if (e.fn === "bytes.absent") return host.own({ name: "null", type: e.type });
   const prefix = e.fn.slice(0, e.fn.indexOf(".")) as LibCallPrefix;
   // events.once builds typed listener adapters beside the emitter calls.
   if (e.fn === "events.once" || e.fn === "events.onceSignal")
diff --git a/packages/compiler/src/frontend/lowering/builtins/arguments.ts b/packages/compiler/src/frontend/lowering/builtins/arguments.ts
index 5e21f6cb3..d3bf46774 100644
--- a/packages/compiler/src/frontend/lowering/builtins/arguments.ts
+++ b/packages/compiler/src/frontend/lowering/builtins/arguments.ts
@@ -238,6 +238,25 @@ export function errorFirstBytesCallback(
   );
 }
 
+/** Whether `type` is an error-first callback's error parameter type:
+ * Error | null, optionally with undefined, or dyn. */
+export function isErrorFirstErrorType(lowerer: Lowerer, type: IrType): boolean {
+  if (type.kind === "dyn") return true;
+  if (type.kind !== "union") return false;
+  const def = lowerer.unions.get(type.unionId);
+  return (
+    !!def &&
+    def.arms.some((arm) => arm.kind === "nullT") &&
+    def.arms.some((arm) => arm.kind === "object" && arm.className === "%Error") &&
+    def.arms.every(
+      (arm) =>
+        arm.kind === "nullT" ||
+        arm.kind === "undefinedT" ||
+        (arm.kind === "object" && arm.className === "%Error"),
+    )
+  );
+}
+
 /** An error-first callback (error, value) whose error parameter is
  * Error | null or dyn and whose value parameter is dyn or accepted by
  * `acceptValue`; `values` names the accepted values in the refusal. */
@@ -248,6 +267,12 @@ export function errorFirstCallback(
   acceptValue: (value: IrType) => boolean,
   values: string,
 ): IrExpr {
+  // A literal here is called only by the callback adapter, which passes
+  // null as the error whenever it passes a result (lowerUndefinedResultBody).
+  let literal: ts.Expression = node;
+  while (ts.isParenthesizedExpression(literal)) literal = literal.expression;
+  if (ts.isArrowFunction(literal) || ts.isFunctionExpression(literal))
+    lowerer.errorFirstLiterals.add(literal);
   let callback = lowerer.lowerExpr(node);
   if (callback.type.kind === "dyn") {
     callback = {
@@ -261,24 +286,8 @@ export function errorFirstCallback(
     lowerer.unsupported("SC1090", node, `${api} callbacks must accept at most (error, buffer)`);
   }
   const error = callback.type.params[0];
-  if (error !== undefined && error.kind !== "dyn") {
-    if (error.kind !== "union") {
-      lowerer.unsupported("SC1090", node, `${api} callback error parameters must be Error | null`);
-    }
-    const def = lowerer.unions.get(error.unionId);
-    const valid =
-      !!def &&
-      def.arms.some((arm) => arm.kind === "nullT") &&
-      def.arms.some((arm) => arm.kind === "object" && arm.className === "%Error") &&
-      def.arms.every(
-        (arm) =>
-          arm.kind === "nullT" ||
-          arm.kind === "undefinedT" ||
-          (arm.kind === "object" && arm.className === "%Error"),
-      );
-    if (!valid)
-      lowerer.unsupported("SC1090", node, `${api} callback error parameters must be Error | null`);
-  }
+  if (error !== undefined && !isErrorFirstErrorType(lowerer, error))
+    lowerer.unsupported("SC1090", node, `${api} callback error parameters must be Error | null`);
   const value = callback.type.params[1];
   if (value !== undefined && value.kind !== "dyn" && !acceptValue(value)) {
     lowerer.unsupported(
diff --git a/packages/compiler/src/frontend/lowering/lower-functions.ts b/packages/compiler/src/frontend/lowering/lower-functions.ts
index 0ddfa0ac4..9254e6213 100644
--- a/packages/compiler/src/frontend/lowering/lower-functions.ts
+++ b/packages/compiler/src/frontend/lowering/lower-functions.ts
@@ -1,14 +1,19 @@
 import { declareTypedArguments } from "./typed-arguments.js";
-import { varRef } from "../../ir/build.js";
+import { dynUndefinedExpr, varRef } from "../../ir/build.js";
+import { everyStmtList, transformStmtList } from "../../ir/traverse.js";
+import { bindingNeverReassigned } from "./binding-analysis.js";
+import { isErrorFirstErrorType } from "./builtins/arguments.js";
 import { InternalCompilerError } from "../../errors.js";
 import * as ts from "../ts7/adapter.js";
 import { isRebindableFunctionSymbol } from "./rebindable-functions.js";
 import { bodyReadsArguments } from "../arguments-usage.js";
 import type { Lowerer } from "./lowerer.js";
 import {
+  BOOL,
   DYN,
   type IrExpr,
   type IrFunction,
+  type IrLocal,
   type IrParam,
   type IrStmt,
   type SrcLoc,
@@ -253,6 +258,14 @@ export function lowerLambda(
       shapes,
       funcType,
     );
+  // An error-first callback that reads its Buffer result: undefined on the
+  // error path, as in Node.
+  const undefinedResult = undefinedResultParam(
+    lowerer,
+    node,
+    shapes,
+    lowerer.errorFirstLiterals.has(node),
+  );
   const nameIdent =
     !ts.isArrowFunction(node) && node.name && ts.isIdentifier(node.name) ? node.name : null;
   const baseName = nameIdent ? nameIdent.text : "";
@@ -340,78 +353,84 @@ export function lowerLambda(
         !shapes.some((s) => s.mode === "dynRest"),
     );
 
-    let body: IrStmt[];
-    if (ts.isBlock(node.body!)) {
-      body = lowerer.lowerStmts(node.body!.statements.nodes);
-    } else {
-      // Bare-expression arrow body: `x => e` is `x => { return e; }`
-      // (or an expression statement when the signature returns void — or
-      // when a union-returning signature wraps a void expression, whose
-      // value is the implicit undefined arm appended below).
-      const bodyExpr = node.body as ts.Expression;
-      if (bodyReturn.kind === "void") {
-        // `() => undefined` — the return type maps to void (standalone
-        // undefined IS void in the type mapping) and the body value is a
-        // bare unit literal: a pure no-op, dropped rather than tripping
-        // the validator's bare-unitLit rule (typeCheckReturnExpression).
-        // A `void e` body rides the statement lowering (the value is
-        // discarded here, so the operand evaluates for effect alone —
-        // `(name) => void doThing(name)`, the fire-and-forget arrow). A
-        // conditional body does the same so its void arms become lazy
-        // statement branches instead of a forbidden void-valued ternary.
-        let stripped: ts.Expression = bodyExpr;
-        while (ts.isParenthesizedExpression(stripped)) stripped = stripped.expression;
-        if (ts.isVoidExpression(stripped) || ts.isConditionalExpression(stripped)) {
-          body = [lowerer.lowerExprStatement(stripped)];
+    const lowerBody = (): IrStmt[] => {
+      let body: IrStmt[];
+      if (ts.isBlock(node.body!)) {
+        body = lowerer.lowerStmts(node.body!.statements.nodes);
+      } else {
+        // Bare-expression arrow body: `x => e` is `x => { return e; }`
+        // (or an expression statement when the signature returns void — or
+        // when a union-returning signature wraps a void expression, whose
+        // value is the implicit undefined arm appended below).
+        const bodyExpr = node.body as ts.Expression;
+        if (bodyReturn.kind === "void") {
+          // `() => undefined` — the return type maps to void (standalone
+          // undefined IS void in the type mapping) and the body value is a
+          // bare unit literal: a pure no-op, dropped rather than tripping
+          // the validator's bare-unitLit rule (typeCheckReturnExpression).
+          // A `void e` body rides the statement lowering (the value is
+          // discarded here, so the operand evaluates for effect alone —
+          // `(name) => void doThing(name)`, the fire-and-forget arrow). A
+          // conditional body does the same so its void arms become lazy
+          // statement branches instead of a forbidden void-valued ternary.
+          let stripped: ts.Expression = bodyExpr;
+          while (ts.isParenthesizedExpression(stripped)) stripped = stripped.expression;
+          if (ts.isVoidExpression(stripped) || ts.isConditionalExpression(stripped)) {
+            body = [lowerer.lowerExprStatement(stripped)];
+          } else {
+            const value = lowerer.lowerExpr(bodyExpr);
+            // `async () => p` with a void result still resolves the
+            // function's promise with p (its settlement, rejections included);
+            // a maybe-promise value adopts only its promise arm.
+            const flattened = isAsync ? lowerer.maybePromiseReturn(bodyExpr, value, VOID) : null;
+            body = flattened
+              ? [flattened]
+              : value.kind === "unitLit"
+                ? []
+                : isAsync && value.type.kind === "promise"
+                  ? [lowerer.adoptingReturn(value, VOID, (e) => e)]
+                  : [{ kind: "exprStmt", expr: value, loc: locOf(node.body!) }];
+          }
         } else {
-          const value = lowerer.lowerExpr(bodyExpr);
-          // `async () => p` with a void result still resolves the
-          // function's promise with p (its settlement, rejections included);
-          // a maybe-promise value adopts only its promise arm.
-          const flattened = isAsync ? lowerer.maybePromiseReturn(bodyExpr, value, VOID) : null;
+          // Concise and block bodies use the same destination layout for
+          // fresh literals. Async bodies must inspect promises first.
+          let value =
+            isAsync || fnCtx.inferReturn
+              ? lowerer.lowerExpr(bodyExpr)
+              : lowerer.lowerExprExpecting(bodyExpr, bodyReturn);
+          // An async concise body whose value is itself a promise
+          // (`async () => p`): the async machinery RESOLVES the returned
+          // thenable into the function's own promise — lowerReturnValue's
+          // await-through, applied to the implicit return.
+          if (isAsync && value.type.kind === "promise" && bodyReturn.kind !== "promise") {
+            value = lowerer.returnedPromiseAwait(value);
+          }
+          const flattened =
+            isAsync && !fnCtx.inferReturn
+              ? lowerer.maybePromiseReturn(bodyExpr, value, bodyReturn)
+              : null;
           body = flattened
             ? [flattened]
-            : value.kind === "unitLit"
-              ? []
-              : isAsync && value.type.kind === "promise"
-                ? [lowerer.adoptingReturn(value, VOID, (e) => e)]
-                : [{ kind: "exprStmt", expr: value, loc: locOf(node.body!) }];
+            : value.type.kind === "void" && lowerer.wrappedUndefined(bodyReturn, locOf(node.body!))
+              ? [{ kind: "exprStmt", expr: value, loc: locOf(node.body!) }]
+              : [
+                  {
+                    kind: "return",
+                    value: fnCtx.inferReturn
+                      ? value
+                      : lowerer.coerceInto(bodyExpr, value, bodyReturn),
+                    loc: locOf(node.body!),
+                  },
+                ];
+          if (fnCtx.inferReturn && body[0]?.kind === "return")
+            fnCtx.inferReturn.entries.push({ stmt: body[0], node: bodyExpr });
         }
-      } else {
-        // Concise and block bodies use the same destination layout for
-        // fresh literals. Async bodies must inspect promises first.
-        let value =
-          isAsync || fnCtx.inferReturn
-            ? lowerer.lowerExpr(bodyExpr)
-            : lowerer.lowerExprExpecting(bodyExpr, bodyReturn);
-        // An async concise body whose value is itself a promise
-        // (`async () => p`): the async machinery RESOLVES the returned
-        // thenable into the function's own promise — lowerReturnValue's
-        // await-through, applied to the implicit return.
-        if (isAsync && value.type.kind === "promise" && bodyReturn.kind !== "promise") {
-          value = lowerer.returnedPromiseAwait(value);
-        }
-        const flattened =
-          isAsync && !fnCtx.inferReturn
-            ? lowerer.maybePromiseReturn(bodyExpr, value, bodyReturn)
-            : null;
-        body = flattened
-          ? [flattened]
-          : value.type.kind === "void" && lowerer.wrappedUndefined(bodyReturn, locOf(node.body!))
-            ? [{ kind: "exprStmt", expr: value, loc: locOf(node.body!) }]
-            : [
-                {
-                  kind: "return",
-                  value: fnCtx.inferReturn
-                    ? value
-                    : lowerer.coerceInto(bodyExpr, value, bodyReturn),
-                  loc: locOf(node.body!),
-                },
-              ];
-        if (fnCtx.inferReturn && body[0]?.kind === "return")
-          fnCtx.inferReturn.entries.push({ stmt: body[0], node: bodyExpr });
       }
-    }
+      return body;
+    };
+    let body = undefinedResult
+      ? lowerUndefinedResultBody(lowerer, node, undefinedResult, lowerBody)
+      : lowerBody();
     if (fnCtx.inferReturn) {
       bodyReturn = resolveInferredReturn(
         lowerer,
@@ -537,7 +556,14 @@ export function lowerFunction(lowerer: Lowerer, decl: ts.FunctionDeclaration): I
         "function declarations whose block body the frontend cannot locate",
       );
     }
-    const body = [...prologue, ...lowerer.lowerStmts(bodyBlock.statements.nodes)];
+    const undefinedResult = undefinedResultParam(lowerer, decl, sig.params, false);
+    const lowerBody = (): IrStmt[] => lowerer.lowerStmts(bodyBlock.statements.nodes);
+    const body = [
+      ...prologue,
+      ...(undefinedResult
+        ? lowerUndefinedResultBody(lowerer, decl, undefinedResult, lowerBody)
+        : lowerBody()),
+    ];
     appendImplicitUndefinedReturn(lowerer, body, bodyReturn, locOf(decl));
     const fn: IrFunction = {
       name: sig.name,
@@ -594,3 +620,216 @@ export function lowerFunction(lowerer: Lowerer, decl: ts.FunctionDeclaration): I
     lowerer.fnStack.pop();
   }
 }
+
+/** The parameters of an error-first callback whose Buffer result its body
+ * reads: `(err, out)` with err typed Error | null (or any) and out a
+ * Buffer. The callback adapters of zlib and crypto pass a NULL Buffer
+ * after an error, where Node passes undefined. `error` is the error
+ * parameter's symbol when nothing writes it; `onlyAdapterCalls` marks a
+ * literal passed straight to such a function, which nothing else calls. */
+interface UndefinedResultParam {
+  symbol: ts.Symbol;
+  name: ts.Identifier;
+  error: ts.Symbol | null;
+  onlyAdapterCalls: boolean;
+}
+
+function undefinedResultParam(
+  lowerer: Lowerer,
+  node: ts.SignatureDeclaration,
+  shapes: readonly ParamShape[],
+  onlyAdapterCalls: boolean,
+): UndefinedResultParam | null {
+  const params = node.parameters.nodes.filter((p) => !isThisParameter(p));
+  if (params.length !== 2 || shapes.length !== 2 || node.asteriskToken !== undefined) return null;
+  const [errorDecl, decl] = params as [ts.ParameterDeclaration, ts.ParameterDeclaration];
+  const [errorShape, shape] = shapes as [ParamShape, ParamShape];
+  if (
+    !ts.isIdentifier(decl.name) ||
+    decl.initializer !== undefined ||
+    decl.questionToken !== undefined ||
+    decl.dotDotDotToken !== undefined ||
+    shape.mode !== "required" ||
+    shape.type.kind !== "bytes" ||
+    shape.type.elem !== "u8" ||
+    errorShape.mode !== "required" ||
+    !isErrorFirstErrorType(lowerer, errorShape.type)
+  )
+    return null;
+  const symbol = lowerer.checker.getSymbolAtLocation(decl.name);
+  if (
+    symbol === undefined ||
+    node.body === undefined ||
+    !readsSymbol(lowerer, node.body, symbol, decl.name)
+  )
+    return null;
+  const errorSymbol = ts.isIdentifier(errorDecl.name)
+    ? lowerer.checker.getSymbolAtLocation(errorDecl.name)
+    : undefined;
+  const error =
+    errorSymbol !== undefined &&
+    errorDecl.initializer === undefined &&
+    bindingNeverReassigned(lowerer, errorSymbol, errorDecl)
+      ? errorSymbol
+      : null;
+  return { symbol, name: decl.name, error, onlyAdapterCalls };
+}
+
+/** Whether `body` reads `symbol` (other than at its declaration `name`). */
+function readsSymbol(
+  lowerer: Lowerer,
+  body: ts.Node,
+  symbol: ts.Symbol,
+  name: ts.Identifier,
+): boolean {
+  let read = false;
+  const visit = (n: ts.Node): void => {
+    if (read) return;
+    if (ts.isShorthandPropertyAssignment(n)) {
+      if (lowerer.checker.getShorthandAssignmentValueSymbol(n) === symbol) read = true;
+    } else if (ts.isIdentifier(n)) {
+      if (n !== name && lowerer.checker.getSymbolAtLocation(n) === symbol) read = true;
+    } else {
+      ts.forEachChild(n, visit);
+    }
+  };
+  visit(body);
+  return read;
+}
+
+/** The body of an error-first callback whose Buffer result may be absent.
+ * With a result, the body lowers as written. Without one (the adapter's
+ * NULL Buffer after an error), the body lowers again with the result read
+ * as `any` holding undefined and the error parameter holding an Error.
+ * Conditions on the error parameter fold in that copy (staticCondition),
+ * and in the first copy too, as null, for a literal only the adapter
+ * calls: a body that returns after `if (err)` then keeps the rest of its
+ * statements in the first copy only.
+ *
+ * Inside an error-path copy, a nested callback lowers once with the result
+ * read as `any`, so nested callbacks do not double at every level. An
+ * error-path copy with no lowering throws a coded error when it runs. */
+function lowerUndefinedResultBody(
+  lowerer: Lowerer,
+  node: ts.SignatureDeclaration,
+  result: UndefinedResultParam,
+  lowerBody: () => IrStmt[],
+): IrStmt[] {
+  const loc = locOf(node);
+  const param = lowerer.bindingIn(lowerer.ctx, result.symbol);
+  if (param === null) throw new InternalCompilerError("lowerer bug: callback result unbound");
+  const absent: IrExpr = {
+    kind: "libCall",
+    fn: "bytes.isAbsent",
+    args: [varRef(param.id, param.type, loc)],
+    type: BOOL,
+    loc,
+  };
+  const fence: IrStmt = {
+    kind: "runtimeFence",
+    code: "SC2020",
+    message: `the callback's '${result.name.text}' is undefined after an error, and this callback has no lowering that reads it as undefined`,
+    loc,
+  };
+  const withKnownError = (error: boolean | null, lower: () => IrStmt[]): IrStmt[] => {
+    if (result.error === null || error === null) return lower();
+    lowerer.knownErrors.set(result.error, error);
+    try {
+      return lower();
+    } finally {
+      lowerer.knownErrors.delete(result.error);
+    }
+  };
+  /** The body with the result read as `any` from `slot`, or null when it
+   * has no such lowering or converts the result into a static slot. */
+  const lowerDynamic = (slot: IrLocal, knownError: boolean | null): IrStmt[] | null => {
+    const diags = lowerer.diags.length;
+    const stats = lowerer.suppressStats;
+    lowerer.scopes.push(new Map([[result.symbol, slot]]));
+    lowerer.anySymbols.add(result.symbol);
+    lowerer.suppressStats = true;
+    lowerer.errorPathCopies++;
+    try {
+      // Passed on into a Buffer slot, the result stays the absent Buffer
+      // the adapter passed: a callee with this entry test reads it as
+      // undefined.
+      const body = transformStmtList(withKnownError(knownError, lowerBody), {
+        expr: (e) =>
+          e.kind === "dynCheck" &&
+          e.value.kind === "varRef" &&
+          e.value.localId === slot.id &&
+          e.type.kind === "bytes" &&
+          e.type.elem === "u8"
+            ? { kind: "libCall", fn: "bytes.absent", args: [], type: e.type, loc: e.loc }
+            : e,
+        stmt: (stmt) => stmt,
+      });
+      if (lowerer.diags.length > diags || !readsSlotDynamically(body, slot.id))
+        throw new PoisonError();
+      return body;
+    } catch (error) {
+      if (error instanceof InternalCompilerError) throw error;
+      lowerer.diags.length = diags;
+      return null;
+    } finally {
+      lowerer.errorPathCopies--;
+      lowerer.anySymbols.delete(result.symbol);
+      lowerer.scopes.pop();
+      lowerer.suppressStats = stats;
+    }
+  };
+  const slot = lowerer.declareHiddenLocal("%result", DYN);
+  const undefinedResult: IrStmt = {
+    kind: "varDecl",
+    localId: slot.id,
+    init: dynUndefinedExpr(loc),
+    loc,
+  };
+  if (lowerer.errorPathCopies > 0) {
+    // One copy for both paths, with the result boxed when present.
+    const dynamic = lowerDynamic(slot, null);
+    if (dynamic !== null)
+      return [
+        {
+          kind: "varDecl",
+          localId: slot.id,
+          init: {
+            kind: "ternary",
+            cond: absent,
+            then: dynUndefinedExpr(loc),
+            else_: lowerer.coerceInto(result.name, varRef(param.id, param.type, loc), DYN),
+            type: DYN,
+            loc,
+          },
+          loc,
+        },
+        ...dynamic,
+      ];
+  }
+  const withResult = withKnownError(result.onlyAdapterCalls ? false : null, lowerBody);
+  const withoutResult = lowerDynamic(slot, true);
+  return [
+    {
+      kind: "if",
+      cond: absent,
+      then: withoutResult === null ? [fence] : [undefinedResult, ...withoutResult],
+      else_: withResult,
+      loc,
+    },
+  ];
+}
+
+/** Whether the error-path copy reads the checked-dynamic result slot only as
+ * a checked-dynamic value, never converted into a static slot (where Node
+ * would hold undefined). */
+function readsSlotDynamically(body: IrStmt[], slotId: string): boolean {
+  const isSlot = (e: IrExpr): boolean => e.kind === "varRef" && e.localId === slotId;
+  return everyStmtList(body, {
+    expr: (e) => {
+      if (isSlot(e)) return e.type.kind === "dyn";
+      if (e.kind === "dynCheck" && isSlot(e.value)) return false;
+      return true;
+    },
+    stmt: () => true,
+  });
+}
diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts
index d81ac546e..40b0bc874 100644
--- a/packages/compiler/src/frontend/lowering/lowerer.ts
+++ b/packages/compiler/src/frontend/lowering/lowerer.ts
@@ -2655,6 +2655,19 @@ export class Lowerer {
   /** True while re-lowering a base function's 2nd+ instance: the same source
    * statements were already counted for the first instance. */
   suppressStats = false;
+  /** Callback literals passed straight to an error-first zlib or crypto
+   * function: only that function's callback adapter calls them
+   * (lowerUndefinedResultBody). */
+  readonly errorFirstLiterals = new Set<ts.Node>();
+  /** Parameters read as `any` in the error-path copy of an error-first
+   * callback. */
+  readonly anySymbols = new Set<ts.Symbol>();
+  /** Error parameters of an error-first callback with a known value in
+   * the copy being lowered: true while it holds an Error, false while it
+   * holds null (staticCondition folds conditions on them). */
+  readonly knownErrors = new Map<ts.Symbol, boolean>();
+  /** The number of error-path callback copies being lowered. */
+  errorPathCopies = 0;
   /** Comparisons interned by operand representations and equality semantics. */
   readonly equalityHelpers = new Map<string, string>();
   /** Synthetic array-HOF loop functions (map/filter/forEach desugar),
@@ -8382,7 +8395,36 @@ export class Lowerer {
     return fenceStaticReadableStreamMember(this, access, use);
   }
 
+  /** Whether `node` reads an anySymbols parameter, or a member, element or
+   * call result of one: the error-path copy of a callback reads those as
+   * `any`. */
+  private readsAnySymbol(node: ts.Node): boolean {
+    let base: ts.Node = node;
+    for (;;) {
+      if (
+        ts.isPropertyAccessExpression(base) ||
+        ts.isElementAccessExpression(base) ||
+        ts.isNonNullExpression(base) ||
+        ts.isParenthesizedExpression(base)
+      ) {
+        base = base.expression;
+      } else if (ts.isCallExpression(base) && ts.isPropertyAccessExpression(base.expression)) {
+        base = base.expression.expression;
+      } else {
+        break;
+      }
+    }
+    if (!ts.isIdentifier(base)) return false;
+    const parent = base.parent;
+    const symbol =
+      parent !== undefined && ts.isShorthandPropertyAssignment(parent) && parent.name === base
+        ? this.checker.getShorthandAssignmentValueSymbol(parent)
+        : this.checker.getSymbolAtLocation(base);
+    return symbol !== undefined && this.anySymbols.has(symbol);
+  }
+
   typeOf(node: ts.Node): ts.Type {
+    if (this.anySymbols.size > 0 && this.readsAnySymbol(node)) return this.checker.getAnyType();
     if (ts.isPropertyAccessExpression(node) && isJsSourceFile(ts.getSourceFileOfNode(node))) {
       const receiver =
         node.expression.kind === ts.SyntaxKind.ThisKeyword && this.fnStack.length > 0
diff --git a/packages/compiler/src/frontend/lowering/static-typeof.ts b/packages/compiler/src/frontend/lowering/static-typeof.ts
index 54f2fdfa0..852cc3117 100644
--- a/packages/compiler/src/frontend/lowering/static-typeof.ts
+++ b/packages/compiler/src/frontend/lowering/static-typeof.ts
@@ -63,9 +63,44 @@ export function staticTypeofComparison(lowerer: Lowerer, e: ts.BinaryExpression)
   }
 }
 
+/** Whether a callback's error parameter holds an Error (true) or null
+ * (false) in the copy of the callback body being lowered
+ * (lowerUndefinedResultBody), or null for other expressions. */
+function knownError(lowerer: Lowerer, e: ts.Expression): boolean | null {
+  while (ts.isParenthesizedExpression(e)) e = e.expression;
+  if (lowerer.knownErrors.size === 0 || !ts.isIdentifier(e)) return null;
+  const symbol = lowerer.checker.getSymbolAtLocation(e);
+  return symbol === undefined ? null : (lowerer.knownErrors.get(symbol) ?? null);
+}
+
+/** A comparison of a known error parameter against `null`
+ * (`err !== null`, `err == null`), folded. Null for other shapes. */
+function knownErrorComparison(lowerer: Lowerer, e: ts.BinaryExpression): boolean | null {
+  const isNull = (x: ts.Expression): boolean => {
+    while (ts.isParenthesizedExpression(x)) x = x.expression;
+    return x.kind === ts.SyntaxKind.NullKeyword;
+  };
+  const error = isNull(e.right)
+    ? knownError(lowerer, e.left)
+    : isNull(e.left)
+      ? knownError(lowerer, e.right)
+      : null;
+  if (error === null) return null;
+  switch (e.operatorToken.kind) {
+    case ts.SyntaxKind.EqualsEqualsEqualsToken:
+    case ts.SyntaxKind.EqualsEqualsToken:
+      return !error;
+    case ts.SyntaxKind.ExclamationEqualsEqualsToken:
+    case ts.SyntaxKind.ExclamationEqualsToken:
+      return error;
+    default:
+      return null;
+  }
+}
+
 /** The value of a condition built from statically answered typeof
- * comparisons, `!`, `&&` and `||` (the global-detection chains), or null
- * when any operand needs evaluation. */
+ * comparisons, known callback error parameters, `!`, `&&` and `||` (the
+ * global-detection chains), or null when any operand needs evaluation. */
 export function staticCondition(lowerer: Lowerer, expr: ts.Expression): boolean | null {
   let e = expr;
   while (ts.isParenthesizedExpression(e)) e = e.expression;
@@ -73,6 +108,7 @@ export function staticCondition(lowerer: Lowerer, expr: ts.Expression): boolean
     const inner = staticCondition(lowerer, e.operand);
     return inner === null ? null : !inner;
   }
+  if (ts.isIdentifier(e)) return knownError(lowerer, e);
   if (!ts.isBinaryExpression(e)) return null;
   const op = e.operatorToken.kind;
   if (op === ts.SyntaxKind.AmpersandAmpersandToken || op === ts.SyntaxKind.BarBarToken) {
@@ -82,7 +118,7 @@ export function staticCondition(lowerer: Lowerer, expr: ts.Expression): boolean
     if (left !== isAnd) return left;
     return staticCondition(lowerer, e.right);
   }
-  return staticTypeofComparison(lowerer, e);
+  return staticTypeofComparison(lowerer, e) ?? knownErrorComparison(lowerer, e);
 }
 
 /** The expression a value reduces to once statically decided conditions
diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts
index 9f383c695..28da4ff61 100644
--- a/packages/compiler/src/ir/builtin-signatures.ts
+++ b/packages/compiler/src/ir/builtin-signatures.ts
@@ -4616,6 +4616,14 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
    * lone surrogate as U+FFFD). Borrowed arg; owned (+1) string; never throws. */
   "text.decode": { argTypes: [BYTES_U8], result: STRING },
   "bytes.bufferSource": { argTypes: [DYN], result: BYTES_U8 },
+  /** Whether an error-first callback's Buffer result is absent: the zlib
+   * and crypto callback adapters pass NULL after an error. Borrowed arg;
+   * never throws. */
+  "bytes.isAbsent": { argTypes: [BYTES_U8], result: BOOL },
+  /** The absent Buffer result itself (NULL), where an error-path callback
+   * body passes its undefined result on into a Buffer slot. Owned (+1);
+   * never throws. */
+  "bytes.absent": { argTypes: [], result: BYTES_U8 },
   /** The Buffer brand of a Uint8Array source onto a fresh Uint8Array
    * result (map and filter of a Buffer return a Buffer). */
   "bytes.copyBrand": { argTypes: [BYTES_U8, BYTES_U8], result: VOID },
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6920-zlib-callback-error-result.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6920-zlib-callback-error-result.ts.json
new file mode 100644
index 000000000..05e138441
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6920-zlib-callback-error-result.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6920-zlib-callback-error-result.ts"
+ ],
+ "diags": []
+}
diff --git a/tests/corpus/6920-zlib-callback-error-result.ts b/tests/corpus/6920-zlib-callback-error-result.ts
new file mode 100644
index 000000000..50998d37f
--- /dev/null
+++ b/tests/corpus/6920-zlib-callback-error-result.ts
@@ -0,0 +1,195 @@
+// zlib callbacks receive undefined as the result when they fail, as in
+// Node: the result reads as undefined in logs, templates, typeof and
+// comparisons, member reads throw Node's TypeError, and the same callbacks
+// read the Buffer as before when the operation succeeds. This holds for
+// callback literals and for function values.
+import * as zlib from "node:zlib";
+
+const good = zlib.deflateSync("hello callbacks");
+const bad = Buffer.from("not deflate data");
+
+function report(label: string, run: () => void): void {
+  try {
+    run();
+  } catch (e) {
+    console.log(label, "threw", (e as Error).name, (e as Error).message);
+  }
+}
+
+function check(label: string, input: Buffer, next: () => void): void {
+  zlib.inflate(input, (err, out) => {
+    console.log(label, "error", err?.code ?? null);
+    console.log(label, "value", out);
+    console.log(label, "template", `${out}`, String(out), out + "");
+    console.log(label, "typeof", typeof out, out === undefined, out !== undefined);
+    console.log(label, "optional", out?.length, out?.toString());
+    console.log(label, "isBuffer", Buffer.isBuffer(out));
+    console.log(label, out ? "truthy" : "falsy");
+    report(label + " length", () => console.log(label, "length", out.length));
+    report(label + " toString", () => console.log(label, "text", out.toString()));
+    report(label + " inflateSync", () => console.log(label, "again", zlib.inflateSync(out).length));
+    setTimeout(() => {
+      console.log(label, "later", typeof out, out?.byteLength);
+      next();
+    });
+  });
+}
+
+function guarded(next: () => void): void {
+  // A callback that checks the error first reads the Buffer only on success.
+  zlib.gunzip(bad, (err, out) => {
+    if (err) {
+      console.log("guarded error", err.code, err.errno);
+      zlib.gzip("guarded text", (err2, packed) => {
+        if (err2) throw err2;
+        zlib.gunzip(packed, (err3, plain) => {
+          console.log("guarded round trip", err3, plain.toString());
+          next();
+        });
+      });
+      return;
+    }
+    console.log("guarded value", out.toString());
+  });
+}
+
+function expressions(): void {
+  // Expression bodies.
+  zlib.unzip(bad, (err, out) =>
+    zlib.deflateRaw("raw", (err2, raw) => console.log("expression", err?.code, out, err2, raw.length > 0)),
+  );
+}
+
+function everyFunction(next: () => void): void {
+  // Each callback function, with and without options. maxOutputLength makes
+  // the compressors fail; a non-matching format makes the decompressors fail.
+  const text = "every function ".repeat(20);
+  const opts = { maxOutputLength: 8 };
+  zlib.deflate(text, opts, (err, out) => {
+    console.log("deflate", err?.code, typeof out, out?.length);
+    zlib.deflateRaw(text, opts, (err, out) => {
+      console.log("deflateRaw", err?.code, typeof out, out?.length);
+      zlib.gzip(text, opts, (err, out) => {
+        console.log("gzip", err?.code, typeof out, out?.length);
+        zlib.inflateRaw(bad, (err, out) => {
+          console.log("inflateRaw", err?.code, typeof out, out?.length);
+          zlib.inflate(zlib.deflateSync(text), opts, (err, out) => {
+            console.log("inflate options", err?.code, typeof out, out?.length);
+            zlib.gunzip(zlib.gzipSync(text), opts, (err, out) => {
+              console.log("gunzip options", err?.code, typeof out, out?.length);
+              zlib.unzip(bad, {}, (err, out) => {
+                console.log("unzip options", err?.code, typeof out, out?.length);
+                zlib.inflateRaw(zlib.deflateRawSync(text), {}, (err, out) => {
+                  console.log("inflateRaw options", err, out.toString() === text);
+                  zlib.deflate(text, {}, (err, out) => {
+                    console.log("deflate options", err, zlib.inflateSync(out).toString() === text);
+                    next();
+                  });
+                });
+              });
+            });
+          });
+        });
+      });
+    });
+  });
+}
+
+function folded(input: Buffer, next: () => void): void {
+  // Conditions on the error parameter.
+  zlib.inflateRaw(input, (err, out) => {
+    if (err !== null) console.log("folded error", err.code, typeof out);
+    else console.log("folded value", out.length);
+    if (!err) console.log("folded ok", out.toString());
+    console.log("folded both", err == null ? out.length : typeof out, err && err.code);
+    if (err) return;
+    console.log("folded after", out.byteLength);
+  });
+  setTimeout(next, 10);
+}
+
+// Function values: declarations, const arrows and forwarded parameters
+// receive undefined too, and a direct call still passes its arguments.
+const steps: (() => void)[] = [];
+function step(): void {
+  const run = steps.shift();
+  if (run) run();
+}
+function named(err: Error | null, out: Buffer): void {
+  if (err) console.log("named error", (err as NodeJS.ErrnoException).code, typeof out, out === undefined);
+  else console.log("named value", out.toString());
+  console.log("named both", err !== null, typeof out, `${out}`, out?.length);
+  step();
+}
+const arrow = (err: Error | null, out: Buffer): void => {
+  console.log("arrow", err?.message ?? null, typeof out, String(out));
+  report("arrow length", () => console.log("arrow length", out.length));
+  step();
+};
+function captures(err: Error | null, out: Buffer): void {
+  setTimeout(() => {
+    console.log("captured", err !== null, typeof out, out?.length);
+    step();
+  });
+}
+function forward(input: Buffer, cb: (err: Error | null, out: Buffer) => void): void {
+  zlib.inflate(input, cb);
+}
+function forwardGzip(text: string, cb: (err: Error | null, out: Buffer) => void): void {
+  zlib.gzip(text, { maxOutputLength: 4 }, cb);
+}
+
+function forwardLiteral(input: Buffer, cb: (err: Error | null, out: Buffer) => void): void {
+  // The literal passes its result on to a typed callback.
+  zlib.inflate(input, (err, out) => cb(err, out));
+}
+function inflated(input: Buffer): Promise<Buffer> {
+  return new Promise<Buffer>((resolve, reject) =>
+    zlib.inflate(input, (err, out) => (err ? reject(err) : resolve(out))),
+  );
+}
+
+function functionValues(next: () => void): void {
+  steps.push(
+    () => zlib.inflate(good, named),
+    () => zlib.inflate(bad, named),
+    () => zlib.inflate(good, arrow),
+    () => zlib.inflate(bad, arrow),
+    () => forward(bad, named),
+    () => forwardLiteral(bad, named),
+    () => forwardLiteral(good, arrow),
+    () =>
+      inflated(bad).then(
+        (out) => console.log("promise value", out.length),
+        (e) => {
+          console.log("promise rejected", (e as NodeJS.ErrnoException).code);
+          step();
+        },
+      ),
+    () =>
+      void inflated(good).then((out) => {
+        console.log("promise value", out.toString());
+        step();
+      }),
+    () => forwardGzip("text that does not fit", arrow),
+    () => zlib.inflate(bad, captures),
+    () => zlib.inflate(good, captures),
+    () => {
+      named(new Error("direct"), Buffer.from("both"));
+    },
+    next,
+  );
+  step();
+}
+
+check("good", good, () =>
+  check("bad", bad, () =>
+    guarded(() =>
+      everyFunction(() =>
+        folded(zlib.deflateRawSync("folded text"), () =>
+          folded(bad, () => functionValues(expressions)),
+        ),
+      ),
+    ),
+  ),
+);
diff --git a/tests/harness/corpus-costs/6920-zlib-callback-error-result.ts.json b/tests/harness/corpus-costs/6920-zlib-callback-error-result.ts.json
new file mode 100644
index 000000000..1241a31c0
--- /dev/null
+++ b/tests/harness/corpus-costs/6920-zlib-callback-error-result.ts.json
@@ -0,0 +1 @@
+{ "plain": 5517, "san": 7607 }

From 349ab75298a9c7534b5b8f084645a9824eb0a5b9 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 12:50:14 -0500
Subject: [PATCH 07/67] Evaluate every ToNumber argument before converting, and
 convert conditionals

The Math functions and String.fromCharCode/fromCodePoint evaluate all of
their arguments before they convert any, as in Node. When an argument's
conversion can run program code (valueOf or toString on a dynamic value)
and a later argument follows, the arguments now evaluate into temporaries
first and convert in order after (lowerToNumberArguments). Before, a
dynamic argument converted before the next one was evaluated.

A conditional argument whose branches are not both numbers boxes its
value and converts it like any dynamic value, so `isFinite(flag ? "12" :
"abc")` in a JavaScript file returns a boolean instead of reaching a
run-time fence.

A statement inside an expression can end its block (an argument call that
always throws). The expression's later statements and result now emit in
a block with no predecessors, so the instructions there read only values
defined in it.
---
 .../src/backend/llvm/expr-primitives.ts       |  11 +-
 .../src/frontend/lowering/builtins/strings.ts |  18 ++-
 .../src/frontend/lowering/lower-exprs.ts      | 106 +++++++++++++++---
 .../src/frontend/lowering/lower-stdlib.ts     |  26 +++--
 tests/corpus/6906-tonumber-arguments.mjs      |  45 ++++++++
 5 files changed, 174 insertions(+), 32 deletions(-)

diff --git a/packages/compiler/src/backend/llvm/expr-primitives.ts b/packages/compiler/src/backend/llvm/expr-primitives.ts
index 69f4def2e..3ab628d69 100644
--- a/packages/compiler/src/backend/llvm/expr-primitives.ts
+++ b/packages/compiler/src/backend/llvm/expr-primitives.ts
@@ -524,8 +524,15 @@ export function emitOperatorExpr(
     case "seqExpr": {
       // Statements mid-expression: each emits in place (its own frame,
       // exactly statement position); the result is an ordinary temp of
-      // the current frame. No jump can leave the expression's region.
-      for (const s of e.stmts) host.emitStmt(s);
+      // the current frame. No jump can leave the expression's region. A
+      // statement can still end the block (a call that always throws):
+      // what follows then emits in a block with no predecessors, so every
+      // value it reads is defined there, and LLVM deletes it.
+      for (const s of e.stmts) {
+        if (host.B.isTerminated()) host.B.startBlock(host.B.newLabel("seq.dead"));
+        host.emitStmt(s);
+      }
+      if (host.B.isTerminated()) host.B.startBlock(host.B.newLabel("seq.dead"));
       return host.emitExpr(e.result);
     }
     default: {
diff --git a/packages/compiler/src/frontend/lowering/builtins/strings.ts b/packages/compiler/src/frontend/lowering/builtins/strings.ts
index 54ab22c05..4b4a8b29b 100644
--- a/packages/compiler/src/frontend/lowering/builtins/strings.ts
+++ b/packages/compiler/src/frontend/lowering/builtins/strings.ts
@@ -3,7 +3,7 @@ import * as ts from "../../ts7/adapter.js";
 import { type Lowerer } from "../lowerer.js";
 import { locOf } from "../../program.js";
 import { lowerOptionalArgument, lowerStringSearchArgument } from "../optional-arguments.js";
-import { lowerToNumberArgument } from "../lower-exprs.js";
+import { lowerToNumberArguments } from "../lower-exprs.js";
 import {
   BOOL,
   DYN,
@@ -115,11 +115,19 @@ export function lowerStringStaticCall(
     const packed = lowerer.lowerExprExpecting(spread.expression, arrayOf(F64));
     return { kind: "libCall", fn: `string.${member}`, args: [packed], type: STRING, loc };
   }
-  // Each code converts with ToNumber: a missing value is NaN (code unit 0
-  // for fromCharCode, a RangeError for fromCodePoint), exactly Node.
-  const elems = call.arguments.nodes.map((a) => lowerToNumberArgument(lowerer, a));
+  // Each code converts with ToNumber after every argument is evaluated: a
+  // missing value is NaN (code unit 0 for fromCharCode, a RangeError for
+  // fromCodePoint), exactly Node.
+  const { stmts, values: elems } = lowerToNumberArguments(lowerer, call.arguments.nodes);
   const packed: IrExpr = { kind: "arrayLit", elems, type: arrayOf(F64), loc };
-  return { kind: "libCall", fn: `string.${member}`, args: [packed], type: STRING, loc };
+  const result: IrExpr = {
+    kind: "libCall",
+    fn: `string.${member}`,
+    args: [packed],
+    type: STRING,
+    loc,
+  };
+  return stmts.length === 0 ? result : { kind: "seqExpr", stmts, result, type: STRING, loc };
 }
 
 /** `String.fromCharCode.apply(thisArg, codes)`, the btoa chunking idiom
diff --git a/packages/compiler/src/frontend/lowering/lower-exprs.ts b/packages/compiler/src/frontend/lowering/lower-exprs.ts
index 4b03e915d..23892d43e 100644
--- a/packages/compiler/src/frontend/lowering/lower-exprs.ts
+++ b/packages/compiler/src/frontend/lowering/lower-exprs.ts
@@ -1420,9 +1420,65 @@ export function lowerOptionalNumber(
  * out-of-range read, a local or field holding one, or a hole — converts to
  * NaN instead of trusting the checker's number type. */
 export function lowerToNumberArgument(lowerer: Lowerer, node: ts.Expression): IrExpr {
+  const operand = numberOperand(lowerer, node);
+  return operand.convert ? operand.convert(operand.value) : operand.value;
+}
+
+/** The ToNumber arguments of one call (the Math functions,
+ * String.fromCharCode): Node evaluates every argument before it converts
+ * any. When an argument's conversion can run program code (valueOf or
+ * toString on a dynamic value) and a later argument follows, the arguments
+ * evaluate into temporaries first and convert in order after. `lowerOther`
+ * lowers an argument that takes no conversion (a spread), or returns null
+ * for a ToNumber argument. Returns the temporaries' statements (empty when
+ * none are needed) and the converted values. */
+export function lowerToNumberArguments(
+  lowerer: Lowerer,
+  nodes: readonly ts.Expression[],
+  lowerOther?: (node: ts.Expression) => IrExpr | null,
+): { stmts: IrStmt[]; values: IrExpr[] } {
+  const operands = nodes.map((node): NumberOperand => {
+    const other = lowerOther?.(node);
+    return other ? { value: other, convert: null, runsCode: false } : numberOperand(lowerer, node);
+  });
+  const late = operands.slice(0, -1).some((operand) => operand.runsCode);
+  if (!late) {
+    const values = operands.map((o) => (o.convert ? o.convert(o.value) : o.value));
+    return { stmts: [], values };
+  }
+  const stmts: IrStmt[] = [];
+  const values = operands.map((operand) => {
+    if (operand.value.kind === "numLit") return operand.value;
+    const temp = lowerer.declareHiddenLocal("%numberArgument", operand.value.type);
+    const loc = operand.value.loc;
+    stmts.push({ kind: "varDecl", localId: temp.id, init: operand.value, loc });
+    const read = varRef(temp.id, operand.value.type, loc);
+    return operand.convert ? operand.convert(read) : read;
+  });
+  return { stmts, values };
+}
+
+/** An argument a ToNumber site lowers: its evaluated value and the
+ * conversion that makes it a number (null when the value already is one).
+ * `runsCode`: the conversion can call program code. */
+interface NumberOperand {
+  value: IrExpr;
+  convert: ((value: IrExpr) => IrExpr) | null;
+  runsCode: boolean;
+}
+
+function numberOperand(lowerer: Lowerer, node: ts.Expression): NumberOperand {
   let inner = node;
   while (ts.isParenthesizedExpression(inner)) inner = inner.expression;
   const loc = locOf(inner);
+  const number = (value: IrExpr): NumberOperand => ({ value, convert: null, runsCode: false });
+  const dynToNumber = (value: IrExpr): IrExpr => ({
+    kind: "libCall",
+    fn: "dyn.toNumberCoerce",
+    args: [value],
+    type: F64,
+    loc,
+  });
   const isOptionalNumber = (value: IrExpr): boolean =>
     value.type.kind === "union" &&
     lowerer.armTag(value.type.unionId, UNDEFINED_T) >= 0 &&
@@ -1433,34 +1489,54 @@ export function lowerToNumberArgument(lowerer: Lowerer, node: ts.Expression): Ir
       ? lowerAbsenceProbe(lowerer, inner)
       : null;
   if (optional && isOptionalNumber(optional))
-    return lowerOptionalNumber(lowerer, optional, loc, inner);
-  // A conditional builds each branch for the destination.
-  if (ts.isConditionalExpression(inner)) return lowerer.lowerExprExpecting(node, F64);
+    return number(lowerOptionalNumber(lowerer, optional, loc, inner));
+  // A conditional with number branches builds each branch as a number;
+  // other branches box, and the value converts like any dynamic value.
+  if (ts.isConditionalExpression(inner)) {
+    const branch = (b: ts.Expression) => lowerer.mapTypeOf(lowerer.typeOf(b))?.kind;
+    if (branch(inner.whenTrue) === "f64" && branch(inner.whenFalse) === "f64")
+      return number(lowerer.lowerExprExpecting(node, F64));
+    return { value: lowerer.lowerExprExpecting(node, DYN), convert: dynToNumber, runsCode: true };
+  }
   const value = lowerer.lowerExpr(node);
-  if (isOptionalNumber(value)) return lowerOptionalNumber(lowerer, value, loc, inner);
+  if (isOptionalNumber(value)) return number(lowerOptionalNumber(lowerer, value, loc, inner));
   // Other values convert with ToNumber: strings parse as numeric literals,
   // booleans and null are numbers, and checked-dynamic values call
   // valueOf/toString or throw Node's TypeError for a Symbol or BigInt.
-  const num = (value: number): IrExpr => ({ kind: "numLit", value, type: F64, loc });
+  const num = (n: number): IrExpr => ({ kind: "numLit", value: n, type: F64, loc });
+  const pure = (convert: (value: IrExpr) => IrExpr): NumberOperand => ({
+    value,
+    convert,
+    runsCode: false,
+  });
   switch (value.type.kind) {
     case "string":
-      return { kind: "libCall", fn: "num.fromString", args: [value], type: F64, loc };
+      return pure((v) => ({ kind: "libCall", fn: "num.fromString", args: [v], type: F64, loc }));
     case "bool":
-      return { kind: "ternary", cond: value, then: num(1), else_: num(0), type: F64, loc };
+      return pure((v) => ({
+        kind: "ternary",
+        cond: v,
+        then: num(1),
+        else_: num(0),
+        type: F64,
+        loc,
+      }));
     case "nullT":
-      return defaultAfterUndefined(value, num(0));
+      return pure((v) => defaultAfterUndefined(v, num(0)));
     case "undefinedT":
-      return defaultAfterUndefined(value, num(NaN));
+      return pure((v) => defaultAfterUndefined(v, num(NaN)));
     case "dyn":
-      return { kind: "libCall", fn: "dyn.toNumberCoerce", args: [value], type: F64, loc };
+      return { value, convert: dynToNumber, runsCode: true };
     case "union":
-      if (lowerer.dynConvertible(value.type)) {
-        const boxed = lowerer.coerceToExpected(value, DYN);
-        return { kind: "libCall", fn: "dyn.toNumberCoerce", args: [boxed], type: F64, loc };
-      }
+      if (lowerer.dynConvertible(value.type))
+        return {
+          value: lowerer.coerceToExpected(value, DYN),
+          convert: dynToNumber,
+          runsCode: true,
+        };
       break;
   }
-  return lowerer.coerceInto(node, value, F64);
+  return number(lowerer.coerceInto(node, value, F64));
 }
 
 /** The stored value of an identifier whose storage holds an undefined arm
diff --git a/packages/compiler/src/frontend/lowering/lower-stdlib.ts b/packages/compiler/src/frontend/lowering/lower-stdlib.ts
index e968af638..2ad3657c7 100644
--- a/packages/compiler/src/frontend/lowering/lower-stdlib.ts
+++ b/packages/compiler/src/frontend/lowering/lower-stdlib.ts
@@ -2,7 +2,7 @@ import { dynUndefinedExpr, nodeThrowExpr } from "../../ir/build.js";
 import { InternalCompilerError } from "../../errors.js";
 
 import * as ts from "../ts7/adapter.js";
-import { lowerToNumberArgument } from "./lower-exprs.js";
+import { lowerToNumberArguments } from "./lower-exprs.js";
 import type { Lowerer } from "./lowerer.js";
 import { isDeclaredInAmbientNamespace } from "../type-mapper.js";
 import {
@@ -2415,8 +2415,14 @@ export function lowerStdlibMethodCall(
   const staticMath = isMath ? own(STATIC_MATH_FNS, name) : undefined;
   // A missing element (a hole bound by a loop, a local or field holding a
   // missing read, or the read itself) converts to NaN, ToNumber's answer
-  // for undefined, instead of trusting the checker's number type.
-  const mathArg = (a: ts.Expression): IrExpr => lowerToNumberArgument(lowerer, a);
+  // for undefined, instead of trusting the checker's number type. The
+  // arguments are all evaluated before any converts (lowerToNumberArguments).
+  const mathArgs = (
+    nodes: readonly ts.Expression[],
+    lowerOther?: (node: ts.Expression) => IrExpr | null,
+  ) => lowerToNumberArguments(lowerer, nodes, lowerOther);
+  const afterArguments = (stmts: IrStmt[], result: IrExpr): IrExpr =>
+    stmts.length === 0 ? result : { kind: "seqExpr", stmts, result, type: result.type, loc };
   // Math.hypot, and Math.max/Math.min with a spread among other arguments
   // (`Math.max(...xs, 5)`): the arguments in order, spreads flattened, as
   // one number[] the runtime folds.
@@ -2427,8 +2433,8 @@ export function lowerStdlibMethodCall(
         call.arguments.nodes.length > 1 &&
         call.arguments.nodes.some(ts.isSpreadElement)))
   ) {
-    const elems = call.arguments.nodes.map((a) =>
-      ts.isSpreadElement(a) ? lowerer.lowerExprExpecting(a.expression, arrayOf(F64)) : mathArg(a),
+    const { stmts, values: elems } = mathArgs(call.arguments.nodes, (a) =>
+      ts.isSpreadElement(a) ? lowerer.lowerExprExpecting(a.expression, arrayOf(F64)) : null,
     );
     const spreads = call.arguments.nodes.flatMap((a, i) => (ts.isSpreadElement(a) ? [i] : []));
     const packed: IrExpr = {
@@ -2439,7 +2445,7 @@ export function lowerStdlibMethodCall(
       loc,
     };
     const fn = name === "max" ? "math.maxArr" : name === "min" ? "math.minArr" : staticMath.fn;
-    return { kind: "libCall", fn, args: [packed], type: F64, loc };
+    return afterArguments(stmts, { kind: "libCall", fn, args: [packed], type: F64, loc });
   }
   if (staticMath && call.arguments.nodes.every((a) => !ts.isSpreadElement(a))) {
     // Math.max/Math.min at ANY plain arity — Node's are variadic. The
@@ -2455,16 +2461,16 @@ export function lowerStdlibMethodCall(
       if (call.arguments.nodes.length === 0) {
         return { kind: "numLit", value: name === "max" ? -Infinity : Infinity, type: F64, loc };
       }
-      const args = call.arguments.nodes.map(mathArg);
+      const { stmts, values: args } = mathArgs(call.arguments.nodes);
       let acc = args[0]!;
       for (let i = 1; i < args.length; i++) {
         acc = { kind: "libCall", fn: staticMath.fn, args: [acc, args[i]!], type: F64, loc };
       }
-      return acc;
+      return afterArguments(stmts, acc);
     }
     if (call.arguments.nodes.length === staticMath.arity) {
-      const args = call.arguments.nodes.map(mathArg);
-      return { kind: "libCall", fn: staticMath.fn, args, type: F64, loc };
+      const { stmts, values: args } = mathArgs(call.arguments.nodes);
+      return afterArguments(stmts, { kind: "libCall", fn: staticMath.fn, args, type: F64, loc });
     }
   }
   // `Math.max(...xs)` / `Math.min(...xs)` over a number[]: a STATIC
diff --git a/tests/corpus/6906-tonumber-arguments.mjs b/tests/corpus/6906-tonumber-arguments.mjs
index 23b150eb8..55da6bb1f 100644
--- a/tests/corpus/6906-tonumber-arguments.mjs
+++ b/tests/corpus/6906-tonumber-arguments.mjs
@@ -30,3 +30,48 @@ for (const value of [Symbol("s"), 10n]) {
     console.log(e instanceof TypeError, e.message);
   }
 }
+
+// A conditional argument converts whichever branch it takes.
+for (const flag of [true, false]) {
+  console.log(isFinite(flag ? "12" : "abc"), isNaN(flag ? null : "x"), Math.floor(flag ? "3.7" : true));
+}
+
+// Every argument is evaluated before any converts, as in Node: valueOf runs
+// after the last argument, and an argument that throws stops the call
+// before any conversion.
+let order = "";
+const valued = (name, n) => ({ valueOf: () => ((order += "v" + name), n) });
+const arg = (name, n) => ((order += "e" + name), valued(name, n));
+console.log(Math.max(arg("a", 1), arg("b", 5), arg("c", 3)), order);
+order = "";
+console.log(Math.pow(arg("a", 2), arg("b", 10)), order);
+order = "";
+console.log(Math.hypot(arg("a", 3), ...[4], arg("c", 12)), order);
+order = "";
+console.log(String.fromCharCode(arg("a", 72), arg("b", 105)), order);
+order = "";
+try {
+  Math.max(
+    arg("a", 1),
+    (() => {
+      order += "throw";
+      throw new Error("boom");
+    })(),
+  );
+} catch (e) {
+  console.log(e.message, order);
+}
+order = "";
+try {
+  Math.min(
+    {
+      valueOf() {
+        order += "x";
+        throw new TypeError("first");
+      },
+    },
+    arg("b", 2),
+  );
+} catch (e) {
+  console.log(e.message, order);
+}

From 1bf49286d1aba8c6cb505d2704a2519a210a556a Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 12:50:36 -0500
Subject: [PATCH 08/67] Document when builds use multiple cores

How It Works gains a Build parallelism section: the frontend runs on one thread, executables divide into
partitions by the size of their LLVM text, the LLVM helper compiles partitions on a thread per hardware thread,
what dev and optimized builds run in parallel and in order, what a rebuild compiles again, and what
profile-guided optimization adds to build time. The CLI reference links to it from --emit, --optimization,
--profile-use, SCRIPTC_CACHE_DIR, and Profile-guided optimization.

Fixes #1340

Co-authored-by: Quino Terrasa <26749475+espetro@users.noreply.github.com>
---
 docs/content/docs/cli.mdx          | 10 ++---
 docs/content/docs/how-it-works.mdx | 61 +++++++++++++++++++++++++++++-
 2 files changed, 65 insertions(+), 6 deletions(-)

diff --git a/docs/content/docs/cli.mdx b/docs/content/docs/cli.mdx
index 9b6e88628..daeb37ea0 100644
--- a/docs/content/docs/cli.mdx
+++ b/docs/content/docs/cli.mdx
@@ -109,7 +109,7 @@ With `--sparse`, the profile leaves out the functions the runs never reached. Th
   <dd>Primary artifact path. An explicit path is exact. Defaults are <code>.scriptc/&lt;name&gt;.ir.json</code>, <code>.ll</code>, <code>.s</code>, <code>.o</code>, or the platform executable name.</dd>
 
   <dt><code>--emit &lt;ir|llvm|asm|obj|exe&gt;</code></dt>
-  <dd>Select the primary artifact: serialized typed IR (<code>ir</code>), textual LLVM IR (<code>llvm</code>), assembly (<code>asm</code>), a relocatable object (<code>obj</code>), or an executable (<code>exe</code>, the default). Every kind except <code>exe</code> is produced without an external compiler, linker, or SDK.</dd>
+  <dd>Select the primary artifact: serialized typed IR (<code>ir</code>), textual LLVM IR (<code>llvm</code>), assembly (<code>asm</code>), a relocatable object (<code>obj</code>), or an executable (<code>exe</code>, the default). Every kind except <code>exe</code> is produced without an external compiler, linker, or SDK. Assembly and object output is compiled as one module; only executables are divided into partitions that compile in parallel (see <a href="/docs/how-it-works#build-parallelism">Build parallelism</a>).</dd>
 
   <dt><code>--print &lt;native-link-info|diagnostics&gt;</code></dt>
   <dd><code>native-link-info</code>: build an object (equivalent to <code>--emit=obj</code>) and print its machine-readable external link recipe as JSON instead of printing the artifact path. The document names the exact installed precompiled runtime pack and all link inputs, but does not invoke a linker. <code>diagnostics</code>: for <code>build</code> and <code>coverage</code>, print the versioned JSON diagnostics document described in <a href="/docs/coverage#machine-readable-diagnostics">Coverage Reports</a> instead of the human output.</dd>
@@ -127,7 +127,7 @@ With `--sparse`, the profile leaves out the functions the runs never reached. Th
   <dd>Remove symbol and debug payload when linking an executable, including cross-compiled targets. This flag preserves code optimization.</dd>
 
   <dt><code>--optimization &lt;release|dev|speed&gt;</code></dt>
-  <dd>Select native optimization for executable, assembly, or object output. The default is <code>release</code> (<code>-O2</code>), which emits string retains and the retains and releases of dynamic values inline and lets LLVM inline small runtime functions that keep no internal runtime state into executable code; programs large enough to be compiled in parallel partitions skip that inlining to keep build time and size in check. <code>dev</code> uses <code>-O0</code> and emits source locations for TypeScript and JavaScript breakpoints and stack frames. LLVM builds include source variable names and native storage descriptions; see <a href="/docs/limitations#native-debugging">Native debugging</a> for the supported representations. macOS executable builds also produce an adjacent <code>.dSYM</code> bundle. <code>speed</code> is <code>-O2</code> plus optimizations that trade binary size and build time for run-time speed: it lets LLVM inline more small runtime functions into program code, emits the remaining reference counting inline, and on x86-64 starts every runtime function on a cache-line boundary. Expect larger executables and longer cold builds than <code>release</code>; how much faster a program runs depends on how much of its time is spent in the runtime. Runtime inlining needs a runtime pack built with the LLVM helper; where a runtime pack lacks it, programs link the same runtime without it and <code>speed</code> links the release runtime and keeps inline reference counting. Selecting <code>speed</code> never changes what <code>release</code> builds produce, and the two never share cached artifacts. Library profiles accept <code>"optimization": "speed"</code> for inline reference counting.</dd>
+  <dd>Select native optimization for executable, assembly, or object output. The default is <code>release</code> (<code>-O2</code>), which emits string retains and the retains and releases of dynamic values inline and lets LLVM inline small runtime functions that keep no internal runtime state into executable code; programs large enough to be compiled in parallel partitions skip that inlining to keep build time and size in check. <code>dev</code> uses <code>-O0</code> and emits source locations for TypeScript and JavaScript breakpoints and stack frames. LLVM builds include source variable names and native storage descriptions; see <a href="/docs/limitations#native-debugging">Native debugging</a> for the supported representations. macOS executable builds also produce an adjacent <code>.dSYM</code> bundle. <code>speed</code> is <code>-O2</code> plus optimizations that trade binary size and build time for run-time speed: it lets LLVM inline more small runtime functions into program code, emits the remaining reference counting inline, and on x86-64 starts every runtime function on a cache-line boundary. Expect larger executables and longer cold builds than <code>release</code>; how much faster a program runs depends on how much of its time is spent in the runtime. Runtime inlining needs a runtime pack built with the LLVM helper; where a runtime pack lacks it, programs link the same runtime without it and <code>speed</code> links the release runtime and keeps inline reference counting. Selecting <code>speed</code> never changes what <code>release</code> builds produce, and the two never share cached artifacts. Library profiles accept <code>"optimization": "speed"</code> for inline reference counting. In executables large enough to be divided into partitions, <code>dev</code> compiles each partition on its own, and <code>release</code> and <code>speed</code> add a step that lets partitions import small functions from each other; see <a href="/docs/how-it-works#build-parallelism">Build parallelism</a>.</dd>
 
   <dt><code>--windows-subsystem &lt;console|gui&gt;</code></dt>
   <dd>Select the subsystem of a Windows executable. <code>console</code> is the default; <code>gui</code> prevents Windows from opening a console window for the app. Valid only for executable builds targeting Windows.</dd>
@@ -139,7 +139,7 @@ With `--sparse`, the profile leaves out the functions the runs never reached. Th
   <dd>On Linux, build an instrumented executable for profile-guided optimization. Each run writes a raw profile to the path pattern, where <code>%p</code> expands to the process ID; the <code>LLVM_PROFILE_FILE</code> environment variable overrides the pattern at run time. A relative pattern resolves from the current working directory. Instrumented programs run slower. Valid only for executable builds with <code>--optimization=release</code> or <code>speed</code>.</dd>
 
   <dt><code>--profile-use &lt;file.profdata&gt;</code></dt>
-  <dd>Optimize the executable with a profile from <code>scriptc merge-profiles</code>: code is laid out, inlined, and split by how the profiled runs used it. Code the profile does not describe, or describes from an older version of the program, is optimized as without a profile, so a stale profile only loses part of its gain. Valid only for executable builds with <code>--optimization=release</code> or <code>speed</code>.</dd>
+  <dd>Optimize the executable with a profile from <code>scriptc merge-profiles</code>: code is laid out, inlined, and split by how the profiled runs used it. Code the profile does not describe, or describes from an older version of the program, is optimized as without a profile, so a stale profile only loses part of its gain. A new or changed profile compiles every partition of the program again. Valid only for executable builds with <code>--optimization=release</code> or <code>speed</code>.</dd>
 
   <dt><code>--npm-static &lt;pkg[,pkg…]|auto&gt;</code></dt>
   <dd>Name npm packages to compile even if they don't ship their own type declarations (repeatable). A trailing <code>...</code>, as in <code>fs-extra...</code>, also names every package that package depends on. <code>auto</code> uses the default automatic selection. Packages that can't compile produce diagnostics. See <a href="/docs/dependencies#explicit-package-selection">npm Dependencies</a>.</dd>
@@ -182,7 +182,7 @@ With `--sparse`, the profile leaves out the functions the runs never reached. Th
 
 <dl>
   <dt><code>SCRIPTC_CACHE_DIR</code></dt>
-  <dd>Override the persistent build-cache root. By default it is <code>$XDG_CACHE_HOME/scriptc/build</code> when set, <code>$HOME/Library/Caches/scriptc/build</code> on macOS, <code>%LOCALAPPDATA%\scriptc\cache\build</code> on Windows, and <code>$HOME/.cache/scriptc/build</code> elsewhere. Cached frontend results and LLVM artifacts are verified against their source, helper, target, and compilation settings. Native outputs also depend on the selected runtime pack and linker inputs. FFI objects, archives, and system libraries relink against their current dependencies. Sanitizer development builds additionally cache instrumented runtime objects and verify external compiler and header inputs. An existing POSIX override must already be private; otherwise caching is bypassed without changing the directory's permissions.</dd>
+  <dd>Override the persistent build-cache root. By default it is <code>$XDG_CACHE_HOME/scriptc/build</code> when set, <code>$HOME/Library/Caches/scriptc/build</code> on macOS, <code>%LOCALAPPDATA%\scriptc\cache\build</code> on Windows, and <code>$HOME/.cache/scriptc/build</code> elsewhere. Cached frontend results and LLVM artifacts, including the compiled partitions of large executables, are verified against their source, helper, target, and compilation settings. Native outputs also depend on the selected runtime pack and linker inputs. FFI objects, archives, and system libraries relink against their current dependencies. Sanitizer development builds additionally cache instrumented runtime objects and verify external compiler and header inputs. An existing POSIX override must already be private; otherwise caching is bypassed without changing the directory's permissions.</dd>
 
   <dt><code>SCRIPTC_NO_CACHE</code></dt>
   <dd>Set to <code>1</code> to bypass all build-cache reads and writes. An explicitly empty <code>SCRIPTC_CACHE_DIR</code> has the same effect.</dd>
@@ -223,7 +223,7 @@ $ scriptc merge-profiles -o app.profdata profiles/*.profraw
 $ scriptc build app.ts --optimization=speed --profile-use app.profdata
 ```
 
-Train on workloads like the ones the program will run: code the training never reached is optimized as without a profile. The profile can be committed and reused as the program changes. Functions whose control flow changed since the profile was collected lose their profile, and the rest keep theirs, so regenerate it when much of the program has changed.
+Train on workloads like the ones the program will run: code the training never reached is optimized as without a profile. The profile can be committed and reused as the program changes. Functions whose control flow changed since the profile was collected lose their profile, and the rest keep theirs, so regenerate it when much of the program has changed. [Build parallelism](/docs/how-it-works#build-parallelism) describes what a profile adds to build time.
 
 ## LLVM backend
 
diff --git a/docs/content/docs/how-it-works.mdx b/docs/content/docs/how-it-works.mdx
index 5c6d7be63..f1b64948d 100644
--- a/docs/content/docs/how-it-works.mdx
+++ b/docs/content/docs/how-it-works.mdx
@@ -27,11 +27,70 @@ Runtime pack and linker -> executable
 
 1. **Frontend:** TypeScript parses and checks the program against `es2025`, scriptc's ambient declarations, and available project declarations. `tsconfig.json` controls checker strictness. The compiler uses the checked types and narrowing information to lower supported operations; unsupported operations produce diagnostics. JavaScript files that TypeScript checks (a `// @ts-check` comment, or `checkJs` in `tsconfig.json`) report values that do not match their JSDoc types as errors, and their classes use those types the way TypeScript classes use annotations.
 2. **Typed IR:** A validated, serializable intermediate representation connects the frontend and backend. Types are concrete: generic functions are specialized, unions use tags, and closures have explicit captures. `--emit=ir` writes this representation as JSON.
-3. **LLVM backend:** `--emit=llvm` writes textual LLVM IR. The matching LLVM 22 helper generates assembly or objects on supported macOS, Linux, and Windows hosts, including output targeting WASI. Executable and library builds use this backend. Large executables, native and WASI alike, are divided into partitions that are optimized and compiled in parallel; optimized builds summarize every partition first so small functions can still be inlined across partitions. The partition count depends only on the program, so output is the same on every host, and a rebuild reuses the compiled partitions that an edit does not affect.
+3. **LLVM backend:** `--emit=llvm` writes textual LLVM IR. The matching LLVM 22 helper generates assembly or objects on supported macOS, Linux, and Windows hosts, including output targeting WASI. Executable and library builds use this backend. Large executables, native and WASI alike, are divided into partitions that are optimized and compiled in parallel; see [Build parallelism](#build-parallelism).
 4. **Linking:** Runtime packs contain the precompiled C runtime and vendored libraries. A hashed manifest selects the artifacts the program needs for its features, optimization mode, and (for libraries) state model. The target linker and SDK or sysroot produce the executable. Sanitizer builds use an instrumented C runtime.
 
 `comptime` calls run during the frontend stage in an isolated evaluator inside the compiler, based on QuickJS. Their results are embedded in the program as constants.
 
+## Build parallelism
+
+Most of a build runs on one CPU core. The LLVM helper uses more cores only when it compiles an executable in partitions.
+
+### Frontend
+
+Parsing, type checking, lowering, and LLVM IR generation run one after another on one thread. The type checker runs in a separate process that the compiler waits on. When none of a build's inputs has changed since an earlier build, the frontend's results come from the build cache and this stage is skipped. A change to any input runs the whole stage again.
+
+### Partitions
+
+The LLVM helper divides an executable's LLVM IR into partitions by its size: one partition per 4 MiB of LLVM text, rounded up to a power of two, and at most 64. `--emit=llvm` writes this text, so its file size shows how many partitions a program gets.
+
+<table>
+  <thead>
+    <tr><th>LLVM text</th><th>Partitions</th></tr>
+  </thead>
+  <tbody>
+    <tr><td>Up to 4 MiB</td><td>1</td></tr>
+    <tr><td>Over 4 MiB, up to 8 MiB</td><td>2</td></tr>
+    <tr><td>Over 8 MiB, up to 16 MiB</td><td>4</td></tr>
+    <tr><td>Over 16 MiB, up to 32 MiB</td><td>8</td></tr>
+    <tr><td>Over 32 MiB, up to 64 MiB</td><td>16</td></tr>
+    <tr><td>Over 64 MiB, up to 128 MiB</td><td>32</td></tr>
+    <tr><td>Over 128 MiB</td><td>64</td></tr>
+  </tbody>
+</table>
+
+The count depends only on the size of the LLVM text, so a program has the same partitions, and builds the same executable, on every host. A function's partition follows from its name, and a small internal function goes with the one function that calls it, so an edit leaves the other functions in their partitions.
+
+These builds are not divided into partitions and compile on one thread: `--emit=asm`, `--emit=obj`, and `--print=native-link-info` output, library builds (`--lib`; `dev` library builds are compiled in pieces, one after another), and `--sanitize` builds, which compile the LLVM IR with the C compiler.
+
+The helper compiles partitions on a pool with one thread per hardware thread of the host, so an executable with two partitions uses at most two cores in the backend. A program of one partition is optimized and compiled on one thread.
+
+How partitions are compiled depends on `--optimization`:
+
+- `dev` compiles each partition on its own, all in parallel.
+- `release` and `speed` optimize each partition and write a summary of its functions, all in parallel. Then a serial step reads every summary and decides which small functions each partition imports from the others, so that calls between partitions can still be inlined. Last, the partitions are optimized with their imports and compiled, again in parallel.
+
+Reading the LLVM text and dividing it into partitions, and the import step, run on one thread.
+
+### Rebuilds
+
+With two or more partitions, the helper keeps each partition's summary and object in the build cache (see `SCRIPTC_CACHE_DIR` in the [CLI reference](/docs/cli#environment-variables)). A rebuild after an edit compiles again only the partitions whose functions changed and, in `release` and `speed` builds, the partitions that import a changed function; the others come from the cache. Dividing the program, the import step, and linking run on every build. A cold build, with nothing cached, compiles every partition.
+
+A program of one partition has no partition cache: a rebuild after an edit compiles the whole program again, and a rebuild that leaves the LLVM text unchanged takes the compiled code from the build cache.
+
+When the LLVM text grows past a partition boundary (4, 8, 16 MiB, and so on), the partition count doubles, functions move to new partitions, and the next build compiles every partition again.
+
+### Profile-guided optimization
+
+Building with a profile adds these costs (see [Profile-guided optimization](/docs/cli#profile-guided-optimization)):
+
+- `--profile-generate` builds an instrumented executable, which runs slower while it records the profile.
+- The profile's contents are part of every partition's cache key. A new or changed profile compiles every partition again; builds without a profile keep their own cache entries.
+- With a profile, the import step lets a hot call import a function of up to twice the usual size limit. LLVM's default limits for profiled calls are 10 and 100 times as large, and on large programs they tripled the build's time and memory without making the program measurably faster.
+- The profile does not change which partition a function is in.
+
+Collecting a profile takes an instrumented build, the training runs, and the merge. With a committed profile, later builds skip those steps and are one optimized build each.
+
 ## Inspect compiler output
 
 The following examples use this program:

From 96f31cbc1838044295653308be2392fce6cca757 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 13:04:07 -0500
Subject: [PATCH 09/67] Shrink the array header to 32 bytes

An array's element ops are a registry id in `spare` instead of a pointer
field: descriptors get their id on their first array (emitted descriptors
are writable for it), and a program with more element types than the id
holds keeps the rest in the array's out-of-line storage.

The out-of-line storage (sparse indices, noncanonical numeric properties,
match metadata) is no longer a header field. An array that has it keeps
its pointer in the 8 bytes before its dense allocation and sets
SCR_ARR_HAS_EXT; such an array always has a dense allocation of its own
(inline slots move out, an empty array gets the prefix alone), and every
allocation, reallocation and free of the dense storage accounts for the
prefix.

Loops over elements look the ops up once, and the state lookup below the
dense capacity reads no out-of-line storage.
---
 .../compiler/src/backend/llvm/array-search.ts |   3 +-
 packages/compiler/src/backend/llvm/common.ts  |   4 +-
 .../compiler/src/backend/llvm/emit-module.ts  |  18 +-
 .../src/backend/llvm/expr-stream-bridges.ts   |   5 +-
 packages/compiler/src/backend/llvm/shapes.ts  |   7 +-
 packages/runtime/src/scr_array.c              | 350 ++++++++++++------
 packages/runtime/src/scr_array.h              |  91 ++++-
 packages/runtime/src/scr_async_dyn.c          |   2 +-
 packages/runtime/src/scr_bytes_io.c           |   4 +-
 packages/runtime/src/scr_copying.c            |   4 +-
 packages/runtime/src/scr_cycle.c              |   2 +-
 packages/runtime/src/scr_events_emitter.c     |   2 +-
 packages/runtime/src/scr_itable.c             |  10 +-
 packages/runtime/src/scr_json.c               |   2 +-
 packages/runtime/src/scr_json.test.c          |   2 +-
 packages/runtime/src/scr_lib.c                |   2 +-
 packages/runtime/src/scr_map.c                |   2 +-
 packages/runtime/src/scr_publish.c            |   8 +-
 packages/runtime/src/scr_regex.c              |  10 +-
 packages/runtime/src/scr_region.c             |  14 +-
 packages/runtime/src/scr_region.test.c        |   2 +-
 packages/runtime/src/scr_stream.c             |   2 +-
 packages/runtime/test/test_array.c            |  66 +++-
 packages/runtime/test/test_lib.c              |   2 +-
 packages/runtime/test/test_map.c              |   2 +-
 packages/runtime/test/test_regex.c            |   2 +-
 26 files changed, 441 insertions(+), 177 deletions(-)

diff --git a/packages/compiler/src/backend/llvm/array-search.ts b/packages/compiler/src/backend/llvm/array-search.ts
index 74d79f7be..d61d91e5c 100644
--- a/packages/compiler/src/backend/llvm/array-search.ts
+++ b/packages/compiler/src/backend/llvm/array-search.ts
@@ -23,6 +23,7 @@
  * is little-endian, which the short-string words assume.
  */
 import type { IrType } from "../../ir/ir.js";
+import { SCR_ARR_FIELD } from "./common.js";
 import { FN_ATTRS } from "./shapes.js";
 
 export type ArraySearchKind = "ptr" | "str";
@@ -72,7 +73,7 @@ export function emitArraySearchHelpers(
       `  %dense = icmp eq ${sz} %f, %len`,
       `  br i1 %dense, label %scan, label %slow`,
       `scan:`,
-      `  %dp = getelementptr inbounds %ScrArr, ptr %a, i32 0, i32 8`,
+      `  %dp = getelementptr inbounds %ScrArr, ptr %a, i32 0, i32 ${SCR_ARR_FIELD.data}`,
       `  %data = load ptr, ptr %dp`,
     );
     if (kind === "ptr") {
diff --git a/packages/compiler/src/backend/llvm/common.ts b/packages/compiler/src/backend/llvm/common.ts
index e6fc56f6f..822ee29e2 100644
--- a/packages/compiler/src/backend/llvm/common.ts
+++ b/packages/compiler/src/backend/llvm/common.ts
@@ -21,9 +21,7 @@ export const SCR_ARR_FIELD = {
   cyc: 4,
   spare: 5,
   filled: 6,
-  ops: 7,
-  data: 8,
-  ext: 9,
+  data: 7,
 } as const;
 
 /** Loads the i32 `len` or `cap` of a %ScrArr at `ptr` into `dest` as a
diff --git a/packages/compiler/src/backend/llvm/emit-module.ts b/packages/compiler/src/backend/llvm/emit-module.ts
index 732a21ee6..17b27fe8d 100644
--- a/packages/compiler/src/backend/llvm/emit-module.ts
+++ b/packages/compiler/src/backend/llvm/emit-module.ts
@@ -439,15 +439,17 @@ export function emitModuleParts(emitter: LlEmitter): string[] {
     `%ScrFfiTable = type { ptr, ${emitter.sizeType}, ${emitter.sizeType}, ptr, i8, ptr, ptr, ${emitter.sizeType}, ${emitter.sizeType}, ${emitter.sizeType}, ptr, ptr }`,
     `%ScrRegex = type { ${emitter.sizeType}, ptr, ptr, ptr, double, ptr, ptr, ptr }`,
     // ScrArr mirrors scr_runtime.h field-for-field: { rc, len (i32), cap
-    // (i32), elem, cyc, spare, filled, ops, data, ext } (field numbers in
+    // (i32), elem, cyc, spare, filled, data } (field numbers in
     // SCR_ARR_FIELD), where the dense states follow the cap value slots at
-    // data, filled bounds the hole-free prefix, ops points at the element type's constant RC descriptor
-    // (%ScrArrOps, SCR_ELEM_REF only) and ext at the out-of-line sparse,
-    // property and metadata storage (NULL until first used). Live dynamic
-    // stream commits swap its dense, presence and out-of-line storage while
+    // data, filled bounds the hole-free prefix, and spare holds the storage
+    // flags and the registry id of the element type's RC descriptor
+    // (%ScrArrOps, SCR_ELEM_REF only; the runtime assigns ids). An array
+    // with out-of-line sparse, property or metadata storage keeps a pointer
+    // to it in the word before its dense allocation. Live dynamic stream
+    // commits swap its dense, presence and out-of-line storage while
     // preserving the target object's identity.
-    `%ScrArr = type { ${emitter.sizeType}, i32, i32, i8, i8, i16, i32, ptr, ptr, ptr }`,
-    `%ScrArrOps = type { ptr, ptr, ptr }`,
+    `%ScrArr = type { ${emitter.sizeType}, i32, i32, i8, i8, i16, i32, ptr }`,
+    `%ScrArrOps = type { ptr, ptr, ptr, i32 }`,
     // The ScrMap prefix { rc, key_kind, val_kind, traced } — the inline
     // RC fast paths test the traced byte (shapes.ts).
     ...(emitter.rcHelpers === null ? [] : [`%ScrMapRc = type { ${emitter.sizeType}, i8, i8, i8 }`]),
@@ -709,7 +711,7 @@ export function emitModuleParts(emitter: LlEmitter): string[] {
       wide ? `ptr ${s}` : `<{ ptr, i32 }> <{ ptr ${s}, i32 0 }>`;
     out.push(
       `@${inst.sym}_data = internal constant <{ [${n} x ${slot}], [${n} x i8] }> <{ [${n} x ${slot}] [ ${inst.slots.map(slotValue).join(", ")} ], [${n} x i8] ${present} }>, align 8`,
-      `@${inst.sym} = internal global %ScrArr { ${emitter.sizeType} -1, i32 ${n}, i32 ${n}, i8 2, i8 0, i16 0, i32 ${n}, ptr null, ptr @${inst.sym}_data, ptr null }`,
+      `@${inst.sym} = internal global %ScrArr { ${emitter.sizeType} -1, i32 ${n}, i32 ${n}, i8 2, i8 0, i16 0, i32 ${n}, ptr @${inst.sym}_data }`,
     );
   }
   if (emitter.templateStringsInstances.size > 0) out.push(``);
diff --git a/packages/compiler/src/backend/llvm/expr-stream-bridges.ts b/packages/compiler/src/backend/llvm/expr-stream-bridges.ts
index 6b51f9afa..ce33aa2cd 100644
--- a/packages/compiler/src/backend/llvm/expr-stream-bridges.ts
+++ b/packages/compiler/src/backend/llvm/expr-stream-bridges.ts
@@ -193,7 +193,10 @@ export function streamTypedRefCommitAdapter(
       { name: "cap", index: SCR_ARR_FIELD.cap, type: "i32" },
       { name: "data", index: SCR_ARR_FIELD.data, type: "ptr" },
       { name: "filled", index: SCR_ARR_FIELD.filled, type: "i32" },
-      { name: "ext", index: SCR_ARR_FIELD.ext, type: "ptr" },
+      // The out-of-line storage's pointer lives before the dense allocation
+      // and moves with data; its flag is in spare, whose element ops id the
+      // two arrays share.
+      { name: "spare", index: SCR_ARR_FIELD.spare, type: "i16" },
     ];
     for (const member of storageMembers) {
       lines.push(
diff --git a/packages/compiler/src/backend/llvm/shapes.ts b/packages/compiler/src/backend/llvm/shapes.ts
index 8844921c5..58295e42b 100644
--- a/packages/compiler/src/backend/llvm/shapes.ts
+++ b/packages/compiler/src/backend/llvm/shapes.ts
@@ -1074,15 +1074,16 @@ export function arrNewCall(
   return `call ptr @scr_arr_new_ops(ptr ${arrOps(host, elem)}, ${host.sizeType} ${capText})`;
 }
 
-/** The constant %ScrArrOps descriptor (retain, release, trace) of a REF
- * element type, defined once per module and shared by all its arrays. */
+/** The %ScrArrOps descriptor (retain, release, trace, registry id) of a REF
+ * element type, defined once per module and shared by all its arrays. It is
+ * writable: the runtime stores its registry id on the first array. */
 export function arrOps(host: ShapeHost, elem: IrType): string {
   const v = vAdapters(host, elem);
   const trace = traceArg(host, elem);
   const part = (sym: string): string => sym.replace(/^@/, "").replace(/[^A-Za-z0-9_.]/g, "_");
   const name = `@sc_arrops.${part(v.retain)}.${part(v.release)}.${part(trace)}`;
   host.declare(
-    `${name} = internal constant %ScrArrOps { ptr ${v.retain}, ptr ${v.release}, ptr ${trace} }`,
+    `${name} = internal global %ScrArrOps { ptr ${v.retain}, ptr ${v.release}, ptr ${trace}, i32 0 }`,
   );
   return name;
 }
diff --git a/packages/runtime/src/scr_array.c b/packages/runtime/src/scr_array.c
index 4887f23ff..51853afce 100644
--- a/packages/runtime/src/scr_array.c
+++ b/packages/runtime/src/scr_array.c
@@ -42,14 +42,100 @@ static void scr_arr_oom(void) {
 static const ScrArrExt scr_arr_no_ext;
 
 SCR_TL bool (*scr_arr_match_copy)(ScrArr *a, ScrDyn *target) = NULL;
-#define SCR_AX(a) ((const ScrArrExt *)((a)->ext ? (a)->ext : &scr_arr_no_ext))
+static inline const ScrArrExt *scr_arr_ax(const ScrArr *a) {
+  const ScrArrExt *x = scr_arr_ext_of(a);
+  return x ? x : &scr_arr_no_ext;
+}
+#define SCR_AX(a) scr_arr_ax(a)
+
+static void scr_arr_move_inline(ScrArr *a, size_t cap, size_t unit);
+
+/* Bytes before the dense slots' allocation start: the ext pointer's word. */
+static size_t scr_arr_prefix(const ScrArr *a) {
+  return (a->spare & SCR_ARR_HAS_EXT) ? SCR_ARR_EXT_PREFIX : 0;
+}
+
+/* The start of the block the dense storage was allocated as. */
+static void *scr_arr_alloc_start(const ScrArr *a) {
+  return (char *)scr_arr_block(a) - scr_arr_prefix(a);
+}
+
+/* Bytes per dense slot with its state: an 8-byte value, or a boolean byte. */
+static size_t scr_arr_slot_unit(const ScrArr *a) {
+  return a->elem == SCR_ELEM_BOOL ? 2 * sizeof(uint8_t) : sizeof(uint64_t) + sizeof(uint8_t);
+}
+
+/* Bytes of dense storage (head room included) after the prefix. */
+static size_t scr_arr_storage_bytes(const ScrArr *a) {
+  return ((size_t)(a->data - scr_arr_block(a)) + a->cap) * scr_arr_slot_unit(a);
+}
 
 ScrArrExt *scr_arr_ext(ScrArr *a) {
-  if (!a->ext) {
-    a->ext = scr_mem_calloc(sizeof(ScrArrExt));
-    if (!a->ext) scr_arr_oom();
+  ScrArrExt *x = scr_arr_ext_of(a);
+  if (x) return x;
+  x = scr_mem_calloc(sizeof(ScrArrExt));
+  if (!x) scr_arr_oom();
+  /* The pointer goes in the word before the dense allocation, which an
+   * array with ext always has: inline slots move out, and an array without
+   * storage gets an allocation of the word alone. */
+  if (a->spare & SCR_ARR_INLINE_SLOTS) scr_arr_move_inline(a, a->cap, scr_arr_slot_unit(a));
+  char *start;
+  if (!a->data) {
+    start = scr_mem_alloc(SCR_ARR_EXT_PREFIX);
+    if (!start) scr_arr_oom();
+    a->data = (uint64_t *)(start + SCR_ARR_EXT_PREFIX);
+    a->cap = 0;
+  } else {
+    size_t bytes = scr_arr_storage_bytes(a);
+    size_t head = (size_t)(a->data - scr_arr_block(a));
+    if (a->rc == SIZE_MAX) {
+      /* An immortal array's storage may be static: copy it, never move it. */
+      start = scr_mem_alloc(bytes + SCR_ARR_EXT_PREFIX);
+      if (!start) scr_arr_oom();
+      memcpy(start + SCR_ARR_EXT_PREFIX, scr_arr_block(a), bytes);
+    } else {
+      start = scr_mem_realloc(scr_arr_block(a), bytes + SCR_ARR_EXT_PREFIX);
+      if (!start) scr_arr_oom();
+      memmove(start + SCR_ARR_EXT_PREFIX, start, bytes);
+    }
+    a->data = (uint64_t *)(start + SCR_ARR_EXT_PREFIX) + head;
   }
-  return a->ext;
+  memcpy(start, &x, sizeof x);
+  a->spare |= SCR_ARR_HAS_EXT;
+  return x;
+}
+
+/* Registry of element ops by id (scr_arr_ops); slot 0 is no ops. */
+const ScrArrOps *scr_arr_ops_table[SCR_ARR_OPS_OVERFLOW] = {0};
+static uint32_t scr_arr_ops_count = 1;
+
+/* Assign `ops` its id on its first array; any thread may get there first,
+ * and every thread then sees the same id. A lost race leaves one table
+ * slot unused. Once the table is full, later descriptors get
+ * SCR_ARR_OPS_OVERFLOW. */
+uint32_t scr_arr_ops_register(ScrArrOps *ops) {
+  uint32_t id = __atomic_load_n(&ops->id, __ATOMIC_ACQUIRE);
+  if (id) return id;
+  uint32_t fresh = __atomic_fetch_add(&scr_arr_ops_count, 1, __ATOMIC_RELAXED);
+  if (fresh < SCR_ARR_OPS_OVERFLOW) {
+    __atomic_store_n(&scr_arr_ops_table[fresh], ops, __ATOMIC_RELEASE);
+  } else {
+    fresh = SCR_ARR_OPS_OVERFLOW;
+  }
+  uint32_t expected = 0;
+  if (__atomic_compare_exchange_n(&ops->id, &expected, fresh, false, __ATOMIC_ACQ_REL,
+                                  __ATOMIC_ACQUIRE))
+    return fresh;
+  return expected;
+}
+
+const ScrArrOps *scr_arr_ops_overflow(const ScrArr *a) { return scr_arr_ext_of(a)->ops; }
+
+/* Record `ops` as the element ops of `a` (NULL for none). */
+static void scr_arr_set_ops(ScrArr *a, const ScrArrOps *ops) {
+  uint32_t id = scr_arr_ops_id(ops);
+  a->spare = (uint16_t)((a->spare & ((1u << SCR_ARR_OPS_SHIFT) - 1)) | (id << SCR_ARR_OPS_SHIFT));
+  if (id == SCR_ARR_OPS_OVERFLOW) scr_arr_ext(a)->ops = ops;
 }
 
 /* Canonical array indices grow indexed storage and may leave holes. Negative,
@@ -133,24 +219,36 @@ static bool scr_elem_is_ref(ScrElemKind k) {
          k == SCR_ELEM_REF;
 }
 
-static void scr_elem_release(const ScrArr *a, uint64_t slot) {
+/* Releases an element slot of kind `elem`, with element ops `ops` for
+ * SCR_ELEM_REF. An array's kind and ops never change, so loops look them up
+ * once (element releases may run teardown, which reloads anything read
+ * through the array). */
+static inline void scr_elem_release_with(uint8_t elem, const ScrArrOps *ops, uint64_t slot) {
   void *p = scr_slot_to_ptr(slot);
   if (!p) return;
-  if (a->elem == SCR_ELEM_STR) scr_str_release((ScrStr *)p);
-  else if (a->elem == SCR_ELEM_ARR) scr_arr_release((ScrArr *)p);
-  else if (a->elem == SCR_ELEM_BYTES) scr_bytes_release((ScrBytes *)p);
-  else if (a->elem == SCR_ELEM_REF) a->ops->release(p);
+  if (elem == SCR_ELEM_STR) scr_str_release((ScrStr *)p);
+  else if (elem == SCR_ELEM_ARR) scr_arr_release((ScrArr *)p);
+  else if (elem == SCR_ELEM_BYTES) scr_bytes_release((ScrBytes *)p);
+  else if (elem == SCR_ELEM_REF) ops->release(p);
+}
+
+static inline uint64_t scr_elem_retain_with(uint8_t elem, const ScrArrOps *ops, uint64_t slot) {
+  if (!scr_elem_is_ref(elem)) return slot;
+  void *p = scr_slot_to_ptr(slot);
+  if (!p) return slot;
+  if (elem == SCR_ELEM_STR) p = scr_str_retain((ScrStr *)p);
+  else if (elem == SCR_ELEM_ARR) p = scr_arr_retain((ScrArr *)p);
+  else if (elem == SCR_ELEM_BYTES) p = scr_bytes_retain((ScrBytes *)p);
+  else p = ops->retain(p);
+  return scr_slot_from_ptr(p);
+}
+
+static void scr_elem_release(const ScrArr *a, uint64_t slot) {
+  scr_elem_release_with(a->elem, scr_arr_ops(a), slot);
 }
 
 static uint64_t scr_elem_retain_slot(const ScrArr *a, uint64_t slot) {
-  if (!scr_elem_is_ref(a->elem)) return slot;
-  void *p = scr_slot_to_ptr(slot);
-  if (!p) return slot;
-  if (a->elem == SCR_ELEM_STR) p = scr_str_retain((ScrStr *)p);
-  else if (a->elem == SCR_ELEM_ARR) p = scr_arr_retain((ScrArr *)p);
-  else if (a->elem == SCR_ELEM_BYTES) p = scr_bytes_retain((ScrBytes *)p);
-  else p = a->ops->retain(p);
-  return scr_slot_from_ptr(p);
+  return scr_elem_retain_with(a->elem, scr_arr_ops(a), slot);
 }
 
 static uint64_t scr_arr_retain_state_slot(const ScrArr *a, uint64_t slot,
@@ -310,7 +408,6 @@ static void scr_arr_sparse_drop_prefix(ScrArr *a, size_t count) {
  * `spare` records it. Growth past the inline capacity moves the slots to an
  * ordinary allocation; the inline room then stays unused until the array is
  * freed. */
-#define SCR_ARR_INLINE_SLOTS 1u
 /* Where inline slots start in the array's block (8-byte aligned on every
  * target). */
 #define SCR_ARR_INLINE_OFFSET ((sizeof(ScrArr) + 7) & ~(size_t)7)
@@ -329,11 +426,10 @@ static bool scr_arr_inline(const ScrArr *a) { return (a->spare & SCR_ARR_INLINE_
  * slot just before `data` holds its size (scr_arr_head). Every reader
  * indexes from `data` and `cap` as before (emitted code included); only the
  * code that frees, reallocates or swaps the allocation needs its start.
- * Static and inline storage never has head room. */
-#define SCR_ARR_HEAD_ROOM 2u
-/* An unshift had to move every element: the next one that would have to
- * move them again opens head room instead (scr_arr_open_head). */
-#define SCR_ARR_UNSHIFTED 4u
+ * Static and inline storage never has head room. SCR_ARR_UNSHIFTED in
+ * `spare` records that an unshift had to move every element, so the next
+ * one that would have to move them again opens head room instead
+ * (scr_arr_open_head). */
 /* Arrays shorter than this keep moving their elements on unshift. */
 #define SCR_ARR_HEAD_MIN ((size_t)16)
 
@@ -351,8 +447,6 @@ static void scr_arr_set_head(ScrArr *a, size_t head) {
   a->spare |= SCR_ARR_HEAD_ROOM;
 }
 
-/* The start of the dense allocation. */
-static void *scr_arr_block(const ScrArr *a) { return a->data - scr_arr_head(a); }
 
 /* Give the head room of an array back to its capacity: the populated dense
  * prefix and its states move to the start of the allocation. */
@@ -404,8 +498,8 @@ static bool scr_arr_drop_front(ScrArr *a, size_t count) {
 }
 
 /* Slots requested by the small constructions. The small allocator rounds
- * them up to fill its block: 3 eight-byte slots after a plain header in an
- * 80-byte block (88 after a collector header), or 8 booleans in a 64-byte
+ * them up to fill its block: 3 eight-byte slots after a plain header in a
+ * 64-byte block (72 after a collector header), or 4 booleans in a 40-byte
  * block. Most small arrays hold up to three elements; two slots make
  * arrays that grow past them move their storage often enough to slow
  * programs that build many short lists. */
@@ -497,8 +591,8 @@ static void scr_arr_grow_dense_slow(ScrArr *a, size_t need, ScrArrGrow mode);
  * paths pick the same capacity. */
 static inline void scr_arr_grow_dense_to(ScrArr *a, size_t need, ScrArrGrow mode) {
   if (need <= a->cap) return;
-  if (a->elem == SCR_ELEM_BOOL || (a->spare & (SCR_ARR_INLINE_SLOTS | SCR_ARR_HEAD_ROOM)) ||
-      (a->ext && a->ext->sparse_len) || need > SCR_ARR_DENSE_LIMIT) {
+  if (a->elem == SCR_ELEM_BOOL || (a->spare & (SCR_ARR_INLINE_SLOTS | SCR_ARR_HEAD_ROOM | SCR_ARR_HAS_EXT)) ||
+      need > SCR_ARR_DENSE_LIMIT) {
     scr_arr_grow_dense_slow(a, need, mode);
     return;
   }
@@ -524,6 +618,7 @@ static inline void scr_arr_grow_dense_to(ScrArr *a, size_t need, ScrArrGrow mode
 
 /* Sparse entries below a raised capacity move into the packed slots. */
 static void scr_arr_absorb_sparse(ScrArr *a) {
+  if (!(a->spare & SCR_ARR_HAS_EXT)) return;
   size_t moved = scr_arr_sparse_lower_bound(SCR_AX(a)->sparse, SCR_AX(a)->sparse_len, a->cap);
   for (size_t i = 0; i < moved; i++) {
     scr_arr_dense_put(a, SCR_AX(a)->sparse[i].index, SCR_AX(a)->sparse[i].slot);
@@ -585,8 +680,10 @@ static void scr_arr_grow_dense_slow(ScrArr *a, size_t need, ScrArrGrow mode) {
   /* Values and states share one allocation. Move the old states to its new
    * end before publishing the larger capacity: their previous location is
    * now part of the value area. */
-  uint64_t *data = scr_mem_realloc(a->data, cap * unit);
-  if (!data) scr_arr_oom();
+  size_t prefix = scr_arr_prefix(a);
+  char *start = scr_mem_realloc((char *)a->data - prefix, prefix + cap * unit);
+  if (!start) scr_arr_oom();
+  uint64_t *data = (uint64_t *)(start + prefix);
   uint8_t *end = (uint8_t *)data + cap * (width + 1);
   if (a->cap) memmove(end - a->cap, (uint8_t *)data + a->cap * width, a->cap);
   memset(end - cap, SCR_ARR_HOLE, cap - a->cap);
@@ -621,8 +718,12 @@ static bool scr_arr_open_head(ScrArr *a, size_t count) {
     size_t room = count + (len + count) / 2;
     if (room > SCR_ARR_MAX_LENGTH || a->cap > SIZE_MAX / SCR_ARR_SLOT_BYTES - room) return false;
     size_t total = room + a->cap;
-    uint64_t *block = scr_mem_alloc(total * SCR_ARR_SLOT_BYTES);
-    if (!block) scr_arr_oom();
+    size_t prefix = scr_arr_prefix(a);
+    char *start = scr_mem_alloc(prefix + total * SCR_ARR_SLOT_BYTES);
+    if (!start) scr_arr_oom();
+    /* The ext pointer's word moves with the allocation. */
+    if (prefix) memcpy(start, scr_arr_alloc_start(a), prefix);
+    uint64_t *block = (uint64_t *)(start + prefix);
     /* The window's states end `room` bytes before the allocation does; the
      * room's states past it are holes. */
     uint8_t *end = (uint8_t *)(block + total) + a->cap;
@@ -630,7 +731,7 @@ static bool scr_arr_open_head(ScrArr *a, size_t count) {
     memset(end, SCR_ARR_HOLE, room);
     memcpy(end - len, scr_arr_state_run(a, 0, len), len);
     memset(end - a->cap, SCR_ARR_HOLE, a->cap - len);
-    scr_mem_free(scr_arr_block(a));
+    scr_mem_free(scr_arr_alloc_start(a));
     a->data = block + room;
     head = room;
   }
@@ -700,21 +801,40 @@ static uint8_t scr_arr_state_at_storage(const ScrArrStorage *s, size_t index,
   return s->sparse[pos].state;
 }
 
-static bool scr_arr_slot_at_storage(const ScrArrStorage *s, size_t index,
-                                    uint64_t *out) {
-  return scr_arr_state_at_storage(s, index, out) != SCR_ARR_HOLE;
+/* A state and its slot (zero for a hole). */
+typedef struct {
+  uint64_t slot;
+  uint8_t state;
+} ScrArrStateSlot;
+
+/* scr_arr_state_at past the dense capacity: the sorted sparse entries. It
+ * only reads memory, so callers keep the array's fields in registers across
+ * it. */
+static __attribute__((noinline, pure)) ScrArrStateSlot scr_arr_sparse_state_at(const ScrArr *a,
+                                                                                size_t index) {
+  const ScrArrExt *x = SCR_AX(a);
+  size_t pos = scr_arr_sparse_lower_bound(x->sparse, x->sparse_len, index);
+  if (pos == x->sparse_len || x->sparse[pos].index != index) return (ScrArrStateSlot){0, SCR_ARR_HOLE};
+  return (ScrArrStateSlot){x->sparse[pos].slot, x->sparse[pos].state};
 }
 
-static bool scr_arr_slot_at(const ScrArr *a, size_t index, uint64_t *out) {
-  ScrArrStorage s = {a->data, scr_arr_states_end(a), a->cap, SCR_AX(a)->sparse,
-                     SCR_AX(a)->sparse_len, SCR_AX(a)->sparse_cap, a->elem, NULL};
-  return scr_arr_slot_at_storage(&s, index, out);
+/* The state at `index` and, unless it is a hole, its slot in `out`: the
+ * dense storage below `cap` (without touching the out-of-line storage), the
+ * sparse entries above it. */
+static inline uint8_t scr_arr_state_at(const ScrArr *a, size_t index, uint64_t *out) {
+  if (index < a->cap) {
+    uint8_t state = *scr_arr_state_in(scr_arr_states_end(a), index);
+    if (state == SCR_ARR_HOLE) return SCR_ARR_HOLE;
+    if (out) *out = scr_arr_dense_get(a, index);
+    return state;
+  }
+  ScrArrStateSlot sparse = scr_arr_sparse_state_at(a, index);
+  if (sparse.state != SCR_ARR_HOLE && out) *out = sparse.slot;
+  return sparse.state;
 }
 
-static uint8_t scr_arr_state_at(const ScrArr *a, size_t index, uint64_t *out) {
-  ScrArrStorage s = {a->data, scr_arr_states_end(a), a->cap, SCR_AX(a)->sparse,
-                     SCR_AX(a)->sparse_len, SCR_AX(a)->sparse_cap, a->elem, NULL};
-  return scr_arr_state_at_storage(&s, index, out);
+static inline bool scr_arr_slot_at(const ScrArr *a, size_t index, uint64_t *out) {
+  return scr_arr_state_at(a, index, out) != SCR_ARR_HOLE;
 }
 
 /* Store an owned slot into an empty index. The caller has already established
@@ -843,7 +963,7 @@ static void scr_arr_prop_set(ScrArr *a, double key, uint64_t slot) {
   char *copy = malloc(len + 1);
   if (!copy) scr_arr_oom();
   memcpy(copy, text, len + 1);
-  a->ext->props[a->ext->prop_len++] = (ScrArrProp){copy, len, slot, SCR_ARR_VALUE};
+  scr_arr_ext_of(a)->props[scr_arr_ext_of(a)->prop_len++] = (ScrArrProp){copy, len, slot, SCR_ARR_VALUE};
 }
 
 static void scr_arr_prop_set_undefined(ScrArr *a, double key) {
@@ -864,7 +984,7 @@ static void scr_arr_prop_set_undefined(ScrArr *a, double key) {
   char *copy = malloc(len + 1);
   if (!copy) scr_arr_oom();
   memcpy(copy, text, len + 1);
-  a->ext->props[a->ext->prop_len++] = (ScrArrProp){copy, len, 0, SCR_ARR_UNDEFINED};
+  scr_arr_ext_of(a)->props[scr_arr_ext_of(a)->prop_len++] = (ScrArrProp){copy, len, 0, SCR_ARR_UNDEFINED};
 }
 
 static bool scr_arr_prop_delete(ScrArr *a, double key) {
@@ -877,7 +997,7 @@ static bool scr_arr_prop_delete(ScrArr *a, double key) {
   free(SCR_AX(a)->props[pos].key);
   memmove(SCR_AX(a)->props + pos, SCR_AX(a)->props + pos + 1,
           (SCR_AX(a)->prop_len - pos - 1) * sizeof(*SCR_AX(a)->props));
-  a->ext->prop_len--;
+  scr_arr_ext_of(a)->prop_len--;
   if (old_state == SCR_ARR_VALUE && scr_elem_is_ref(a->elem)) {
     scr_elem_release(a, old);
   }
@@ -885,17 +1005,25 @@ static bool scr_arr_prop_delete(ScrArr *a, double key) {
 }
 
 static ScrArrStorage scr_arr_take_storage(ScrArr *a) {
+  ScrArrExt *x = scr_arr_ext_of(a);
   ScrArrStorage old = {a->data, scr_arr_states_end(a), a->cap, SCR_AX(a)->sparse,
                        SCR_AX(a)->sparse_len, SCR_AX(a)->sparse_cap, a->elem,
-                       scr_arr_inline(a) ? NULL : scr_arr_block(a)};
-  a->spare &= (uint16_t)~(SCR_ARR_INLINE_SLOTS | SCR_ARR_HEAD_ROOM);
+                       scr_arr_inline(a) ? NULL : scr_arr_alloc_start(a)};
+  a->spare &= (uint16_t)~(SCR_ARR_INLINE_SLOTS | SCR_ARR_HEAD_ROOM | SCR_ARR_HAS_EXT);
   a->data = NULL;
   a->cap = 0;
   a->filled = 0;
-  if (a->ext) {
-    a->ext->sparse = NULL;
-    a->ext->sparse_len = 0;
-    a->ext->sparse_cap = 0;
+  if (x) {
+    /* The ext pointer's word left with the old allocation: the array keeps
+     * its ext in an allocation of the word alone. */
+    char *start = scr_mem_alloc(SCR_ARR_EXT_PREFIX);
+    if (!start) scr_arr_oom();
+    memcpy(start, &x, sizeof x);
+    a->data = (uint64_t *)(start + SCR_ARR_EXT_PREFIX);
+    a->spare |= SCR_ARR_HAS_EXT;
+    x->sparse = NULL;
+    x->sparse_len = 0;
+    x->sparse_cap = 0;
   }
   return old;
 }
@@ -910,7 +1038,7 @@ static void scr_arr_free_storage(ScrArrStorage *s) {
  * operations move ownership with the slots and move the states alongside
  * them; they never inspect an uninitialized hole payload. */
 static bool scr_arr_is_dense(const ScrArr *a) {
-  return a->len <= a->cap && SCR_AX(a)->sparse_len == 0;
+  return a->len <= a->cap && (!(a->spare & SCR_ARR_HAS_EXT) || scr_arr_ext_of(a)->sparse_len == 0);
 }
 
 static void scr_arr_move_dense(ScrArr *a, size_t to, size_t from, size_t count) {
@@ -1025,9 +1153,11 @@ static void scr_arr_copy_dense(ScrArr *dst, size_t to, const ScrArr *src,
   }
   bool refs = scr_elem_is_ref(src->elem);
   if (!refs && !materialize_holes) return;
+  uint8_t elem = src->elem;
+  const ScrArrOps *ops = scr_arr_ops(src);
   for (size_t i = to; i < to + count; i++) {
     if (*scr_arr_state_in(dst_states, i) == SCR_ARR_VALUE) {
-      if (refs) dst->data[i] = scr_elem_retain_slot(src, dst->data[i]);
+      if (refs) dst->data[i] = scr_elem_retain_with(elem, ops, dst->data[i]);
     } else if (materialize_holes && *scr_arr_state_in(dst_states, i) == SCR_ARR_HOLE) {
       scr_arr_dense_put(dst, i, 0);
       *scr_arr_state_in(dst_states, i) = SCR_ARR_UNDEFINED;
@@ -1060,9 +1190,7 @@ static inline __attribute__((always_inline)) ScrArr *scr_arr_make(ScrElemKind el
   a->cyc = 0;
   a->spare = 0;
   a->filled = 0;
-  a->ops = NULL;
   a->data = NULL;
-  a->ext = NULL;
   if (inline_cap) scr_arr_use_inline(a, inline_cap);
   else if (initial_cap > 0) scr_arr_grow_dense_to(a, initial_cap, SCR_ARR_GROW_EXACT);
 #ifdef SCR_RC_AUDIT
@@ -1094,9 +1222,7 @@ ScrArr *scr_arr_new_inline(ScrElemKind elem, size_t cap) {
   a->cyc = 0;
   a->spare = 0;
   a->filled = 0;
-  a->ops = NULL;
   a->data = NULL;
-  a->ext = NULL;
   scr_arr_use_inline(a, cap);
 #ifdef SCR_RC_AUDIT
   scr_live_arrays++;
@@ -1159,20 +1285,25 @@ void scr_arr_trace_v(void *a0, ScrTraceVisit visit, void *ctx) {
 }
 
 /* Frees the out-of-line storage; callers check for it first, since most
- * arrays have none. */
+ * arrays have none. The word that pointed at it stays in the dense
+ * allocation until that is freed. */
 static void scr_arr_ext_free(ScrArr *a) {
-  ScrArrExt *x = a->ext;
+  ScrArrExt *x = scr_arr_ext_of(a);
   scr_arr_sparse_free(x->sparse);
   for (size_t i = 0; i < x->prop_len; i++) free(x->props[i].key);
   free(x->props);
   scr_mem_free(x);
-  a->ext = NULL;
+}
+
+/* Frees the dense allocation and the out-of-line storage of a dying array. */
+static inline __attribute__((always_inline)) void scr_arr_free_parts(ScrArr *a) {
+  if (a->spare & SCR_ARR_HAS_EXT) scr_arr_ext_free(a);
+  if (!scr_arr_inline(a)) scr_mem_free(scr_arr_alloc_start(a));
 }
 
 static void scr_arr_gc_free(void *a0) {
   ScrArr *a = (ScrArr *)a0;
-  if (!scr_arr_inline(a)) scr_mem_free(scr_arr_block(a));
-  if (a->ext) scr_arr_ext_free(a);
+  scr_arr_free_parts(a);
 #ifdef SCR_RC_AUDIT
   scr_live_arrays--;
 #endif
@@ -1199,9 +1330,8 @@ static ScrArr *scr_arr_make_ops(const ScrArrOps *ops, size_t initial_cap, bool s
   a->cyc = cyc;
   a->spare = 0;
   a->filled = 0;
-  a->ops = ops;
   a->data = NULL;
-  a->ext = NULL;
+  scr_arr_set_ops(a, ops);
   if (inline_cap) scr_arr_use_inline(a, inline_cap);
   else if (initial_cap > 0) scr_arr_grow_dense_to(a, initial_cap, SCR_ARR_GROW_EXACT);
 #ifdef SCR_RC_AUDIT
@@ -1218,9 +1348,9 @@ ScrArr *scr_arr_new_ops_small(const ScrArrOps *ops) { return scr_arr_make_ops(op
 
 static void scr_arr_destroy(void *object) {
   ScrArr *a = object;
-  if (a->ext) {
-    scr_dyn_release(a->ext->metadata);
-    a->ext->metadata = NULL;
+  if (scr_arr_ext_of(a)) {
+    scr_dyn_release(scr_arr_ext_of(a)->metadata);
+    scr_arr_ext_of(a)->metadata = NULL;
   }
   if (scr_elem_is_ref(a->elem)) {
     size_t end = a->len < a->cap ? a->len : a->cap;
@@ -1243,30 +1373,32 @@ static void scr_arr_destroy(void *object) {
       }
     } else {
       uint8_t *states = scr_arr_states_end(a);
+      uint8_t elem = a->elem;
+      const ScrArrOps *ops = scr_arr_ops(a);
       for (size_t i = 0; i < end; i++) {
         if (*scr_arr_state_in(states, i) != SCR_ARR_HOLE) {
           uint64_t old = a->data[i];
           uint8_t state = *scr_arr_state_in(states, i);
           *scr_arr_state_in(states, i) = 0;
           a->data[i] = 0;
-          if (state == SCR_ARR_VALUE) scr_elem_release(a, old);
+          if (state == SCR_ARR_VALUE) scr_elem_release_with(elem, ops, old);
         }
       }
     }
-    if (a->ext) {
-      while (a->ext->sparse_len > 0) {
-        size_t i = a->ext->sparse_len - 1;
-        uint64_t old = a->ext->sparse[i].slot;
-        uint8_t state = a->ext->sparse[i].state;
-        a->ext->sparse_len = i;
+    if (scr_arr_ext_of(a)) {
+      while (scr_arr_ext_of(a)->sparse_len > 0) {
+        size_t i = scr_arr_ext_of(a)->sparse_len - 1;
+        uint64_t old = scr_arr_ext_of(a)->sparse[i].slot;
+        uint8_t state = scr_arr_ext_of(a)->sparse[i].state;
+        scr_arr_ext_of(a)->sparse_len = i;
         if (state == SCR_ARR_VALUE) scr_elem_release(a, old);
       }
-      while (a->ext->prop_len > 0) {
-        size_t i = a->ext->prop_len - 1;
-        uint64_t old = a->ext->props[i].slot;
-        uint8_t state = a->ext->props[i].state;
-        free(a->ext->props[i].key);
-        a->ext->prop_len = i;
+      while (scr_arr_ext_of(a)->prop_len > 0) {
+        size_t i = scr_arr_ext_of(a)->prop_len - 1;
+        uint64_t old = scr_arr_ext_of(a)->props[i].slot;
+        uint8_t state = scr_arr_ext_of(a)->props[i].state;
+        free(scr_arr_ext_of(a)->props[i].key);
+        scr_arr_ext_of(a)->prop_len = i;
         if (state == SCR_ARR_VALUE) scr_elem_release(a, old);
       }
     }
@@ -1274,8 +1406,7 @@ static void scr_arr_destroy(void *object) {
   if (a->cyc) {
     scr_arr_gc_free(a);
   } else {
-    if (!scr_arr_inline(a)) scr_mem_free(scr_arr_block(a));
-    if (a->ext) scr_arr_ext_free(a);
+    scr_arr_free_parts(a);
 #ifdef SCR_RC_AUDIT
     scr_live_arrays--;
 #endif
@@ -1303,7 +1434,10 @@ bool scr_arr_has(const ScrArr *a, double i) {
   return scr_arr_slot_at(a, idx, NULL);
 }
 
-double scr_arr_state(const ScrArr *a, double i) {
+/* Emitted element reads call this on their cold path. It stays out of line
+ * so that, under link-time optimization, those reads stay small enough to
+ * inline where they are used. */
+__attribute__((noinline)) double scr_arr_state(const ScrArr *a, double i) {
   size_t idx;
   if (!scr_arr_valid_index(i, &idx)) {
     uint8_t state;
@@ -1359,13 +1493,13 @@ void scr_arr_set_len(ScrArr *a, double length) {
           if (state == SCR_ARR_VALUE) scr_elem_release(a, old);
         }
       }
-      if (a->ext) {
-        size_t keep = scr_arr_sparse_lower_bound(a->ext->sparse, a->ext->sparse_len, next);
-        while (a->ext->sparse_len > keep) {
-          size_t i = a->ext->sparse_len - 1;
-          uint64_t old = a->ext->sparse[i].slot;
-          uint8_t state = a->ext->sparse[i].state;
-          a->ext->sparse_len = i;
+      if (scr_arr_ext_of(a)) {
+        size_t keep = scr_arr_sparse_lower_bound(scr_arr_ext_of(a)->sparse, scr_arr_ext_of(a)->sparse_len, next);
+        while (scr_arr_ext_of(a)->sparse_len > keep) {
+          size_t i = scr_arr_ext_of(a)->sparse_len - 1;
+          uint64_t old = scr_arr_ext_of(a)->sparse[i].slot;
+          uint8_t state = scr_arr_ext_of(a)->sparse[i].state;
+          scr_arr_ext_of(a)->sparse_len = i;
           if (state == SCR_ARR_VALUE) scr_elem_release(a, old);
         }
       }
@@ -1375,7 +1509,7 @@ void scr_arr_set_len(ScrArr *a, double length) {
         memset(scr_arr_dense_at(a, dense_stop), 0,
                (dense_end - dense_stop) * scr_arr_slot_width(a));
       }
-      if (a->ext) a->ext->sparse_len = scr_arr_sparse_lower_bound(a->ext->sparse, a->ext->sparse_len, next);
+      if (scr_arr_ext_of(a)) scr_arr_ext_of(a)->sparse_len = scr_arr_sparse_lower_bound(scr_arr_ext_of(a)->sparse, scr_arr_ext_of(a)->sparse_len, next);
     }
   }
   a->len = next;
@@ -1709,7 +1843,7 @@ void *scr_arr_get_ref(ScrArr *a, double i) {
   if (!p) return NULL;
   if (a->elem == SCR_ELEM_STR) scr_str_retain((ScrStr *)p);
   else if (a->elem == SCR_ELEM_BYTES) scr_bytes_retain((ScrBytes *)p);
-  else if (a->elem == SCR_ELEM_REF) p = a->ops->retain(p);
+  else if (a->elem == SCR_ELEM_REF) p = scr_arr_ops(a)->retain(p);
   else scr_arr_retain((ScrArr *)p);
   return p;
 }
@@ -2193,7 +2327,7 @@ ScrArr *scr_arr_splice(ScrArr *a, double start, double deleteCount) {
   size_t hint = scr_arr_is_dense(a) || n <= SCR_ARR_DENSE_LIMIT ? n : SCR_ARR_DENSE_LIMIT;
   ScrArr *out =
       a->elem == SCR_ELEM_REF
-          ? scr_arr_new_ops(a->ops, hint ? hint : 1)
+          ? scr_arr_new_ops(scr_arr_ops(a), hint ? hint : 1)
           : scr_arr_new(a->elem, hint ? hint : 1);
   out->len = n;
   size_t old_len = a->len;
@@ -2273,7 +2407,7 @@ ScrArr *scr_arr_splice_insert(ScrArr *a, double start, double deleteCount,
     ScrArr *snapshot = items == a ? scr_arr_slice(a, 0, INFINITY) : NULL;
     if (snapshot) items = snapshot;
     ScrArr *removed = a->elem == SCR_ELEM_REF
-        ? scr_arr_new_ops(a->ops, n)
+        ? scr_arr_new_ops(scr_arr_ops(a), n)
         : scr_arr_new(a->elem, n);
     if (n) {
       memcpy(removed->data, scr_arr_dense_at(a, from), n * scr_arr_slot_width(a));
@@ -2319,7 +2453,7 @@ void scr_arr_splice_drop(ScrArr *a, double start, double deleteCount, size_t cou
   bool refs = scr_elem_is_ref(a->elem);
   if (!scr_arr_is_dense(a) || !scr_arr_dense_ok(a, next_len, count)) {
     ScrArr *items = a->elem == SCR_ELEM_REF
-        ? scr_arr_new_ops(a->ops, count)
+        ? scr_arr_new_ops(scr_arr_ops(a), count)
         : scr_arr_new(a->elem, count);
     scr_arr_push_many(items, count, slots);
     scr_arr_release(scr_arr_splice_insert(a, start, deleteCount, items));
@@ -2400,10 +2534,10 @@ ScrArr *scr_arr_flat_copy(const ScrArr *a, ScrArr *out, bool flatten) {
 static bool scr_arr_ref_eq(const ScrArr *a, uint64_t slot, void *v) {
   void *p = scr_slot_to_ptr(slot);
   if (a->elem == SCR_ELEM_STR) return scr_str_eq((ScrStr *)p, (ScrStr *)v);
-  if (a->elem == SCR_ELEM_REF && a->ops->retain == scr_dyn_retain_v) {
+  if (a->elem == SCR_ELEM_REF && scr_arr_ops(a)->retain == scr_dyn_retain_v) {
     return scr_dyn_strict_eq((ScrDyn *)p, (ScrDyn *)v);
   }
-  if (a->elem == SCR_ELEM_REF && a->ops->retain == scr_closure_retain_v)
+  if (a->elem == SCR_ELEM_REF && scr_arr_ops(a)->retain == scr_closure_retain_v)
     return scr_closure_identity_equal((ScrClosure *)p, (ScrClosure *)v);
   return p == v;
 }
@@ -2461,7 +2595,7 @@ bool scr_arr_includes_bool(ScrArr *a, bool v) {
 }
 
 bool scr_arr_includes_ref(ScrArr *a, void *v) {
-  if (a->elem == SCR_ELEM_REF && a->ops->retain == scr_dyn_retain_v) {
+  if (a->elem == SCR_ELEM_REF && scr_arr_ops(a)->retain == scr_dyn_retain_v) {
     const ScrDyn *needle = (const ScrDyn *)v;
     if (needle->kind == SCR_DYN_NUM && needle->v.num != needle->v.num) {
       const uint8_t *states = scr_arr_states_end(a);
@@ -2525,7 +2659,7 @@ ScrArr *scr_arr_slice(ScrArr *a, double start, double end) {
   size_t hint = to <= a->cap || n <= SCR_ARR_DENSE_LIMIT ? n : SCR_ARR_DENSE_LIMIT;
   ScrArr *out =
       a->elem == SCR_ELEM_REF
-          ? scr_arr_new_ops(a->ops, hint ? hint : 1)
+          ? scr_arr_new_ops(scr_arr_ops(a), hint ? hint : 1)
           : scr_arr_new(a->elem, hint ? hint : 1);
   out->len = n;
   if (to <= a->cap && to <= a->filled && a->elem != SCR_ELEM_BOOL && !scr_elem_is_ref(a->elem)) {
@@ -2828,7 +2962,7 @@ static ScrSortCompare scr_sort_compare_for(const ScrArr *a, ScrClosure *f, uint3
     if (a->elem == SCR_ELEM_STR) c.retain = scr_sort_retain_str;
     else if (a->elem == SCR_ELEM_ARR) c.retain = scr_sort_retain_arr;
     else if (a->elem == SCR_ELEM_BYTES) c.retain = scr_sort_retain_bytes;
-    else if (a->elem == SCR_ELEM_REF) c.retain = a->ops->retain;
+    else if (a->elem == SCR_ELEM_REF) c.retain = scr_arr_ops(a)->retain;
     else scr_trap("scriptc: invalid comparator sort element kind\n");
   }
   return c;
@@ -4441,6 +4575,8 @@ const uint64_t *scr_arr_dense_slots(const ScrArr *a, size_t *len) {
  * slots of `a` in place. */
 bool scr_arr_sort_dense(ScrArr *a, ScrClosure *f, uint32_t arity, bool owned, int32_t order,
                         ScrClosure *key) {
+  uint8_t elem = a->elem;
+  const ScrArrOps *ops = scr_arr_ops(a);
   if (a->rc == SIZE_MAX || !scr_arr_dense_values(a)) return false;
   size_t n = a->len;
   if (n < 2) return true;
@@ -4459,10 +4595,10 @@ bool scr_arr_sort_dense(ScrArr *a, ScrClosure *f, uint32_t arity, bool owned, in
   if (!src) scr_arr_oom();
   memcpy(src, a->data, n * sizeof(*src));
   if (retained)
-    for (size_t i = 0; i < n; i++) src[i] = scr_elem_retain_slot(a, src[i]);
+    for (size_t i = 0; i < n; i++) src[i] = scr_elem_retain_with(elem, ops, src[i]);
   if (!scr_sort_slots(src, n, &c, true)) {
     if (retained)
-      for (size_t i = 0; i < n; i++) scr_elem_release(a, src[i]);
+      for (size_t i = 0; i < n; i++) scr_elem_release_with(elem, ops, src[i]);
     free(src);
     return true;
   }
@@ -4470,7 +4606,7 @@ bool scr_arr_sort_dense(ScrArr *a, ScrClosure *f, uint32_t arity, bool owned, in
     /* The comparator published the array: the first write fails as in Node
      * (scr_throw_published_array's index write). */
     if (retained)
-      for (size_t i = 0; i < n; i++) scr_elem_release(a, src[i]);
+      for (size_t i = 0; i < n; i++) scr_elem_release_with(elem, ops, src[i]);
     static const char assign[] = "Cannot assign to read only property '0' of object '[object Array]'";
     static const char add[] = "Cannot add property 0, object is not extensible";
     if (a->len > 0) scr_throw_error_msg(SCR_ERR_TYPE, assign, sizeof assign - 1);
diff --git a/packages/runtime/src/scr_array.h b/packages/runtime/src/scr_array.h
index 1678d1568..95ee7ce00 100644
--- a/packages/runtime/src/scr_array.h
+++ b/packages/runtime/src/scr_array.h
@@ -60,6 +60,9 @@ typedef struct ScrArrOps {
   void *(*retain)(void *);
   void (*release)(void *);
   ScrTraceFn trace;
+  /* Registry id (scr_arr_ops_table), 0 until scr_arr_ops_register assigns
+   * it on the first array of the type. Descriptors are writable for it. */
+  uint32_t id;
 } ScrArrOps;
 
 typedef struct ScrArr {
@@ -78,7 +81,10 @@ typedef struct ScrArr {
    * ref elements and the historic element kinds keep the lean 1-word
    * header. Kept beside `elem` so the RC fast paths test it with one load. */
   uint8_t cyc;
-  /* Storage flags private to scr_array.c (inline slots, head room). */
+  /* The low SCR_ARR_OPS_SHIFT bits: storage flags (SCR_ARR_INLINE_SLOTS,
+   * SCR_ARR_HEAD_ROOM, SCR_ARR_UNSHIFTED, SCR_ARR_HAS_EXT). The rest: the
+   * registry id of the element type's ops (scr_arr_ops), 0 for every kind
+   * but SCR_ELEM_REF. */
   uint16_t spare;
   /* A lower bound on the hole-free prefix: filled <= len, filled <= cap,
    * and every dense state below it is SCR_ARR_VALUE. Element reads below
@@ -87,17 +93,15 @@ typedef struct ScrArr {
    * undefined) or move states below it lowers it first (scr_arr_cut);
    * 0 is always valid. */
   uint32_t filled;
-  /* SCR_ELEM_REF only; NULL for every other element kind. */
-  const ScrArrOps *ops;
   /* Dense values: `cap` 8-byte slots, or `cap` bytes for SCR_ELEM_BOOL
    * (scr_arr_slot_width), followed in the same allocation by one state byte
    * per slot in reverse slot order (scr_arr_states_end). Sparse entries and properties keep 8-byte
-   * slots for every kind; a bool slot is 0 or 1 wherever it lives. */
+   * slots for every kind; a bool slot is 0 or 1 wherever it lives. Rarely
+   * used storage (sparse indices, noncanonical numeric properties,
+   * match-result metadata) lives out of line, and an array that has it
+   * (SCR_ARR_HAS_EXT) keeps a pointer to it in the word before the dense
+   * allocation (scr_arr_ext_of). */
   uint64_t *data;
-  /* Rarely used storage (sparse indices, noncanonical numeric properties,
-   * match-result metadata) lives out of line: NULL until first needed, so
-   * the common dense array stays small. */
-  struct ScrArrExt *ext;
 } ScrArr;
 
 typedef struct ScrArrExt {
@@ -113,11 +117,14 @@ typedef struct ScrArrExt {
    * scr_regex.c), and match_index is the result's UTF-16 start index. */
   struct ScrDyn *metadata;
   double match_index;
+  /* The element ops of an array whose ops have no registry id
+   * (SCR_ARR_OPS_OVERFLOW). */
+  const ScrArrOps *ops;
 } ScrArrExt;
 /* The LLVM backend mirrors ScrArr as %ScrArr: its inline retain/release read
  * `cyc` (field 4, i8) to decide mark-live / candidate buffering exactly like
  * scr_arr_retain and scr_arr_release; its inline element access uses len and
- * cap (fields 1 and 2, i32), filled (field 6, i32) and data (field 8), and
+ * cap (fields 1 and 2, i32), filled (field 6, i32) and data (field 7), and
  * finds the state of slot i at data + cap * (slot width + 1) - 1 - i. */
 _Static_assert(offsetof(ScrArr, len) == sizeof(size_t) && sizeof(((ScrArr *)0)->len) == 4,
                "emitted length reads load ScrArr.len as %ScrArr field 1, an i32");
@@ -127,10 +134,68 @@ _Static_assert(offsetof(ScrArr, cyc) == sizeof(size_t) + 9,
                "inline RC fast paths read ScrArr.cyc as %ScrArr field 4");
 _Static_assert(offsetof(ScrArr, filled) == sizeof(size_t) + 12,
                "inline element access reads ScrArr.filled as %ScrArr field 6");
-_Static_assert(offsetof(ScrArr, data) == sizeof(size_t) + 16 + sizeof(void *),
-               "inline element reads use ScrArr.data as %ScrArr field 8");
-_Static_assert(sizeof(ScrArr) == sizeof(size_t) + 16 + 3 * sizeof(void *),
-               "ScrArr is 48 bytes on 64-bit targets");
+_Static_assert(offsetof(ScrArr, data) == sizeof(size_t) + 16,
+               "inline element reads use ScrArr.data as %ScrArr field 7");
+_Static_assert(sizeof(ScrArr) == sizeof(size_t) + 16 + sizeof(void *),
+               "ScrArr is 32 bytes on 64-bit targets");
+
+/* Storage flags in `spare`. Inline slots: the dense slots live in the
+ * array's own block, after the header. Head room: `data` has advanced past
+ * vacated slots of its allocation, and the slot before `data` holds their
+ * count. Unshifted: an unshift had to move every element. Has ext: the word
+ * before the dense allocation (head room included) points at the array's
+ * ScrArrExt; such an array always has an allocation of its own, without
+ * inline slots. */
+#define SCR_ARR_INLINE_SLOTS 1u
+#define SCR_ARR_HEAD_ROOM 2u
+#define SCR_ARR_UNSHIFTED 4u
+#define SCR_ARR_HAS_EXT 8u
+
+/* The start of the dense slots' allocation: `data` less any head room. */
+static inline uint64_t *scr_arr_block(const ScrArr *a) {
+  return (a->spare & SCR_ARR_HEAD_ROOM) ? a->data - (size_t)a->data[-1] : a->data;
+}
+
+/* Bytes before the dense allocation of an array with out-of-line storage:
+ * its pointer, in a word that keeps the 8-byte slots aligned on every
+ * target. */
+#define SCR_ARR_EXT_PREFIX sizeof(uint64_t)
+
+/* The out-of-line storage of `a`, or NULL while it has none. */
+static inline struct ScrArrExt *scr_arr_ext_of(const ScrArr *a) {
+  if (!(a->spare & SCR_ARR_HAS_EXT)) return NULL;
+  struct ScrArrExt *x;
+  memcpy(&x, (const char *)scr_arr_block(a) - SCR_ARR_EXT_PREFIX, sizeof x);
+  return x;
+}
+
+/* Element ops by registry id: `spare >> SCR_ARR_OPS_SHIFT` of an array.
+ * Id 0 is no ops; ids are assigned on each descriptor's first array, in
+ * any thread. A program with more element types than the field holds keeps
+ * the ops of the rest in the array's ext (SCR_ARR_OPS_OVERFLOW). */
+#define SCR_ARR_OPS_SHIFT 4
+#define SCR_ARR_OPS_OVERFLOW (UINT16_MAX >> SCR_ARR_OPS_SHIFT)
+extern const ScrArrOps *scr_arr_ops_table[SCR_ARR_OPS_OVERFLOW];
+/* Assigns the id on a descriptor's first array; out of line, so the id
+ * load in scr_arr_ops_id stays the only cost on later arrays. */
+__attribute__((cold, noinline)) uint32_t scr_arr_ops_register(ScrArrOps *ops);
+
+/* The registry id an array of element ops `ops` stores (0 for NULL). */
+static inline uint32_t scr_arr_ops_id(const ScrArrOps *ops) {
+  if (!ops) return 0;
+  uint32_t id = __atomic_load_n(&ops->id, __ATOMIC_ACQUIRE);
+  return id ? id : scr_arr_ops_register((ScrArrOps *)ops);
+}
+
+/* The element ops of an array whose ops have no registry id. */
+const ScrArrOps *scr_arr_ops_overflow(const ScrArr *a);
+
+/* The element ops of `a`: NULL for every kind but SCR_ELEM_REF. */
+static inline const ScrArrOps *scr_arr_ops(const ScrArr *a) {
+  uint32_t id = (uint32_t)a->spare >> SCR_ARR_OPS_SHIFT;
+  if (__builtin_expect(id == SCR_ARR_OPS_OVERFLOW, 0)) return scr_arr_ops_overflow(a);
+  return scr_arr_ops_table[id];
+}
 
 /* Bytes per dense value slot. */
 static inline size_t scr_arr_slot_width(const ScrArr *a) {
diff --git a/packages/runtime/src/scr_async_dyn.c b/packages/runtime/src/scr_async_dyn.c
index ec4dad794..a6cd813de 100644
--- a/packages/runtime/src/scr_async_dyn.c
+++ b/packages/runtime/src/scr_async_dyn.c
@@ -1274,7 +1274,7 @@ static void scr_dyn_all_result(ScrPromise *destination, ScrPromise *source) {
   scr_promise_fulfill_ref(destination, result, scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v);
 }
 
-static const ScrArrOps scr_dyn_arr_ops = { scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v };
+static ScrArrOps scr_dyn_arr_ops = { scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v };
 
 /* ── Thenable adoption (PromiseResolve over a checked-dynamic value) ──
  * A non-promise object whose `then` is callable resolves through
diff --git a/packages/runtime/src/scr_bytes_io.c b/packages/runtime/src/scr_bytes_io.c
index eb3661fc6..5532d96da 100644
--- a/packages/runtime/src/scr_bytes_io.c
+++ b/packages/runtime/src/scr_bytes_io.c
@@ -6,8 +6,8 @@
  * exact source lists). */
 #include "scr_runtime.h"
 
-static const ScrArrOps scr_bytes_io_str_ops = { scr_str_retain_v, scr_str_release_v, NULL };
-static const ScrArrOps scr_bytes_io_bytes_ops = { scr_bytes_retain_v, scr_bytes_release_v, NULL };
+static ScrArrOps scr_bytes_io_str_ops = { scr_str_retain_v, scr_str_release_v, NULL };
+static ScrArrOps scr_bytes_io_bytes_ops = { scr_bytes_retain_v, scr_bytes_release_v, NULL };
 
 #include <errno.h>
 #include <math.h>
diff --git a/packages/runtime/src/scr_copying.c b/packages/runtime/src/scr_copying.c
index 6864a6262..df4da1738 100644
--- a/packages/runtime/src/scr_copying.c
+++ b/packages/runtime/src/scr_copying.c
@@ -23,7 +23,7 @@ static bool copying_elem_is_ref(ScrElemKind kind) {
 
 static ScrArr *copying_arr_new_like(const ScrArr *a, size_t cap) {
   ScrArr *out = a->elem == SCR_ELEM_REF
-                    ? scr_arr_new_ops(a->ops, cap ? cap : 1)
+                    ? scr_arr_new_ops(scr_arr_ops(a), cap ? cap : 1)
                     : scr_arr_new(a->elem, cap ? cap : 1);
   out->len = cap;
   return out;
@@ -35,7 +35,7 @@ static uint64_t copying_arr_retain_slot(const ScrArr *a, uint64_t slot) {
   if (a->elem == SCR_ELEM_STR) p = scr_str_retain((ScrStr *)p);
   else if (a->elem == SCR_ELEM_ARR) p = scr_arr_retain((ScrArr *)p);
   else if (a->elem == SCR_ELEM_BYTES) p = scr_bytes_retain((ScrBytes *)p);
-  else p = a->ops->retain(p);
+  else p = scr_arr_ops(a)->retain(p);
   return copying_slot_from_ptr(p);
 }
 
diff --git a/packages/runtime/src/scr_cycle.c b/packages/runtime/src/scr_cycle.c
index ce4dfa5fa..682f8bfcd 100644
--- a/packages/runtime/src/scr_cycle.c
+++ b/packages/runtime/src/scr_cycle.c
@@ -1239,7 +1239,7 @@ void scr_cyc_on_release(void *obj) {
  * cycle-capable array and through the type's trace otherwise. */
 #define SCR_CYC_CHILDREN(obj, type, ARRAY_WALK, VISIT, depth)                         \
   do {                                                                               \
-    if ((type)->kind == SCR_CYC_KIND_ARRAY && ((const ScrArr *)(obj))->ext == NULL)   \
+    if ((type)->kind == SCR_CYC_KIND_ARRAY && !(((const ScrArr *)(obj))->spare & SCR_ARR_HAS_EXT))   \
       ARRAY_WALK((const ScrArr *)(obj), (void *)(depth));                            \
     else                                                                             \
       (type)->trace((obj), (VISIT), (void *)(depth));                                \
diff --git a/packages/runtime/src/scr_events_emitter.c b/packages/runtime/src/scr_events_emitter.c
index c11b7897d..901e2d114 100644
--- a/packages/runtime/src/scr_events_emitter.c
+++ b/packages/runtime/src/scr_events_emitter.c
@@ -1352,7 +1352,7 @@ ScrArr *scr_emitter_event_names(ScrEmitter *em) {
  * The once wrapper is runtime-internal here, so BOTH forms answer the
  * original listeners (SEMANTICS.md documents the rawListeners
  * divergence). */
-static const ScrArrOps scr_ee_closure_arr_ops = { &scr_closure_retain_v, &scr_closure_release_v,
+static ScrArrOps scr_ee_closure_arr_ops = { &scr_closure_retain_v, &scr_closure_release_v,
                                                   &scr_closure_trace_v };
 
 ScrArr *scr_emitter_listeners(ScrEmitter *em, ScrStr *name) {
diff --git a/packages/runtime/src/scr_itable.c b/packages/runtime/src/scr_itable.c
index 7b5202b81..a333aab95 100644
--- a/packages/runtime/src/scr_itable.c
+++ b/packages/runtime/src/scr_itable.c
@@ -474,11 +474,11 @@ static ScrArrState scr_itable_element(ScrITableElements *w, size_t i, uint64_t *
     *slot = a->data[i];
     return (ScrArrState)*scr_arr_state_ptr(a, i);
   }
-  if (a->ext) {
-    while (w->sparse < a->ext->sparse_len && a->ext->sparse[w->sparse].index < i) w->sparse++;
-    if (w->sparse < a->ext->sparse_len && a->ext->sparse[w->sparse].index == i) {
-      *slot = a->ext->sparse[w->sparse].slot;
-      return (ScrArrState)a->ext->sparse[w->sparse].state;
+  if (scr_arr_ext_of(a)) {
+    while (w->sparse < scr_arr_ext_of(a)->sparse_len && scr_arr_ext_of(a)->sparse[w->sparse].index < i) w->sparse++;
+    if (w->sparse < scr_arr_ext_of(a)->sparse_len && scr_arr_ext_of(a)->sparse[w->sparse].index == i) {
+      *slot = scr_arr_ext_of(a)->sparse[w->sparse].slot;
+      return (ScrArrState)scr_arr_ext_of(a)->sparse[w->sparse].state;
     }
   }
   return SCR_ARR_HOLE;
diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c
index d18ce85e4..adcc96560 100644
--- a/packages/runtime/src/scr_json.c
+++ b/packages/runtime/src/scr_json.c
@@ -12445,7 +12445,7 @@ ScrDynEntryPairs *scr_dyn_obj_entry_pairs(const ScrDyn *v) {
 
 void scr_dyn_entry_pairs_free(ScrDynEntryPairs *pairs) { free(pairs); }
 
-static const ScrArrOps scr_dyn_value_list_ops = {scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v};
+static ScrArrOps scr_dyn_value_list_ops = {scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v};
 
 /* A native array of `count` owned dyn values, moved in with one dense push.
  * Frees `values` unless it is `stack`. */
diff --git a/packages/runtime/src/scr_json.test.c b/packages/runtime/src/scr_json.test.c
index 3946331be..736eca540 100644
--- a/packages/runtime/src/scr_json.test.c
+++ b/packages/runtime/src/scr_json.test.c
@@ -520,7 +520,7 @@ static void test_item_release(void *ptr) {
 
 static ScrArr *test_tags_new(size_t cap) { return scr_arr_new(SCR_ELEM_STR, cap); }
 static ScrArr *test_list_new(size_t cap) {
-  static const ScrArrOps item_ops = { test_item_retain, test_item_release, NULL };
+  static ScrArrOps item_ops = { test_item_retain, test_item_release, NULL };
   return scr_arr_new_ops(&item_ops, cap);
 }
 static void test_arr_release(void *ptr) { scr_arr_release(ptr); }
diff --git a/packages/runtime/src/scr_lib.c b/packages/runtime/src/scr_lib.c
index db0926690..3441e6142 100644
--- a/packages/runtime/src/scr_lib.c
+++ b/packages/runtime/src/scr_lib.c
@@ -5788,7 +5788,7 @@ void scr_fs_symlink(ScrStr *target, ScrStr *destination, int kind) {
   if (!scr_fs_path_ok(target, "target")) return;
   if (!scr_fs_path_ok(destination, "path")) return;
 #ifdef _WIN32
-  static const ScrArrOps str_ops = { scr_str_retain_v, scr_str_release_v, NULL };
+  static ScrArrOps str_ops = { scr_str_retain_v, scr_str_release_v, NULL };
   ScrArr *parts = scr_arr_new_ops(&str_ops, 3);
   scr_arr_push_ref(parts, scr_str_retain(destination));
   scr_arr_push_ref(parts, scr_str_new("..", 2));
diff --git a/packages/runtime/src/scr_map.c b/packages/runtime/src/scr_map.c
index 5d4935ed0..99caa31a8 100644
--- a/packages/runtime/src/scr_map.c
+++ b/packages/runtime/src/scr_map.c
@@ -1558,7 +1558,7 @@ void scr_map_values_into(ScrMap *set, const ScrMap *source, bool checked) {
 }
 
 ScrArr *scr_set_to_arr_dyn(const ScrMap *map) {
-  static const ScrArrOps dyn_ops = { scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v };
+  static ScrArrOps dyn_ops = { scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v };
   ScrArr *out = scr_arr_new_ops(&dyn_ops, map->nlive);
   for (size_t i = 0; i < map->nentries; i++) {
     if (scr_map_iter_live(map, (double)i)) scr_arr_push_ref(out, scr_map_dyn_key(map, (double)i));
diff --git a/packages/runtime/src/scr_publish.c b/packages/runtime/src/scr_publish.c
index 025e13a51..675a13ca9 100644
--- a/packages/runtime/src/scr_publish.c
+++ b/packages/runtime/src/scr_publish.c
@@ -201,7 +201,7 @@ static void scr_pub_slot(ScrPub *ctx, uint64_t slot, ScrPubFn fn) {
 
 void scr_pub_arr(void *v, ScrPub *ctx, ScrPubFn elem) {
   ScrArr *a = v;
-  if (a->ext && (a->ext->props || a->ext->metadata)) {
+  if (scr_arr_ext_of(a) && (scr_arr_ext_of(a)->props || scr_arr_ext_of(a)->metadata)) {
     scr_pub_refuse(ctx, "Cannot publish an array with non-index properties");
     return;
   }
@@ -212,9 +212,9 @@ void scr_pub_arr(void *v, ScrPub *ctx, ScrPubFn elem) {
   const uint8_t *states = scr_arr_states_end(a);
   for (size_t i = 0; i < dense; i++)
     if (!states || *scr_arr_state_in(states, i)) scr_pub_slot(ctx, a->data[i], fn);
-  if (a->ext)
-    for (size_t i = 0; i < a->ext->sparse_len; i++)
-      if (a->ext->sparse[i].state) scr_pub_slot(ctx, a->ext->sparse[i].slot, fn);
+  if (scr_arr_ext_of(a))
+    for (size_t i = 0; i < scr_arr_ext_of(a)->sparse_len; i++)
+      if (scr_arr_ext_of(a)->sparse[i].state) scr_pub_slot(ctx, scr_arr_ext_of(a)->sparse[i].slot, fn);
 }
 
 /* publish() of a scalar Node.js refuses (a Date): nothing to walk. */
diff --git a/packages/runtime/src/scr_regex.c b/packages/runtime/src/scr_regex.c
index 73440c110..b62cba896 100644
--- a/packages/runtime/src/scr_regex.c
+++ b/packages/runtime/src/scr_regex.c
@@ -667,7 +667,7 @@ static void scr_regex_defer_metadata(ScrArr *row, ScrDyn *source, int index) {
 
 /* The pending match source of a result, or NULL once its metadata exists. */
 static ScrRegexMatchSource *scr_regex_pending(const ScrArr *a) {
-  const ScrDyn *metadata = a->ext ? a->ext->metadata : NULL;
+  const ScrDyn *metadata = scr_arr_ext_of(a) ? scr_arr_ext_of(a)->metadata : NULL;
   if (!metadata || metadata->kind != SCR_DYN_HANDLE || metadata->v.handle.tag != SCR_DYNH_MATCH_SOURCE)
     return NULL;
   return metadata->v.handle.ptr;
@@ -707,7 +707,7 @@ static ScrDyn *scr_regex_groups_of(const ScrArr *a, uint8_t *bc) {
 static void scr_regex_materialize_metadata(ScrArr *a) {
   ScrRegexMatchSource *src = scr_regex_pending(a);
   if (!src) return;
-  ScrArrExt *x = a->ext;
+  ScrArrExt *x = scr_arr_ext_of(a);
   ScrDyn *source = x->metadata;
   ScrDyn *props = scr_dyn_new_obj();
   scr_dyn_obj_set(props, "index", 5, scr_dyn_new_num(x->match_index));
@@ -724,7 +724,7 @@ static bool scr_regex_copy_pending_metadata(ScrArr *a, ScrDyn *target) {
     scr_regex_materialize_metadata(a);
     return false;
   }
-  scr_dyn_arr_named_put(target, "index", 5, scr_dyn_new_num(a->ext->match_index));
+  scr_dyn_arr_named_put(target, "index", 5, scr_dyn_new_num(scr_arr_ext_of(a)->match_index));
   scr_dyn_arr_named_put(target, "input", 5, scr_regex_source_input(src));
   scr_dyn_arr_named_put(target, "groups", 6, scr_regex_groups_of(a, scr_regex_bc(src->re)));
   return true;
@@ -734,11 +734,11 @@ ScrDyn *scr_regex_result_prop(ScrArr *a, ScrStr *key) {
   ScrRegexMatchSource *src = scr_regex_pending(a);
   if (src) {
     if (key->len == 5 && memcmp(key->data, "index", 5) == 0)
-      return scr_dyn_new_num(a->ext->match_index);
+      return scr_dyn_new_num(scr_arr_ext_of(a)->match_index);
     if (key->len == 5 && memcmp(key->data, "input", 5) == 0) return scr_regex_source_input(src);
     scr_regex_materialize_metadata(a);
   }
-  ScrDyn *metadata = a->ext ? a->ext->metadata : NULL;
+  ScrDyn *metadata = scr_arr_ext_of(a) ? scr_arr_ext_of(a)->metadata : NULL;
   ScrDyn *value = metadata ? scr_dyn_obj_get(metadata, key->data, key->len) : NULL;
   return scr_dyn_retain(value ? value : scr_dyn_undefined());
 }
diff --git a/packages/runtime/src/scr_region.c b/packages/runtime/src/scr_region.c
index 3a7dad541..dbd74f3ac 100644
--- a/packages/runtime/src/scr_region.c
+++ b/packages/runtime/src/scr_region.c
@@ -803,17 +803,17 @@ static void *scr_rgn_slot_ptr(uint64_t slot) {
 static void scr_rgn_walk_arr(ScrRgnWalk *w, ScrArr *a) {
   if (a->elem != SCR_ELEM_REF && a->elem != SCR_ELEM_ARR) return;
   ScrRgnSlotKind k = a->elem == SCR_ELEM_ARR ? (ScrRgnSlotKind){SCR_RGN_W_ARR, NULL}
-                                             : scr_rgn_slot_kind(a->ops ? a->ops->release : NULL);
+                                             : scr_rgn_slot_kind(scr_arr_ops(a) ? scr_arr_ops(a)->release : NULL);
   size_t dense = a->len < a->cap ? a->len : a->cap;
   const uint8_t *states = scr_arr_states_end(a);
   for (size_t i = 0; i < dense; i++)
     if (!states || *scr_arr_state_in(states, i) == SCR_ARR_VALUE) scr_rgn_slot_as(w, scr_rgn_slot_ptr(a->data[i]), k);
-  if (!a->ext) return;
-  for (size_t i = 0; i < a->ext->sparse_len; i++)
-    if (a->ext->sparse[i].state == SCR_ARR_VALUE) scr_rgn_slot_as(w, scr_rgn_slot_ptr(a->ext->sparse[i].slot), k);
-  for (size_t i = 0; i < a->ext->prop_len; i++)
-    if (a->ext->props[i].state == SCR_ARR_VALUE) scr_rgn_slot_as(w, scr_rgn_slot_ptr(a->ext->props[i].slot), k);
-  scr_rgn_enter(w, a->ext->metadata, SCR_RGN_W_DYN, NULL);
+  if (!scr_arr_ext_of(a)) return;
+  for (size_t i = 0; i < scr_arr_ext_of(a)->sparse_len; i++)
+    if (scr_arr_ext_of(a)->sparse[i].state == SCR_ARR_VALUE) scr_rgn_slot_as(w, scr_rgn_slot_ptr(scr_arr_ext_of(a)->sparse[i].slot), k);
+  for (size_t i = 0; i < scr_arr_ext_of(a)->prop_len; i++)
+    if (scr_arr_ext_of(a)->props[i].state == SCR_ARR_VALUE) scr_rgn_slot_as(w, scr_rgn_slot_ptr(scr_arr_ext_of(a)->props[i].slot), k);
+  scr_rgn_enter(w, scr_arr_ext_of(a)->metadata, SCR_RGN_W_DYN, NULL);
 }
 
 static void scr_rgn_walk_map(ScrRgnWalk *w, ScrMap *m) {
diff --git a/packages/runtime/src/scr_region.test.c b/packages/runtime/src/scr_region.test.c
index 31e98942a..ad1f92518 100644
--- a/packages/runtime/src/scr_region.test.c
+++ b/packages/runtime/src/scr_region.test.c
@@ -61,7 +61,7 @@ static void node_release(void *o) {
   if (c) c->count--;
 }
 
-static const ScrArrOps node_ops = {node_retain, node_release, NULL};
+static ScrArrOps node_ops = {node_retain, node_release, NULL};
 
 /* ── the "emitted" ordinary class (acyclic, plain heap block) ────────── */
 
diff --git a/packages/runtime/src/scr_stream.c b/packages/runtime/src/scr_stream.c
index 7d7ec04ed..f7330b615 100644
--- a/packages/runtime/src/scr_stream.c
+++ b/packages/runtime/src/scr_stream.c
@@ -4420,7 +4420,7 @@ static ScrPromise *scr_sc_consume(ScrStream *s, int kind) {
     scr_promise_reject_pending(p);
     return p;
   }
-  static const ScrArrOps bytes_ops = { scr_bytes_retain_v, scr_bytes_release_v, NULL };
+  static ScrArrOps bytes_ops = { scr_bytes_retain_v, scr_bytes_release_v, NULL };
   ScrArr *chunks = scr_arr_new_ops(&bytes_ops, 4);
   ScrStreamErrInv fin_inv = kind == SCR_SC_TEXT    ? &scr_sc_fin_text
                             : kind == SCR_SC_JSON  ? &scr_sc_fin_json
diff --git a/packages/runtime/test/test_array.c b/packages/runtime/test/test_array.c
index 3eea84dcf..02da2fac2 100644
--- a/packages/runtime/test/test_array.c
+++ b/packages/runtime/test/test_array.c
@@ -19,7 +19,7 @@
 #include <string.h>
 
 /* Sparse entries live in the array's out-of-line storage. */
-static size_t arr_sparse_len(const ScrArr *a) { return a->ext ? a->ext->sparse_len : 0; }
+static size_t arr_sparse_len(const ScrArr *a) { return scr_arr_ext_of(a) ? scr_arr_ext_of(a)->sparse_len : 0; }
 
 #ifdef SCR_RC_AUDIT
 long scr_str_live_count(void); /* provided by scr_string.c */
@@ -396,8 +396,8 @@ static MockRec *mock_cyc_new(int value) {
   return r;
 }
 
-static const ScrArrOps mock_ops = { &mock_retain, &mock_release, NULL };
-static const ScrArrOps mock_cyc_ops = { &mock_cyc_retain, &mock_cyc_release, &mock_trace };
+static ScrArrOps mock_ops = { &mock_retain, &mock_release, NULL };
+static ScrArrOps mock_cyc_ops = { &mock_cyc_retain, &mock_cyc_release, &mock_trace };
 
 static void test_ref_elements(void) {
 #ifdef SCR_RC_AUDIT
@@ -444,6 +444,58 @@ static void test_ref_elements(void) {
 #endif
 }
 
+/* Element ops past the registry's capacity: every descriptor still finds its
+ * own retain and release, and the first ones keep their registry ids. */
+static void test_ops_overflow(void) {
+  enum { N = SCR_ARR_OPS_OVERFLOW + 8 };
+  static ScrArrOps many[N];
+  static ScrArr *arrays[N];
+  for (int i = 0; i < N; i++) many[i] = (ScrArrOps){ &mock_retain, &mock_release, NULL, 0 };
+  for (int i = 0; i < N; i++) {
+    arrays[i] = scr_arr_new_ops(&many[i], 0);
+    scr_arr_push_ref(arrays[i], mock_new(i));
+  }
+  check(scr_arr_ops(arrays[0]) == &many[0], "a registered descriptor answers by id");
+  check(scr_arr_ops(arrays[N - 1]) == &many[N - 1], "an overflow descriptor answers through the array");
+  check(many[N - 1].id == SCR_ARR_OPS_OVERFLOW, "descriptors past the table get the overflow id");
+  MockRec *r = (MockRec *)scr_arr_get_ref(arrays[N - 1], 0);
+  check(r->rc == 2 && r->value == N - 1, "an overflow array retains through its own ops");
+  mock_release(r);
+  for (int i = 0; i < N; i++) scr_arr_release(arrays[i]);
+  check(mock_live == 0, "overflow arrays release their elements");
+}
+
+/* An array with out-of-line storage keeps it through every change of its
+ * dense allocation: growth, head room, unshift into new room, sorting
+ * (which rebuilds the storage) and a sparse tail. */
+static void test_ext_through_storage_changes(void) {
+  ScrArr *a = scr_arr_new(SCR_ELEM_F64, 0);
+  scr_arr_set_f64(a, -1, 7); /* a noncanonical property: out-of-line storage */
+  check(scr_arr_ext_of(a) != NULL, "a numeric property creates out-of-line storage");
+  for (int i = 0; i < 100; i++) scr_arr_push_f64(a, 100 - i);
+  check_f64(scr_arr_get_f64(a, -1), 7, "the property survives growth");
+  for (int i = 0; i < 40; i++) scr_arr_shift_f64(a);
+  check_f64(scr_arr_get_f64(a, -1), 7, "the property survives head room");
+  for (int i = 0; i < 60; i++) scr_arr_unshift_f64(a, 1000 + i);
+  check_f64(scr_arr_len(a), 120, "unshift after shifts keeps the length");
+  check_f64(scr_arr_get_f64(a, -1), 7, "the property survives new head room");
+  ScrArr *same = scr_arr_sort_primitive(a, false);
+  check(same == a, "an in-place sort returns the array");
+  check_f64(scr_arr_get_f64(a, 0), 1, "sorting reorders the values");
+  check_f64(scr_arr_get_f64(a, -1), 7, "the property survives a sort");
+  scr_arr_set_f64(a, 5000000, 9); /* a sparse tail entry */
+  check(arr_sparse_len(a) == 1 && scr_arr_get_f64(a, 5000000) == 9, "a sparse entry joins the out-of-line storage");
+  scr_arr_release(same); /* the sort's result reference */
+  scr_arr_release(a);
+
+  ScrArr *empty = scr_arr_new(SCR_ELEM_F64, 0);
+  scr_arr_set_f64(empty, 0.5, 3);
+  check_f64(scr_arr_get_f64(empty, 0.5), 3, "an array without elements keeps a property");
+  scr_arr_push_f64(empty, 1);
+  check_f64(scr_arr_get_f64(empty, 0.5), 3, "the property survives the first element");
+  scr_arr_release(empty);
+}
+
 static void test_ref_cycle(void) {
 #ifdef SCR_RC_AUDIT
   long arrays0 = scr_arr_live_count();
@@ -1522,7 +1574,11 @@ static void test_inline_slots(void) {
   scr_arr_push_ref(words, scr_str_new("a", 1));
   scr_arr_push_ref(words, scr_str_new("b", 1));
   scr_arr_set_ref(words, 3000000, scr_str_new("far", 3));
-  check(inline_slots(words) && arr_sparse_len(words) == 1, "a far index leaves inline slots in place");
+  /* A sparse entry needs out-of-line storage, whose pointer lives before the
+   * dense allocation: the inline slots move out of line with their values. */
+  check(!inline_slots(words) && arr_sparse_len(words) == 1 &&
+            strcmp(((ScrStr *)scr_arr_peek_ref(words, 1))->data, "b") == 0,
+        "a far index moves the inline slots out of line");
   scr_arr_unshift_ref(words, scr_str_new("z", 1));
   check(!inline_slots(words) && scr_arr_len(words) == 3000002 &&
             strcmp(((ScrStr *)scr_arr_peek_ref(words, 0))->data, "z") == 0 &&
@@ -2149,6 +2205,8 @@ int main(int argc, char **argv) {
   test_nested_rc();
   test_index_of_includes();
   test_ref_elements();
+  test_ops_overflow();
+  test_ext_through_storage_changes();
   test_ref_cycle();
   test_ref_truncate_cycle();
   test_ref_trace_storage_boundaries();
diff --git a/packages/runtime/test/test_lib.c b/packages/runtime/test/test_lib.c
index db8d29693..6bdbb085d 100644
--- a/packages/runtime/test/test_lib.c
+++ b/packages/runtime/test/test_lib.c
@@ -22,7 +22,7 @@
 #include <sys/wait.h>
 
 /* Sparse entries live in the array's out-of-line storage. */
-static size_t arr_sparse_len(const ScrArr *a) { return a->ext ? a->ext->sparse_len : 0; }
+static size_t arr_sparse_len(const ScrArr *a) { return scr_arr_ext_of(a) ? scr_arr_ext_of(a)->sparse_len : 0; }
 #endif
 
 static int checks = 0;
diff --git a/packages/runtime/test/test_map.c b/packages/runtime/test/test_map.c
index 9957a994c..32bdb7be1 100644
--- a/packages/runtime/test/test_map.c
+++ b/packages/runtime/test/test_map.c
@@ -636,7 +636,7 @@ static void test_value_keys_and_copies(void) {
 }
 
 #ifdef SCR_RC_AUDIT
-static const ScrArrOps map_arr_ops = { scr_map_retain_v, scr_map_release_v, scr_map_trace_v };
+static ScrArrOps map_arr_ops = { scr_map_retain_v, scr_map_release_v, scr_map_trace_v };
 
 static void test_identity_cycles(void) {
   scr_collect_cycles();
diff --git a/packages/runtime/test/test_regex.c b/packages/runtime/test/test_regex.c
index 6084c5102..6afa8391e 100644
--- a/packages/runtime/test/test_regex.c
+++ b/packages/runtime/test/test_regex.c
@@ -333,7 +333,7 @@ static void test_exec_groups(void) {
   check(full && lean && full->len == lean->len && lean->len == 2, "exec_groups keeps the capture count");
   check(*scr_arr_state_ptr(lean, 0) == SCR_ARR_UNDEFINED && *scr_arr_state_ptr(lean, 1) == SCR_ARR_UNDEFINED,
         "exec_groups: unselected and nonparticipating captures are undefined");
-  check(lean->ext == NULL || lean->ext->metadata == NULL, "exec_groups: no index/input properties");
+  check(scr_arr_ext_of(lean) == NULL || scr_arr_ext_of(lean)->metadata == NULL, "exec_groups: no index/input properties");
   scr_arr_release(full);
   scr_arr_release(lean);
   ScrStr *ab = S("ab");

From 5c851762d6d96b263557c61d79d88c595916a674 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 13:12:24 -0500
Subject: [PATCH 10/67] Read ASCII characters of strings inline in charAt and
 indexing

charAt and s[i] on a string proven ASCII at an exact in-range index now
return the character from a module-level table of the 128 one-character
strings, emitted with the helper as immortal literals with the same
capacity word and key hash as the runtime's single-character statics.
An exact integer index (a counted-loop counter) skips the double
conversion. Every other string or index calls scr_str_char_at as before.
---
 .../src/backend/llvm/expr-containers.ts       | 25 ++++--
 .../src/backend/llvm/string-lifetimes.test.ts |  3 +-
 .../compiler/src/backend/llvm/string-reads.ts | 86 +++++++++++++++++++
 .../test/string-char-at-emission.test.ts      | 55 ++++++++++++
 4 files changed, 160 insertions(+), 9 deletions(-)
 create mode 100644 packages/compiler/test/string-char-at-emission.test.ts

diff --git a/packages/compiler/src/backend/llvm/expr-containers.ts b/packages/compiler/src/backend/llvm/expr-containers.ts
index bf8d502a1..8d1d1d28f 100644
--- a/packages/compiler/src/backend/llvm/expr-containers.ts
+++ b/packages/compiler/src/backend/llvm/expr-containers.ts
@@ -45,6 +45,8 @@ import { emitBorrowedInput } from "./borrowed-inputs.js";
 import { emitFusedMapSet, rememberMapEntry } from "./map-entry-fusion.js";
 import { emitScratchStringSlice, emitStringSliceRead } from "./string-slices.js";
 import {
+  STRING_CHAR_AT_DECL,
+  STRING_CHAR_AT_INT_MARKER,
   STRING_CHAR_CODE_AT_DECL,
   STRING_CHAR_CODE_AT_INT_MARKER,
   STRING_UTF16_LEN_DECL,
@@ -325,14 +327,21 @@ export function emitStrIntrinsic(
       B.line(`${t} = call double @sc_str_char_code_at(ptr ${r.name}, double ${args[0]!.name})`);
       return { name: t, type: e.type };
     }
-    case "charAt":
-      return call(
-        "scr_str_char_at",
-        "ptr (ptr, double)",
-        `ptr ${r.name}, double ${args[0]!.name}`,
-        "ptr",
-        true,
-      );
+    case "charAt": {
+      // sc_str_char_at (string-reads.ts) answers proven-ASCII strings inline.
+      host.declare(STRING_CHAR_AT_DECL);
+      const t = B.tmp();
+      const index = e.args[0] ? exactInteger(host, args[0]!, e.args[0]) : null;
+      if (index) {
+        host.declare(STRING_CHAR_AT_INT_MARKER);
+        const wide = widenInteger(host, index);
+        B.line(`${t} = call ptr @sc_str_char_at_int(ptr ${r.name}, i64 ${wide})`);
+      } else {
+        const at = args[0]?.name ?? f64Lit(0);
+        B.line(`${t} = call ptr @sc_str_char_at(ptr ${r.name}, double ${at})`);
+      }
+      return host.own({ name: t, type: e.type });
+    }
     case "indexOf":
       return call(
         "scr_str_index_of",
diff --git a/packages/compiler/src/backend/llvm/string-lifetimes.test.ts b/packages/compiler/src/backend/llvm/string-lifetimes.test.ts
index 8622085b4..f85addcf8 100644
--- a/packages/compiler/src/backend/llvm/string-lifetimes.test.ts
+++ b/packages/compiler/src/backend/llvm/string-lifetimes.test.ts
@@ -311,7 +311,8 @@ const methodCases: {
   // enters through the double ABI.
   { method: "charCodeAt", args: [num(1)], result: F64, target: "char_code_at_int", inline: true },
   { method: "charCodeAt", args: [num(1.5)], result: F64, target: "char_code_at", inline: true },
-  { method: "charAt", args: [num(1)], result: STRING, target: "char_at" },
+  { method: "charAt", args: [num(1)], result: STRING, target: "char_at_int", inline: true },
+  { method: "charAt", args: [num(1.5)], result: STRING, target: "char_at", inline: true },
   { method: "indexOf", args: [ref("argument"), num(1)], result: F64, target: "index_of" },
   { method: "includes", args: [ref("argument")], result: BOOL, target: "includes" },
   {
diff --git a/packages/compiler/src/backend/llvm/string-reads.ts b/packages/compiler/src/backend/llvm/string-reads.ts
index d7bbed272..03a9fa282 100644
--- a/packages/compiler/src/backend/llvm/string-reads.ts
+++ b/packages/compiler/src/backend/llvm/string-reads.ts
@@ -18,6 +18,8 @@
  */
 
 import { exactIndexLines, sizeToDouble } from "./common.js";
+import { wtf8Bytes } from "../literals.js";
+import { literalCapWord, literalCapWord32 } from "./string-key-hash.js";
 
 export const STRING_UTF16_LEN_DECL = "declare double @scr_str_utf16_len(ptr)";
 export const STRING_CHAR_CODE_AT_DECL = "declare double @scr_str_char_code_at(ptr, double)";
@@ -31,6 +33,9 @@ const READ_CALL_ATTRS = "cold nocallback nounwind willreturn";
 /** Requests the integer-index helper below; an LLVM comment line among the
  * declarations, so it never declares anything itself. */
 export const STRING_CHAR_CODE_AT_INT_MARKER = "; uses @sc_str_char_code_at_int";
+export const STRING_CHAR_AT_DECL = "declare ptr @scr_str_char_at(ptr, double)";
+/** Requests the integer-index charAt helper, as the marker above does. */
+export const STRING_CHAR_AT_INT_MARKER = "; uses @sc_str_char_at_int";
 
 /** Load the proven-ASCII flag of `%s` into `%ascii`. */
 function asciiTest(): string[] {
@@ -85,6 +90,34 @@ function scanRead(): string[] {
   ];
 }
 
+/** The one-character strings of the ASCII range as immortal literals
+ * ({ rc = SIZE_MAX, len = 1, capacity word, char, NUL }), indexed by
+ * character code: the inline charAt result. Their bytes, capacity words
+ * and key hashes equal those of the runtime's single-character statics, so
+ * they are interchangeable with the strings the runtime returns. */
+function asciiCharTable(sz: string): string[] {
+  const type = `{ ${sz}, ${sz}, ${sz}, [2 x i8] }`;
+  const entries: string[] = [];
+  for (let c = 0; c < 128; c++) {
+    const bytes = wtf8Bytes(String.fromCharCode(c));
+    const word = sz === "i64" ? literalCapWord(bytes) : literalCapWord32(bytes);
+    entries.push(`${type} { ${sz} -1, ${sz} 1, ${sz} ${word}, [2 x i8] [i8 ${c}, i8 0] }`);
+  }
+  return [`@sc_ascii_chars = internal constant [128 x ${type}] [${entries.join(", ")}]`];
+}
+
+/** The table entry for byte `%byte` of a proven-ASCII string. */
+function asciiCharRead(sz: string): string[] {
+  return [
+    `  %data = getelementptr inbounds %ScrStr, ptr %s, i32 1`,
+    `  %p = getelementptr inbounds i8, ptr %data, i64 %k`,
+    `  %byte = load i8, ptr %p`,
+    `  %code = zext i8 %byte to i64`,
+    `  %char = getelementptr inbounds [128 x { ${sz}, ${sz}, ${sz}, [2 x i8] }], ptr @sc_ascii_chars, i64 0, i64 %code`,
+    `  ret ptr %char`,
+  ];
+}
+
 export interface StringReadHelper {
   decl: string;
   define(sz: string, attrs: string, scan: boolean): string[];
@@ -200,4 +233,57 @@ export const STRING_READ_HELPERS: readonly StringReadHelper[] = [
       `}`,
     ],
   },
+  {
+    // charAt of a proven-ASCII string at an exact in-range index is the
+    // table entry for its byte; every other case calls the runtime, which
+    // keeps the complete semantics. The table is defined with the helper.
+    decl: STRING_CHAR_AT_DECL,
+    define: (sz, attrs) => {
+      let n = 0;
+      const exactIndex = exactIndexLines("%i", "%len", sz, () => `%ix${n++}`);
+      return [
+        ...asciiCharTable(sz),
+        ``,
+        `define internal ptr @sc_str_char_at(ptr %s, double %i) ${attrs} {`,
+        `entry:`,
+        ...asciiTest(),
+        `  br i1 %ascii, label %bounds, label %slow`,
+        `bounds:`,
+        ...loadLength(sz),
+        ...exactIndex.lines.map((line) => `  ${line}`),
+        `  br i1 ${exactIndex.ok}, label %read, label %slow`,
+        `read:`,
+        `  %k = add i64 ${exactIndex.wide}, 0`,
+        ...asciiCharRead(sz),
+        `slow:`,
+        `  %r = call ptr @scr_str_char_at(ptr %s, double %i) ${READ_CALL_ATTRS}`,
+        `  ret ptr %r`,
+        `}`,
+      ];
+    },
+  },
+  {
+    // An exact integer index, as for sc_str_char_code_at_int. Requested
+    // together with STRING_CHAR_AT_DECL, which defines the table.
+    decl: STRING_CHAR_AT_INT_MARKER,
+    define: (sz, attrs) => [
+      `define internal ptr @sc_str_char_at_int(ptr %s, i64 %i) ${attrs} {`,
+      `entry:`,
+      ...asciiTest(),
+      `  br i1 %ascii, label %bounds, label %slow`,
+      `bounds:`,
+      ...loadLength(sz),
+      ...(sz === "i64" ? [] : [`  %len64 = zext ${sz} %len to i64`]),
+      `  %ok = icmp ult i64 %i, ${sz === "i64" ? "%len" : "%len64"}`,
+      `  br i1 %ok, label %read, label %slow`,
+      `read:`,
+      `  %k = add i64 %i, 0`,
+      ...asciiCharRead(sz),
+      `slow:`,
+      `  %d = sitofp i64 %i to double`,
+      `  %r = call ptr @scr_str_char_at(ptr %s, double %d) ${READ_CALL_ATTRS}`,
+      `  ret ptr %r`,
+      `}`,
+    ],
+  },
 ];
diff --git a/packages/compiler/test/string-char-at-emission.test.ts b/packages/compiler/test/string-char-at-emission.test.ts
new file mode 100644
index 000000000..8e5814120
--- /dev/null
+++ b/packages/compiler/test/string-char-at-emission.test.ts
@@ -0,0 +1,55 @@
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { expect, test } from "vitest";
+import { compile, deserializeModule, validateModule } from "../src/index.js";
+import { emitLlvmModule } from "../src/backend/llvm/emitter.js";
+import { literalCapWord } from "../src/backend/llvm/string-key-hash.js";
+import type { IrModule } from "../src/ir/ir.js";
+
+async function lower(source: string): Promise<IrModule> {
+  const dir = await mkdtemp(join(tmpdir(), "scriptc-char-at-"));
+  try {
+    const entry = join(dir, "main.ts");
+    const outPath = join(dir, "main.ir.json");
+    await writeFile(entry, source);
+    const result = await compile(entry, { outDir: dir, outPath, outputKind: "ir" });
+    if (!result.ok)
+      throw new Error(result.diagnostics.map((d) => `${d.code}: ${d.message}`).join("\n"));
+    const mod = deserializeModule(await readFile(outPath, "utf8"));
+    expect(validateModule(mod)).toEqual([]);
+    return mod;
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+const options = { targetTriple: "x86_64-unknown-linux-gnu", pointerBits: 64 } as const;
+
+test("charAt reads proven-ASCII strings through the module's character table", async () => {
+  const mod = await lower(
+    'const s = process.argv.length > 9 ? "x" : "hello";\nconst i: number = process.argv.length - 1;\nconsole.log(s.charAt(i), s[i]);\n',
+  );
+  const ir = emitLlvmModule(mod, options);
+  expect(ir).toContain("define internal ptr @sc_str_char_at(ptr %s, double %i)");
+  expect(ir).toContain("call ptr @scr_str_char_at(ptr %s, double %i) cold");
+  // Each entry is an immortal one-character literal with the runtime's
+  // capacity word (length, proven-ASCII bit and key hash).
+  const word = literalCapWord(new Uint8Array([65]));
+  expect(ir).toContain(`{ i64 -1, i64 1, i64 ${word}, [2 x i8] [i8 65, i8 0] }`);
+  expect(ir.match(/^@sc_ascii_chars = internal constant \[128 x /gm)).toHaveLength(1);
+});
+
+test("charAt at a counted-loop index uses the integer helper", async () => {
+  const mod = await lower(
+    'const s = process.argv.length > 9 ? "x" : "hello";\nlet out = "";\nfor (let i = 0; i < s.length; i++) out += s.charAt(i);\nconsole.log(out);\n',
+  );
+  const ir = emitLlvmModule(mod, options);
+  expect(ir).toContain("define internal ptr @sc_str_char_at_int(ptr %s, i64 %i)");
+  expect(ir).toMatch(/call ptr @sc_str_char_at_int\(ptr %\w+, i64 %\w+\)/);
+});
+
+test("programs without charAt carry no character table", async () => {
+  const mod = await lower('console.log("hello".length + process.argv.length);\n');
+  expect(emitLlvmModule(mod, options)).not.toContain("@sc_ascii_chars");
+});

From a4d32a8e38fd765dc688ff057110c8ace10b7d3a Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 13:22:56 -0500
Subject: [PATCH 11/67] Use the default TLS version bound for null minVersion
 and maxVersion in tls.createServer

tls.createServer validated minVersion and maxVersion with its own loop,
which threw ERR_TLS_INVALID_PROTOCOL_VERSION for null. It now uses the
same check as tls.connect, where null and undefined select the default
bound, as in Node.
---
 packages/runtime/src/scr_tls.c           | 37 ++++--------------------
 tests/corpus/6722-tls-min-max-version.ts | 18 +++++++++++-
 2 files changed, 22 insertions(+), 33 deletions(-)

diff --git a/packages/runtime/src/scr_tls.c b/packages/runtime/src/scr_tls.c
index 59f3c2c0a..526dd7760 100644
--- a/packages/runtime/src/scr_tls.c
+++ b/packages/runtime/src/scr_tls.c
@@ -1813,38 +1813,11 @@ static bool scr_tls_opts_validate(const ScrDyn *opts) {
       return false;
     }
   }
-  static const char *const VERSION_OPTS[] = { "minVersion", "maxVersion", NULL };
-  for (size_t i = 0; VERSION_OPTS[i] != NULL; i++) {
-    const ScrDyn *v = scr_dyn_obj_get(opts, VERSION_OPTS[i], strlen(VERSION_OPTS[i]));
-    if (v == NULL || v->kind == SCR_DYN_UNDEF) continue;
-    bool valid = false;
-    if (v->kind == SCR_DYN_STR) {
-      static const char *const KNOWN[] = { "TLSv1", "TLSv1.1", "TLSv1.2", "TLSv1.3", NULL };
-      for (size_t k = 0; KNOWN[k] != NULL; k++) {
-        if (v->v.str->len == strlen(KNOWN[k]) && memcmp(v->v.str->data, KNOWN[k], v->v.str->len) == 0) {
-          valid = true;
-          break;
-        }
-      }
-    }
-    if (!valid) {
-      /* %j: strings render JSON-quoted, everything else inspect-lite. */
-      char rendered[96];
-      if (v->kind == SCR_DYN_STR) {
-        snprintf(rendered, sizeof rendered, "\"%.*s\"",
-                 (int)(v->v.str->len < 80 ? v->v.str->len : 80), v->v.str->data);
-      } else {
-        /* %j over non-strings: JSON.stringify's scalar renderings. */
-        char lite[64];
-        snprintf(rendered, sizeof rendered, "%s", scr_dyn_inspect_lite(v, lite, sizeof lite));
-      }
-      char msg[192];
-      int len = snprintf(msg, sizeof msg, "%s is not a valid %s TLS protocol version",
-                         rendered, VERSION_OPTS[i][2] == 'n' ? "minimum" : "maximum");
-      scr_throw_error_msg_code(SCR_ERR_TYPE, msg, (size_t)len, "ERR_TLS_INVALID_PROTOCOL_VERSION");
-      return false;
-    }
-  }
+  /* Node's toV: null and undefined select the default bound. */
+  int version;
+  if (!scr_tls_version_dyn(scr_dyn_obj_get(opts, "minVersion", 10), "minimum", 12, &version) ||
+      !scr_tls_version_dyn(scr_dyn_obj_get(opts, "maxVersion", 10), "maximum", 13, &version))
+    return false;
   static const char *const NUM_OPTS[] = { "handshakeTimeout", "keepAliveInitialDelay", NULL };
   for (size_t i = 0; NUM_OPTS[i] != NULL; i++) {
     const ScrDyn *v = scr_dyn_obj_get(opts, NUM_OPTS[i], strlen(NUM_OPTS[i]));
diff --git a/tests/corpus/6722-tls-min-max-version.ts b/tests/corpus/6722-tls-min-max-version.ts
index 07d01867d..70cddae52 100644
--- a/tests/corpus/6722-tls-min-max-version.ts
+++ b/tests/corpus/6722-tls-min-max-version.ts
@@ -4,7 +4,8 @@
 // ERR_SSL_TLSV1_ALERT_PROTOCOL_VERSION, a client range with neither TLSv1.2
 // nor TLSv1.3 fails with ERR_SSL_NO_PROTOCOLS_AVAILABLE once the handshake
 // starts, and an invalid version or a secureProtocol conflict throws Node's
-// TypeError from tls.connect.
+// TypeError from tls.connect and tls.createServer. null selects the default
+// bound, as undefined does.
 import * as tls from "node:tls";
 import { readFileSync } from "node:fs";
 
@@ -16,6 +17,17 @@ const key = readFileSync(dir + "localhost-key.pem");
 const upTo12 = tls.createServer({ cert, key, maxVersion: "TLSv1.2" }, (s) => s.end(`server:${s.getProtocol()}`));
 const from13 = tls.createServer({ cert, key, minVersion: "TLSv1.3" }, (s) => s.end(`server:${s.getProtocol()}`));
 const any = tls.createServer({ cert, key }, (s) => s.end(`server:${s.getProtocol()}`));
+const nullBounds = tls.createServer({ cert, key, minVersion: null as any, maxVersion: null as any }, (s) =>
+  s.end(`server:${s.getProtocol()}`),
+);
+for (const maxVersion of [3, "TLSv9"]) {
+  try {
+    tls.createServer({ cert, key, maxVersion: maxVersion as any });
+  } catch (e) {
+    const err = e as NodeJS.ErrnoException;
+    console.log("createServer", err.name, err.code, err.message);
+  }
+}
 
 function listen(server: tls.Server): Promise<number> {
   return new Promise<number>((resolve) =>
@@ -74,12 +86,16 @@ async function main(): Promise<void> {
   await attempt("max-1.1", pAny, { maxVersion: "TLSv1.1" });
   await attempt("min-above-max", pAny, { minVersion: "TLSv1.3", maxVersion: "TLSv1.2" });
   await attempt("null-min", pAny, { minVersion: null });
+  const pNull = await listen(nullBounds);
+  await attempt("null-server", pNull, {});
+  await attempt("null-both", pNull, { minVersion: null, maxVersion: null });
   await attempt("invalid-min", pAny, { minVersion: "TLSv9" });
   await attempt("invalid-max", pAny, { maxVersion: 3 });
   await attempt("conflict", pAny, { minVersion: "TLSv1.2", secureProtocol: "TLSv1_2_method" });
   upTo12.close();
   from13.close();
   any.close();
+  nullBounds.close();
 }
 
 void main();

From 23ec584deb26ef1d50834d548abd0c1a7b463604 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 13:24:10 -0500
Subject: [PATCH 12/67] Read nullable union chunks of push and write by their
 representation

Readable.push and Writable.write with a union chunk (Buffer, string and
null arms) read the chunk's tag and payload from a tagged union box. A
union with one reference arm and null, such as `string | null` or
`Buffer | null`, is the arm pointer itself, so `push(line)` with
`line: string | null` and `push(done ? null : text)` read past the
string and crashed. Both now read the tag and payload with unionTag and
unionPeek, as the other union consumers do. unshift and end refuse
union chunks and are unchanged.
---
 .../compiler/src/backend/llvm/lib-stream.ts   | 12 +--
 .../6820-stream-push-nullable-chunks.ts.json  |  6 ++
 ...6821-stream-write-nullable-chunks.cjs.json |  6 ++
 .../6820-stream-push-nullable-chunks.ts       | 77 +++++++++++++++++++
 .../6821-stream-write-nullable-chunks.cjs     | 23 ++++++
 .../6820-stream-push-nullable-chunks.ts.json  |  1 +
 ...6821-stream-write-nullable-chunks.cjs.json |  1 +
 7 files changed, 118 insertions(+), 8 deletions(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6820-stream-push-nullable-chunks.ts.json
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6821-stream-write-nullable-chunks.cjs.json
 create mode 100644 tests/corpus/6820-stream-push-nullable-chunks.ts
 create mode 100644 tests/corpus/6821-stream-write-nullable-chunks.cjs
 create mode 100644 tests/harness/corpus-costs/6820-stream-push-nullable-chunks.ts.json
 create mode 100644 tests/harness/corpus-costs/6821-stream-write-nullable-chunks.cjs.json

diff --git a/packages/compiler/src/backend/llvm/lib-stream.ts b/packages/compiler/src/backend/llvm/lib-stream.ts
index a319d0257..d3b4b1f5b 100644
--- a/packages/compiler/src/backend/llvm/lib-stream.ts
+++ b/packages/compiler/src/backend/llvm/lib-stream.ts
@@ -274,10 +274,9 @@ export function emitStreamLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlV
       .filter((a) => a.tag >= 0);
     if (present.length === 0)
       throw new InternalCompilerError(`llvm emitter bug: ${e.fn} union lacks its arms`);
-    const tagP = B.tmp();
-    const tag = B.tmp();
-    B.line(`${tagP} = getelementptr inbounds %ScrUnion, ptr ${args[1]!.name}, i64 0, i32 1`);
-    B.line(`${tag} = load i32, ptr ${tagP}`);
+    // A tagged box, or the arm pointer itself for a nullable union
+    // (`string | null`, `Buffer | null`).
+    const tag = host.unionTag(args[1]!.name, t.unionId);
     const slot = B.slot();
     B.entryAllocas.push(`${slot} = alloca i1`);
     const lj = B.newLabel("scu.j");
@@ -290,10 +289,7 @@ export function emitStreamLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlV
         B.line(`store i1 ${r}, ptr ${slot}`);
         return;
       }
-      const pk = B.tmp();
-      const pv = B.tmp();
-      B.line(`${pk} = getelementptr inbounds %ScrUnion, ptr ${args[1]!.name}, i64 0, i32 5`);
-      B.line(`${pv} = load ptr, ptr ${pk} ; borrowed payload`);
+      const pv = host.unionPeek(args[1]!.name, t.unionId); // borrowed payload
       const r = B.tmp();
       if (pushing) {
         host.declare(`declare zeroext i1 @${entry}(ptr, ptr)`);
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6820-stream-push-nullable-chunks.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6820-stream-push-nullable-chunks.ts.json
new file mode 100644
index 000000000..26bb4ae9e
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6820-stream-push-nullable-chunks.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6820-stream-push-nullable-chunks.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6821-stream-write-nullable-chunks.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6821-stream-write-nullable-chunks.cjs.json
new file mode 100644
index 000000000..e296beb66
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6821-stream-write-nullable-chunks.cjs.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6821-stream-write-nullable-chunks.cjs"
+ ],
+ "diags": []
+}
diff --git a/tests/corpus/6820-stream-push-nullable-chunks.ts b/tests/corpus/6820-stream-push-nullable-chunks.ts
new file mode 100644
index 000000000..5b79525b1
--- /dev/null
+++ b/tests/corpus/6820-stream-push-nullable-chunks.ts
@@ -0,0 +1,77 @@
+// Readable subclasses pushing `string | null` and `Buffer | null` chunks, a
+// conditional `push(done ? null : chunk)`, and writes of `string | Buffer`
+// chunks.
+import { Readable, Writable } from "node:stream";
+
+class Lines extends Readable {
+  private index = 0;
+  private readonly lines: string[];
+  constructor(lines: string[]) {
+    super();
+    this.lines = lines;
+  }
+  next(): string | null {
+    return this.index < this.lines.length ? this.lines[this.index++]! : null;
+  }
+  _read(): void {
+    const line: string | null = this.next();
+    this.push(line);
+  }
+}
+
+class Blocks extends Readable {
+  private sent = 0;
+  _read(): void {
+    const block: Buffer | null = this.sent < 3 ? Buffer.from([65 + this.sent, 10]) : null;
+    this.sent++;
+    this.push(block);
+  }
+}
+
+class Countdown extends Readable {
+  private left: number;
+  constructor(left: number) {
+    super({ encoding: "utf8" });
+    this.left = left;
+  }
+  _read(): void {
+    this.left--;
+    this.push(this.left < 0 ? null : `t-${this.left} `);
+  }
+}
+
+function collect(label: string, stream: Readable): Promise<void> {
+  return new Promise((resolve) => {
+    const parts: string[] = [];
+    stream.on("data", (chunk: Buffer | string) =>
+      parts.push(typeof chunk === "string" ? chunk : chunk.toString()),
+    );
+    stream.on("end", () => {
+      console.log(label, JSON.stringify(parts.join("")), parts.length);
+      resolve();
+    });
+  });
+}
+
+async function main(): Promise<void> {
+  await collect("lines", new Lines(["a\n", "bb\n", "ccc\n"]));
+  await collect("empty lines", new Lines([]));
+  await collect("blocks", new Blocks());
+  await collect("countdown", new Countdown(3));
+
+  const written: string[] = [];
+  const sink = new Writable({
+    write(chunk: Buffer, _encoding, callback) {
+      written.push(chunk.toString());
+      callback();
+    },
+  });
+  const pieces: (string | Buffer)[] = ["x", Buffer.from("y"), "z"];
+  for (const piece of pieces) {
+    const chunk: string | Buffer = piece;
+    console.log("write", Buffer.isBuffer(chunk) ? "buffer" : "string", sink.write(chunk));
+  }
+  sink.end(() => console.log("written", JSON.stringify(written.join(""))));
+}
+
+void main();
diff --git a/tests/corpus/6821-stream-write-nullable-chunks.cjs b/tests/corpus/6821-stream-write-nullable-chunks.cjs
new file mode 100644
index 000000000..c7bf32bc0
--- /dev/null
+++ b/tests/corpus/6821-stream-write-nullable-chunks.cjs
@@ -0,0 +1,23 @@
+// Writes and pushes of a chunk that is a string or null: a null write throws
+// ERR_STREAM_NULL_VALUES, and a null push ends the readable.
+const { Writable, Readable } = require("node:stream");
+const written = [];
+const sink = new Writable({
+  write(chunk, _encoding, callback) {
+    written.push(chunk.toString());
+    callback();
+  },
+});
+for (let i = 0; i < 3; i++) {
+  const chunk = i === 1 ? null : `c${i}`;
+  try {
+    console.log("write", JSON.stringify(chunk), sink.write(chunk));
+  } catch (error) {
+    console.log("write threw", error.name, error.code, error.message);
+  }
+}
+const r = new Readable({ read() {} });
+for (let i = 0; i < 3; i++) r.push(i === 2 ? null : `r${i}`);
+r.on("data", (d) => console.log("data", String(d)));
+r.on("end", () => console.log("end"));
+sink.end(() => console.log("written", JSON.stringify(written.join(""))));
diff --git a/tests/harness/corpus-costs/6820-stream-push-nullable-chunks.ts.json b/tests/harness/corpus-costs/6820-stream-push-nullable-chunks.ts.json
new file mode 100644
index 000000000..dd2eae649
--- /dev/null
+++ b/tests/harness/corpus-costs/6820-stream-push-nullable-chunks.ts.json
@@ -0,0 +1 @@
+{ "plain": 3100, "san": 41100 }
diff --git a/tests/harness/corpus-costs/6821-stream-write-nullable-chunks.cjs.json b/tests/harness/corpus-costs/6821-stream-write-nullable-chunks.cjs.json
new file mode 100644
index 000000000..24b9052ff
--- /dev/null
+++ b/tests/harness/corpus-costs/6821-stream-write-nullable-chunks.cjs.json
@@ -0,0 +1 @@
+{ "plain": 2400, "san": 40400 }

From 1d6f26a071f35f64b9a5addf20428fa37dfa4c89 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 13:26:50 -0500
Subject: [PATCH 13/67] Give arrays of a known final length exact dense
 capacity

---
 .../src/backend/llvm/expr-containers.ts       |  6 +-
 .../src/backend/llvm/expr-primitives.ts       | 16 ++++-
 .../array-exact-capacity-builders.ts.json     |  6 ++
 packages/runtime/src/scr_array.c              | 37 +++++++++++
 packages/runtime/src/scr_array.h              |  9 +++
 tests/corpus/array-exact-capacity-builders.ts | 65 +++++++++++++++++++
 .../array-exact-capacity-builders.ts.json     |  1 +
 7 files changed, 136 insertions(+), 4 deletions(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-exact-capacity-builders.ts.json
 create mode 100644 tests/corpus/array-exact-capacity-builders.ts
 create mode 100644 tests/harness/corpus-costs/array-exact-capacity-builders.ts.json

diff --git a/packages/compiler/src/backend/llvm/expr-containers.ts b/packages/compiler/src/backend/llvm/expr-containers.ts
index 8d1d1d28f..8970aa3be 100644
--- a/packages/compiler/src/backend/llvm/expr-containers.ts
+++ b/packages/compiler/src/backend/llvm/expr-containers.ts
@@ -647,10 +647,12 @@ export function emitArrIntrinsic(
       return { name: t, type: e.type };
     }
     case "concatSpread": {
+      // Appends to concat's fresh result: its storage grows to exactly
+      // the combined length (scr_arr_concat_copy_exact).
       const src = emitBorrowedInput(host, e.args[0]!);
-      host.declare(`declare double @scr_arr_concat_copy(ptr, ptr)`);
+      host.declare(`declare double @scr_arr_concat_copy_exact(ptr, ptr)`);
       const t = B.tmp();
-      B.line(`${t} = call double @scr_arr_concat_copy(ptr ${r.name}, ptr ${src.name})`);
+      B.line(`${t} = call double @scr_arr_concat_copy_exact(ptr ${r.name}, ptr ${src.name})`);
       return { name: t, type: e.type };
     }
     case "unshift": {
diff --git a/packages/compiler/src/backend/llvm/expr-primitives.ts b/packages/compiler/src/backend/llvm/expr-primitives.ts
index 69f4def2e..cc6053f4b 100644
--- a/packages/compiler/src/backend/llvm/expr-primitives.ts
+++ b/packages/compiler/src/backend/llvm/expr-primitives.ts
@@ -855,11 +855,15 @@ export function emitContainerExpr(
       const elem = e.type.elem;
       const arr = B.tmp();
       const small = host.appendedArrayLiterals.has(e);
-      const capacity = small ? 0 : (e.capacity ?? e.elems.length);
+      const spreadSet = new Set(e.spreads ?? []);
+      // With spreads, storage starts at the plain elements before the first
+      // spread, and each spread reserves exactly its source's length plus
+      // the plain elements up to the next one (scr_arr_reserve_spread).
+      const firstSpread = e.elems.findIndex((_, i) => spreadSet.has(i));
+      const capacity = small ? 0 : (e.capacity ?? (firstSpread < 0 ? e.elems.length : firstSpread));
       B.line(`${arr} = ${arrNewCall(host.shapeHost, elem, String(capacity), small)}`);
       const out = host.own({ name: arr, type: e.type });
       const acc = elemAccess(elem);
-      const spreadSet = new Set(e.spreads ?? []);
       let pending: LlValue[] = [];
       let buffer: string | undefined;
       const flush = (): void => {
@@ -874,6 +878,12 @@ export function emitContainerExpr(
         if (spreadSet.has(i)) {
           flush();
           const v = host.emitExpr(el);
+          let plain = 0;
+          for (let j = i + 1; j < e.elems.length && !spreadSet.has(j); j++) plain++;
+          host.declare(`declare void @scr_arr_reserve_spread(ptr, ptr, ${host.sizeType})`);
+          B.line(
+            `call void @scr_arr_reserve_spread(ptr ${arr}, ptr ${v.name}, ${host.sizeType} ${plain})`,
+          );
           host.emitArrayCopyLoop(arr, v.name, acc);
           return;
         }
@@ -895,6 +905,8 @@ export function emitContainerExpr(
       const n = host.emitExpr(e.length);
       const arr = B.tmp();
       B.line(`${arr} = ${arrNewCall(host.shapeHost, elem, "0")}`);
+      host.declare(`declare void @scr_arr_reserve_len(ptr, double)`);
+      B.line(`call void @scr_arr_reserve_len(ptr ${arr}, double ${n.name})`);
       const out = host.own({ name: arr, type: e.type });
       const acc = elemAccess(elem);
       let fill = acc === "f64" ? f64Lit(0) : acc === "bool" ? "false" : "null";
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-exact-capacity-builders.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-exact-capacity-builders.ts.json
new file mode 100644
index 000000000..20dc485de
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-exact-capacity-builders.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/array-exact-capacity-builders.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/runtime/src/scr_array.c b/packages/runtime/src/scr_array.c
index 51853afce..f8b5813a2 100644
--- a/packages/runtime/src/scr_array.c
+++ b/packages/runtime/src/scr_array.c
@@ -1470,6 +1470,14 @@ static void scr_arr_invalid_length(double length) {
   scr_throw_error_msg(SCR_ERR_RANGE, msg, sizeof msg - 1);
 }
 
+static void scr_arr_reserve_exact(ScrArr *a, size_t need);
+
+/* A length set on an empty array without storage of its own (`new
+ * Array(n)`, Array.prototype.map's result) reserves exactly that many
+ * slots, as holes, up to this many; the writes that fill the array then
+ * need no geometric growth. */
+#define SCR_ARR_PRESIZE_LIMIT ((size_t)1 << 16)
+
 void scr_arr_set_len(ScrArr *a, double length) {
   if (!(length >= 0) || !isfinite(length) || length != trunc(length) ||
       length > (double)SCR_ARR_MAX_LENGTH) {
@@ -1511,6 +1519,8 @@ void scr_arr_set_len(ScrArr *a, double length) {
       }
       if (scr_arr_ext_of(a)) scr_arr_ext_of(a)->sparse_len = scr_arr_sparse_lower_bound(scr_arr_ext_of(a)->sparse, scr_arr_ext_of(a)->sparse_len, next);
     }
+  } else if (a->len == 0 && next <= SCR_ARR_PRESIZE_LIMIT && (a->cap == 0 || scr_arr_inline(a))) {
+    scr_arr_reserve_exact(a, next);
   }
   a->len = next;
 }
@@ -2037,6 +2047,33 @@ double scr_arr_concat_copy(ScrArr *a, const ScrArr *src) {
   return SCR_ARR_LEN_F64(a->len);
 }
 
+/* Dense capacity of exactly `need` (rounded to the storage block) for an
+ * array whose final length is known: a fresh concat result, a spread
+ * literal, or a length set on an empty array. Arrays with sparse entries,
+ * and lengths past the dense cutoff, keep their ordinary growth. */
+static void scr_arr_reserve_exact(ScrArr *a, size_t need) {
+  if (need <= a->cap || need > SCR_ARR_DENSE_LIMIT || SCR_AX(a)->sparse_len != 0) return;
+  scr_arr_grow_dense_to(a, need, SCR_ARR_GROW_EXACT);
+}
+
+double scr_arr_concat_copy_exact(ScrArr *a, const ScrArr *src) {
+  if (src != a && scr_arr_is_dense(src) && src->len <= SCR_ARR_MAX_LENGTH - a->len)
+    scr_arr_reserve_exact(a, (size_t)a->len + src->len);
+  return scr_arr_concat_copy(a, src);
+}
+
+void scr_arr_reserve_spread(ScrArr *a, const ScrArr *src, size_t plain) {
+  if (src == a || !scr_arr_is_dense(src)) return;
+  size_t need = (size_t)a->len + src->len;
+  if (plain > SCR_ARR_DENSE_LIMIT || need > SCR_ARR_DENSE_LIMIT) return;
+  scr_arr_reserve_exact(a, need + plain);
+}
+
+void scr_arr_reserve_len(ScrArr *a, double n) {
+  if (!(n >= 1) || n > (double)SCR_ARR_DENSE_LIMIT) return;
+  scr_arr_reserve_exact(a, (size_t)n);
+}
+
 /* ── unshift / reverse ──────────────────────────────────────────────────
  * Single-element unshift takes ownership, matching push. The emitter calls
  * it from right to left after evaluating every variadic argument, preserving
diff --git a/packages/runtime/src/scr_array.h b/packages/runtime/src/scr_array.h
index 95ee7ce00..2068a324d 100644
--- a/packages/runtime/src/scr_array.h
+++ b/packages/runtime/src/scr_array.h
@@ -442,6 +442,15 @@ double scr_arr_unshift_many(ScrArr *a, size_t count, const uint64_t *slots);
 double scr_arr_push_spread(ScrArr *a, const ScrArr *src);
 /* Append a concat argument by indexed property copy, preserving holes. */
 double scr_arr_concat_copy(ScrArr *a, const ScrArr *src);
+/* The same append for Array.prototype.concat's fresh result: dense storage
+ * grows to exactly the combined length instead of geometrically. */
+double scr_arr_concat_copy_exact(ScrArr *a, const ScrArr *src);
+/* Exact dense capacity for an array literal about to copy `src` and then
+ * `plain` more elements (a spread position). */
+void scr_arr_reserve_spread(ScrArr *a, const ScrArr *src, size_t plain);
+/* Exact dense capacity for `n` elements of an array that is filled to that
+ * length next (Array.from({ length: n })); no effect for other lengths. */
+void scr_arr_reserve_len(ScrArr *a, double n);
 
 /* unshift returns the new length and _ref takes ownership. The spread form
  * borrows a same-element-kind source, retains copied refs, and snapshots
diff --git a/tests/corpus/array-exact-capacity-builders.ts b/tests/corpus/array-exact-capacity-builders.ts
new file mode 100644
index 000000000..da3a587ed
--- /dev/null
+++ b/tests/corpus/array-exact-capacity-builders.ts
@@ -0,0 +1,65 @@
+// Arrays whose final length is known while they are built: map results,
+// new Array(n) filled by index, concat results, spread literals and
+// Array.from({ length: n }). Holes, lengths and later appends behave as
+// in JavaScript.
+class Item {
+  id: number;
+  constructor(id: number) {
+    this.id = id;
+  }
+}
+const items: Item[] = [];
+for (let i = 0; i < 9; i++) items.push(new Item(i));
+const ids = (xs: Item[]): string => xs.map((x) => x.id).join(",");
+
+const doubled = items.map((x) => new Item(x.id * 2));
+console.log(doubled.length, ids(doubled));
+doubled.push(new Item(99));
+console.log(doubled.length, ids(doubled));
+
+const filled: Item[] = new Array<Item>(5);
+for (let i = 0; i < filled.length; i++) filled[i] = items[i]!;
+console.log(filled.length, ids(filled));
+const partial: number[] = new Array<number>(6);
+partial[1] = 10;
+partial[4] = 40;
+console.log(partial.length, 0 in partial, 1 in partial, JSON.stringify(partial));
+partial.push(7);
+console.log(partial.length, JSON.stringify(partial));
+
+const wide: number[] = [];
+wide.length = 200000;
+wide[150000] = 1;
+console.log(wide.length, wide[150000], 5 in wide);
+const empty: number[] = [];
+empty.length = 0;
+empty.push(3);
+console.log(empty.length, empty[0]);
+
+const left = items.slice(0, 3);
+const right = items.slice(3, 7);
+const joined = left.concat(right, items.slice(8));
+console.log(joined.length, ids(joined));
+const holey: number[] = [1, 2, 3];
+holey.length = 5;
+const withHoles = holey.concat([6, 7]);
+console.log(withHoles.length, 3 in withHoles, 4 in withHoles, JSON.stringify(withHoles));
+
+const spread = [new Item(-1), ...left, new Item(-2), ...right, new Item(-3)];
+console.log(spread.length, ids(spread));
+const spreadHoles = [...holey, 9];
+console.log(spreadHoles.length, 3 in spreadHoles, JSON.stringify(spreadHoles));
+const self = [...left, ...left];
+console.log(self.length, ids(self));
+
+const zeros = Array.from({ length: 7 }, () => 0);
+console.log(zeros.length, zeros.join(""));
+const counted = Array.from({ length: 4 }, (_, i) => i * i);
+console.log(counted.join(","));
+const none = Array.from({ length: 0 }, () => 1);
+console.log(none.length);
+
+const sparseSource: number[] = [];
+sparseSource[3] = 30;
+const mapped = sparseSource.map((x) => x + 1);
+console.log(mapped.length, 0 in mapped, 3 in mapped, mapped[3]);
diff --git a/tests/harness/corpus-costs/array-exact-capacity-builders.ts.json b/tests/harness/corpus-costs/array-exact-capacity-builders.ts.json
new file mode 100644
index 000000000..5a4cc1dfd
--- /dev/null
+++ b/tests/harness/corpus-costs/array-exact-capacity-builders.ts.json
@@ -0,0 +1 @@
+{ "plain": 4230, "san": 6130 }

From a7e84cd48c34bfee5ab3c5e09460e0d85d5b069d Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 13:56:07 -0500
Subject: [PATCH 14/67] Support SNICallback in tls.createServer

tls.createServer({ cert, key, SNICallback }) hands each ClientHello's
servername to the callback and serves the SecureContext it answers,
synchronously or later, or the default cert and key when it answers none.
An error answer closes that connection. This uses the SNI handling that
http2.createSecureServer already has. A callback expression with side
effects, or SNICallback combined with ALPNProtocols, minVersion, maxVersion
or the other options the runtime walk reads, fails with SC2020.

A tls.connect or https.request client whose peer closes or resets the
connection before the handshake completes now fails with Node's ECONNRESET
"Client network socket disconnected before secure TLS connection was
established" instead of closing without an error.

Refs #1438

Co-authored-by: saboursepideh <25549001+saboursepideh@users.noreply.github.com>
---
 .../compiler/src/backend/llvm/lib-http2.ts    |  34 ++--
 packages/compiler/src/backend/llvm/lib-tls.ts |  22 +++
 .../src/frontend/lowering/lower-server.ts     | 157 ++++++++++++------
 .../compiler/src/ir/builtin-signatures.ts     |   5 +
 .../corpus/6933-tls-sni-callback.ts.json      |   6 +
 .../6934-tls-handshake-disconnect.ts.json     |   6 +
 .../tls-sni-callback-fences.ts.json           |   6 +
 packages/runtime/src/scr_error.c              |   6 +-
 packages/runtime/src/scr_tls.c                |  35 +++-
 packages/runtime/src/scr_tls.h                |   3 +
 tests/corpus/6933-tls-sni-callback.ts         |  65 ++++++++
 tests/corpus/6934-tls-handshake-disconnect.ts |  27 +++
 tests/diagnostics/tls-sni-callback-fences.ts  |  15 ++
 .../tls-sni-callback-fences.ts.txt            |  17 ++
 14 files changed, 330 insertions(+), 74 deletions(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6933-tls-sni-callback.ts.json
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6934-tls-handshake-disconnect.ts.json
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/tls-sni-callback-fences.ts.json
 create mode 100644 tests/corpus/6933-tls-sni-callback.ts
 create mode 100644 tests/corpus/6934-tls-handshake-disconnect.ts
 create mode 100644 tests/diagnostics/tls-sni-callback-fences.ts
 create mode 100644 tests/harness/__snapshots__/tls-sni-callback-fences.ts.txt

diff --git a/packages/compiler/src/backend/llvm/lib-http2.ts b/packages/compiler/src/backend/llvm/lib-http2.ts
index 0254db555..791987f86 100644
--- a/packages/compiler/src/backend/llvm/lib-http2.ts
+++ b/packages/compiler/src/backend/llvm/lib-http2.ts
@@ -3,6 +3,7 @@ import type { IrType } from "../../ir/ir.js";
 import { typeKey } from "../../ir/ir.js";
 import type { LibCallExpr, LlValue, LlvmEmitterContext } from "./expr-context.js";
 import {
+  type AbiArgument,
   abiValue,
   callbackAdapter,
   callbackType,
@@ -84,6 +85,23 @@ function sniAnswer(host: LlvmEmitterContext, type: IrType): string {
   return symbol;
 }
 
+/** The (closure, answer thunk) pair of an SNICallback argument: a function,
+ * or a function | undefined union whose undefined arm passes no callback. */
+export function sniCallbackArgs(host: LlvmEmitterContext, cb: LlValue): AbiArgument[] {
+  let type = cb.type,
+    value = cb.name;
+  if (type.kind === "union") {
+    const arms = host.unionsById.get(type.unionId)?.arms ?? [];
+    const tag = arms.findIndex((arm) => arm.kind === "func");
+    if (tag < 0) throw new InternalCompilerError("SNI callback union lacks its function arm");
+    type = arms[tag]!;
+    value = host.unwrapNullableClosure(value, tag);
+  } else host.toHeap(cb);
+  if (type.kind !== "func" || type.params[1] === undefined)
+    throw new InternalCompilerError("SNI callback lacks its answer function");
+  return [ptr(value), ptr("@" + sniAnswer(host, type.params[1]))];
+}
+
 export function emitHttp2LibCall(host: LlvmEmitterContext, e: LibCallExpr): LlValue {
   const args = e.args.map((arg) => host.emitExpr(arg)),
     a = args.map((arg) => abiValue(host, arg));
@@ -160,21 +178,7 @@ export function emitHttp2LibCall(host: LlvmEmitterContext, e: LibCallExpr): LlVa
       let handler = [ptr(), ptr()],
         sni = [ptr(), ptr()];
       if (e.fn === "http2.createSecureServerReq") handler = requestHandler(host, args[2]!);
-      if (e.fn === "http2.createSecureServerSni") {
-        const cb = args[2]!;
-        let type = cb.type,
-          value = cb.name;
-        if (type.kind === "union") {
-          const arms = host.unionsById.get(type.unionId)?.arms ?? [];
-          const tag = arms.findIndex((arm) => arm.kind === "func");
-          if (tag < 0) throw new InternalCompilerError("SNI callback union lacks its function arm");
-          type = arms[tag]!;
-          value = host.unwrapNullableClosure(value, tag);
-        } else host.toHeap(cb);
-        if (type.kind !== "func" || type.params[1] === undefined)
-          throw new InternalCompilerError("SNI callback lacks its answer function");
-        sni = [ptr(value), ptr("@" + sniAnswer(host, type.params[1]))];
-      }
+      if (e.fn === "http2.createSecureServerSni") sni = sniCallbackArgs(host, args[2]!);
       return finishRuntimeCall(host, e, "scr_http2_create_secure_server_allow_http1", [
         ...rawBytes(host, args[0]!),
         ...rawBytes(host, args[1]!),
diff --git a/packages/compiler/src/backend/llvm/lib-tls.ts b/packages/compiler/src/backend/llvm/lib-tls.ts
index 18fc006d4..c5c77d3a6 100644
--- a/packages/compiler/src/backend/llvm/lib-tls.ts
+++ b/packages/compiler/src/backend/llvm/lib-tls.ts
@@ -11,6 +11,7 @@ import {
   rawBytes,
   requestHandler,
 } from "./lib-abi.js";
+import { sniCallbackArgs } from "./lib-http2.js";
 import { emitAlwaysThrowLibCall } from "./lib-shared.js";
 
 export function emitTlsLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlValue {
@@ -43,6 +44,27 @@ export function emitTlsLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlValu
         [...rawBytes(host, args[0]!), ...rawBytes(host, args[1]!), ...handler],
       );
     }
+    case "tls.createServerSni":
+    case "tls.createServerSniCb": {
+      const cb = args[3];
+      const handler =
+        cb === undefined
+          ? [ptr(), ptr()]
+          : callbackAdapter(
+              host,
+              cb,
+              callbackType(cb).params.length === 0
+                ? "scr_net_conn_thunk0"
+                : "scr_net_conn_thunk_sock",
+              ["ptr", "ptr"],
+            );
+      return finishRuntimeCall(host, e, "scr_tls_create_server_sni", [
+        ...rawBytes(host, args[0]!),
+        ...rawBytes(host, args[1]!),
+        ...handler,
+        ...sniCallbackArgs(host, args[2]!),
+      ]);
+    }
     case "tls.createServerDyn":
     case "tls.createServerDynCb":
     case "https.createServerDyn":
diff --git a/packages/compiler/src/frontend/lowering/lower-server.ts b/packages/compiler/src/frontend/lowering/lower-server.ts
index 4a7c00d84..c27b2513e 100644
--- a/packages/compiler/src/frontend/lowering/lower-server.ts
+++ b/packages/compiler/src/frontend/lowering/lower-server.ts
@@ -4749,7 +4749,8 @@ function lowerTlsServerOptions(
   lowerer: Lowerer,
   node: ts.Expression,
   what: string,
-): { cert: IrExpr; key: IrExpr } {
+  allowSni = false,
+): { cert: IrExpr; key: IrExpr; sni?: IrExpr } {
   if (!ts.isObjectLiteralExpression(node)) {
     lowerer.noLowering(
       `${what} with a non-literal options argument`,
@@ -4760,6 +4761,7 @@ function lowerTlsServerOptions(
   const loc = locOf(node);
   let cert: IrExpr | null = null;
   let key: IrExpr | null = null;
+  let sni: IrExpr | undefined;
   for (const prop of node.properties.nodes) {
     let initializer: ts.Expression | null;
     if (
@@ -4777,6 +4779,23 @@ function lowerTlsServerOptions(
       );
     }
     const k = (prop.name as ts.Identifier | ts.StringLiteral).text;
+    if (k === "SNICallback" && allowSni) {
+      // The callback is a value read (a function or a binding), so it may
+      // be read after cert and key without changing what the program sees.
+      if (initializer !== null && !sideEffectFreeOptionValue(initializer)) {
+        lowerer.noLowering(
+          `a ${what} SNICallback expression with side effects`,
+          prop,
+          "pass a function or a variable that holds one",
+        );
+      }
+      const value =
+        initializer !== null
+          ? lowerer.lowerExpr(initializer)
+          : lowerer.lowerShorthandValue(prop as ts.ShorthandPropertyAssignment);
+      sni = checkSniCallbackValue(lowerer, value, prop, what);
+      continue;
+    }
     if (k !== "cert" && k !== "key") {
       const init = ts.isPropertyAssignment(prop) ? prop.initializer : null;
       if (
@@ -4801,7 +4820,7 @@ function lowerTlsServerOptions(
         "cert and key (PEM strings or Buffers) are the supported options",
         {
           SNICallback:
-            "SNICallback lowers only on http2.createSecureServer({ allowHTTP1: true, ... }) — serve one cert/key pair here",
+            "SNICallback lowers on tls.createServer and http2.createSecureServer({ allowHTTP1: true, ... }) — serve one cert/key pair here",
           requestCert:
             "client-certificate handshakes are not modeled (SEMANTICS.md divergence 55) — requestCert: false is the lowered value",
         },
@@ -4848,7 +4867,7 @@ function lowerTlsServerOptions(
       "the supported options object is { cert, key } (PEM strings or Buffers)",
     );
   }
-  return { cert, key };
+  return sni === undefined ? { cert, key } : { cert, key, sni };
 }
 
 /** The options argument of tls/https createServer, split three ways: an
@@ -4911,12 +4930,24 @@ function lowerTlsServerOptionsOrDyn(
   what: string,
   includeHttpTimeoutOptions = false,
   runtimeKeys: ReadonlySet<string> = new Set(),
-): { cert: IrExpr; key: IrExpr; dyn?: undefined } | { dyn: IrExpr } {
-  if (
-    ts.isObjectLiteralExpression(node) &&
-    !tlsLiteralNeedsRuntimeWalk(node, includeHttpTimeoutOptions, runtimeKeys)
-  ) {
-    return lowerTlsServerOptions(lowerer, node, what);
+  allowSni = false,
+): { cert: IrExpr; key: IrExpr; sni?: IrExpr; dyn?: undefined } | { dyn: IrExpr } {
+  if (ts.isObjectLiteralExpression(node)) {
+    if (!tlsLiteralNeedsRuntimeWalk(node, includeHttpTimeoutOptions, runtimeKeys))
+      return lowerTlsServerOptions(lowerer, node, what, allowSni);
+    const sniOption = node.properties.nodes.find(
+      (p) =>
+        (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
+        (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) &&
+        p.name.text === "SNICallback",
+    );
+    if (allowSni && sniOption !== undefined) {
+      lowerer.noLowering(
+        `${what} with SNICallback and options the runtime walk reads`,
+        sniOption,
+        "SNICallback lowers with cert and key; ALPNProtocols, minVersion, maxVersion and the validated options are not combined with it yet",
+      );
+    }
   }
   const v = lowerer.lowerExpr(node);
   if (v.type.kind === "dyn") return { dyn: v };
@@ -5078,10 +5109,25 @@ function lowerTlsModuleCall(
       "tls.createServer",
       false,
       TLS_SERVER_RUNTIME_OPTIONS,
+      true,
     );
     if (args.length === 1) {
-      return opts.dyn !== undefined
-        ? { kind: "libCall", fn: "tls.createServerDyn", args: [opts.dyn], type: NETSERVER_T, loc }
+      if (opts.dyn !== undefined)
+        return {
+          kind: "libCall",
+          fn: "tls.createServerDyn",
+          args: [opts.dyn],
+          type: NETSERVER_T,
+          loc,
+        };
+      return opts.sni !== undefined
+        ? {
+            kind: "libCall",
+            fn: "tls.createServerSni",
+            args: [opts.cert, opts.key, opts.sni],
+            type: NETSERVER_T,
+            loc,
+          }
         : {
             kind: "libCall",
             fn: "tls.createServer",
@@ -5099,11 +5145,19 @@ function lowerTlsModuleCall(
       "use (socket) or ()",
       [NETSOCKET_T],
     );
-    return opts.dyn !== undefined
+    if (opts.dyn !== undefined)
+      return {
+        kind: "libCall",
+        fn: "tls.createServerDynCb",
+        args: [opts.dyn, cb],
+        type: NETSERVER_T,
+        loc,
+      };
+    return opts.sni !== undefined
       ? {
           kind: "libCall",
-          fn: "tls.createServerDynCb",
-          args: [opts.dyn, cb],
+          fn: "tls.createServerSniCb",
+          args: [opts.cert, opts.key, opts.sni, cb],
           type: NETSERVER_T,
           loc,
         }
@@ -5481,6 +5535,44 @@ const SNI_HINT =
   "...(x ? { SNICallback: x } : {}) — the callback is (servername, cb) => void " +
   "with cb: (err: Error | null, ctx?: tls.SecureContext) => void";
 
+/** An SNICallback option value: (servername: string, cb) => void where cb
+ * is (err: Error | null, ctx?: SecureContext) => void, or that function
+ * unioned with undefined (no callback). cb may declare fewer params (the
+ * emitted answer thunk matches its ABI), but what it does declare must
+ * carry the arms the thunk decodes. */
+function lowerSniCallbackValue(
+  lowerer: Lowerer,
+  node: ts.Expression,
+  blame: ts.Node,
+  what: string,
+): IrExpr {
+  return checkSniCallbackValue(lowerer, lowerer.lowerExpr(node), blame, what);
+}
+
+function checkSniCallbackValue(lowerer: Lowerer, v: IrExpr, blame: ts.Node, what: string): IrExpr {
+  const shapeOk = (t: IrType): boolean => {
+    if (t.kind !== "func" || t.ret.kind !== "void" || t.params.length !== 2) return false;
+    if (t.params[0]!.kind !== "string") return false;
+    const cbT = t.params[1]!;
+    if (cbT.kind !== "func" || cbT.ret.kind !== "void" || cbT.params.length > 2) return false;
+    const armKinds = (u: IrType): string[] =>
+      u.kind === "union" ? (lowerer.unions.get(u.unionId)?.arms ?? []).map((a) => a.kind) : [];
+    const p0 = cbT.params[0];
+    if (p0 !== undefined && !armKinds(p0).includes("nullT")) return false;
+    const p1 = cbT.params[1];
+    if (p1 !== undefined && !armKinds(p1).includes("secureCtx")) return false;
+    return true;
+  };
+  const arms = v.type.kind === "union" ? (lowerer.unions.get(v.type.unionId)?.arms ?? []) : [];
+  const funcArm = v.type.kind === "func" ? v.type : arms.find((a) => a.kind === "func");
+  const unionOk =
+    v.type.kind !== "union" || (arms.length === 2 && arms.some((a) => a.kind === "undefinedT"));
+  if (funcArm === undefined || !unionOk || !shapeOk(funcArm)) {
+    lowerer.noLowering(`a ${what} SNICallback of '${lowerer.fmt(v.type)}' values`, blame, SNI_HINT);
+  }
+  return v;
+}
+
 /** Strips parentheses and type assertions: the portless spelling wraps
  * an options spread as `...({ ... } as Record<string, unknown>)`. */
 function stripParensAndCasts(node: ts.Expression): ts.Expression {
@@ -5733,43 +5825,8 @@ function lowerHttp2ModuleCall(
     let sni: IrExpr | null = null;
     let allowHttp1 = false;
     let enableConnectProtocol = false;
-    // The SNICallback value shape: (servername: string, cb) => void where
-    // cb is (err: Error | null, ctx?: SecureContext) => void — cb may
-    // declare fewer params (the emitted answer thunk matches its ABI),
-    // but what it does declare must carry the arms the thunk decodes.
-    const sniShapeOk = (t: IrType): boolean => {
-      if (t.kind !== "func" || t.ret.kind !== "void" || t.params.length !== 2) return false;
-      if (t.params[0]!.kind !== "string") return false;
-      const cbT = t.params[1]!;
-      if (cbT.kind !== "func" || cbT.ret.kind !== "void" || cbT.params.length > 2) return false;
-      const armKinds = (u: IrType): string[] =>
-        u.kind === "union" ? (lowerer.unions.get(u.unionId)?.arms ?? []).map((a) => a.kind) : [];
-      const p0 = cbT.params[0];
-      if (p0 !== undefined && !armKinds(p0).includes("nullT")) return false;
-      const p1 = cbT.params[1];
-      if (p1 !== undefined && !armKinds(p1).includes("secureCtx")) return false;
-      return true;
-    };
     const lowerSniValue = (node: ts.Expression, blame: ts.Node): void => {
-      const v = lowerer.lowerExpr(node);
-      const funcArm =
-        v.type.kind === "func"
-          ? v.type
-          : v.type.kind === "union"
-            ? (lowerer.unions.get(v.type.unionId)?.arms ?? []).find((a) => a.kind === "func")
-            : undefined;
-      const unionOk =
-        v.type.kind !== "union" ||
-        ((lowerer.unions.get(v.type.unionId)?.arms ?? []).length === 2 &&
-          (lowerer.unions.get(v.type.unionId)?.arms ?? []).some((a) => a.kind === "undefinedT"));
-      if (funcArm === undefined || !unionOk || !sniShapeOk(funcArm)) {
-        lowerer.noLowering(
-          `a createSecureServer SNICallback of '${lowerer.fmt(v.type)}' values`,
-          blame,
-          SNI_HINT,
-        );
-      }
-      sni = v;
+      sni = lowerSniCallbackValue(lowerer, node, blame, "createSecureServer");
     };
     const lowerOption = (prop: ts.ObjectLiteralElementLike): void => {
       if (ts.isSpreadAssignment(prop)) {
diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts
index 9f383c695..da045a6f5 100644
--- a/packages/compiler/src/ir/builtin-signatures.ts
+++ b/packages/compiler/src/ir/builtin-signatures.ts
@@ -2110,6 +2110,11 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
    * surface — the handles are the same kinds. */
   "tls.createServer": { argTypes: [null, null], result: NETSERVER_T },
   "tls.createServerCb": { argTypes: [null, null, null], result: NETSERVER_T },
+  /** The SNICallback forms: (cert, key, SNICallback[, handler]). The
+   * callback is http2.createSecureServerSni's shape, a function or a
+   * function | undefined union. */
+  "tls.createServerSni": { argTypes: [null, null, null], result: NETSERVER_T },
+  "tls.createServerSniCb": { argTypes: [null, null, null, null], result: NETSERVER_T },
   // The runtime options records (divergence 66's stance): a dyn options
   // value whose members read at runtime; pemDyn extracts a runtime-valued
   // cert/key member (arg 1 is the precomposed fence label).
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6933-tls-sni-callback.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6933-tls-sni-callback.ts.json
new file mode 100644
index 000000000..4cf80592f
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6933-tls-sni-callback.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6933-tls-sni-callback.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6934-tls-handshake-disconnect.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6934-tls-handshake-disconnect.ts.json
new file mode 100644
index 000000000..ae362a423
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6934-tls-handshake-disconnect.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6934-tls-handshake-disconnect.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/tls-sni-callback-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/tls-sni-callback-fences.ts.json
new file mode 100644
index 000000000..ee2ea72f0
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/tls-sni-callback-fences.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/diagnostics/tls-sni-callback-fences.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/runtime/src/scr_error.c b/packages/runtime/src/scr_error.c
index 94523fc43..b974474bf 100644
--- a/packages/runtime/src/scr_error.c
+++ b/packages/runtime/src/scr_error.c
@@ -409,13 +409,15 @@ SCR_TL ScrError *scr_event_error_payload = NULL;
 
 /* The code Node attaches to the runtime's event-error messages whose text
  * carries no errno name: connResetException's "socket hang up" and
- * "aborted", the HTTP parser's header overflow, and the TLS verification
- * failures (the openssl reason Node reports as the code). NULL for any
+ * "aborted", the TLS client's disconnect before the handshake completes,
+ * the HTTP parser's header overflow, and the TLS verification failures (the openssl reason Node reports as the code). NULL for any
  * other message. */
 const char *scr_error_message_code(const ScrStr *msg) {
   static const struct { const char *prefix; bool whole; const char *code; } known[] = {
     { "socket hang up", true, "ECONNRESET" },
     { "aborted", true, "ECONNRESET" },
+    { "Client network socket disconnected before secure TLS connection was established", true,
+      "ECONNRESET" },
     { "Parse Error: Header overflow", true, "HPE_HEADER_OVERFLOW" },
     { "certificate has expired", true, "CERT_HAS_EXPIRED" },
     { "self-signed certificate in certificate chain", true, "SELF_SIGNED_CERT_IN_CHAIN" },
diff --git a/packages/runtime/src/scr_tls.c b/packages/runtime/src/scr_tls.c
index 526dd7760..b4d125cb2 100644
--- a/packages/runtime/src/scr_tls.c
+++ b/packages/runtime/src/scr_tls.c
@@ -1057,10 +1057,10 @@ static int scr_tls_handshake(void *tctx) {
   if (r == MBEDTLS_ERR_X509_CERT_VERIFY_FAILED) {
     scr_tls_verify_msg(t, msg, sizeof msg);
   } else if (r == MBEDTLS_ERR_SSL_CONN_EOF || r == MBEDTLS_ERR_NET_CONN_RESET) {
-    /* the peer died mid-handshake: the http layer's own premature-close
-     * shape ('socket hang up') is Node's message — tear down without an error
-     * at this level and let the closed hook classify it */
-    scr_net_sock_transport_error(t->sock, NULL);
+    /* The peer closed or reset the connection mid-handshake: Node's
+     * ECONNRESET for tls.connect and https.request alike. */
+    scr_net_sock_transport_error(
+        t->sock, "Client network socket disconnected before secure TLS connection was established");
     return -1;
   } else if (r == MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE &&
              t->ssl.MBEDTLS_PRIVATE(in_msg) != NULL &&
@@ -1170,8 +1170,15 @@ static ScrNetServer *scr_tls_create_server_alpn(const char *cert, size_t cert_le
                                                 const char *key, size_t key_len,
                                                 ScrClosure *handler /*moves, nullable*/,
                                                 ScrNetConnFn fn, char **alpn /*moves, nullable*/,
-                                                int min_version, int max_version) {
+                                                int min_version, int max_version,
+                                                ScrClosure *sni_cb /*moves, nullable*/,
+                                                void *sni_answer_fn) {
   ScrTlsSrv *srv = scr_tls_srv_new(cert, cert_len, key, key_len, false);
+  if (sni_cb != NULL) {
+    srv->sni_cb = sni_cb; /* moves; released with srv */
+    srv->sni_answer_fn = sni_answer_fn;
+    mbedtls_ssl_conf_sni(&srv->conf, &scr_tls_f_sni, NULL);
+  }
   srv->max_tls12 = max_version == 12;
   if (!scr_tls_conf_versions(&srv->conf, min_version, max_version)) {
     /* Node's server then fails every handshake; nothing here models
@@ -1198,7 +1205,21 @@ static ScrNetServer *scr_tls_create_server_alpn(const char *cert, size_t cert_le
 ScrNetServer *scr_tls_create_server(const char *cert, size_t cert_len, const char *key,
                                      size_t key_len, ScrClosure *handler /*moves, nullable*/,
                                      ScrNetConnFn fn) {
-  return scr_tls_create_server_alpn(cert, cert_len, key, key_len, handler, fn, NULL, 12, 13);
+  return scr_tls_create_server_alpn(cert, cert_len, key, key_len, handler, fn, NULL, 12, 13, NULL,
+                                    NULL);
+}
+
+/* tls.createServer({ cert, key, SNICallback }): the pre-parse machinery
+ * (design note atop the SNI section) hands each ClientHello's servername
+ * to the callback and serves the context it answers, or the default pair
+ * for none. A NULL sni_cb (the callback union's undefined arm) is
+ * scr_tls_create_server. */
+ScrNetServer *scr_tls_create_server_sni(const char *cert, size_t cert_len, const char *key,
+                                         size_t key_len, ScrClosure *handler /*moves, nullable*/,
+                                         ScrNetConnFn fn, ScrClosure *sni_cb /*moves, nullable*/,
+                                         void *sni_answer_fn) {
+  return scr_tls_create_server_alpn(cert, cert_len, key, key_len, handler, fn, NULL, 12, 13, sni_cb,
+                                    sni_answer_fn);
 }
 
 ScrNetServer *scr_https_create_server(const char *cert, size_t cert_len, const char *key,
@@ -2024,7 +2045,7 @@ ScrNetServer *scr_tls_create_server_dyn(const ScrDyn *opts /*borrowed*/,
   }
   ScrNetServer *s = scr_tls_create_server_alpn((const char *)cert->data, cert->len,
                                                 (const char *)key->data, key->len, handler, fn,
-                                                alpn, min_version, max_version);
+                                                alpn, min_version, max_version, NULL, NULL);
   scr_bytes_release(cert);
   scr_bytes_release(key);
   return s;
diff --git a/packages/runtime/src/scr_tls.h b/packages/runtime/src/scr_tls.h
index 0b1714eb3..fcb221b42 100644
--- a/packages/runtime/src/scr_tls.h
+++ b/packages/runtime/src/scr_tls.h
@@ -15,6 +15,9 @@
  * (port 443 default, `ca` / rejectUnauthorized for local-CA flows —
  * cert/key/ca all arrive as borrowed PEM bytes). */
 ScrNetServer *scr_tls_create_server(const char *cert, size_t cert_len, const char *key, size_t key_len, ScrClosure *handler /*moves, nullable*/, ScrNetConnFn fn); /* +1 */
+/* The SNICallback form: sni_cb (moves, nullable) receives (servername, answer), and
+ * sni_answer_fn is the emitted thunk that hands the answer to scr_tls_sni_answer. */
+ScrNetServer *scr_tls_create_server_sni(const char *cert, size_t cert_len, const char *key, size_t key_len, ScrClosure *handler /*moves, nullable*/, ScrNetConnFn fn, ScrClosure *sni_cb /*moves, nullable*/, void *sni_answer_fn); /* +1 */
 
 /* ── RUNTIME tls/https options records (the divergence-66 stance: a
  * non-literal options value reads its members at runtime; members whose
diff --git a/tests/corpus/6933-tls-sni-callback.ts b/tests/corpus/6933-tls-sni-callback.ts
new file mode 100644
index 000000000..7958882d5
--- /dev/null
+++ b/tests/corpus/6933-tls-sni-callback.ts
@@ -0,0 +1,65 @@
+// tls.createServer with an SNICallback: the callback receives each
+// ClientHello's servername and answers a SecureContext synchronously or
+// later, or none, so the default cert/key pair serves; an error answer
+// fails that handshake. Clients that trust the CA see the certificate the
+// answer chose: alt.localhost verifies only with the alt context, and a
+// name served the default localhost pair fails Node's hostname check.
+import { readFileSync } from "node:fs";
+import * as net from "node:net";
+import * as tls from "node:tls";
+
+const certs = "tests/fixtures/server/certs";
+const ca = readFileSync(`${certs}/ca.pem`);
+const cert = readFileSync(`${certs}/localhost.pem`);
+const key = readFileSync(`${certs}/localhost-key.pem`);
+const altContext = tls.createSecureContext({
+  cert: readFileSync(`${certs}/alt.pem`),
+  key: readFileSync(`${certs}/alt-key.pem`),
+});
+
+const server = tls.createServer(
+  {
+    cert,
+    key,
+    SNICallback: (servername: string, cb: (err: Error | null, ctx?: tls.SecureContext) => void) => {
+      console.log("sni", servername);
+      if (servername === "alt.localhost") setTimeout(() => cb(null, altContext), 5);
+      else if (servername === "fail.localhost") cb(new Error(`no certificate for ${servername}`));
+      else cb(null, undefined);
+    },
+  },
+  (socket) => {
+    socket.end("hello");
+  },
+);
+
+function attempt(port: number, servername: string, next: () => void): void {
+  let done = false;
+  const finish = (line: string): void => {
+    if (done) return;
+    done = true;
+    console.log(servername, line);
+    next();
+  };
+  const socket = tls.connect({ port, host: "127.0.0.1", servername, ca }, () => {
+    let text = "";
+    socket.on("data", (data: Buffer) => {
+      text += data.toString();
+    });
+    socket.on("end", () => finish(`authorized ${socket.authorized} ${text}`));
+  });
+  socket.on("error", (error: Error) => {
+    finish(`error ${(error as NodeJS.ErrnoException).code}`);
+  });
+}
+
+server.listen(0, "127.0.0.1", () => {
+  const port = (server.address() as net.AddressInfo).port;
+  attempt(port, "localhost", () =>
+    attempt(port, "alt.localhost", () =>
+      attempt(port, "other.localhost", () =>
+        attempt(port, "fail.localhost", () => server.close(() => console.log("closed"))),
+      ),
+    ),
+  );
+});
diff --git a/tests/corpus/6934-tls-handshake-disconnect.ts b/tests/corpus/6934-tls-handshake-disconnect.ts
new file mode 100644
index 000000000..1f13c6684
--- /dev/null
+++ b/tests/corpus/6934-tls-handshake-disconnect.ts
@@ -0,0 +1,27 @@
+// A server that closes the connection before the TLS handshake completes:
+// tls.connect and https.get fail with ECONNRESET and Node's "Client network
+// socket disconnected before secure TLS connection was established".
+import * as https from "node:https";
+import * as net from "node:net";
+import * as tls from "node:tls";
+
+const server = net.createServer((socket) => {
+  socket.end();
+});
+
+server.listen(0, "127.0.0.1", () => {
+  const port = (server.address() as net.AddressInfo).port;
+  const client = tls.connect({ port, host: "127.0.0.1", rejectUnauthorized: false }, () => {
+    console.log("tls connected");
+  });
+  client.on("error", (error: Error) => {
+    console.log("tls", (error as NodeJS.ErrnoException).code, error.message);
+    const request = https.get({ host: "127.0.0.1", port, rejectUnauthorized: false }, () => {
+      console.log("https response");
+    });
+    request.on("error", (err: Error) => {
+      console.log("https", (err as NodeJS.ErrnoException).code, err.message);
+      server.close();
+    });
+  });
+});
diff --git a/tests/diagnostics/tls-sni-callback-fences.ts b/tests/diagnostics/tls-sni-callback-fences.ts
new file mode 100644
index 000000000..0c745365c
--- /dev/null
+++ b/tests/diagnostics/tls-sni-callback-fences.ts
@@ -0,0 +1,15 @@
+// tls.createServer SNICallback forms that have no lowering.
+import { readFileSync } from "node:fs";
+import * as tls from "node:tls";
+
+const cert = readFileSync("cert.pem");
+const key = readFileSync("key.pem");
+type Answer = (err: Error | null, ctx?: tls.SecureContext) => void;
+function makeSni(): (servername: string, cb: Answer) => void {
+  return (_servername, cb) => cb(null, undefined);
+}
+
+// The callback expression has side effects.
+tls.createServer({ cert, key, SNICallback: makeSni() }, (socket) => socket.end());
+// SNICallback with options the runtime options walk reads.
+tls.createServer({ cert, key, ALPNProtocols: ["h2"], SNICallback: makeSni });
diff --git a/tests/harness/__snapshots__/tls-sni-callback-fences.ts.txt b/tests/harness/__snapshots__/tls-sni-callback-fences.ts.txt
new file mode 100644
index 000000000..920e65532
--- /dev/null
+++ b/tests/harness/__snapshots__/tls-sni-callback-fences.ts.txt
@@ -0,0 +1,17 @@
+tls-sni-callback-fences.ts:13:31 - error SC2020: 'a tls.createServer SNICallback expression with side effects' is part of the standard library types but has no scriptc lowering yet
+
+  12 | // The callback expression has side effects.
+  13 | tls.createServer({ cert, key, SNICallback: makeSni() }, (socket) => socket.end());
+     |                               ^~~~~~~~~~~~~~~~~~~~~~
+  14 | // SNICallback with options the runtime options walk reads.
+
+  hint: pass a function or a variable that holds one
+
+tls-sni-callback-fences.ts:15:54 - error SC2020: 'tls.createServer with SNICallback and options the runtime walk reads' is part of the standard library types but has no scriptc lowering yet
+
+  14 | // SNICallback with options the runtime options walk reads.
+  15 | tls.createServer({ cert, key, ALPNProtocols: ["h2"], SNICallback: makeSni });
+     |                                                      ^~~~~~~~~~~~~~~~~~~~
+  16 | 
+
+  hint: SNICallback lowers with cert and key; ALPNProtocols, minVersion, maxVersion and the validated options are not combined with it yet
\ No newline at end of file

From fc38e627915826a2e56e9f1843f3c5bc56df9752 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 14:10:23 -0500
Subject: [PATCH 15/67] Stop importing runtime bitcode into program builds

---
 docs/content/docs/cli.mdx                     |  2 +-
 native/llvm-codegen/README.md                 |  2 +-
 .../src/backend/native-codegen.test.ts        | 24 ------
 .../compiler/src/backend/native-codegen.ts    |  8 --
 packages/compiler/src/backend/optimization.ts |  4 +-
 .../compiler/src/backend/runtime-pack.test.ts | 79 +------------------
 packages/compiler/src/backend/runtime-pack.ts | 46 -----------
 packages/compiler/src/index.ts                | 35 +-------
 8 files changed, 11 insertions(+), 189 deletions(-)

diff --git a/docs/content/docs/cli.mdx b/docs/content/docs/cli.mdx
index daeb37ea0..efdb03d7d 100644
--- a/docs/content/docs/cli.mdx
+++ b/docs/content/docs/cli.mdx
@@ -127,7 +127,7 @@ With `--sparse`, the profile leaves out the functions the runs never reached. Th
   <dd>Remove symbol and debug payload when linking an executable, including cross-compiled targets. This flag preserves code optimization.</dd>
 
   <dt><code>--optimization &lt;release|dev|speed&gt;</code></dt>
-  <dd>Select native optimization for executable, assembly, or object output. The default is <code>release</code> (<code>-O2</code>), which emits string retains and the retains and releases of dynamic values inline and lets LLVM inline small runtime functions that keep no internal runtime state into executable code; programs large enough to be compiled in parallel partitions skip that inlining to keep build time and size in check. <code>dev</code> uses <code>-O0</code> and emits source locations for TypeScript and JavaScript breakpoints and stack frames. LLVM builds include source variable names and native storage descriptions; see <a href="/docs/limitations#native-debugging">Native debugging</a> for the supported representations. macOS executable builds also produce an adjacent <code>.dSYM</code> bundle. <code>speed</code> is <code>-O2</code> plus optimizations that trade binary size and build time for run-time speed: it lets LLVM inline more small runtime functions into program code, emits the remaining reference counting inline, and on x86-64 starts every runtime function on a cache-line boundary. Expect larger executables and longer cold builds than <code>release</code>; how much faster a program runs depends on how much of its time is spent in the runtime. Runtime inlining needs a runtime pack built with the LLVM helper; where a runtime pack lacks it, programs link the same runtime without it and <code>speed</code> links the release runtime and keeps inline reference counting. Selecting <code>speed</code> never changes what <code>release</code> builds produce, and the two never share cached artifacts. Library profiles accept <code>"optimization": "speed"</code> for inline reference counting. In executables large enough to be divided into partitions, <code>dev</code> compiles each partition on its own, and <code>release</code> and <code>speed</code> add a step that lets partitions import small functions from each other; see <a href="/docs/how-it-works#build-parallelism">Build parallelism</a>.</dd>
+  <dd>Select native optimization for executable, assembly, or object output. The default is <code>release</code> (<code>-O2</code>), which emits string retains and the retains and releases of dynamic values inline. <code>dev</code> uses <code>-O0</code> and emits source locations for TypeScript and JavaScript breakpoints and stack frames. LLVM builds include source variable names and native storage descriptions; see <a href="/docs/limitations#native-debugging">Native debugging</a> for the supported representations. macOS executable builds also produce an adjacent <code>.dSYM</code> bundle. <code>speed</code> is <code>-O2</code> plus optimizations that trade binary size and build time for run-time speed: it emits the remaining reference counting inline and, on x86-64, starts every runtime function on a cache-line boundary. Expect larger executables and longer cold builds than <code>release</code>; how much faster a program runs depends on how much of its time is spent in the runtime. Where a runtime pack has no speed runtime, <code>speed</code> links the release runtime and keeps inline reference counting. Selecting <code>speed</code> never changes what <code>release</code> builds produce, and the two never share cached artifacts. Library profiles accept <code>"optimization": "speed"</code> for inline reference counting. In executables large enough to be divided into partitions, <code>dev</code> compiles each partition on its own, and <code>release</code> and <code>speed</code> add a step that lets partitions import small functions from each other; see <a href="/docs/how-it-works#build-parallelism">Build parallelism</a>.</dd>
 
   <dt><code>--windows-subsystem &lt;console|gui&gt;</code></dt>
   <dd>Select the subsystem of a Windows executable. <code>console</code> is the default; <code>gui</code> prevents Windows from opening a console window for the app. Valid only for executable builds targeting Windows.</dd>
diff --git a/native/llvm-codegen/README.md b/native/llvm-codegen/README.md
index 8debaeeaf..0e8abbc47 100644
--- a/native/llvm-codegen/README.md
+++ b/native/llvm-codegen/README.md
@@ -39,7 +39,7 @@ WebAssembly code generation differs from LLVM's default pipeline in two ways tha
 
 `--cache-dir <dir>` names a private directory the caller owns for one helper build. Simplified partitions are stored under the hash of their exact source and objects under the hash of the exact module after importing, each with a trailing digest and published by rename, so a rebuild recompiles only the partitions an edit can affect.
 
-Unsanitized `speed` program builds, and unsanitized `release` builds of programs small enough for one partition, pass `--import-bitcode <unit.bc>` once per runtime-pack unit the program links that ships bitcode. Small runtime functions reachable from the program's runtime calls are imported as `available_externally` so LLVM can inline them; the runtime objects remain the only definitions. The helper never runs a sanitizer pass, so with import it also drops the emitter's inert `sanitize_address` attributes, which would otherwise block that inlining. Without `--import-bitcode` the module is optimized exactly as emitted.
+`--import-bitcode <unit.bc>`, given once per runtime-pack unit that ships bitcode, imports runtime functions for inlining; scriptc's program builds do not pass it. Small runtime functions reachable from the program's runtime calls are imported as `available_externally` so LLVM can inline them; the runtime objects remain the only definitions. The helper never runs a sanitizer pass, so with import it also drops the emitter's inert `sanitize_address` attributes, which would otherwise block that inlining. Without `--import-bitcode` the module is optimized exactly as emitted.
 
 Runtime-pack builds emit each unit of the executable `speed` flavor through the helper:
 
diff --git a/packages/compiler/src/backend/native-codegen.test.ts b/packages/compiler/src/backend/native-codegen.test.ts
index 21c74e51c..545711a60 100644
--- a/packages/compiler/src/backend/native-codegen.test.ts
+++ b/packages/compiler/src/backend/native-codegen.test.ts
@@ -168,30 +168,6 @@ test("resolves a package helper, emits atomically, and caches by all native inpu
   expect(secondArtifact.dependencies).toEqual(firstArtifact.dependencies);
 });
 
-test("runtime bitcode imports reach the helper and key the native cache", async () => {
-  const pkg = await fakePackage();
-  const base = request(pkg.root, pkg.packageJson, join(pkg.root, "plain.o"));
-  await emitNativeArtifact(base);
-  const imported = {
-    ...request(pkg.root, pkg.packageJson, join(pkg.root, "imported.o")),
-    importBitcode: {
-      paths: ["/pack/a.bc", "/pack/b.bc"],
-      digests: ["a".repeat(64), "b".repeat(64)],
-    },
-  };
-  await emitNativeArtifact(imported);
-  await emitNativeArtifact({
-    ...imported,
-    outputPath: join(pkg.root, "changed.o"),
-    importBitcode: { ...imported.importBitcode, digests: ["a".repeat(64), "c".repeat(64)] },
-  });
-  await emitNativeArtifact({ ...imported, outputPath: join(pkg.root, "again.o") });
-  const calls = (await readFile(pkg.log, "utf8")).trim().split("\n");
-  expect(calls).toHaveLength(3);
-  expect(calls[0]).not.toContain("--import-bitcode");
-  expect(calls[1]).toContain("--import-bitcode /pack/a.bc --import-bitcode /pack/b.bc");
-});
-
 test("profiles reach the helper and key the native cache by their bytes", async () => {
   const pkg = await fakePackage();
   const base = request(pkg.root, pkg.packageJson, join(pkg.root, "plain.o"));
diff --git a/packages/compiler/src/backend/native-codegen.ts b/packages/compiler/src/backend/native-codegen.ts
index 39e570cd5..5b91c60e7 100644
--- a/packages/compiler/src/backend/native-codegen.ts
+++ b/packages/compiler/src/backend/native-codegen.ts
@@ -111,8 +111,6 @@ export interface NativeCodegenOptions {
   cacheRoot?: string | null;
   /** Program partitions, written to nativePartitionPaths(outputPath). */
   partitions?: number;
-  /** Runtime bitcode whose small functions the helper imports for inlining. */
-  importBitcode?: { paths: readonly string[]; digests: readonly string[] };
   /** Profile-guided optimization: instrumentation or an indexed profile. */
   profile?: NativeProfileOptions;
 }
@@ -339,11 +337,6 @@ function cacheKey(
     .update("\0")
     .update(options.sourcePath)
     .update((options.partitions ?? 1) > 1 ? `\0partitions:${options.partitions}` : "")
-    .update(
-      options.importBitcode === undefined
-        ? ""
-        : `\0import:${options.importBitcode.digests.join(",")}`,
-    )
     .update(options.profile === undefined ? "" : `\0${nativeProfileKey(options.profile)}`)
     .digest("hex");
 }
@@ -482,7 +475,6 @@ export async function emitNativeArtifact(
       "json",
       "--source-path",
       options.sourcePath,
-      ...(options.importBitcode?.paths ?? []).flatMap((path) => ["--import-bitcode", path]),
       ...(partitionCache === null ? [] : ["--cache-dir", partitionCache]),
       ...nativeProfileHelperArgs(options.profile),
     ]);
diff --git a/packages/compiler/src/backend/optimization.ts b/packages/compiler/src/backend/optimization.ts
index f26b99dcc..05e275afd 100644
--- a/packages/compiler/src/backend/optimization.ts
+++ b/packages/compiler/src/backend/optimization.ts
@@ -3,8 +3,8 @@
  * - `release` (default): -O2 program code against the release runtime flavor.
  * - `dev`: -O0, source line tables, and cached object shards.
  * - `speed`: -O2 plus optimizations that trade binary size and build time for
- *   run-time speed (a size-for-speed runtime flavor, runtime bitcode import,
- *   inline reference counting). Release output never depends on them.
+ *   run-time speed (a size-for-speed runtime flavor, inline reference
+ *   counting). Release output never depends on them.
  *
  * Speed is an optimized posture everywhere release is: it shares -O2, release
  * linker flags, and release-only program partitioning. Cache keys spell it
diff --git a/packages/compiler/src/backend/runtime-pack.test.ts b/packages/compiler/src/backend/runtime-pack.test.ts
index 4fd53c01e..ee2301172 100644
--- a/packages/compiler/src/backend/runtime-pack.test.ts
+++ b/packages/compiler/src/backend/runtime-pack.test.ts
@@ -9,7 +9,6 @@ import type { NativeLinkFeatures } from "./native-link-info.js";
 import {
   effectiveRuntimeFeatures,
   evaluateRuntimePredicate,
-  loadRuntimeBitcode,
   loadRuntimePack,
   parseRuntimePackManifest,
   RuntimePackError,
@@ -262,80 +261,10 @@ describe("runtime pack manifests", () => {
     expect(fileHandle.archives.map((path) => path.split("/").at(-1))).toEqual(["zlib.a"]);
   });
 
-  test("runtime bitcode follows the selected flavor variant and is verified", async () => {
-    const { root, packagePath, manifest } = await fixture();
-    const bitcode = async (path: string, bytes: string) => {
-      await writeFile(join(root, path), bytes);
-      return {
-        path,
-        sha256: createHash("sha256").update(bytes).digest("hex"),
-        size: Buffer.byteLength(bytes),
-      };
-    };
-    const unit = manifest.flavors.release!.runtime_units[0]!;
-    const withBitcode: RuntimePackManifest = {
-      ...manifest,
-      flavors: {
-        ...manifest.flavors,
-        speed: {
-          optimization: "-O2",
-          runtime_units: [
-            {
-              ...unit,
-              variants: [
-                { ...unit.variants[0]!, bitcode: await bitcode("artifacts/base.bc", "base-bc") },
-                {
-                  ...unit.variants[1]!,
-                  bitcode: await bitcode("artifacts/legacy.bc", "legacy-bc"),
-                },
-                unit.variants[2]!,
-              ],
-            },
-          ],
-        },
-      },
-    };
-    const resolver = () => packagePath;
-    const speed = { target: MACOS_ARM64_TARGET, optimization: "speed" } as const;
-    // Release programs import their own units' bitcode. Speed programs
-    // never import release bitcode: without a speed flavor they import none.
-    await writeFile(
-      join(root, "runtime-pack.json"),
-      JSON.stringify({
-        ...withBitcode,
-        flavors: { ...withBitcode.flavors, release: withBitcode.flavors.speed, speed: undefined },
-      }),
-    );
-    expect(await loadRuntimeBitcode({ ...speed, features: BASE, resolver })).toBeNull();
-    const release = await loadRuntimeBitcode({
-      target: MACOS_ARM64_TARGET,
-      optimization: "release",
-      features: BASE,
-      resolver,
-    });
-    expect(release?.paths.map((path) => basename(path))).toEqual(["base.bc"]);
-    await writeFile(join(root, "runtime-pack.json"), JSON.stringify(withBitcode));
-    const legacy = await loadRuntimeBitcode({
-      ...speed,
-      features: { ...BASE, textDecoderLegacy: true },
-      resolver,
-    });
-    expect(legacy?.paths.map((path) => basename(path))).toEqual(["legacy.bc"]);
-    expect(legacy?.digests).toEqual([createHash("sha256").update("legacy-bc").digest("hex")]);
-    // A variant without bitcode imports nothing.
-    expect(
-      await loadRuntimeBitcode({
-        ...speed,
-        features: { ...BASE, fileHandle: true },
-        resolver,
-      }),
-    ).toBeNull();
-    await writeFile(join(root, "artifacts/base.bc"), "damaged");
-    await expect(loadRuntimeBitcode({ ...speed, features: BASE, resolver })).rejects.toThrow(
-      "hash mismatch",
-    );
-    const malformed = structuredClone(withBitcode);
-    malformed.flavors.speed!.runtime_units[0]!.variants[0]!.bitcode = {
+  test("runtime unit bitcode must stay inside the pack", async () => {
+    const { manifest } = await fixture();
+    const malformed = structuredClone(manifest);
+    malformed.flavors.release!.runtime_units[0]!.variants[0]!.bitcode = {
       path: "../escape.bc",
       sha256: "0".repeat(64),
       size: 1,
diff --git a/packages/compiler/src/backend/runtime-pack.ts b/packages/compiler/src/backend/runtime-pack.ts
index 5f813802c..2bfe71756 100644
--- a/packages/compiler/src/backend/runtime-pack.ts
+++ b/packages/compiler/src/backend/runtime-pack.ts
@@ -46,8 +46,6 @@ export interface RuntimePackSelection {
   sourceDependencies: NativeArtifactDependency[];
   selectedRuntimeArtifacts: RuntimePackArtifact[];
   selectedArchiveArtifacts: RuntimePackArtifact[];
-  /** Bitcode of the selected runtime units that ship it, in unit order. */
-  selectedRuntimeBitcode: RuntimePackArtifact[];
 }
 
 async function verifyArtifact(root: string, artifact: RuntimePackArtifact): Promise<string> {
@@ -249,49 +247,5 @@ export async function loadRuntimePack(options: {
     sourceDependencies,
     selectedRuntimeArtifacts: selectedVariants,
     selectedArchiveArtifacts: selectedArchives,
-    selectedRuntimeBitcode: selectedVariants.flatMap((variant) =>
-      variant.bitcode === undefined ? [] : [variant.bitcode],
-    ),
-  };
-}
-
-export interface RuntimeBitcodeImport {
-  paths: string[];
-  /** Content digests, in path order, for cache keys. */
-  digests: string[];
-  dependencies: NativeArtifactDependency[];
-}
-
-/** Verified bitcode for the runtime units of the given flavor that a program
- * links, for the helper's available_externally import. Release units carry
- * their compiled bitcode reduced to the bodies that need no unit-local
- * state; speed units carry their promoted bitcode. Null when the selected
- * units ship no bitcode (a pack built without the helper, or no speed
- * flavor). */
-export async function loadRuntimeBitcode(options: {
-  target: NativeTargetSpec;
-  features: NativeLinkFeatures;
-  optimization: "release" | "speed";
-  env?: NodeJS.ProcessEnv;
-  resolver?: (specifier: string) => string;
-}): Promise<RuntimeBitcodeImport | null> {
-  const pack = await loadRuntimePack(options);
-  // Without a speed flavor, speed programs link release units; only the
-  // speed flavor's promoted objects match speed bitcode.
-  if (options.optimization === "speed" && pack.manifest.flavors.speed === undefined) return null;
-  if (pack.selectedRuntimeBitcode.length === 0) return null;
-  const paths = await Promise.all(
-    pack.selectedRuntimeBitcode.map((artifact) => verifyArtifact(pack.root, artifact)),
-  );
-  let dependencies: NativeArtifactDependency[];
-  try {
-    dependencies = await snapshotDependencies([pack.manifestPath, ...paths]);
-  } catch {
-    throw new RuntimePackError("runtime pack bitcode changed during selection", "invalid");
-  }
-  return {
-    paths,
-    digests: pack.selectedRuntimeBitcode.map((artifact) => artifact.sha256),
-    dependencies,
   };
 }
diff --git a/packages/compiler/src/index.ts b/packages/compiler/src/index.ts
index 08457f86b..8b0ea6825 100644
--- a/packages/compiler/src/index.ts
+++ b/packages/compiler/src/index.ts
@@ -82,7 +82,7 @@ import { privateSiblingPath } from "./backend/build-cache.js";
 import { nativeCodegenTarget, nativeCodegenTargetRefusal } from "./backend/targets.js";
 import { windowsSubsystemLinkerArgs, type WindowsSubsystem } from "./backend/targets.js";
 import { createNativeLinkInfo } from "./backend/native-link-info.js";
-import { RuntimePackError, loadRuntimeBitcode } from "./backend/runtime-pack.js";
+import { RuntimePackError } from "./backend/runtime-pack.js";
 import { createNativeLinkPlan } from "./backend/link-plan.js";
 import {
   nativeProfileKey,
@@ -634,7 +634,6 @@ async function emitNativeProgramObject(
   entryPath: string,
   opts: CompileRequestOptions,
   llvm: LlvmInput,
-  features: EarlyExecutableNativeFeatures,
   profile: NativeProfileOptions | undefined,
 ): Promise<NativeProgramObject> {
   const stem = basename(entryPath).replace(/\.(ts|mts|cts|js|mjs|cjs)$/, "");
@@ -648,24 +647,6 @@ async function emitNativeProgramObject(
   const llvmBytes = llvmInputBytes(llvm);
   const partitions =
     opts.nativeProgramObject === true || target === null ? 1 : nativeProgramPartitions(llvmBytes);
-  // Optimized programs import small runtime functions from the bitcode of
-  // the exact runtime units they link, so LLVM can inline across the
-  // boundary. Release units ship only the bodies that need none of their
-  // unit-local state, which keeps the import cheap; speed units promote
-  // that state and offer more. Every partition reads the bitcode again, so
-  // release imports only into programs small enough for one partition: in
-  // larger ones the build-time and size cost outgrows the gain.
-  const runtimeBitcode =
-    opts.sanitize !== true &&
-    target !== null &&
-    (opts.optimization === "speed" ||
-      (opts.optimization !== "dev" && nativeProgramPartitions(llvmBytes) === 1))
-      ? await loadRuntimeBitcode({
-          target,
-          features,
-          optimization: opts.optimization === "speed" ? "speed" : "release",
-        })
-      : null;
   try {
     const artifact = await emitNativeArtifact({
       outputPath: linkPath,
@@ -675,16 +656,13 @@ async function emitNativeProgramObject(
       optimization: opts.optimization === "dev" ? "0" : "2",
       ...(opts.sanitize === undefined ? {} : { sanitize: opts.sanitize }),
       partitions,
-      ...(runtimeBitcode === null
-        ? {}
-        : { importBitcode: { paths: runtimeBitcode.paths, digests: runtimeBitcode.digests } }),
       ...(profile === undefined ? {} : { profile }),
     });
     return {
       linkPath,
       partitionPaths: artifact.outputPaths.slice(1),
       artifactPath,
-      dependencies: [...artifact.dependencies, ...(runtimeBitcode?.dependencies ?? [])],
+      dependencies: artifact.dependencies,
     };
   } catch (error) {
     await removeNativeProgramObject(linkPath, nativePartitionPaths(linkPath, partitions));
@@ -1467,7 +1445,6 @@ async function compileTracked(
           // A large program's LLVM exceeds the engine's string limit as one
           // string; the emitter takes it in parts, as on a cold build.
           await readTextParts(earlyHit.llvmPath),
-          earlyHit.native,
           profile,
         );
         nativeInputPath = nativeProgramObject.linkPath;
@@ -1583,13 +1560,7 @@ async function compileTracked(
         );
       }
       try {
-        nativeProgramObject = await emitNativeProgramObject(
-          entryPath,
-          opts,
-          llvmSource,
-          nativeFeatures,
-          profile,
-        );
+        nativeProgramObject = await emitNativeProgramObject(entryPath, opts, llvmSource, profile);
         timing("native-object");
         await recordEarlyExecutableNativeBuild(cacheRoot, executableCacheOptions).catch(
           () => undefined,

From 453bcf8e3887f33f9b47b6f07cdfc4266d38f6f1 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 14:19:48 -0500
Subject: [PATCH 16/67] Revisit only the changed sites of the optional-read
 fixed point

---
 .../compiler/src/frontend/lowering/lowerer.ts | 87 ++++++++++++++++---
 .../lowering/runtime-optional-elements.ts     | 22 ++++-
 .../lowering/site-dependencies.test.ts        | 56 ++++++++++++
 .../frontend/lowering/site-dependencies.ts    | 79 +++++++++++++++++
 4 files changed, 232 insertions(+), 12 deletions(-)
 create mode 100644 packages/compiler/src/frontend/lowering/site-dependencies.test.ts
 create mode 100644 packages/compiler/src/frontend/lowering/site-dependencies.ts

diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts
index cbd70a913..1b5e30545 100644
--- a/packages/compiler/src/frontend/lowering/lowerer.ts
+++ b/packages/compiler/src/frontend/lowering/lowerer.ts
@@ -121,6 +121,7 @@ import { ArrayElementStates } from "./runtime-optional-elements.js";
 import { indexReadInBounds } from "./runtime-optional-bounds.js";
 import { ArrayOwnership } from "./runtime-optional-ownership.js";
 import { RecordFlowClasses } from "./runtime-optional-records.js";
+import { SiteDependencies } from "./site-dependencies.js";
 import { StringIndexBounds } from "./string-index-bounds.js";
 import { NanCodedReads } from "./nan-coded-reads.js";
 import { RuntimeOptionalLocals } from "./runtime-optional-locals.js";
@@ -4688,10 +4689,15 @@ export class Lowerer {
     // resolveValueSymbol also flushes deferred diagnostics and applies
     // merged-namespace fences, whose authority remains ordinary lowering.
     this.checker.prefetchSymbolRoots(sourceFiles, true);
+    // The facts each fixed-point site reads, by the symbols, nodes and
+    // element keys they belong to (created with the site list below).
+    let siteDependencies: SiteDependencies | null = null;
     const symbolOf = (node: ts.Node): ts.Symbol | null => {
       const s = this.checker.getSymbolAtLocation(node);
       if (!s) return null;
-      return s.flags & ts.SymbolFlags.Alias ? this.checker.getAliasedSymbol(s) : s;
+      const symbol = s.flags & ts.SymbolFlags.Alias ? this.checker.getAliasedSymbol(s) : s;
+      siteDependencies?.read(symbol);
+      return symbol;
     };
     const signatureOf = (node: ts.Identifier): FnSig | null => {
       const symbol = symbolOf(node);
@@ -4876,7 +4882,10 @@ export class Lowerer {
     const callableSymbols = new Map<ts.Expression, ts.Symbol | null>();
     const callableSymbolOf = (node: ts.Expression): ts.Symbol | null => {
       const cached = callableSymbols.get(node);
-      if (cached !== undefined) return cached;
+      if (cached !== undefined) {
+        if (cached !== null) siteDependencies?.read(cached);
+        return cached;
+      }
       let symbol = symbolOf(ts.isPropertyAccessExpression(node) ? node.name : node);
       if (symbol === null || signatureBySymbol.has(symbol)) {
         callableSymbols.set(node, symbol);
@@ -5165,7 +5174,10 @@ export class Lowerer {
       if (ts.isPropertyAccessExpression(e) && isSettledIteratorValueRead(this, e)) return true;
       if (ts.isPropertyAccessExpression(e) && isOsConstantsSymbol(symbolOf(e.expression), this))
         return true;
-      if (ts.isCallExpression(e) && this.runtimeOptionalReduceTypes.has(e)) return true;
+      if (ts.isCallExpression(e)) {
+        siteDependencies?.read(e);
+        if (this.runtimeOptionalReduceTypes.has(e)) return true;
+      }
       if (
         ts.isCallExpression(e) &&
         e.arguments.nodes.length === 0 &&
@@ -5663,6 +5675,7 @@ export class Lowerer {
         if (fnType?.kind === "func" && bodyReturnsOptional(fn)) {
           const widenedReturn = this.runtimeOptionalType(fnType.ret);
           provenance?.note("callback-return", fn, provenanceSite);
+          siteDependencies?.read(fn);
           const previousReturn = this.runtimeOptionalFunctionReturnType(fn, fnType.ret);
           this.runtimeOptionalFunctionReturns.set(fn, widenedReturn);
           if (!typeEquals(previousReturn, widenedReturn)) changed = true;
@@ -5898,8 +5911,10 @@ export class Lowerer {
           arm.elem.kind === "union"
             ? this.armTag(arm.elem.unionId, UNDEFINED_T) >= 0
             : isUnitType(arm.elem) || arm.elem.kind === "void"
-        )
+        ) {
+          if (!optionalElementKeys.has(key)) siteDependencies?.changed(key);
           optionalElementKeys.add(key);
+        }
         keys.push(key);
       }
       return keys;
@@ -6011,7 +6026,10 @@ export class Lowerer {
       return keys;
     };
     const elementStates = new ArrayElementStates({
-      elementAdmitsUndefined: (key) => optionalElementKeys.has(key),
+      elementAdmitsUndefined: (key) => {
+        siteDependencies?.read(key);
+        return optionalElementKeys.has(key);
+      },
       ownerOf: (node) => ownership.ownerOf(node),
       allocationOwner: (node) => ownership.allocationOwner(node),
       arrayKeys: arrayKeysOf,
@@ -6084,6 +6102,8 @@ export class Lowerer {
       note: provenance
         ? (fact, key, site) => provenance.note(`element-${fact}`, site, site, key)
         : null,
+      read: (fact) => siteDependencies?.read(fact),
+      changed: (fact) => siteDependencies?.changed(fact),
     });
     // Each pass revisits every array callback site; the last visit holds
     // the decision at the fixed point.
@@ -6385,6 +6405,7 @@ export class Lowerer {
               ) {
                 if (promoteHofCallback(callback, [0, 1])) changed = true;
                 const result = this.runtimeOptionalType(this.irTypeOf(node));
+                siteDependencies?.read(node);
                 const previous = this.runtimeOptionalReduceTypes.get(node);
                 if (!previous || !typeEquals(previous, result)) {
                   this.runtimeOptionalReduceTypes.set(node, result);
@@ -6452,6 +6473,7 @@ export class Lowerer {
               )
                 continue;
               for (const target of familyBySymbol.get(symbol) ?? [symbol]) {
+                siteDependencies?.read(target);
                 const shape = signatureBySymbol.get(target)?.params[i];
                 if (!shape || shape.mode !== "required") continue;
                 const widened = addUndefined(shape.type);
@@ -6496,6 +6518,7 @@ export class Lowerer {
             if (!ts.isSpreadElement(arg) && shape && i !== restAt && fieldsOfValue(arg)) {
               const fields = fieldsOfValue(arg)!;
               for (const target of familyBySymbol.get(symbol) ?? [symbol]) {
+                siteDependencies?.read(target);
                 const parameterShape = signatureBySymbol.get(target)?.params[i];
                 const parameter = functionDeclBySymbol.get(target)?.parameters?.nodes[i];
                 if (!parameterShape || parameterShape.type.kind !== "record") continue;
@@ -6541,6 +6564,7 @@ export class Lowerer {
               // argument can make its elements undefined, not the pack.
               // Keep every virtual implementation on the same array ABI.
               for (const target of familyBySymbol.get(symbol) ?? [symbol]) {
+                siteDependencies?.read(target);
                 const rest = signatureBySymbol.get(target)?.params[i];
                 if (rest?.mode !== "rest" || rest.type.kind !== "array") continue;
                 const widened = arrayOf(addUndefined(rest.type.elem));
@@ -6562,6 +6586,7 @@ export class Lowerer {
             // downstream calls and returns see the same optional value.
             const family = familyBySymbol.get(symbol);
             for (const target of family ?? [symbol]) {
+              siteDependencies?.read(target);
               const parameterShape = signatureBySymbol.get(target)?.params[i];
               if (!parameterShape) continue;
               parameterShape.type = addUndefined(parameterShape.type);
@@ -6592,8 +6617,21 @@ export class Lowerer {
           });
         }
       };
-      for (const node of sitesOf(sf)) scan(node);
-      return changed;
+      // A site whose facts are unchanged since its last visit would compute
+      // that visit's result again, except in a full pass.
+      const base = siteBase.get(sf)!;
+      const dependencies = siteDependencies!;
+      const sites = sitesOf(sf);
+      let fileChanged = false;
+      for (let i = 0; i < sites.length; i++) {
+        if (!fullPass && !dependencies.isStale(base + i)) continue;
+        changed = false;
+        dependencies.begin(base + i);
+        scan(sites[i]!);
+        dependencies.end(changed);
+        if (changed) fileChanged = true;
+      }
+      return fileChanged;
     };
     const scanReturns = (symbol: ts.Symbol, decl: ts.FunctionLikeDeclaration): boolean => {
       let changed = false;
@@ -6643,23 +6681,41 @@ export class Lowerer {
       optionalSymbols.add(symbol);
       this.earlyReadVars.add(symbol);
     }
-    let changed = true;
-    while (changed) {
+    // Number the sites of every file. The first and the last pass visit
+    // every site; the passes between visit only the sites whose facts
+    // changed (SiteDependencies). When such a pass changes nothing, a full
+    // pass confirms the fixed point, and the iteration resumes if it
+    // changes a fact after all.
+    const siteBase = new Map<ts.SourceFile, number>();
+    let siteCount = 0;
+    for (const sf of sourceFiles) {
+      siteBase.set(sf, siteCount);
+      siteCount += sitesOf(sf).length;
+    }
+    siteDependencies = new SiteDependencies(siteCount);
+    let fullPass = true;
+    for (let changed = true, first = true; changed || !fullPass; first = false) {
+      fullPass = first || !changed;
       changed = false;
       for (const [symbol, field] of staticFieldsBySymbol) {
         if (!optionalSymbols.has(symbol) && mayBeOptional(field.initializer)) {
           optionalSymbols.add(symbol);
+          siteDependencies.changed(symbol);
           provenance?.note("static-field", field.initializer.parent, field.initializer);
           changed = true;
         }
       }
       for (const sf of sourceFiles) if (scanFile(sf)) changed = true;
-      for (const [symbol, decl] of functionDeclBySymbol)
-        if (scanReturns(symbol, decl)) changed = true;
+      for (const [symbol, decl] of functionDeclBySymbol) {
+        if (!scanReturns(symbol, decl)) continue;
+        siteDependencies.changed(symbol);
+        changed = true;
+      }
       const noteGenericReturn = (symbol: ts.Symbol, decl: ts.FunctionLikeDeclaration): void => {
         if (optionalReturns.has(symbol) || isJsSourceFile(ts.getSourceFileOfNode(decl))) return;
         if (!returnsOf(decl).some(genericMayBeOptional)) return;
         optionalReturns.add(symbol);
+        siteDependencies!.changed(symbol);
         this.runtimeOptionalGenericReturns.add(decl);
         provenance?.note("return", decl.name ?? decl, decl);
         changed = true;
@@ -6696,6 +6752,7 @@ export class Lowerer {
               : previous;
         if (!typeEquals(previous, next)) {
           this.runtimeOptionalFunctionReturns.set(fn, next);
+          siteDependencies.changed(fn);
           provenance?.note("lambda-return", fn, fn.body);
           changed = true;
         }
@@ -6713,10 +6770,12 @@ export class Lowerer {
           if (symbol && next.kind === "union" && this.armTag(next.unionId, UNDEFINED_T) >= 0) {
             if (!optionalReturns.has(symbol)) {
               optionalReturns.add(symbol);
+              siteDependencies.changed(symbol);
               changed = true;
             }
           } else if (symbol && !arithmeticReturns.has(symbol)) {
             arithmeticReturns.set(symbol, next);
+            siteDependencies.changed(symbol);
             changed = true;
           }
         }
@@ -6733,6 +6792,7 @@ export class Lowerer {
             : this.runtimeOptionalType(previous);
         if (!typeEquals(previous, next)) {
           this.runtimeOptionalFunctionReturns.set(fn, next);
+          siteDependencies.changed(fn);
           changed = true;
         }
       }
@@ -6746,6 +6806,7 @@ export class Lowerer {
         for (const symbol of optional ? family : []) {
           if (!optionalReturns.has(symbol)) {
             optionalReturns.add(symbol);
+            siteDependencies.changed(symbol);
             provenance?.note(
               "return",
               functionDeclBySymbol.get(symbol),
@@ -6768,10 +6829,14 @@ export class Lowerer {
           const previous = arithmeticReturns.get(symbol);
           if (previous && typeEquals(previous, joined)) continue;
           arithmeticReturns.set(symbol, joined);
+          siteDependencies.changed(symbol);
           changed = true;
         }
       }
     }
+    // The site facts serve only the fixed point; release them for the rest
+    // of lowering.
+    siteDependencies = null;
     // NaN-coded slots convert optional values on entry instead of holding
     // the union, so promotion never applies to them.
     for (const symbol of [...optionalSymbols])
diff --git a/packages/compiler/src/frontend/lowering/runtime-optional-elements.ts b/packages/compiler/src/frontend/lowering/runtime-optional-elements.ts
index 5ed011ce1..96d20d2c4 100644
--- a/packages/compiler/src/frontend/lowering/runtime-optional-elements.ts
+++ b/packages/compiler/src/frontend/lowering/runtime-optional-elements.ts
@@ -39,8 +39,16 @@ export interface ElementStateHost {
   allocationOwner(node: ts.Expression): ts.Symbol | null;
   /** Debug provenance for a new fact. */
   note: ((fact: "undefined" | "holes", key: string, site: ts.Node | undefined) => void) | null;
+  /** The scan read, or added to, the facts of an element key, of an owning
+   * slot, or of every array (ANY_ARRAY), for dependency tracking
+   * (SiteDependencies). */
+  read?(fact: string | ts.Symbol): void;
+  changed?(fact: string | ts.Symbol): void;
 }
 
+/** The fact name of the facts shared by every array. */
+const ANY_ARRAY = "*";
+
 /** What an array value can contain besides present values. */
 interface Contents {
   undefined: boolean;
@@ -179,8 +187,10 @@ export class ArrayElementStates {
       if (built !== undefined) return built;
     }
     const owner = this.host.ownerOf(e);
-    if (owner !== null)
+    if (owner !== null) {
+      this.host.read?.(owner);
       return { undefined: this.undefinedOwners.has(owner), holes: this.holeyOwners.has(owner) };
+    }
     return this.stored(this.host.arrayKeys(e));
   }
 
@@ -317,7 +327,9 @@ export class ArrayElementStates {
   /** The facts recorded for arrays with these element ABIs. */
   private stored(keys: readonly string[] | null): Contents | null {
     if (this.ownFactsOnly) return NOTHING;
+    this.host.read?.(ANY_ARRAY);
     if (keys === null) return null;
+    for (const key of keys) this.host.read?.(key);
     return {
       undefined:
         this.anyUndefined ||
@@ -333,6 +345,7 @@ export class ArrayElementStates {
     const keys = this.host.arrayKeys(node);
     if (keys !== null && keys.length === 0) return false;
     const contents = this.contents(node);
+    this.host.read?.(ANY_ARRAY);
     return contents === null
       ? this.anyUndefined || this.anyHoley
       : contents.undefined || contents.holes;
@@ -368,6 +381,7 @@ export class ArrayElementStates {
         this.holeyOwners.add(owner);
         changed = true;
       }
+      if (changed) this.host.changed?.(owner);
       return changed;
     }
     let changed = false;
@@ -406,6 +420,7 @@ export class ArrayElementStates {
     if (owner === null) return this.addUndefined(this.host.arrayKeys(receiver));
     if (this.undefinedOwners.has(owner)) return false;
     this.undefinedOwners.add(owner);
+    this.host.changed?.(owner);
     return true;
   }
 
@@ -415,6 +430,7 @@ export class ArrayElementStates {
     if (owner === null) return this.addHoles(this.host.arrayKeys(receiver));
     if (this.holeyOwners.has(owner)) return false;
     this.holeyOwners.add(owner);
+    this.host.changed?.(owner);
     return true;
   }
 
@@ -422,6 +438,7 @@ export class ArrayElementStates {
     if (keys === null) {
       if (this.anyUndefined) return false;
       this.anyUndefined = true;
+      this.host.changed?.(ANY_ARRAY);
       this.host.note?.("undefined", "*", this.site);
       return true;
     }
@@ -429,6 +446,7 @@ export class ArrayElementStates {
     for (const key of keys) {
       if (this.undefinedKeys.has(key)) continue;
       this.undefinedKeys.add(key);
+      this.host.changed?.(key);
       this.host.note?.("undefined", key, this.site);
       changed = true;
     }
@@ -439,6 +457,7 @@ export class ArrayElementStates {
     if (keys === null) {
       if (this.anyHoley) return false;
       this.anyHoley = true;
+      this.host.changed?.(ANY_ARRAY);
       this.host.note?.("holes", "*", this.site);
       return true;
     }
@@ -446,6 +465,7 @@ export class ArrayElementStates {
     for (const key of keys) {
       if (this.holeyKeys.has(key)) continue;
       this.holeyKeys.add(key);
+      this.host.changed?.(key);
       this.host.note?.("holes", key, this.site);
       changed = true;
     }
diff --git a/packages/compiler/src/frontend/lowering/site-dependencies.test.ts b/packages/compiler/src/frontend/lowering/site-dependencies.test.ts
new file mode 100644
index 000000000..ca5affcbe
--- /dev/null
+++ b/packages/compiler/src/frontend/lowering/site-dependencies.test.ts
@@ -0,0 +1,56 @@
+import { expect, test } from "vitest";
+import { SiteDependencies } from "./site-dependencies.js";
+
+test("a changed fact makes the sites that read it stale", () => {
+  const dependencies = new SiteDependencies(3);
+  const a = {};
+  const b = "key";
+  dependencies.begin(0);
+  dependencies.read(a);
+  dependencies.end(false);
+  dependencies.begin(1);
+  dependencies.read(b);
+  dependencies.end(false);
+  expect([0, 1, 2].map((site) => dependencies.isStale(site))).toEqual([false, false, false]);
+  dependencies.changed(b);
+  expect([0, 1, 2].map((site) => dependencies.isStale(site))).toEqual([false, true, false]);
+  dependencies.begin(1);
+  expect(dependencies.isStale(1)).toBe(false);
+});
+
+test("a visit that changes a fact makes every reader of its facts stale", () => {
+  const dependencies = new SiteDependencies(3);
+  const shared = {};
+  const own = {};
+  dependencies.begin(0);
+  dependencies.read(shared);
+  dependencies.end(false);
+  dependencies.begin(2);
+  dependencies.read(own);
+  dependencies.end(false);
+  dependencies.begin(1);
+  dependencies.read(shared);
+  dependencies.read(shared);
+  dependencies.end(true);
+  expect([0, 1, 2].map((site) => dependencies.isStale(site))).toEqual([true, true, false]);
+});
+
+test("reads outside a visit are not recorded", () => {
+  const dependencies = new SiteDependencies(1);
+  const fact = {};
+  dependencies.read(fact);
+  dependencies.changed(fact);
+  expect(dependencies.isStale(0)).toBe(false);
+});
+
+test("a site visited again is listed once per fact", () => {
+  const dependencies = new SiteDependencies(3);
+  const fact = {};
+  for (const site of [0, 2, 1, 2, 0]) {
+    dependencies.begin(site);
+    dependencies.read(fact);
+    dependencies.end(false);
+  }
+  dependencies.changed(fact);
+  expect([0, 1, 2].map((site) => dependencies.isStale(site))).toEqual([true, true, true]);
+});
diff --git a/packages/compiler/src/frontend/lowering/site-dependencies.ts b/packages/compiler/src/frontend/lowering/site-dependencies.ts
new file mode 100644
index 000000000..da8531e48
--- /dev/null
+++ b/packages/compiler/src/frontend/lowering/site-dependencies.ts
@@ -0,0 +1,79 @@
+/** The facts each site of a fixed-point scan read on its last visit, so that
+ * a pass visits again only the sites whose facts changed since.
+ *
+ * Sites are numbered from 0. A fact is any value usable as a Map key: a
+ * symbol, a syntax node, or a string that names a derived fact. A visit
+ * reports what it reads (`read`). When a visit changes a fact, every site
+ * that read one of the facts this visit read is visited again: the facts a
+ * visit changes belong to what it read. Facts changed outside a visit, or
+ * not read before they change, are reported with `changed`.
+ *
+ * A site that is not visited again would compute what its last visit
+ * computed, as long as every fact it reads is reported. The scan confirms
+ * that with a pass over every site once a pass changes nothing, and resumes
+ * when that pass changes a fact: a fact this tracking misses costs passes,
+ * not a different result. */
+export class SiteDependencies {
+  /** Each fact's entry: the visit that last read it, so that a visit lists a
+   * fact once, followed by the sites that read it, ascending. */
+  private readonly readers = new Map<unknown, number[]>();
+  private readonly stale: Uint8Array;
+  private site = -1;
+  private visit = 0;
+  private facts: unknown[] = [];
+
+  constructor(siteCount: number) {
+    this.stale = new Uint8Array(siteCount);
+  }
+
+  /** A fact that site `index` read changed since its last visit. */
+  isStale(index: number): boolean {
+    return this.stale[index] === 1;
+  }
+
+  /** Starts a visit of site `index`. */
+  begin(index: number): void {
+    this.site = index;
+    this.visit++;
+    this.stale[index] = 0;
+    this.facts = [];
+  }
+
+  /** Ends the visit; `changed` when it changed a fact. */
+  end(changed: boolean): void {
+    this.site = -1;
+    if (changed) for (const fact of this.facts) this.changed(fact);
+  }
+
+  /** The site being visited read `fact`. */
+  read(fact: unknown): void {
+    if (this.site < 0) return;
+    const entry = this.readers.get(fact);
+    if (entry === undefined) {
+      this.readers.set(fact, [this.visit, this.site]);
+      this.facts.push(fact);
+      return;
+    }
+    if (entry[0] === this.visit) return;
+    entry[0] = this.visit;
+    this.facts.push(fact);
+    // A pass visits sites in ascending order, so a site is new at the end;
+    // a site visited again is usually listed already.
+    const site = this.site;
+    let low = 1;
+    let high = entry.length;
+    if (entry[high - 1]! < site) low = high;
+    while (low < high) {
+      const middle = (low + high) >>> 1;
+      if (entry[middle]! < site) low = middle + 1;
+      else high = middle;
+    }
+    if (entry[low] !== site) entry.splice(low, 0, site);
+  }
+
+  /** `fact` changed: every site that read it is visited again. */
+  changed(fact: unknown): void {
+    const entry = this.readers.get(fact);
+    if (entry !== undefined) for (let i = 1; i < entry.length; i++) this.stale[entry[i]!] = 1;
+  }
+}

From 558fb7c8bab2c969592df5c0ff8224a8d7cc56b6 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 14:20:20 -0500
Subject: [PATCH 17/67] Bind only conditional-dependent class type arguments as
 checker types

A generic class instance now binds a type parameter to its checker type
only when a conditional type in the class depends on it, and that checker
type keys the instance. Before, every type argument was bound while only
literal arguments of those parameters were in the key, so two instances
such as Holder<R, "a"> and Holder<R, "b"> with a `T[K]` field shared the
first instance's layout. The other parameters get no checker binding, so
member types that depend on their literal identity stay unresolved, as
before.

Detection now follows the type aliases and interfaces a member's type
refers to, so a conditional wrapped in a union alias, such as
`(K extends "required" ? T : T | undefined) | null`, also separates the
instances.
---
 .../src/frontend/lowering/lower-classes.ts    | 77 ++++++++++++++-----
 .../6908-generic-class-literal-conditional.ts | 15 ++++
 2 files changed, 71 insertions(+), 21 deletions(-)

diff --git a/packages/compiler/src/frontend/lowering/lower-classes.ts b/packages/compiler/src/frontend/lowering/lower-classes.ts
index ae03a748c..3db208f55 100644
--- a/packages/compiler/src/frontend/lowering/lower-classes.ts
+++ b/packages/compiler/src/frontend/lowering/lower-classes.ts
@@ -4616,22 +4616,28 @@ export function genericClassInstanceType(
       if (bound) tsArgs.push(bound);
     }
   }
-  // A literal argument for a type parameter that a conditional type
-  // depends on (`K extends "required" ? T : T | undefined`) selects the
-  // members' types, so it keys its own instance; mapType alone widens it.
+  // A type parameter that a conditional type in the class depends on
+  // (`K extends "required" ? T : T | undefined`) is bound to its checker
+  // type for the members, and that type keys the instance: mapType alone
+  // widens a literal, so Field<string, "required"> and Field<string,
+  // "optional"> would otherwise share one layout. The other parameters get
+  // no checker binding, so nothing in the members depends on a literal
+  // the key does not carry.
   gci.literalSensitive ??= literalSensitiveTypeParams(lowerer, gci);
-  const literalKey = (i: number): string | null => {
-    if (!gci.literalSensitive!.has(gci.typeParams[i]!)) return null;
-    const arg = tsArgs[i];
+  const sensitive = (i: number): boolean =>
+    tsArgs.length === gci.typeParams.length && gci.literalSensitive!.has(gci.typeParams[i]!);
+  const checkerKey = gci.typeParams
+    .map((_, i) => (sensitive(i) ? `#${tsArgs[i]!.id}` : "*"))
+    .join(",");
+  const key =
+    mapped.map(typeKey).join(",") + (gci.literalSensitive.size > 0 ? `@${checkerKey}` : "");
+  const literalText = (i: number): string | null => {
+    const arg = sensitive(i) ? tsArgs[i] : undefined;
     if (arg?.isStringLiteralType()) return JSON.stringify(arg.value);
     if (arg?.isNumberLiteralType()) return String(arg.value);
     if (arg && arg.flags & ts.TypeFlags.BooleanLiteral) return lowerer.checker.typeToString(arg);
     return null;
   };
-  const literals = gci.typeParams.map((_, i) => literalKey(i));
-  const key =
-    mapped.map(typeKey).join(",") +
-    (literals.some((l) => l !== null) ? `@${literals.map((l) => l ?? "*").join(",")}` : "");
   const existing = gci.instances.get(key);
   if (existing) {
     if (existing.info) lowerer.noteGenericClassInstanceDemand(existing.info);
@@ -4654,9 +4660,10 @@ export function genericClassInstanceType(
   const bindings = new Map<ts.Symbol, IrType>();
   gci.typeParams.forEach((tp, i) => bindings.set(tp, mapped[i]!));
   const tsBindings = new Map<ts.Symbol, ts.Type>();
-  if (tsArgs.length === gci.typeParams.length)
-    gci.typeParams.forEach((tp, i) => tsBindings.set(tp, tsArgs[i]!));
-  const rendered = mapped.map((m, i) => literals[i] ?? lowerer.fmt(m)).join(", ");
+  gci.typeParams.forEach((tp, i) => {
+    if (sensitive(i)) tsBindings.set(tp, tsArgs[i]!);
+  });
+  const rendered = mapped.map((m, i) => literalText(i) ?? lowerer.fmt(m)).join(", ");
   const typeArgsText = `<${rendered.length > 80 ? rendered.slice(0, 77) + "..." : rendered}>`;
   const prevBindings = lowerer.typeParamBindings;
   const prevTsBindings = lowerer.typeParamTsBindings;
@@ -4702,12 +4709,43 @@ export function genericClassInstanceType(
 
 /** The class's type parameters that a conditional type inside it depends
  * on: the parameters named within a type node that is a conditional type
- * or refers to one (`get(): Value<T, K>` with `type Value<T, K> = K
- * extends "required" ? T : T | undefined`). Their literal arguments pick
- * the conditional's branch. */
+ * or reaches one through the type aliases and interfaces it refers to
+ * (`get(): Value<T, K>` with `type Value<T, K> = K extends "required" ? T
+ * : T | undefined`, also when the alias wraps the conditional in a union
+ * or another alias). Their arguments pick the conditional's branch. */
 function literalSensitiveTypeParams(lowerer: Lowerer, gci: GenericClassInfo): Set<ts.Symbol> {
   const params = new Set(gci.typeParams);
   const found = new Set<ts.Symbol>();
+  const reaches = new Map<ts.Symbol, boolean>();
+  const declarationsReach = (symbol: ts.Symbol): boolean => {
+    const target =
+      symbol.flags & ts.SymbolFlags.Alias ? lowerer.checker.getAliasedSymbol(symbol) : symbol;
+    const known = reaches.get(target);
+    if (known !== undefined) return known;
+    reaches.set(target, false); // a recursive alias reaches through its other parts
+    const result = target.declarations.some((d) =>
+      ts.isTypeAliasDeclaration(d)
+        ? reachesConditional(d.type)
+        : ts.isInterfaceDeclaration(d)
+          ? d.members.nodes.some(reachesConditional)
+          : false,
+    );
+    reaches.set(target, result);
+    return result;
+  };
+  const reachesConditional = (node: ts.Node): boolean => {
+    if (ts.isConditionalTypeNode(node)) return true;
+    if (ts.isTypeReferenceNode(node)) {
+      const name = ts.isIdentifier(node.typeName) ? node.typeName : node.typeName.right;
+      const symbol = lowerer.checker.getSymbolAtLocation(name);
+      if (symbol && !params.has(symbol) && declarationsReach(symbol)) return true;
+    }
+    let found = false;
+    ts.forEachChild(node, (child) => {
+      if (!found && reachesConditional(child)) found = true;
+    });
+    return found;
+  };
   const collect = (node: ts.Node): void => {
     if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName)) {
       const symbol = lowerer.checker.getSymbolAtLocation(node.typeName);
@@ -4716,12 +4754,9 @@ function literalSensitiveTypeParams(lowerer: Lowerer, gci: GenericClassInfo): Se
     ts.forEachChild(node, collect);
   };
   const visit = (node: ts.Node): void => {
-    if (
-      ts.isConditionalTypeNode(node) ||
-      (ts.isTypeReferenceNode(node) &&
-        lowerer.checker.getTypeFromTypeNode(node).isConditionalType())
-    ) {
+    if (ts.isTypeNode(node) && reachesConditional(node)) {
       collect(node);
+      return;
     }
     ts.forEachChild(node, visit);
   };
diff --git a/tests/corpus/6908-generic-class-literal-conditional.ts b/tests/corpus/6908-generic-class-literal-conditional.ts
index d06669be3..8bf7a0533 100644
--- a/tests/corpus/6908-generic-class-literal-conditional.ts
+++ b/tests/corpus/6908-generic-class-literal-conditional.ts
@@ -48,3 +48,18 @@ class Switch<B extends boolean> {
   }
 }
 console.log(new Switch(true).label(), new Switch(false).label());
+
+// A conditional wrapped in a union alias selects its branch the same way.
+type MaybeValue<T, K extends Kind> = (K extends "required" ? T : T | undefined) | null;
+class Slot<T, K extends Kind> {
+  value: MaybeValue<T, K>;
+  kind: K;
+  constructor(value: MaybeValue<T, K>, kind: K) {
+    this.value = value;
+    this.kind = kind;
+  }
+}
+const filled = new Slot<string, "required">("a", "required");
+const empty = new Slot<string, "optional">(undefined, "optional");
+const cleared = new Slot<number, "optional">(null, "optional");
+console.log(filled.value, empty.value, cleared.value, filled.kind, empty.kind);

From 644f42373471845ab82d9ea9c66bb472ece533bc Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 14:22:51 -0500
Subject: [PATCH 18/67] Evaluate fs arguments up to the last one with effects
 before a URL path conversion

A synchronous fs call with a URL path evaluated only the later arguments
with effects ahead of the path conversion. When such an argument
reassigned the variable an earlier argument reads, as in
fs.chownSync(url, uid, next()), the earlier argument was read after the
reassignment. Every argument from the URL through the last one with
effects is now evaluated in source order before the conversion.

The npm fixture node24-fs-descriptors now reaches its SC2020 refusal for
writeSync with a hex encoding, since openSync accepts its file URL.
---
 .../frontend/lowering/builtins/fs-paths.ts    | 31 +++++++++++++------
 tests/corpus/6931-fs-url-paths.ts             | 12 +++++++
 tests/harness/npm.test.ts                     |  2 +-
 3 files changed, 34 insertions(+), 11 deletions(-)

diff --git a/packages/compiler/src/frontend/lowering/builtins/fs-paths.ts b/packages/compiler/src/frontend/lowering/builtins/fs-paths.ts
index fb9176b53..181e27e34 100644
--- a/packages/compiler/src/frontend/lowering/builtins/fs-paths.ts
+++ b/packages/compiler/src/frontend/lowering/builtins/fs-paths.ts
@@ -2,9 +2,10 @@
  * fileURLToPath inside each function (getValidatedPath), after every
  * argument has been evaluated, and validates some arguments before the
  * path and others after it. A URL-typed path lowers to the same
- * conversion (url.fileURLToPathUrl). Later arguments with side effects are
- * evaluated into hidden locals before the conversion, so they run even
- * when it throws. The conversion keeps Node's error order when every
+ * conversion (url.fileURLToPathUrl). The later arguments through the last
+ * one with side effects are evaluated into hidden locals before the
+ * conversion, in source order, so they run even when it throws and each
+ * reads what it reads in Node. The conversion keeps Node's error order when every
  * earlier path is a URL too and each argument Node validates before the
  * path is absent or a literal that passes that validation; other URL
  * forms fence with SC2020, as do the fs.promises functions, whose
@@ -134,16 +135,26 @@ function checkUrlPaths(
   // path Node checks first cannot precede the URL.
   if (row.paths.some((i) => i < first && args[i] !== undefined))
     lowerer.noLowering(`${name} with a string path before a URL path`, call, hint);
+  // Every argument from the URL through the last one with effects is
+  // evaluated ahead of the conversion, in source order: a later argument's
+  // effect (an assignment, say) must not change what an earlier one read.
+  let last = first;
+  for (let i = first + 1; i < args.length; i++) if (!sideEffectFreeOptionValue(args[i]!)) last = i;
   const staged: ts.Expression[] = [];
-  for (let i = first + 1; i < args.length; i++) {
-    const arg = args[i]!;
-    if (sideEffectFreeOptionValue(arg)) continue;
+  for (let i = first + 1; i <= last; i++) {
+    let e = args[i]!;
+    while (ts.isParenthesizedExpression(e)) e = e.expression;
     // Literals are read by their members, so a whole-value slot cannot
     // hold them.
-    let e = arg;
-    while (ts.isParenthesizedExpression(e)) e = e.expression;
-    if (ts.isObjectLiteralExpression(e) || ts.isArrayLiteralExpression(e))
-      lowerer.noLowering(`${name} with a URL path and a later literal that has effects`, arg, hint);
+    if (ts.isObjectLiteralExpression(e) || ts.isArrayLiteralExpression(e)) {
+      lowerer.noLowering(
+        sideEffectFreeOptionValue(e)
+          ? `${name} with a URL path and a literal before a later argument that has effects`
+          : `${name} with a URL path and a later literal that has effects`,
+        e,
+        hint,
+      );
+    }
     staged.push(e);
   }
   if (staged.length > 0) {
diff --git a/tests/corpus/6931-fs-url-paths.ts b/tests/corpus/6931-fs-url-paths.ts
index 91a630d1b..cf6889066 100644
--- a/tests/corpus/6931-fs-url-paths.ts
+++ b/tests/corpus/6931-fs-url-paths.ts
@@ -18,6 +18,13 @@ function mode(): number {
   console.log("evaluated mode");
   return 0o600;
 }
+// A later argument that reassigns an earlier argument's variable runs after
+// that argument was read.
+let uid = -1;
+function bumpUid(): number {
+  uid = 123456;
+  return -1;
+}
 
 function clean(text: string): string {
   return text.split(dir).join("<dir>");
@@ -91,6 +98,11 @@ attempt("mkdir", () => {
 attempt("later effects", () => fs.copyFileSync(new URL("http://a/"), logged("dest.txt")));
 attempt("later mode", () => fs.chmodSync(new URL("http://a/"), mode()));
 attempt("chmod", () => fs.chmodSync(new URL("data:text/plain,a"), 0o600));
+attempt("chown order", () => fs.chownSync(file, uid, bumpUid()));
+console.log("uid", uid);
+uid = -1;
+attempt("chown order scheme", () => fs.chownSync(new URL("http://a/"), uid, bumpUid()));
+console.log("uid", uid);
 
 fs.rmSync(dir, { recursive: true, force: true });
 console.log("done", fs.existsSync(dir));
diff --git a/tests/harness/npm.test.ts b/tests/harness/npm.test.ts
index 9ab93f287..2df0d87ef 100644
--- a/tests/harness/npm.test.ts
+++ b/tests/harness/npm.test.ts
@@ -72,7 +72,7 @@ const KNOWN: Record<string, Known> = {
   "node24-esm-metadata": { run: "SC1090" },
   "node24-event-emitter": { run: "SC2020" },
   "node24-file-url-conversion": { build: "SC1090" },
-  "node24-fs-descriptors": { run: "SC1090" },
+  "node24-fs-descriptors": { run: "SC2020" },
   "node24-mime": { run: "SC2020" },
   "node24-mime-errors": { run: "SC1090" },
   "node24-no-error-assertions": { run: "SC2020" },

From 3b35db6b6bee6c3a0785cea52b0952108d8f632a Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 14:24:57 -0500
Subject: [PATCH 19/67] Resolve the stream-construction fixture's file read on
 close

readFileStream resolved on 'end' while its 'close' listener printed
"released". 'close' follows 'end' once the descriptor is closed, so the
line landed wherever that completion fell among the child processes
the fixture starts next, and the comparison with Node depended on
timing. The read now resolves from its 'close' listener, after the line
is printed.
---
 tests/fixtures/node-types/stream-construction.ts | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/tests/fixtures/node-types/stream-construction.ts b/tests/fixtures/node-types/stream-construction.ts
index a28643f7c..dfe4a2320 100644
--- a/tests/fixtures/node-types/stream-construction.ts
+++ b/tests/fixtures/node-types/stream-construction.ts
@@ -42,17 +42,21 @@ function gunzipThrough(payload: Buffer): Promise<string> {
   });
 }
 
+// Resolves after 'close', which follows 'end' once the descriptor is
+// closed: the result never races the child processes started next.
 function readFileStream(file: string): Promise<string> {
   return new Promise((resolve) => {
     const stream = fs.createReadStream(file);
     let text = "";
-    const release = () => console.log("released");
+    const release = () => {
+      console.log("released");
+      resolve(text);
+    };
     stream.on("close", release);
     stream.on("error", release);
     stream.on("data", (chunk) => {
       text += chunk.toString();
     });
-    stream.on("end", () => resolve(text));
   });
 }
 

From c1b413e5ccfe14f3375dbfad85172cbcda0e0f08 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 14:25:23 -0500
Subject: [PATCH 20/67] Shorten the cycle collector's per-object paths

markGray's edge visitor kept a stack frame on every call, though most
edges end at an object that is skipped or already gray. Those now return
without one, and the first visit and skipped cross-generation edges
tail-call out of line, as the scan visitors already do.

The walks no longer call the dense-array walker for an empty array. The
routing of nursery candidates past bypassed levels inlines its bypass
test, and the end of each pass tests its work vectors' capacity inline.
What is collected, and when, is unchanged.
---
 packages/runtime/src/scr_cycle.c | 77 ++++++++++++++++++++------------
 1 file changed, 49 insertions(+), 28 deletions(-)

diff --git a/packages/runtime/src/scr_cycle.c b/packages/runtime/src/scr_cycle.c
index 682f8bfcd..591f544b8 100644
--- a/packages/runtime/src/scr_cycle.c
+++ b/packages/runtime/src/scr_cycle.c
@@ -991,7 +991,8 @@ static inline ScrCycKind *scr_cyc_kind(uint32_t kind) {
 /* Whether a candidate of this type at level `gen` (nursery or mature)
  * skips that level's passes (see above). The last candidate a bypass sends
  * past the level opens a probe window, with fresh counts. */
-static inline bool scr_cyc_bypassed(const ScrCycType *type, unsigned gen) {
+static inline __attribute__((always_inline)) bool scr_cyc_bypassed(const ScrCycType *type,
+                                                                  unsigned gen) {
   uint32_t kind = type->kind;
   if (kind >= scr_cyc_kinds_cap) return false;
   ScrCycLevelStat *k = &scr_cyc_kinds[kind].level[gen];
@@ -1006,8 +1007,10 @@ static inline bool scr_cyc_bypassed(const ScrCycType *type, unsigned gen) {
 }
 
 /* The generation a release buffers an object into: its own, or past the
- * levels its type bypasses. */
-static inline unsigned scr_cyc_buffer_gen(const ScrCycType *type, unsigned gen) {
+ * levels its type bypasses. Both run once per candidate that the routing
+ * below moves, so they are inlined there too. */
+static inline __attribute__((always_inline)) unsigned scr_cyc_buffer_gen(const ScrCycType *type,
+                                                                 unsigned gen) {
   if (gen == SCR_CYC_NURSERY && scr_cyc_bypassed(type, SCR_CYC_NURSERY)) gen = SCR_CYC_MATURE;
   if (gen == SCR_CYC_MATURE && scr_cyc_bypassed(type, SCR_CYC_MATURE)) gen = SCR_CYC_OLD;
   return gen;
@@ -1236,13 +1239,17 @@ void scr_cyc_on_release(void *obj) {
   }
 
 /* Visit every child of `obj` with VISIT, through ARRAY_WALK for a dense
- * cycle-capable array and through the type's trace otherwise. */
+ * cycle-capable array and through the type's trace otherwise. An empty
+ * dense array has no children to visit, and ARRAY_WALK is not called. */
 #define SCR_CYC_CHILDREN(obj, type, ARRAY_WALK, VISIT, depth)                         \
-  do {                                                                               \
-    if ((type)->kind == SCR_CYC_KIND_ARRAY && !(((const ScrArr *)(obj))->spare & SCR_ARR_HAS_EXT))   \
-      ARRAY_WALK((const ScrArr *)(obj), (void *)(depth));                            \
-    else                                                                             \
-      (type)->trace((obj), (VISIT), (void *)(depth));                                \
+  do {                                                                                \
+    if ((type)->kind == SCR_CYC_KIND_ARRAY &&                                         \
+        !(((const ScrArr *)(obj))->spare & SCR_ARR_HAS_EXT)) {                        \
+      if (((const ScrArr *)(obj))->len != 0)                                          \
+        ARRAY_WALK((const ScrArr *)(obj), (void *)(depth));                           \
+    } else {                                                                          \
+      (type)->trace((obj), (VISIT), (void *)(depth));                                 \
+    }                                                                                 \
   } while (0)
 
 static void scr_mg_visit(void *child, void *ctx);
@@ -1253,12 +1260,23 @@ SCR_CYC_ARRAY_WALK(scr_sb_array, scr_sb_visit)
 SCR_CYC_ARRAY_WALK(scr_scan_array, scr_scan_visit)
 
 static inline __attribute__((always_inline)) void scr_mark_gray(void *obj, uintptr_t depth);
+/* An edge into a generation this pass does not walk, for settle. */
+static __attribute__((noinline)) void scr_mg_skip_edge(void *child) {
+  scr_cyc_push_work(&scr_xgen_edges, scr_gray_holder);
+  scr_cyc_push_work(&scr_xgen_edges, child);
+}
+/* The first visit of an object: gray it and walk its children. */
+static __attribute__((noinline)) void scr_mg_first(void *child, void *ctx) {
+  scr_mark_gray(child, (uintptr_t)ctx);
+}
+/* Most edges end at an object that is skipped or gray already. Those
+ * return without a stack frame; the other two cases tail-call out of
+ * line. */
 static void scr_mg_visit(void *child, void *ctx) {
   if (child == NULL || SCR_RC(child) == SCR_RC_IMMORTAL) return;
   ScrCycHdr *h = scr_cyc_hdr(child);
   if (SCR_CYC_WALK_GEN(h) > scr_gen_limit) {
-    scr_cyc_push_work(&scr_xgen_edges, scr_gray_holder);
-    scr_cyc_push_work(&scr_xgen_edges, child);
+    scr_mg_skip_edge(child);
     return;
   }
   size_t rc = --SCR_RC(child);
@@ -1269,7 +1287,7 @@ static void scr_mg_visit(void *child, void *ctx) {
     }
     return;
   }
-  scr_mark_gray(child, (uintptr_t)ctx);
+  scr_mg_first(child, ctx);
 }
 /* markGray reaches `obj` (its count already trial-decremented): gray it,
  * number it with the walk's component, record it, count it while it is
@@ -1436,6 +1454,25 @@ static SCR_CYC_COMPACT void scr_xg_release(void *obj) {
   scr_rc_destroy(obj, scr_xg_destroy);
 }
 
+/* A work vector that holds more than this many entries is freed at the end
+ * of a pass that used less than a quarter of it, so a spike in one pass
+ * does not keep its buffers for the rest of the program, while passes of a
+ * steady size keep reusing theirs. */
+#define SCR_CYC_KEEP_VECTOR 65536
+
+static SCR_CYC_COMPACT void scr_cyc_trim_free(ScrVec *vec) {
+  free(vec->v);
+  vec->v = NULL;
+  vec->cap = 0;
+}
+/* Every pass ends by trimming its work vectors, and most of them stay
+ * small: only the capacity test runs inline. */
+static inline void scr_cyc_trim(ScrVec *vec) {
+  if (vec->cap > SCR_CYC_KEEP_VECTOR && vec->n == 0 && vec->used < vec->cap / 4)
+    scr_cyc_trim_free(vec);
+  vec->used = 0;
+}
+
 #ifdef SCR_YIN
 /* ── young-in nursery ─────────────────────────────────────────────────── */
 
@@ -1488,7 +1525,6 @@ static SCR_CYC_COMPACT void scr_xg_release(void *obj) {
  * deletion reaches the survivor from the root's candidate; garbage formed
  * after the promotion has a candidate from the release that formed it,
  * since survivors are no longer young. */
-static void scr_cyc_trim(ScrVec *vec);
 #define SCR_YIN_DEFAULT_SIZE 4096
 #define SCR_CYC_YIN_PROMOTED SCR_CYC_NURSERY
 
@@ -1928,21 +1964,6 @@ static SCR_CYC_COMPACT size_t scr_cyc_settle(unsigned gen_limit, bool doomed) {
   return freed;
 }
 
-/* A work vector that holds more than this many entries is freed at the end
- * of a pass that used less than a quarter of it, so a spike in one pass
- * does not keep its buffers for the rest of the program, while passes of a
- * steady size keep reusing theirs. */
-#define SCR_CYC_KEEP_VECTOR 65536
-
-static SCR_CYC_COMPACT void scr_cyc_trim(ScrVec *vec) {
-  if (vec->n == 0 && vec->cap > SCR_CYC_KEEP_VECTOR && vec->used < vec->cap / 4) {
-    free(vec->v);
-    vec->v = NULL;
-    vec->cap = 0;
-  }
-  vec->used = 0;
-}
-
 /* The end of every pass. The candidate list keeps its count, which the
  * scheduler reads; its buffer goes when this pass's candidates filled
  * less than a quarter of it. */

From 7ff0ea472d28a05788dd39fbdb421c01d0fceea5 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 14:59:26 -0500
Subject: [PATCH 21/67] Walk AST subtrees by their node ranges

---
 .../src/frontend/lowering/lower-stmts.test.ts |  2 +-
 .../compiler/src/frontend/program.test.ts     |  2 +-
 .../src/frontend/ts7/ast-node.test.ts         | 34 +++++++++
 .../compiler/src/frontend/ts7/ast-node.ts     | 53 +++++++++++---
 .../compiler/src/frontend/ts7/ast-wire.ts     | 71 +++++++++++++++++++
 packages/compiler/src/frontend/ts7/ast.ts     | 59 ++++++++++++++-
 6 files changed, 207 insertions(+), 14 deletions(-)

diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.test.ts b/packages/compiler/src/frontend/lowering/lower-stmts.test.ts
index 322b21b2a..8e0c809b7 100644
--- a/packages/compiler/src/frontend/lowering/lower-stmts.test.ts
+++ b/packages/compiler/src/frontend/lowering/lower-stmts.test.ts
@@ -54,7 +54,7 @@ function mutate(value) { captured = value; compound += value; let shadow = 0; sh
   ctx.bind(shadow, []);
   ctx.bind(untouched, []);
   ctx.bind(innerShadow, [at(ctx.assignments, 2)]);
-  const walk = vi.spyOn(ctx.file, "appendChildIndices");
+  const walk = vi.spyOn(ctx.file.file.wire, "preorder");
   for (let i = 0; i < 20; i++) {
     expect(jsBindingHasOpenWrites(ctx.lowerer, captured)).toBe(true);
     expect(jsBindingHasOpenWrites(ctx.lowerer, compound)).toBe(true);
diff --git a/packages/compiler/src/frontend/program.test.ts b/packages/compiler/src/frontend/program.test.ts
index c1bd183f2..bdd6260ed 100644
--- a/packages/compiler/src/frontend/program.test.ts
+++ b/packages/compiler/src/frontend/program.test.ts
@@ -351,7 +351,7 @@ test("repeated cycle edges reuse a file's binding index", () => {
       [peer, peerImports.map((stmt) => ({ dep: main, stmt }))],
     ]);
     const admit = makeCycleAdmission(load.program, (file) => edges.get(file) ?? []);
-    const walk = vi.spyOn(peer, "appendChildIndices");
+    const walk = vi.spyOn(peer.file.wire, "preorder");
     try {
       expect(admit(peer, edges.get(peer)![0]!)).toBeNull();
       expect(walk).toHaveBeenCalled();
diff --git a/packages/compiler/src/frontend/ts7/ast-node.test.ts b/packages/compiler/src/frontend/ts7/ast-node.test.ts
index 60bfaa005..6b2725b93 100644
--- a/packages/compiler/src/frontend/ts7/ast-node.test.ts
+++ b/packages/compiler/src/frontend/ts7/ast-node.test.ts
@@ -511,6 +511,40 @@ test("preorder traversal preserves depth, skipped subtrees and early termination
   expect(prefix).toEqual(expected.slice(0, 7));
 });
 
+test("preorder walks from every node match a recursive visit of every file", () => {
+  const kinds = new Set<AstNode["kind"]>([AstKind.Identifier, AstKind.JSDocTypeLiteral]);
+  for (const [name, { file, oracle }] of decoded) {
+    expect(file.wire.preorder(), name).not.toBeNull();
+    for (let index = 1; index < file.wire.nodeCount; index++) {
+      if (file.wire.kind(index) === KIND_NODE_LIST) continue;
+      const expected: [number, number][] = [];
+      const selected: [number, number][] = [];
+      const visit = (node: OracleNode, depth: number): void => {
+        expected.push([node.index, depth]);
+        if (kinds.has(node.kind)) selected.push([node.index, depth]);
+        node.forEachChild((child) => {
+          visit(child as OracleNode, depth + 1);
+        });
+      };
+      visit(oracle.getOrCreateNodeAtIndex(index), 0);
+      const actual: [number, number][] = [];
+      walkPreorder(file.node(index), (node, depth) => {
+        actual.push([node.index, depth]);
+      });
+      expect(actual, `${name}:${index}`).toEqual(expected);
+      const actualSelected: [number, number][] = [];
+      walkPreorder(
+        file.node(index),
+        (node, depth) => {
+          actualSelected.push([node.index, depth]);
+        },
+        kinds,
+      );
+      expect(actualSelected, `${name}:${index}`).toEqual(selected);
+    }
+  }
+});
+
 test("child traversal still rejects a sibling belonging to another parent", () => {
   const { file, bytes } = decoded.get("main.ts")!;
   let parent = 0;
diff --git a/packages/compiler/src/frontend/ts7/ast-node.ts b/packages/compiler/src/frontend/ts7/ast-node.ts
index f337bd623..be2745616 100644
--- a/packages/compiler/src/frontend/ts7/ast-node.ts
+++ b/packages/compiler/src/frontend/ts7/ast-node.ts
@@ -9,6 +9,7 @@ import {
 import { astLineOfPosition, astLineStarts, astSkipTrivia } from "./ast-text.js";
 import {
   AstWireFile,
+  PREORDER_LIST,
   parseAstNodeHandle,
   type AstFileReference,
   type AstNodeHandle,
@@ -359,6 +360,32 @@ export class AstNode {
   forEachChild<T>(
     visitNode: (node: AstNode) => T,
     visitList?: (nodes: AstNodeList) => T,
+  ): T | undefined {
+    const wire = this.file.wire;
+    const tree = wire.preorder();
+    if (tree === null) return this.forEachLinkedChild(visitNode, visitList);
+    // In the checked preorder tree, the first child follows its parent and
+    // each later child starts where the previous child's subtree ends.
+    const kinds = tree.kinds;
+    const ends = tree.ends;
+    const stop = ends[this.index]!;
+    for (let index = this.index + 1; index < stop; index = ends[index]!) {
+      const kind = kinds[index]!;
+      if (kind === PREORDER_LIST) {
+        const result = this.visitChildList(index, visitNode, visitList);
+        if (result) return result;
+      } else if (kind !== AstKind.JSDoc) {
+        const result = visitNode(this.file.node(index));
+        if (result) return result;
+      }
+    }
+    return undefined;
+  }
+
+  /** forEachChild through the sibling and parent links. */
+  private forEachLinkedChild<T>(
+    visitNode: (node: AstNode) => T,
+    visitList?: (nodes: AstNodeList) => T,
   ): T | undefined {
     const wire = this.file.wire;
     // Walk the immutable sibling links directly. Repeated semantic scans
@@ -368,16 +395,8 @@ export class AstNode {
         throw new AstDecodeError("sibling belongs to another parent");
       const kind = wire.kind(index);
       if (kind === KIND_NODE_LIST) {
-        const list = this.file.list(index);
-        if (visitList !== undefined) {
-          const result = visitList(list);
-          if (result) return result;
-        } else {
-          for (const node of list.nodes) {
-            const result = visitNode(node);
-            if (result) return result;
-          }
-        }
+        const result = this.visitChildList(index, visitNode, visitList);
+        if (result) return result;
       } else if (kind !== AstKind.JSDoc) {
         const result = visitNode(this.file.node(index));
         if (result) return result;
@@ -386,6 +405,20 @@ export class AstNode {
     return undefined;
   }
 
+  private visitChildList<T>(
+    index: number,
+    visitNode: (node: AstNode) => T,
+    visitList?: (nodes: AstNodeList) => T,
+  ): T | undefined {
+    const list = this.file.list(index);
+    if (visitList !== undefined) return visitList(list);
+    for (const node of list.nodes) {
+      const result = visitNode(node);
+      if (result) return result;
+    }
+    return undefined;
+  }
+
   get jsDoc(): AstNode[] | undefined {
     const docs: AstNode[] = [];
     for (const index of this.file.wire.children(this.index)) {
diff --git a/packages/compiler/src/frontend/ts7/ast-wire.ts b/packages/compiler/src/frontend/ts7/ast-wire.ts
index a2466a743..ff70148df 100644
--- a/packages/compiler/src/frontend/ts7/ast-wire.ts
+++ b/packages/compiler/src/frontend/ts7/ast-wire.ts
@@ -32,6 +32,16 @@ import {
   astChildOrder,
 } from "./ast-schema.generated.js";
 
+/** A node table read as a preorder tree (AstWireFile.preorder): each
+ * node's kind, with PREORDER_LIST for lists, and the end of its subtree. */
+export interface AstPreorder {
+  readonly kinds: Uint16Array;
+  readonly ends: Uint32Array;
+}
+
+/** The kind AstPreorder records for a list (KIND_NODE_LIST on the wire). */
+export const PREORDER_LIST = 0xffff;
+
 export interface AstFileReference {
   pos: number;
   end: number;
@@ -125,6 +135,7 @@ export class AstWireFile {
   private readonly words: Uint32Array;
   /** Decoded strings by string word index / 2. */
   private readonly stringCache: (string | undefined)[];
+  private preorderTree: AstPreorder | null | undefined;
 
   constructor(private readonly bytes: Uint8Array) {
     astBounds(bytes, 0, HEADER_SIZE);
@@ -317,6 +328,66 @@ export class AstWireFile {
     return children;
   }
 
+  /** The node table as a preorder tree, built on first use: every node's
+   * subtree is the index range up to `ends[index]`, and `kinds[index]` is its
+   * kind. The pass checks the links the linked walk checks one child at a
+   * time: each node's parent is open, the first child follows its parent,
+   * each sibling link names the end of the previous sibling's subtree, a
+   * last child has no sibling link, and each list holds `data` nodes and no
+   * lists. null when any check fails; walks then follow the links and fail
+   * where they read the inconsistent node. */
+  preorder(): AstPreorder | null {
+    if (this.preorderTree === undefined) this.preorderTree = this.buildPreorder();
+    return this.preorderTree;
+  }
+
+  private buildPreorder(): AstPreorder | null {
+    const count = this.nodeCount;
+    const words = this.words;
+    const kinds = new Uint16Array(count);
+    const ends = new Uint32Array(count);
+    // The nodes whose subtrees contain the current index, innermost last,
+    // with the number of children each has so far.
+    const open: number[] = [1];
+    const children: number[] = [0];
+    const rootKind = words[NODE_WORDS + WORD_KIND]!;
+    if (rootKind >= PREORDER_LIST) return null;
+    kinds[1] = rootKind;
+    for (let index = 2; index <= count; index++) {
+      const word = index * NODE_WORDS;
+      const parent = index < count ? words[word + WORD_PARENT]! : 0;
+      let previous = 0;
+      while (open.length > 0 && open[open.length - 1] !== parent) {
+        const closed = open.pop()!;
+        const closedChildren = children.pop()!;
+        ends[closed] = index;
+        const closedWord = closed * NODE_WORDS;
+        if (kinds[closed] === PREORDER_LIST && closedChildren !== words[closedWord + WORD_DATA]!)
+          return null;
+        if (open.length > 0 && open[open.length - 1] === parent) previous = closed;
+        else if (closed !== 1 && words[closedWord + WORD_NEXT]! !== 0) return null;
+      }
+      if (index === count) break;
+      if (open.length === 0 || parent >= index) return null;
+      if (
+        previous !== 0 ? words[previous * NODE_WORDS + WORD_NEXT]! !== index : index !== parent + 1
+      )
+        return null;
+      const kind = words[word + WORD_KIND]!;
+      if (kind === KIND_NODE_LIST) {
+        if (kinds[parent] === PREORDER_LIST) return null;
+        kinds[index] = PREORDER_LIST;
+      } else {
+        if (kind >= PREORDER_LIST) return null;
+        kinds[index] = kind;
+      }
+      children[children.length - 1] = children[children.length - 1]! + 1;
+      open.push(index);
+      children.push(0);
+    }
+    return { kinds, ends };
+  }
+
   /** The semantic walk flattens lists and omits attached JSDoc trees.
    * Validate the same list links as list(), without materializing nodes
    * that a selective syntax scan will never inspect. */
diff --git a/packages/compiler/src/frontend/ts7/ast.ts b/packages/compiler/src/frontend/ts7/ast.ts
index a92cfafd8..369213d89 100644
--- a/packages/compiler/src/frontend/ts7/ast.ts
+++ b/packages/compiler/src/frontend/ts7/ast.ts
@@ -47,6 +47,8 @@ import {
 } from "./ast-guards.generated.js";
 import type { Ts7DiagnosticData as Diagnostic } from "./session-schema.generated.js";
 import { ModifierFlags, SyntaxKind } from "./enums.js";
+import { AstKind } from "./ast-schema.generated.js";
+import { PREORDER_LIST } from "./ast-wire.js";
 
 /* ---- everything 7 kept under the same name ---- */
 
@@ -101,7 +103,7 @@ export function forEachChild<T>(
   return node.forEachChild(cbNode, cbNodes);
 }
 
-/** Preorder walk over a whole subtree with an EXPLICIT stack. The idiomatic
+/** Preorder walk over a whole subtree without recursion. The idiomatic
  * recursive forEachChild visit costs two JS frames per AST level, so a
  * pathologically deep tree — the ~6500-term left-nested binary chain of the
  * binderBinaryExpressionStress corpus pair — overflows the stack as an ICE
@@ -110,11 +112,64 @@ export function forEachChild<T>(
  * detection) walk this way instead, so absurd nesting always reaches the
  * named fence. The callback may answer "skip" to leave a node's children
  * unvisited (scope and depth cut-offs — `depth` counts levels below the
- * root) or "stop" to end the walk early. */
+ * root) or "stop" to end the walk early.
+ *
+ * The wire stores nodes in preorder, so the walk visits the subtree's index
+ * range in order: it enters lists without a level of their own, and passes
+ * over attached JSDoc trees and skipped subtrees by their end index. A table
+ * that is not a checked preorder tree (AstWireFile.preorder) is walked
+ * through its links instead. */
 export function walkPreorder(
   root: Node,
   cb: (node: Node, depth: number) => void | "skip" | "stop",
   kinds?: ReadonlySet<SyntaxKind>,
+): void {
+  const file = root.file;
+  const tree = file.wire.preorder();
+  if (tree === null) {
+    walkLinkedPreorder(root, cb, kinds);
+    return;
+  }
+  const nodeKinds = tree.kinds;
+  const ends = tree.ends;
+  const start = root.index;
+  const stop = ends[start]!;
+  // The subtree ends of the visited nodes that contain the current index.
+  const open: number[] = [];
+  let index = start;
+  while (index < stop) {
+    const kind = nodeKinds[index]!;
+    if (kind === PREORDER_LIST) {
+      index++;
+      continue;
+    }
+    if (
+      kind === AstKind.JSDoc &&
+      index !== start &&
+      nodeKinds[file.wire.parent(index)] !== PREORDER_LIST
+    ) {
+      index = ends[index]!;
+      continue;
+    }
+    while (open.length > 0 && open[open.length - 1]! <= index) open.pop();
+    const node = kinds === undefined || kinds.has(kind) ? file.node(index) : undefined;
+    const verdict = node === undefined ? undefined : cb(node, open.length);
+    if (verdict === "stop") return;
+    if (verdict === "skip") {
+      index = ends[index]!;
+      continue;
+    }
+    open.push(ends[index]!);
+    index++;
+  }
+}
+
+/** walkPreorder through the sibling and parent links, with an explicit
+ * stack. */
+function walkLinkedPreorder(
+  root: Node,
+  cb: (node: Node, depth: number) => void | "skip" | "stop",
+  kinds?: ReadonlySet<SyntaxKind>,
 ): void {
   const file = root.file;
   const stack: number[] = [root.index];

From ca68d63c1c4a70267668d82aea9159712f7dee8e Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 15:00:22 -0500
Subject: [PATCH 22/67] Finish a worker message batch before port messages, and
 count queued messages as they arrive

- Port messages that a 'message' listener posts while more worker
  messages are queued are delivered after those messages and before
  setImmediate callbacks, as in Node. The ports' poll phase waits while a
  batch's next message is queued, and the loop pass continues once more
  after the batch when a port has something to deliver.
- A mailbox counts its queued events per kind as they are posted and
  taken, so starting a batch reads the count instead of scanning the
  queue under the lock. Messages that alternate with a worker's captured
  stdout or stderr start a batch each, which made delivery quadratic:
  20000 such messages took 5.6 s to drain, and now take 0.5 s (Node 0.57 s).
- The continue hook passes on that the batch's next message is at the
  head, so the dispatch that follows does not lock the mailbox again.
- Corpus 6212 checks the order of worker messages, a MessageChannel
  message posted by the first listener, and setImmediate against Node.
  6211's costs are now taken from its CI timings.
---
 .../6212-worker-message-batch-ports.ts.json   |  6 +++
 packages/runtime/src/scr_mailbox.c            | 10 +++-
 packages/runtime/src/scr_mailbox.h            |  3 +-
 packages/runtime/src/scr_worker_events.c      | 37 +++++++++++++--
 .../corpus/6212-worker-message-batch-ports.ts | 47 +++++++++++++++++++
 .../6211-worker-message-batches.ts.json       |  2 +-
 .../6212-worker-message-batch-ports.ts.json   |  1 +
 7 files changed, 97 insertions(+), 9 deletions(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6212-worker-message-batch-ports.ts.json
 create mode 100644 tests/corpus/6212-worker-message-batch-ports.ts
 create mode 100644 tests/harness/corpus-costs/6212-worker-message-batch-ports.ts.json

diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6212-worker-message-batch-ports.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6212-worker-message-batch-ports.ts.json
new file mode 100644
index 000000000..76d4c8da7
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6212-worker-message-batch-ports.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6212-worker-message-batch-ports.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/runtime/src/scr_mailbox.c b/packages/runtime/src/scr_mailbox.c
index 39e7801ed..a8dc7e5cc 100644
--- a/packages/runtime/src/scr_mailbox.c
+++ b/packages/runtime/src/scr_mailbox.c
@@ -25,11 +25,15 @@
 #endif
 #endif
 
+/* Event kinds below this have their queued events counted (scr_mailbox_count_kind). */
+#define SCR_MAILBOX_COUNTED_KINDS 16u
+
 struct ScrMailbox {
   atomic_size_t references;
   ScrMailEvent *head;
   ScrMailEvent **tail;
   bool closed;
+  size_t queued[SCR_MAILBOX_COUNTED_KINDS]; /* under the lock */
   /* head != NULL || closed, written under the lock, read without it by
    * scr_mailbox_wait's spin. */
   atomic_bool ready;
@@ -167,6 +171,7 @@ bool scr_mailbox_post(ScrMailbox *mailbox, ScrMailEvent *event) {
   event->next = NULL;
   *mailbox->tail = event;
   mailbox->tail = &event->next;
+  if (event->kind < SCR_MAILBOX_COUNTED_KINDS) mailbox->queued[event->kind]++;
   atomic_store_explicit(&mailbox->ready, true, memory_order_release);
   scr_mailbox_unlock(mailbox);
   /* Signaled after the unlock: a woken or spinning taker then finds the
@@ -182,6 +187,7 @@ ScrMailEvent *scr_mailbox_take(ScrMailbox *mailbox) {
   if (event) {
     mailbox->head = event->next;
     event->next = NULL;
+    if (event->kind < SCR_MAILBOX_COUNTED_KINDS) mailbox->queued[event->kind]--;
   }
   if (!mailbox->head) {
     mailbox->tail = &mailbox->head;
@@ -201,6 +207,7 @@ ScrMailEvent *scr_mailbox_take_kind(ScrMailbox *mailbox, unsigned kind, uint64_t
     *slot = event->next;
     if (mailbox->tail == &event->next) mailbox->tail = slot;
     event->next = NULL;
+    if (event->kind < SCR_MAILBOX_COUNTED_KINDS) mailbox->queued[event->kind]--;
   }
   if (!mailbox->head) {
     mailbox->tail = &mailbox->head;
@@ -235,8 +242,7 @@ unsigned scr_mailbox_head_kind(ScrMailbox *mailbox) {
 
 size_t scr_mailbox_count_kind(ScrMailbox *mailbox, unsigned kind) {
   scr_mailbox_lock(mailbox);
-  size_t count = 0;
-  for (ScrMailEvent *event = mailbox->head; event; event = event->next) count += event->kind == kind;
+  size_t count = kind < SCR_MAILBOX_COUNTED_KINDS ? mailbox->queued[kind] : 0;
   scr_mailbox_unlock(mailbox);
   return count;
 }
diff --git a/packages/runtime/src/scr_mailbox.h b/packages/runtime/src/scr_mailbox.h
index ac8493057..4e5f253b5 100644
--- a/packages/runtime/src/scr_mailbox.h
+++ b/packages/runtime/src/scr_mailbox.h
@@ -28,7 +28,8 @@ void scr_mailbox_close(ScrMailbox *mailbox);
 bool scr_mailbox_pending(ScrMailbox *mailbox);
 /* The kind of the first queued event, or 0 when none is queued. */
 unsigned scr_mailbox_head_kind(ScrMailbox *mailbox);
-/* The number of queued events of this kind. */
+/* The number of queued events of this kind, kept as events are posted and
+ * taken; 0 for kinds of 16 and above. */
 size_t scr_mailbox_count_kind(ScrMailbox *mailbox, unsigned kind);
 void scr_mailbox_wait(ScrMailbox *mailbox, double milliseconds);
 int scr_mailbox_pollfd(const ScrMailbox *mailbox);
diff --git a/packages/runtime/src/scr_worker_events.c b/packages/runtime/src/scr_worker_events.c
index f7778f3fa..252230372 100644
--- a/packages/runtime/src/scr_worker_events.c
+++ b/packages/runtime/src/scr_worker_events.c
@@ -63,9 +63,22 @@ static SCR_TL bool scr_channel_closing_phase;
  * has taken SCR_WORKER_BATCH_MIN, with a microtask checkpoint after each,
  * before the loop goes on to timers and immediates. A delivered message
  * starts a batch; the loop pass continues it (scr_workers_more) while the
- * next event is a message and the batch has room. */
+ * next event is a message and the batch has room. Port messages that a
+ * listener posts meanwhile wait for the batch to end, and the pass then
+ * continues once more so they are delivered before immediates, as in Node. */
 #define SCR_WORKER_BATCH_MIN 1000
 static SCR_TL size_t scr_worker_batch_left;
+static SCR_TL bool scr_worker_batch_ended;
+/* scr_workers_more found the batch's next message at the head of the
+ * mailbox. Only this thread takes events and others append them, so it is
+ * still there when the pass dispatches. */
+static SCR_TL bool scr_worker_batch_queued;
+
+/* Whether a batch is open and its next message is queued. */
+static bool scr_worker_batch_next(void) {
+  return scr_worker_batch_left > 0 && scr_worker_events &&
+         scr_mailbox_head_kind(scr_worker_events) == SCR_WORKER_MESSAGE;
+}
 static const char *const scr_worker_method_names[] = {
   "ref", "unref", "hasRef", "terminate", "postMessage", "on", "once", "addListener",
   "prependListener", "prependOnceListener", "off", "removeListener", "removeAllListeners",
@@ -710,15 +723,29 @@ static bool scr_channel_more(void) {
 }
 
 static bool scr_workers_more(void) {
+  if (scr_worker_batch_left > 0) {
+    if (scr_worker_batch_next()) {
+      scr_worker_batch_queued = true;
+      return true;
+    }
+    scr_worker_batch_left = 0;
+    scr_worker_batch_ended = true;
+  }
   if (scr_channel_more()) return true;
-  if (scr_worker_batch_left == 0) return false;
-  if (scr_worker_events && scr_mailbox_head_kind(scr_worker_events) == SCR_WORKER_MESSAGE) return true;
-  scr_worker_batch_left = 0;
+  /* One more pass after a batch when a port has something to deliver: the
+   * ports' poll phase for what its listeners posted. */
+  bool ended = scr_worker_batch_ended;
+  scr_worker_batch_ended = false;
+  if (ended)
+    for (ScrWorkerView *view = scr_channel_ports; view; view = view->next)
+      if (scr_channel_port_ready(view)) return true;
   return false;
 }
 
 static void scr_worker_dispatch(void) {
-  if (scr_channel_dispatch()) return;
+  bool batch = scr_worker_batch_queued;
+  scr_worker_batch_queued = false;
+  if (!batch && scr_channel_dispatch()) return;
   ScrWorkerView *port = scr_worker_port;
   if (port && port->closing) {
     port->closing = false;
diff --git a/tests/corpus/6212-worker-message-batch-ports.ts b/tests/corpus/6212-worker-message-batch-ports.ts
new file mode 100644
index 000000000..3f5a2a476
--- /dev/null
+++ b/tests/corpus/6212-worker-message-batch-ports.ts
@@ -0,0 +1,47 @@
+import { MessageChannel, Worker, isMainThread, parentPort, workerData } from "node:worker_threads";
+
+// A MessageChannel message that a worker 'message' listener posts while
+// more worker messages are queued arrives after those messages and before
+// setImmediate callbacks, as in Node. The listener waits on a shared flag
+// until the worker has posted the rest.
+function waitFor(flag: Int32Array, index: number): void {
+  while (Atomics.load(flag, index) === 0) Atomics.wait(flag, index, 0, 50);
+}
+function signal(flag: Int32Array, index: number): void {
+  Atomics.store(flag, index, 1);
+  Atomics.notify(flag, index);
+}
+
+if (isMainThread) {
+  const flag = new Int32Array(new SharedArrayBuffer(8));
+  const worker = new Worker(new URL(import.meta.url), { workerData: flag });
+  const channel = new MessageChannel();
+  const log: string[] = [];
+  channel.port2.on("message", (m: unknown) => {
+    log.push(`channel ${String(m)}`);
+  });
+  let count = 0;
+  worker.on("message", (m: unknown) => {
+    count++;
+    log.push(`worker ${String(m)}`);
+    if (count === 1) {
+      signal(flag, 0);
+      waitFor(flag, 1);
+      channel.port1.postMessage("c1");
+      setImmediate(() => {
+        log.push("immediate");
+        setImmediate(() => {
+          log.push("second immediate");
+          for (const line of log) console.log(line);
+          channel.port1.close();
+        });
+      });
+    }
+  });
+} else {
+  const flag = workerData as Int32Array;
+  parentPort!.postMessage("w1");
+  waitFor(flag, 0);
+  for (let i = 2; i <= 6; i++) parentPort!.postMessage(`w${i}`);
+  signal(flag, 1);
+}
diff --git a/tests/harness/corpus-costs/6211-worker-message-batches.ts.json b/tests/harness/corpus-costs/6211-worker-message-batches.ts.json
index 75b17b215..af8e672d4 100644
--- a/tests/harness/corpus-costs/6211-worker-message-batches.ts.json
+++ b/tests/harness/corpus-costs/6211-worker-message-batches.ts.json
@@ -1 +1 @@
-{ "plain": 2507, "san": 20224 }
+{ "plain": 3694, "san": 3271 }
diff --git a/tests/harness/corpus-costs/6212-worker-message-batch-ports.ts.json b/tests/harness/corpus-costs/6212-worker-message-batch-ports.ts.json
new file mode 100644
index 000000000..fb0e48437
--- /dev/null
+++ b/tests/harness/corpus-costs/6212-worker-message-batch-ports.ts.json
@@ -0,0 +1 @@
+{ "plain": 5538, "san": 3201 }

From eca349d2440b2c4274823b952d6201022992b9c3 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 15:32:52 -0500
Subject: [PATCH 23/67] Forward nested zlib callback results and keep
 self-calling callbacks' error checks

A nested callback lowered inside an outer error path passed the absent
Buffer on into a Buffer slot even when its own operation succeeded, so a
callee such as (err, out) => cb(err, out) received undefined instead of
the result. The forwarded value is now the Buffer when there is one.

A named function expression passed to zlib can call itself, and a
function expression can reach itself through arguments.callee, with an
error and a Buffer. Such functions no longer count as called only by
the adapter, so their success copy keeps the runtime error checks
instead of folding them to the success case.
---
 .../frontend/lowering/builtins/arguments.ts   |  8 ++++-
 .../src/frontend/lowering/lower-functions.ts  | 24 ++++++++++-----
 .../corpus/6920-zlib-callback-error-result.ts | 29 +++++++++++++++++++
 .../6920-zlib-callback-error-result.ts.json   |  2 +-
 4 files changed, 53 insertions(+), 10 deletions(-)

diff --git a/packages/compiler/src/frontend/lowering/builtins/arguments.ts b/packages/compiler/src/frontend/lowering/builtins/arguments.ts
index d3bf46774..7f862f603 100644
--- a/packages/compiler/src/frontend/lowering/builtins/arguments.ts
+++ b/packages/compiler/src/frontend/lowering/builtins/arguments.ts
@@ -20,6 +20,7 @@ import * as ts from "../../ts7/adapter.js";
 import { type Lowerer } from "../lowerer.js";
 import { locOf } from "../../program.js";
 import { lowerAbsenceProbe } from "../lower-exprs.js";
+import { bodyReadsArguments } from "../../arguments-usage.js";
 import { defaultAfterUndefined, lowerStaticallyUndefinedArgument } from "../optional-arguments.js";
 import { voidizedCallback } from "../lower-server.js";
 export function optionalStringTags(
@@ -269,9 +270,14 @@ export function errorFirstCallback(
 ): IrExpr {
   // A literal here is called only by the callback adapter, which passes
   // null as the error whenever it passes a result (lowerUndefinedResultBody).
+  // A named function expression can also call itself, and a function
+  // expression can reach itself through `arguments.callee`.
   let literal: ts.Expression = node;
   while (ts.isParenthesizedExpression(literal)) literal = literal.expression;
-  if (ts.isArrowFunction(literal) || ts.isFunctionExpression(literal))
+  if (
+    ts.isArrowFunction(literal) ||
+    (ts.isFunctionExpression(literal) && literal.name === undefined && !bodyReadsArguments(literal))
+  )
     lowerer.errorFirstLiterals.add(literal);
   let callback = lowerer.lowerExpr(node);
   if (callback.type.kind === "dyn") {
diff --git a/packages/compiler/src/frontend/lowering/lower-functions.ts b/packages/compiler/src/frontend/lowering/lower-functions.ts
index 9254e6213..6fc083468 100644
--- a/packages/compiler/src/frontend/lowering/lower-functions.ts
+++ b/packages/compiler/src/frontend/lowering/lower-functions.ts
@@ -718,13 +718,13 @@ function lowerUndefinedResultBody(
   const loc = locOf(node);
   const param = lowerer.bindingIn(lowerer.ctx, result.symbol);
   if (param === null) throw new InternalCompilerError("lowerer bug: callback result unbound");
-  const absent: IrExpr = {
+  const absent = (): IrExpr => ({
     kind: "libCall",
     fn: "bytes.isAbsent",
     args: [varRef(param.id, param.type, loc)],
     type: BOOL,
     loc,
-  };
+  });
   const fence: IrStmt = {
     kind: "runtimeFence",
     code: "SC2020",
@@ -750,9 +750,10 @@ function lowerUndefinedResultBody(
     lowerer.suppressStats = true;
     lowerer.errorPathCopies++;
     try {
-      // Passed on into a Buffer slot, the result stays the absent Buffer
-      // the adapter passed: a callee with this entry test reads it as
-      // undefined.
+      // Passed on into a Buffer slot, the result stays what the adapter
+      // passed: the Buffer, or the absent Buffer, which a callee with this
+      // entry test reads as undefined. (The copy that serves both paths
+      // reaches this with a Buffer.)
       const body = transformStmtList(withKnownError(knownError, lowerBody), {
         expr: (e) =>
           e.kind === "dynCheck" &&
@@ -760,7 +761,14 @@ function lowerUndefinedResultBody(
           e.value.localId === slot.id &&
           e.type.kind === "bytes" &&
           e.type.elem === "u8"
-            ? { kind: "libCall", fn: "bytes.absent", args: [], type: e.type, loc: e.loc }
+            ? {
+                kind: "ternary",
+                cond: absent(),
+                then: { kind: "libCall", fn: "bytes.absent", args: [], type: e.type, loc: e.loc },
+                else_: varRef(param.id, param.type, e.loc),
+                type: e.type,
+                loc: e.loc,
+              }
             : e,
         stmt: (stmt) => stmt,
       });
@@ -795,7 +803,7 @@ function lowerUndefinedResultBody(
           localId: slot.id,
           init: {
             kind: "ternary",
-            cond: absent,
+            cond: absent(),
             then: dynUndefinedExpr(loc),
             else_: lowerer.coerceInto(result.name, varRef(param.id, param.type, loc), DYN),
             type: DYN,
@@ -811,7 +819,7 @@ function lowerUndefinedResultBody(
   return [
     {
       kind: "if",
-      cond: absent,
+      cond: absent(),
       then: withoutResult === null ? [fence] : [undefinedResult, ...withoutResult],
       else_: withResult,
       loc,
diff --git a/tests/corpus/6920-zlib-callback-error-result.ts b/tests/corpus/6920-zlib-callback-error-result.ts
index 50998d37f..cc9128221 100644
--- a/tests/corpus/6920-zlib-callback-error-result.ts
+++ b/tests/corpus/6920-zlib-callback-error-result.ts
@@ -149,6 +149,33 @@ function inflated(input: Buffer): Promise<Buffer> {
   );
 }
 
+function sink(err: Error | null, out: Buffer): void {
+  console.log("sink", err, typeof out, out?.length);
+  step();
+}
+function nestedForward(): void {
+  // On the outer error path, the nested callback forwards its own result.
+  zlib.inflate(bad, (err, out) => {
+    console.log("outer", err?.code, typeof out);
+    zlib.inflate(good, (err2, out2) => sink(err2, out2));
+  });
+}
+let attempts = 0;
+function namedRetry(): void {
+  // A named callback that calls itself with an error and a Buffer.
+  zlib.inflate(bad, function retry(err, out) {
+    attempts++;
+    if (err) {
+      if (attempts < 3) return retry(new Error("again"), Buffer.from("x"));
+      console.log("gave up", attempts, err.message, out.length);
+      step();
+      return;
+    }
+    console.log("retry value", out.length);
+    step();
+  });
+}
+
 function functionValues(next: () => void): void {
   steps.push(
     () => zlib.inflate(good, named),
@@ -174,6 +201,8 @@ function functionValues(next: () => void): void {
     () => forwardGzip("text that does not fit", arrow),
     () => zlib.inflate(bad, captures),
     () => zlib.inflate(good, captures),
+    nestedForward,
+    namedRetry,
     () => {
       named(new Error("direct"), Buffer.from("both"));
     },
diff --git a/tests/harness/corpus-costs/6920-zlib-callback-error-result.ts.json b/tests/harness/corpus-costs/6920-zlib-callback-error-result.ts.json
index 1241a31c0..247292295 100644
--- a/tests/harness/corpus-costs/6920-zlib-callback-error-result.ts.json
+++ b/tests/harness/corpus-costs/6920-zlib-callback-error-result.ts.json
@@ -1 +1 @@
-{ "plain": 5517, "san": 7607 }
+{ "plain": 6386, "san": 8023 }

From 2b48451cf4dcf3669a213defda4bde701b419c7a Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 15:33:37 -0500
Subject: [PATCH 24/67] Build the native compiler with profile-guided
 optimization

---
 RELEASING.md                             |   2 +
 packages/compiler/native/cli.profdata.gz | Bin 0 -> 1452782 bytes
 scripts/build-native-cli.mts             |  38 ++++-
 scripts/refresh-cli-profile.mjs          | 205 +++++++++++++++++++++++
 4 files changed, 240 insertions(+), 5 deletions(-)
 create mode 100644 packages/compiler/native/cli.profdata.gz
 create mode 100644 scripts/refresh-cli-profile.mjs

diff --git a/RELEASING.md b/RELEASING.md
index 6cafe84a3..b6c5239ee 100644
--- a/RELEASING.md
+++ b/RELEASING.md
@@ -16,6 +16,8 @@ CI (`.github/workflows/release.yml`) compares the version in `packages/cli/packa
 
 The release job builds each pinned LLVM helper, precompiled runtime pack, and native CLI on its matching host. The native CLI bundles its TypeScript checker, LLVM helper, runtime pack, declarations, and comptime evaluator. npm postinstall installs the matching native executable; Node is needed for npm installation but not native compilation or execution. The user's toolchain performs the final platform link. Sanitized builds also use it to instrument program LLVM and compile the C runtime. Platform packages publish ahead of `@scriptc/compiler` and `scriptc`. The GitHub release attaches standalone compiler archives, their SHA-256 checksums, and the surface manifest after npm publication succeeds.
 
+Release builds of the native CLI optimize the compiler with the committed profile `packages/compiler/native/cli.profdata` on every platform. Code the profile does not describe, or describes from older compiler sources, is optimized as without a profile. Refresh the profile on a quiet Linux x64 host when compiler code has changed substantially since the last refresh: `node scripts/refresh-cli-profile.mjs --tsc-ts <tsc-ts checkout>` builds an instrumented compiler, runs it on tsc-ts, a slice of the corpus, and the runtime benchmark workloads, and writes the merged sparse profile. Commit the new profile on its own.
+
 Publishing uses npm trusted publishing (OIDC) — there is no npm token secret.
 Each published package must have a GitHub Actions trusted publisher for
 `release.yml` and the `Release` environment. A missing configuration fails
diff --git a/packages/compiler/native/cli.profdata.gz b/packages/compiler/native/cli.profdata.gz
new file mode 100644
index 0000000000000000000000000000000000000000..55523e76548ae821bbce8762876d84a3b3ccd182
GIT binary patch
literal 1452782
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%0DhH@3AOuMv9m2chG^{i!QLxG&TL@Xbf?
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
E2PZ|_F8}}l

literal 0
HcmV?d00001

diff --git a/scripts/build-native-cli.mts b/scripts/build-native-cli.mts
index c8a14adbd..e539cea1d 100644
--- a/scripts/build-native-cli.mts
+++ b/scripts/build-native-cli.mts
@@ -1,8 +1,9 @@
 /** Build the production CLI seed and its relocatable compiler assets. */
 import { execFileSync } from "node:child_process";
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { gunzipSync } from "node:zlib";
 import { compile } from "../packages/compiler/src/index.js";
 import { NATIVE_TARGETS, nativeCodegenTarget } from "../packages/compiler/src/backend/targets.js";
 import { tsgoExecutable } from "../packages/compiler/src/frontend/ts7/rpc-api.js";
@@ -11,12 +12,29 @@ import type { NativeToolchainManifest } from "../packages/compiler/src/native/to
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const output = resolve(process.argv[2] ?? join(root, ".scriptc/native-cli"));
+const optimization = process.env["SCRIPTC_NATIVE_OPTIMIZATION"] === "dev" ? "dev" : "release";
+const sanitize = process.env["SCRIPTC_SAN"] === "1";
+// SCRIPTC_NATIVE_PROFILE_GENERATE=<pattern> builds a compiler that writes a
+// raw profile per run (scripts/refresh-cli-profile.mjs). Optimized builds
+// otherwise use the committed profile, or the indexed profile that
+// SCRIPTC_NATIVE_PROFILE_USE names; an empty SCRIPTC_NATIVE_PROFILE_USE
+// builds without one.
+const profileGenerate = process.env["SCRIPTC_NATIVE_PROFILE_GENERATE"] || undefined;
+const committedProfile = join(root, "packages/compiler/native/cli.profdata.gz");
+const requestedProfile = process.env["SCRIPTC_NATIVE_PROFILE_USE"];
+const useProfile =
+  profileGenerate === undefined &&
+  optimization !== "dev" &&
+  !sanitize &&
+  requestedProfile !== "" &&
+  (requestedProfile !== undefined || existsSync(committedProfile));
 let target = nativeCodegenTarget();
 if (target === null || target.platform === "wasi")
   throw new Error("a supported native host is required to build the compiler");
 // Release executables use the runtime pack's libc baseline, even when the
-// build host has a newer libc. Sanitizer builds use the host's sanitizer SDK.
-if (target.name.endsWith("-gnu") && process.env["SCRIPTC_SAN"] !== "1") {
+// build host has a newer libc. Sanitizer builds use the host's sanitizer SDK,
+// and instrumented builds the host compiler driver's profile runtime.
+if (target.name.endsWith("-gnu") && !sanitize && profileGenerate === undefined) {
   const architecture = target.architecture === "x64" ? "x86_64" : "aarch64";
   process.env["SCRIPTC_TARGET"] = `${architecture}-linux-gnu.2.34`;
   target = nativeCodegenTarget()!;
@@ -25,6 +43,14 @@ const bin = join(output, "bin");
 const lib = join(output, "lib");
 const seed = join(dirname(output), ".scriptc", basename(output) + "-seed");
 for (const dir of [bin, lib, seed]) mkdirSync(dir, { recursive: true });
+let profileUse: string | undefined;
+if (useProfile) {
+  profileUse = requestedProfile;
+  if (profileUse === undefined) {
+    profileUse = join(seed, "cli.profdata");
+    writeFileSync(profileUse, gunzipSync(readFileSync(committedProfile)));
+  }
+}
 const compiler = process.env["SCRIPTC_CC"] ?? target.defaultLinker;
 const compilerArgs = process.env["SCRIPTC_CC"] === undefined ? [...target.defaultLinkerArgs] : [];
 // Zig's C debug mode otherwise inserts UBSan calls into these objects. They
@@ -84,10 +110,12 @@ const result = await compile(join(root, "packages/compiler/src/native/cli.ts"),
   outDir: seed,
   outPath: executable,
   backend: "llvm",
-  optimization: process.env["SCRIPTC_NATIVE_OPTIMIZATION"] === "dev" ? "dev" : "release",
+  optimization,
   strip: process.env["SCRIPTC_NATIVE_KEEP_SYMBOLS"] !== "1",
   ffiProfilePath: ffi,
-  sanitize: process.env["SCRIPTC_SAN"] === "1",
+  sanitize,
+  ...(profileGenerate === undefined ? {} : { profileGenerate }),
+  ...(profileUse === undefined ? {} : { profileUse }),
   emitIr: process.env["SCRIPTC_NATIVE_EMIT_IR"] === "1",
 });
 if (!result.ok)
diff --git a/scripts/refresh-cli-profile.mjs b/scripts/refresh-cli-profile.mjs
new file mode 100644
index 000000000..e9554e911
--- /dev/null
+++ b/scripts/refresh-cli-profile.mjs
@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+/* Refreshes packages/compiler/native/cli.profdata.gz, the profile that release
+ * builds of the native compiler optimize with (scripts/build-native-cli.mts).
+ *
+ * Builds an instrumented native compiler for this Linux host, runs it on the
+ * training builds below, and merges the raw profiles it writes into one
+ * sparse indexed profile. The training builds are tsc-ts (a cold `speed`
+ * build, then a rebuild after an edit), every seventh corpus program at the
+ * default optimization and a further slice in `dev`, and the runtime
+ * benchmark workloads. Run it on a quiet Linux x64 host after changes that
+ * move much compiler code; a stale profile only loses part of its gain. A
+ * refresh takes about 11 minutes on 16 cores.
+ *
+ *   node scripts/refresh-cli-profile.mjs --tsc-ts <tsc-ts checkout> [--jobs 8]
+ */
+import { spawn, spawnSync } from "node:child_process";
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { cpus, tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+import { constants, gzipSync } from "node:zlib";
+
+const root = fileURLToPath(new URL("..", import.meta.url));
+const { values } = parseArgs({
+  options: {
+    "tsc-ts": { type: "string" },
+    jobs: { type: "string", default: String(Math.max(1, Math.floor(cpus().length / 2))) },
+    output: { type: "string", default: join(root, "packages/compiler/native/cli.profdata.gz") },
+    work: { type: "string" },
+    instrumented: { type: "string" },
+    help: { type: "boolean", default: false },
+  },
+});
+if (values.help || values["tsc-ts"] === undefined) {
+  console.log(
+    "Usage: node scripts/refresh-cli-profile.mjs --tsc-ts <tsc-ts checkout> [--jobs N] [--output <profdata.gz>] [--work <dir>] [--instrumented <compiler dir>]",
+  );
+  process.exit(values.help ? 0 : 2);
+}
+if (process.platform !== "linux" || process.arch !== "x64")
+  throw new Error("the compiler profile is collected on Linux x64");
+const tscTs = resolve(values["tsc-ts"]);
+const tscTsPackage = join(tscTs, "packages/tsc-ts");
+if (!existsSync(join(tscTsPackage, "src/main.ts")))
+  throw new Error(`${tscTs} is not a tsc-ts checkout with installed dependencies`);
+const jobs = Number(values.jobs);
+const work = resolve(values.work ?? mkdtempSync(join(tmpdir(), "scriptc-cli-profile-")));
+const raw = join(work, "raw");
+const builds = join(work, "builds");
+rmSync(raw, { recursive: true, force: true });
+for (const dir of [raw, builds]) mkdirSync(dir, { recursive: true });
+const log = join(work, "training.log");
+
+// Every run merges its counters into one of four pooled raw profiles.
+const profileFile = join(raw, "cli-%4m.profraw");
+// --instrumented reuses a compiler an earlier run built in <work>/cli.
+const cli = resolve(values.instrumented ?? join(work, "cli"));
+if (values.instrumented === undefined) {
+  console.log(`building the instrumented compiler in ${cli}`);
+  const built = spawnSync(
+    process.execPath,
+    [
+      "--max-old-space-size=8192",
+      "--import",
+      "tsx",
+      join(root, "scripts/build-native-cli.mts"),
+      cli,
+    ],
+    {
+      cwd: root,
+      stdio: "inherit",
+      env: { ...process.env, SCRIPTC_NATIVE_PROFILE_GENERATE: profileFile },
+    },
+  );
+  if (built.status !== 0) throw new Error("the instrumented compiler did not build");
+}
+const scriptc = join(cli, "bin/scriptc");
+// The compiler trains with the helper it bundles, so a helper override in
+// the environment does not apply.
+const trainingEnv = { ...process.env, LLVM_PROFILE_FILE: profileFile };
+delete trainingEnv["SCRIPTC_LLVM_HELPER"];
+
+/** Runs the instrumented compiler; a failing build still profiles the
+ * paths it took. */
+function run(args, options) {
+  return new Promise((done) => {
+    const child = spawn(scriptc, args, {
+      cwd: options.cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...trainingEnv, SCRIPTC_CACHE_DIR: options.cache },
+    });
+    let output = "";
+    child.stdout.on("data", (chunk) => (output += chunk));
+    child.stderr.on("data", (chunk) => (output += chunk));
+    child.on("close", (code) => {
+      appendFileSync(log, `$ scriptc ${args.join(" ")}\n${output}exit ${code}\n`);
+      done(code === 0);
+    });
+  });
+}
+
+async function pool(tasks) {
+  let next = 0;
+  let passed = 0;
+  await Promise.all(
+    Array.from({ length: jobs }, async () => {
+      while (next < tasks.length) if (await tasks[next++]()) passed++;
+    }),
+  );
+  return passed;
+}
+
+const programNumber = (name) => Number.parseInt(name, 10);
+const corpus = readdirSync(join(root, "tests/corpus"))
+  .filter((name) => /^\d+-.*\.ts$/.test(name))
+  .sort((a, b) => programNumber(a) - programNumber(b));
+const training = [
+  ...corpus
+    .filter((name) => programNumber(name) % 7 === 0)
+    .map((name) => ({ file: join(root, "tests/corpus", name), optimization: "release" })),
+  ...corpus
+    .filter((name) => programNumber(name) % 14 === 7)
+    .map((name) => ({ file: join(root, "tests/corpus", name), optimization: "dev" })),
+  ...readdirSync(join(root, "benchmarks/runtime/workloads"))
+    .filter((name) => name.endsWith(".ts"))
+    .map((name) => ({
+      file: join(root, "benchmarks/runtime/workloads", name),
+      optimization: "release",
+    })),
+];
+
+const started = Date.now();
+console.log("training: tsc-ts, cold and after an edit");
+const tscCache = join(work, "cache-tsc-ts");
+const tscArgs = [
+  "build",
+  "src/main.ts",
+  "--optimization=speed",
+  "--detached-exit",
+  "-o",
+  join(builds, "tsc"),
+];
+await run(tscArgs, { cwd: tscTsPackage, cache: tscCache });
+const edited = join(tscTsPackage, "src/main.ts");
+const source = readFileSync(edited, "utf8");
+try {
+  writeFileSync(edited, source + "\n// profile training edit\n");
+  await run(tscArgs, { cwd: tscTsPackage, cache: tscCache });
+} finally {
+  writeFileSync(edited, source);
+}
+
+console.log(`training: ${training.length} programs, ${jobs} at a time`);
+const passed = await pool(
+  training.map((program, index) => () => {
+    const cache = join(work, `cache-${index}`);
+    return run(
+      [
+        "build",
+        program.file,
+        `--optimization=${program.optimization}`,
+        "-o",
+        join(builds, `program-${index}`),
+      ],
+      { cwd: root, cache },
+    ).then((ok) => {
+      rmSync(cache, { recursive: true, force: true });
+      rmSync(join(builds, `program-${index}`), { force: true });
+      return ok;
+    });
+  }),
+);
+console.log(
+  `trained in ${Math.round((Date.now() - started) / 1000)} s; ${passed} of ${training.length} programs built (failures still profile; see ${log})`,
+);
+
+const profiles = readdirSync(raw)
+  .filter((name) => name.endsWith(".profraw"))
+  .map((name) => join(raw, name));
+rmSync(builds, { recursive: true, force: true });
+const indexed = join(work, "cli.profdata");
+const merged = spawnSync(scriptc, ["merge-profiles", "--sparse", "-o", indexed, ...profiles], {
+  stdio: "inherit",
+  env: { ...trainingEnv, LLVM_PROFILE_FILE: join(work, "merge.profraw") },
+});
+if (merged.status !== 0) throw new Error("merge-profiles failed");
+// The indexed profile compresses to about an eighth of its size.
+const output = resolve(values.output);
+writeFileSync(output, gzipSync(readFileSync(indexed), { level: constants.Z_BEST_COMPRESSION }));
+console.log(
+  `wrote ${output} (${statSync(output).size} bytes; ${statSync(indexed).size} uncompressed)`,
+);
+// A work directory the caller named stays for inspection.
+if (values.work === undefined) rmSync(work, { recursive: true, force: true });

From 692569a8040dfc357dc769c6587388c2e78444f9 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 15:50:32 -0500
Subject: [PATCH 25/67] Collect the compiler's heap as lowering and LLVM
 emission grow it

---
 packages/cli/src/main.ts                      |  4 ++
 .../compiler/src/backend/llvm/emit-module.ts  |  2 +
 packages/compiler/src/backend/llvm/emitter.ts |  3 +
 packages/compiler/src/frontend-process.ts     |  7 +-
 .../compiler/src/frontend/lowering/lowerer.ts |  4 ++
 packages/compiler/src/heap-collection.test.ts | 64 +++++++++++++++++++
 packages/compiler/src/heap-collection.ts      | 49 ++++++++++++++
 packages/compiler/src/heap-pressure.ts        | 13 ++++
 packages/compiler/src/index.ts                |  1 +
 9 files changed, 145 insertions(+), 2 deletions(-)
 create mode 100644 packages/compiler/src/heap-collection.test.ts
 create mode 100644 packages/compiler/src/heap-collection.ts
 create mode 100644 packages/compiler/src/heap-pressure.ts

diff --git a/packages/cli/src/main.ts b/packages/cli/src/main.ts
index 99d0f78e3..8203b959e 100644
--- a/packages/cli/src/main.ts
+++ b/packages/cli/src/main.ts
@@ -4,6 +4,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import {
   analyzeCached,
+  collectGarbageUnderHeapPressure,
   compile,
   compileLibrary,
   mergeProfiles,
@@ -26,6 +27,9 @@ function version(): string {
   return manifest.version ?? "unknown";
 }
 
+// The compiler process collects its heap as lowering and LLVM emission grow it.
+collectGarbageUnderHeapPressure();
+
 process.exitCode = await runCli(process.argv.slice(2), {
   version,
   analyze: analyzeCached,
diff --git a/packages/compiler/src/backend/llvm/emit-module.ts b/packages/compiler/src/backend/llvm/emit-module.ts
index 17b27fe8d..5ccf7ccd8 100644
--- a/packages/compiler/src/backend/llvm/emit-module.ts
+++ b/packages/compiler/src/backend/llvm/emit-module.ts
@@ -1,4 +1,5 @@
 /* LlEmitter's module-level output: module parts, helper definitions, library declarations and FFI callback definitions. */
+import { relieveHeapPressure } from "../../heap-pressure.js";
 import { emitWasmModules } from "./wasm-modules.js";
 import { type LlEmitter, ffiCallbackDummyLl, llStrBytes } from "./emitter.js";
 import { JS_IC_WORDS } from "./js-ic.js";
@@ -66,6 +67,7 @@ export function emitModuleParts(emitter: LlEmitter): string[] {
     const def = emitter.emitFunction(fn);
     fnDefs.push(def);
     emitter.fnDefText.set(fn.name, def);
+    relieveHeapPressure();
   }
   emitter.selectStacklessAsync(fnDefs);
   const errorViews: string[] = [];
diff --git a/packages/compiler/src/backend/llvm/emitter.ts b/packages/compiler/src/backend/llvm/emitter.ts
index 05e297304..1dcd1f6c8 100644
--- a/packages/compiler/src/backend/llvm/emitter.ts
+++ b/packages/compiler/src/backend/llvm/emitter.ts
@@ -1,3 +1,4 @@
+import { relieveHeapPressure } from "../../heap-pressure.js";
 import { wasmBoundsChecks } from "./wasm-modules.js";
 import { jsTruthy } from "./jsval.js";
 import { JsIcSites } from "../../ir/js-ic.js";
@@ -458,6 +459,8 @@ export function emitLlvmModuleSource(
   input: IrModule,
   options: LlvmTargetOptions = {},
 ): string | readonly string[] {
+  // IR validation, contracts and the frontend's disposal run after lowering without checks.
+  relieveHeapPressure(true);
   const mod = unshareNodes(input);
   const parts = new LlEmitter(
     options.debugSources === undefined
diff --git a/packages/compiler/src/frontend-process.ts b/packages/compiler/src/frontend-process.ts
index a3d59516f..dc2388038 100644
--- a/packages/compiler/src/frontend-process.ts
+++ b/packages/compiler/src/frontend-process.ts
@@ -8,11 +8,14 @@ try {
 } catch {
   // Bytecode caching only speeds up loading.
 }
-const { runFrontendProcess } = await import("./index.js");
+const { collectGarbageUnderHeapPressure, runFrontendProcess } = await import("./index.js");
 let input = "";
 for await (const chunk of process.stdin) input += String(chunk);
 const [requestPath, resultPath] = input.split("\n");
-if (requestPath !== undefined && requestPath !== "" && resultPath !== undefined)
+if (requestPath !== undefined && requestPath !== "" && resultPath !== undefined) {
+  // As in the CLI process, lowering and LLVM emission collect the heap as they grow it.
+  collectGarbageUnderHeapPressure();
   await runFrontendProcess(requestPath, resultPath);
+}
 // The frontend's own helpers (the checker process, timers) must not keep this process alive.
 process.exit(0);
diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts
index a6278a2a3..c4d24cef1 100644
--- a/packages/compiler/src/frontend/lowering/lowerer.ts
+++ b/packages/compiler/src/frontend/lowering/lowerer.ts
@@ -1,3 +1,4 @@
+import { relieveHeapPressure } from "../../heap-pressure.js";
 import { onlyForwarded } from "./typed-arguments.js";
 import {
   needsGeneralNodeStreams,
@@ -7789,6 +7790,7 @@ export class Lowerer {
                 this.shapes.withDeclaredOrderPriority(ref, () => this.lowerClassMembers(info)),
               ),
             );
+            relieveHeapPressure();
           }
         }
         while (instLowered < this.instantiationQueue.length) {
@@ -7816,6 +7818,7 @@ export class Lowerer {
                   ),
                 ),
               );
+              relieveHeapPressure();
             } catch (e) {
               if (!(e instanceof PoisonError)) throw e;
             }
@@ -7892,6 +7895,7 @@ export class Lowerer {
               this.shapes.withDeclaredOrderPriority(priority, unit.lower),
             );
             if (fn) loweredUnits.set(name, fn);
+            relieveHeapPressure();
           } catch (e) {
             if (!(e instanceof PoisonError)) throw e;
           }
diff --git a/packages/compiler/src/heap-collection.test.ts b/packages/compiler/src/heap-collection.test.ts
new file mode 100644
index 000000000..39baaf147
--- /dev/null
+++ b/packages/compiler/src/heap-collection.test.ts
@@ -0,0 +1,64 @@
+import { expect, test } from "vitest";
+import { heapPressureCheck } from "./heap-collection.js";
+
+const MB = 1024 * 1024;
+
+/** A heap whose used size the test sets; a collection leaves `live` bytes. */
+function fakeHeap(initial: number) {
+  const heap = { used: initial, live: initial, collections: 0, reads: 0 };
+  const check = heapPressureCheck(
+    () => {
+      heap.reads++;
+      return heap.used;
+    },
+    () => {
+      heap.collections++;
+      heap.used = heap.live;
+    },
+  );
+  return { heap, check };
+}
+
+test("the check reads the heap every 64th call and at phase ends", () => {
+  const { heap, check } = fakeHeap(100 * MB);
+  heap.reads = 0;
+  for (let i = 0; i < 63; i++) check(false);
+  expect(heap.reads).toBe(0);
+  check(false);
+  expect(heap.reads).toBe(1);
+  check(true);
+  expect(heap.reads).toBe(2);
+});
+
+test("the check collects once the heap doubles and grows by 512 MB", () => {
+  const { heap, check } = fakeHeap(100 * MB);
+  // Five times the size, but only 400 MB more: no collection.
+  heap.used = 500 * MB;
+  check(true);
+  expect(heap.collections).toBe(0);
+  heap.used = 612 * MB;
+  check(true);
+  expect(heap.collections).toBe(1);
+  // The size after the collection is the new baseline: 400 MB live needs 912 MB.
+  heap.live = 400 * MB;
+  heap.used = 1000 * MB;
+  check(true);
+  expect(heap.collections).toBe(2);
+  heap.used = 900 * MB;
+  check(true);
+  expect(heap.collections).toBe(2);
+  heap.used = 912 * MB;
+  check(true);
+  expect(heap.collections).toBe(3);
+  // From 1 GB live, doubling is the larger bound.
+  heap.live = 1024 * MB;
+  heap.used = 2000 * MB;
+  check(true);
+  expect(heap.collections).toBe(4);
+  heap.used = 2047 * MB;
+  check(true);
+  expect(heap.collections).toBe(4);
+  heap.used = 2048 * MB;
+  check(true);
+  expect(heap.collections).toBe(5);
+});
diff --git a/packages/compiler/src/heap-collection.ts b/packages/compiler/src/heap-collection.ts
new file mode 100644
index 000000000..f7ef34e4e
--- /dev/null
+++ b/packages/compiler/src/heap-collection.ts
@@ -0,0 +1,49 @@
+import { getHeapStatistics, setFlagsFromString } from "node:v8";
+import { runInNewContext } from "node:vm";
+import { setHeapPressureCheck } from "./heap-pressure.js";
+
+/** Calls of the check between two reads of the heap size, outside phase ends. */
+const SAMPLE_INTERVAL = 64;
+/** The heap grows by at least this much before a collection. */
+const MIN_GROWTH_BYTES = 512 * 1024 * 1024;
+
+/**
+ * The check `collectGarbageUnderHeapPressure` installs: every 64th call, and at every phase end,
+ * reads the used heap size and runs `collect` once it is at least twice the size after the
+ * previous collection and 512 MB above it.
+ */
+export function heapPressureCheck(
+  usedHeap: () => number,
+  collect: () => void,
+): (phase: boolean) => void {
+  let live = usedHeap();
+  let calls = 0;
+  return (phase) => {
+    if (!phase && ++calls % SAMPLE_INTERVAL !== 0) return;
+    const used = usedHeap();
+    if (used < Math.max(2 * live, live + MIN_GROWTH_BYTES)) return;
+    collect();
+    live = usedHeap();
+  };
+}
+
+/**
+ * Runs a full garbage collection from the compiler's allocation-heavy loops
+ * (`relieveHeapPressure`) as `heapPressureCheck` decides. Without it, V8 lets the heap of a long
+ * lowering or LLVM emission grow to several times its live size between full collections, and
+ * Node keeps those pages for the life of the process.
+ *
+ * This sets --expose-gc for the process, so only the compiler's own processes call it (the CLI and
+ * the frontend process, frontend-process.ts), not `compile()` callers.
+ */
+export function collectGarbageUnderHeapPressure(): void {
+  setFlagsFromString("--expose-gc");
+  const gc: unknown = runInNewContext("gc");
+  if (typeof gc !== "function") return;
+  setHeapPressureCheck(
+    heapPressureCheck(
+      () => getHeapStatistics().used_heap_size,
+      () => (gc as () => void)(),
+    ),
+  );
+}
diff --git a/packages/compiler/src/heap-pressure.ts b/packages/compiler/src/heap-pressure.ts
new file mode 100644
index 000000000..fa8b35b43
--- /dev/null
+++ b/packages/compiler/src/heap-pressure.ts
@@ -0,0 +1,13 @@
+/** Allocation-heavy loops (lowering reached bodies and generic instances, emitting LLVM
+ * functions) call `relieveHeapPressure` between units of work. It does nothing unless the process
+ * installed a check with `setHeapPressureCheck` (collectGarbageUnderHeapPressure in
+ * heap-collection.ts). `phase` is true where a phase that allocates without these calls ends. */
+let check: (phase: boolean) => void = () => {};
+
+export function relieveHeapPressure(phase = false): void {
+  check(phase);
+}
+
+export function setHeapPressureCheck(next: (phase: boolean) => void): void {
+  check = next;
+}
diff --git a/packages/compiler/src/index.ts b/packages/compiler/src/index.ts
index 8b0ea6825..a1f8601cc 100644
--- a/packages/compiler/src/index.ts
+++ b/packages/compiler/src/index.ts
@@ -180,6 +180,7 @@ export {
 } from "./backend/external-c.js";
 export { warmNativeCaches } from "./backend/warm-cache.js";
 export { mergeNativeProfiles as mergeProfiles } from "./backend/native-codegen.js";
+export { collectGarbageUnderHeapPressure } from "./heap-collection.js";
 export {
   ANDROID_MIN_API,
   IPHONEOS_MIN_VERSION,

From 47671d5bedcd89897fc73ecf92fddda9dce86ee9 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 15:54:23 -0500
Subject: [PATCH 26/67] Give the fs corpus programs per-process scratch
 directories

5568-fs-cp-errors built its fixture in a /tmp directory named after the
program file, which it deletes and recreates. The Node oracle and the
native runs of one program run at the same time, so two runs with the
same name deleted each other's files and the program exited 1 on
random shards. Its root, and that of the five other corpus programs
that name a /tmp/scr-* directory after the program file alone, now
ends in the process id, as 5571-fs-cp-deep's does.
---
 tests/corpus/1541-fs-readdir-dirent.ts  | 2 +-
 tests/corpus/5565-fs-dirent-untyped.mjs | 2 +-
 tests/corpus/5567-fs-cpsync.ts          | 2 +-
 tests/corpus/5568-fs-cp-errors.js       | 2 +-
 tests/corpus/5569-fs-cp-symlinks.ts     | 2 +-
 tests/corpus/5570-fs-cp-async.ts        | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/tests/corpus/1541-fs-readdir-dirent.ts b/tests/corpus/1541-fs-readdir-dirent.ts
index ac30ab615..8db6243b2 100644
--- a/tests/corpus/1541-fs-readdir-dirent.ts
+++ b/tests/corpus/1541-fs-readdir-dirent.ts
@@ -15,7 +15,7 @@ function tail(path: string): string {
   }
   return path.slice(i + 1);
 }
-const dir = `/tmp/scr-dirent-${tail(process.argv[1] === undefined ? "x" : process.argv[1])}`;
+const dir = `/tmp/scr-dirent-${tail(process.argv[1] === undefined ? "x" : process.argv[1])}-${process.pid}`;
 if (fs.existsSync(dir)) fs.rmSync(dir, { recursive: true, force: true });
 fs.mkdirSync(dir);
 fs.mkdirSync(`${dir}/sub-a`);
diff --git a/tests/corpus/5565-fs-dirent-untyped.mjs b/tests/corpus/5565-fs-dirent-untyped.mjs
index acb5be704..9751c3d1f 100644
--- a/tests/corpus/5565-fs-dirent-untyped.mjs
+++ b/tests/corpus/5565-fs-dirent-untyped.mjs
@@ -9,7 +9,7 @@ function tail(path) {
   while (i >= 0 && path.charAt(i) !== "/" && path.charAt(i) !== "\\") i = i - 1;
   return path.slice(i + 1);
 }
-const dir = `/tmp/scr-dirent-untyped-${tail(process.argv[1] === undefined ? "x" : process.argv[1])}`;
+const dir = `/tmp/scr-dirent-untyped-${tail(process.argv[1] === undefined ? "x" : process.argv[1])}-${process.pid}`;
 if (fs.existsSync(dir)) fs.rmSync(dir, { recursive: true, force: true });
 fs.mkdirSync(`${dir}/sub`, { recursive: true });
 fs.writeFileSync(`${dir}/a.txt`, "x");
diff --git a/tests/corpus/5567-fs-cpsync.ts b/tests/corpus/5567-fs-cpsync.ts
index 7e258ca85..ef736ec92 100644
--- a/tests/corpus/5567-fs-cpsync.ts
+++ b/tests/corpus/5567-fs-cpsync.ts
@@ -8,7 +8,7 @@ function tail(path: string): string {
   while (i >= 0 && path.charAt(i) !== "/" && path.charAt(i) !== "\\") i = i - 1;
   return path.slice(i + 1);
 }
-const root = `/tmp/scr-cpsync-${tail(process.argv[1] === undefined ? "x" : process.argv[1])}`;
+const root = `/tmp/scr-cpsync-${tail(process.argv[1] === undefined ? "x" : process.argv[1])}-${process.pid}`;
 if (fs.existsSync(root)) fs.rmSync(root, { recursive: true, force: true });
 fs.mkdirSync(root);
 const home = process.cwd();
diff --git a/tests/corpus/5568-fs-cp-errors.js b/tests/corpus/5568-fs-cp-errors.js
index e9a87f14e..9089d612c 100644
--- a/tests/corpus/5568-fs-cp-errors.js
+++ b/tests/corpus/5568-fs-cp-errors.js
@@ -11,7 +11,7 @@ function tail(path) {
   while (i >= 0 && path.charAt(i) !== "/" && path.charAt(i) !== "\\") i = i - 1;
   return path.slice(i + 1);
 }
-const root = `/tmp/scr-cp-errors-${tail(process.argv[1] === undefined ? "x" : process.argv[1])}`;
+const root = `/tmp/scr-cp-errors-${tail(process.argv[1] === undefined ? "x" : process.argv[1])}-${process.pid}`;
 if (fs.existsSync(root)) fs.rmSync(root, { recursive: true, force: true });
 fs.mkdirSync(root);
 const home = process.cwd();
diff --git a/tests/corpus/5569-fs-cp-symlinks.ts b/tests/corpus/5569-fs-cp-symlinks.ts
index ae4621ce6..2bc3c8ba4 100644
--- a/tests/corpus/5569-fs-cp-symlinks.ts
+++ b/tests/corpus/5569-fs-cp-symlinks.ts
@@ -9,7 +9,7 @@ function tail(path: string): string {
   while (i >= 0 && path.charAt(i) !== "/" && path.charAt(i) !== "\\") i = i - 1;
   return path.slice(i + 1);
 }
-const root = `/tmp/scr-cp-links-${tail(process.argv[1] === undefined ? "x" : process.argv[1])}`;
+const root = `/tmp/scr-cp-links-${tail(process.argv[1] === undefined ? "x" : process.argv[1])}-${process.pid}`;
 if (fs.existsSync(root)) fs.rmSync(root, { recursive: true, force: true });
 fs.mkdirSync(root);
 const home = process.cwd();
diff --git a/tests/corpus/5570-fs-cp-async.ts b/tests/corpus/5570-fs-cp-async.ts
index 9f3ce6c87..d83750095 100644
--- a/tests/corpus/5570-fs-cp-async.ts
+++ b/tests/corpus/5570-fs-cp-async.ts
@@ -9,7 +9,7 @@ function tail(path: string): string {
   while (i >= 0 && path.charAt(i) !== "/" && path.charAt(i) !== "\\") i = i - 1;
   return path.slice(i + 1);
 }
-const root = `/tmp/scr-cp-async-${tail(process.argv[1] === undefined ? "x" : process.argv[1])}`;
+const root = `/tmp/scr-cp-async-${tail(process.argv[1] === undefined ? "x" : process.argv[1])}-${process.pid}`;
 if (fs.existsSync(root)) fs.rmSync(root, { recursive: true, force: true });
 fs.mkdirSync(root);
 const home = process.cwd();

From ea4d570e597f9a317eb9146901c8d681f3fe291d Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 16:12:52 -0500
Subject: [PATCH 27/67] Speed up split, indexOf, slice and Number() on ASCII
 fields

Number() of a string with an optional sign and 1 to 15 digits returns
the integer directly; every other string keeps the full StringToNumber
grammar, out of line.

split() with a separator collects its first batch of pieces before
creating the result, so the result is an inline array of exactly that
size, filled in place. A split's default limit skips the uint32
conversion, and pieces of a proven-ASCII string are created ASCII,
including the scratch pieces of split loops.

indexOf() from the start of a proven-ASCII string searches bytes
directly, and slice() of one skips the UTF-16 index map. The one-byte
case of the byte search reaches memchr without a stack frame.
---
 packages/runtime/src/scr_string.c             | 107 +++++++++++++++---
 tests/corpus/6950-string-field-fast-paths.ts  |  48 ++++++++
 .../6950-string-field-fast-paths.ts.json      |   1 +
 3 files changed, 138 insertions(+), 18 deletions(-)
 create mode 100644 tests/corpus/6950-string-field-fast-paths.ts
 create mode 100644 tests/harness/corpus-costs/6950-string-field-fast-paths.ts.json

diff --git a/packages/runtime/src/scr_string.c b/packages/runtime/src/scr_string.c
index 41588f25a..9b21dd722 100644
--- a/packages/runtime/src/scr_string.c
+++ b/packages/runtime/src/scr_string.c
@@ -1769,14 +1769,9 @@ static inline double scr_to_integer_or_infinity(double x) {
   return isnan(x) ? 0.0 : x;
 }
 
-/* Byte substring search (needle and hay are both canonical WTF-8,
- * so any byte-level match starts on a char boundary — UTF-8 is
- * self-synchronizing). Empty needle matches at hay. */
-static const char *scr_byte_find(const char *hay, size_t hay_len,
-                                  const char *nee, size_t nee_len) {
-  if (nee_len == 0) return hay;
-  if (nee_len > hay_len) return NULL;
-  if (nee_len == 1) return memchr(hay, (unsigned char)nee[0], hay_len);
+/* scr_byte_find for a needle of at least two bytes, no longer than hay. */
+static __attribute__((noinline)) const char *scr_byte_find_long(const char *hay, size_t hay_len,
+                                                                const char *nee, size_t nee_len) {
   const unsigned char first = (unsigned char)nee[0];
   const unsigned char second = (unsigned char)nee[1];
   /* The last possible match start. */
@@ -1826,6 +1821,18 @@ static const char *scr_byte_find(const char *hay, size_t hay_len,
   return NULL;
 }
 
+/* Byte substring search (needle and hay are both canonical WTF-8,
+ * so any byte-level match starts on a char boundary — UTF-8 is
+ * self-synchronizing). Empty needle matches at hay. The one-byte case,
+ * every split on a separator character, goes to memchr without a frame. */
+static inline const char *scr_byte_find(const char *hay, size_t hay_len,
+                                        const char *nee, size_t nee_len) {
+  if (nee_len == 0) return hay;
+  if (nee_len > hay_len) return NULL;
+  if (nee_len == 1) return memchr(hay, (unsigned char)nee[0], hay_len);
+  return scr_byte_find_long(hay, hay_len, nee, nee_len);
+}
+
 /* ── searches for a needle that can match half of a surrogate pair ─────
  * Canonical storage makes byte matches exact for every needle except one
  * that starts with a lone low surrogate or ends with a lone high one: JS
@@ -2020,6 +2027,13 @@ double scr_str_char_code_at(ScrStr *s, double i) {
 }
 
 double scr_str_index_of(ScrStr *s, ScrStr *needle, double fromIndex) {
+  /* A search from the start of a proven-ASCII receiver: byte offsets are
+   * UTF-16 indexes, and a needle with other bytes is never found. A start
+   * index that is not positive (NaN, -0 or negative) clamps to 0. */
+  if (s->ascii && !(fromIndex > 0)) {
+    const char *found = scr_byte_find(s->data, s->len, needle->data, needle->len);
+    return found ? (double)(found - s->data) : -1.0;
+  }
   double pos = scr_to_integer_or_infinity(fromIndex);
   if (needle->len > s->len) return -1.0;
   ScrSidx *e = scr_sidx_for(s);
@@ -2142,6 +2156,12 @@ static size_t scr_slice_boundary(double v, size_t len16) {
 }
 
 ScrStr *scr_str_slice(ScrStr *s, double start, double end) {
+  /* A proven-ASCII receiver needs no index map (scr_str_slice_units). */
+  if (s->ascii) {
+    size_t from = scr_slice_boundary(scr_to_integer_or_infinity(start), s->len);
+    size_t to = scr_slice_boundary(scr_to_integer_or_infinity(end), s->len);
+    return scr_str_slice_units(s, NULL, from, to);
+  }
   ScrSidx *e = scr_sidx_for(s);
   size_t len16 = scr_sidx_len(s, e);
   size_t from = scr_slice_boundary(scr_to_integer_or_infinity(start), len16);
@@ -2407,8 +2427,10 @@ void scr_str_split_cursor_init(ScrSplitCursor *cursor, uint32_t limit) {
   cursor->pending_unit = 0;
 }
 
-static ScrStr *scr_str_split_piece(const char *bytes, size_t len, ScrStr **scratch) {
-  if (!scratch || len <= 4) return scr_str_from_span(bytes, len);
+/* `ascii`: the bytes are a span of a proven-ASCII string. */
+static ScrStr *scr_str_split_piece(const char *bytes, size_t len, ScrStr **scratch, bool ascii) {
+  if (!scratch || len <= 4) return ascii ? scr_str_from_span_ascii(bytes, len)
+                                         : scr_str_from_span(bytes, len);
   ScrStr *piece = *scratch;
   if (piece && piece->rc == 1 && piece->cap >= len) {
     /* The scratch owner is the only remaining reference. Invalidate all
@@ -2419,10 +2441,12 @@ static ScrStr *scr_str_split_piece(const char *bytes, size_t len, ScrStr **scrat
     memcpy(piece->data, bytes, len);
     piece->len = len;
     piece->data[len] = '\0';
+    piece->ascii = ascii;
   } else {
     ScrStr *fresh = scr_str_alloc_raw(len, len < 64 ? 64 : len);
     memcpy(fresh->data, bytes, len);
     fresh->data[len] = '\0';
+    fresh->ascii = ascii;
     *scratch = fresh;
     scr_str_release(piece);
     piece = fresh;
@@ -2480,7 +2504,7 @@ const char *scr_str_split_cursor_span(ScrStr *s, ScrStr *sep, ScrSplitCursor *cu
 }
 
 ScrStr *scr_str_split_materialize(const char *bytes, size_t length, ScrStr **scratch) {
-  return scr_str_split_piece(bytes, length, scratch);
+  return scr_str_split_piece(bytes, length, scratch, false);
 }
 
 ScrStr *scr_str_split_cursor_next(ScrStr *s, ScrStr *sep, ScrSplitCursor *cursor,
@@ -2488,7 +2512,7 @@ ScrStr *scr_str_split_cursor_next(ScrStr *s, ScrStr *sep, ScrSplitCursor *cursor
   size_t len;
   const char *bytes = scr_str_split_span(s, sep, cursor, sep->len == 0, &len);
   if (!bytes) return NULL;
-  return scr_str_split_piece(bytes, len, scratch);
+  return scr_str_split_piece(bytes, len, scratch, s->ascii);
 }
 
 /* Move a bounded batch of pieces into array storage in one operation.
@@ -2513,7 +2537,8 @@ static void scr_str_split_fill(ScrArr *out, ScrStr *s, ScrStr *sep,
     size_t count = 0, len;
     const char *bytes;
     while (count < 64 && (bytes = scr_str_split_span(s, sep, cursor, units, &len))) {
-      ScrStr *piece = scr_str_from_span(bytes, len);
+      ScrStr *piece =
+          s->ascii ? scr_str_from_span_ascii(bytes, len) : scr_str_from_span(bytes, len);
       slots[count++] = (uint64_t)(uintptr_t)piece;
     }
     if (count) scr_arr_push_many(out, count, slots);
@@ -2522,18 +2547,43 @@ static void scr_str_split_fill(ScrArr *out, ScrStr *s, ScrStr *sep,
 }
 
 ScrArr *scr_str_split_limit(ScrStr *s, ScrStr *sep, double limit_num) {
-  uint32_t limit = scr_to_uint32(limit_num);
+  /* split(sep) passes the default limit, 2^32 - 1. */
+  uint32_t limit = limit_num == 4294967295.0 ? UINT32_MAX : scr_to_uint32(limit_num);
   /* An empty separator yields one piece per UTF-16 unit: size it once. */
   size_t pieces = 0;
   if (sep->len == 0) {
     pieces = s->ascii ? s->len : scr_sidx_len(s, scr_sidx(s));
     if (pieces > limit) pieces = limit;
   }
-  ScrArr *out = scr_arr_new(SCR_ELEM_STR, pieces);
   ScrSplitCursor cursor;
   scr_str_split_cursor_init(&cursor, limit);
-  if (sep->len == 0) scr_str_split_fill(out, s, sep, &cursor, true);
-  else scr_str_split_fill(out, s, sep, &cursor, false);
+  if (sep->len == 0) {
+    ScrArr *out = scr_arr_new(SCR_ELEM_STR, pieces);
+    scr_str_split_fill(out, s, sep, &cursor, true);
+    return out;
+  }
+  /* Most splits fit one batch: its count sizes the result, whose slots then
+   * share the header's block (scr_arr_new_inline). A longer split appends
+   * the rest batch by batch. */
+  uint64_t slots[64];
+  size_t count = 0, len;
+  const char *bytes;
+  while (count < 64 && (bytes = scr_str_split_span(s, sep, &cursor, false, &len)))
+    slots[count++] = (uint64_t)(uintptr_t)(s->ascii ? scr_str_from_span_ascii(bytes, len)
+                                                    : scr_str_from_span(bytes, len));
+  ScrArr *out = scr_arr_new_inline(SCR_ELEM_STR, count);
+  if (count) {
+    /* A fresh inline array of exactly `count` slots: store the pieces and
+     * their states directly. */
+    uint8_t *states = scr_arr_states_end(out);
+    for (size_t k = 0; k < count; k++) {
+      out->data[k] = slots[k];
+      *scr_arr_state_in(states, k) = SCR_ARR_VALUE;
+    }
+    out->len = (uint32_t)count;
+    out->filled = (uint32_t)count;
+  }
+  if (count == 64) scr_str_split_fill(out, s, sep, &cursor, false);
   return out;
 }
 
@@ -3104,7 +3154,7 @@ double scr_string_to_number(ScrStr *s) {
   return scr_bytes_to_number(s->data, s->len);
 }
 
-double scr_bytes_to_number(const char *p, size_t len) {
+static __attribute__((noinline)) double scr_bytes_to_number_any(const char *p, size_t len) {
   size_t b = 0, e = len;
   while (b < e) {
     unsigned char c = (unsigned char)p[b];
@@ -3164,6 +3214,27 @@ double scr_bytes_to_number(const char *p, size_t len) {
   return r;
 }
 
+/* An optional sign and 1 to 15 decimal digits, the common shape of a
+ * parsed field, is an exact integer below 2^53 with no whitespace to trim
+ * and no other grammar to apply ("-0" is -0, leading zeros are decimal).
+ * Everything else takes the full grammar. */
+double scr_bytes_to_number(const char *p, size_t len) {
+  if (len - 1 < 16) {
+    size_t i = p[0] == '-' || p[0] == '+';
+    if (i < len && len - i <= 15) {
+      int64_t m = 0;
+      size_t k = i;
+      for (; k < len; k++) {
+        unsigned d = (unsigned)(unsigned char)p[k] - '0';
+        if (d > 9) break;
+        m = m * 10 + d;
+      }
+      if (k == len) return p[0] == '-' ? -(double)m : (double)m;
+    }
+  }
+  return scr_bytes_to_number_any(p, len);
+}
+
 ScrStr *scr_f64_to_scrstr(double x) {
   if (x >= 0 && x < 100) { /* -0 prints "0" as well */
     unsigned v = (unsigned)x;
diff --git a/tests/corpus/6950-string-field-fast-paths.ts b/tests/corpus/6950-string-field-fast-paths.ts
new file mode 100644
index 000000000..4e9d52b38
--- /dev/null
+++ b/tests/corpus/6950-string-field-fast-paths.ts
@@ -0,0 +1,48 @@
+// Field parsing on ASCII text: Number() on digit strings (signs, zeros,
+// 15 and 16 digits, whitespace and other grammar), indexOf from the start
+// and from other positions, slice bounds, and split results of every
+// size, including more pieces than one batch and results that grow.
+const numbers = [
+  "0", "-0", "+0", "7", "-7", "+42", "007", "-007", "123456789012345", "-123456789012345",
+  "1234567890123456", "9007199254740993", "-", "+", "", " 12", "12 ", "\t3\n", "1e3",
+  "1.5", "0x1f", "-0x1f", "12px", "1_000", "Infinity", "-Infinity", "+-1", "--1",
+];
+for (const text of numbers) {
+  const value = Number(text);
+  console.log(JSON.stringify(text), value, Object.is(value, -0));
+}
+
+const line = "/route/17?request=123 200 45 3200";
+console.log(line.indexOf("?"), line.indexOf(" "), line.indexOf("x"), line.indexOf(""));
+console.log(line.indexOf("?", -5), line.indexOf("?", NaN), line.indexOf("?", 10), line.indexOf(" ", 30));
+console.log(line.indexOf("", 100), line.indexOf("", -1), "".indexOf(""), "".indexOf("a"));
+console.log(line.indexOf("é"), "aé?".indexOf("?"), "aé?".indexOf("é"));
+console.log(line.slice(0, line.indexOf("?")), line.slice(-4), line.slice(5, 2), line.slice(-100, 3));
+console.log(line.slice(NaN, Infinity) === line, line.slice(2, -2), "héllo".slice(1, 3));
+
+const fields = line.split(" ");
+console.log(fields.length, fields.join("|"));
+fields.push("extra");
+fields[0] = fields[0]!.slice(0, 6);
+console.log(fields.length, fields.join("|"));
+
+const many = Array.from({ length: 150 }, (_, i) => String(i * 7)).join(",");
+const pieces = many.split(",");
+console.log(pieces.length, pieces[0], pieces[63], pieces[64], pieces[149]);
+let sum = 0;
+for (const piece of pieces) sum += Number(piece);
+console.log(sum);
+console.log("a,b,,c,".split(","), ",".split(","), "".split(","), "abc".split(",", 0));
+console.log("a b c d".split(" ", 2), "x--y--z".split("--"), "héllo wörld".split(" "));
+
+const rows = "/a?x=1 200 5 10\n/b 404 7 20\n/a?y=2 500 9 30\n";
+const totals = new Map<string, number>();
+for (const row of rows.split("\n")) {
+  const parts = row.split(" ");
+  if (parts.length !== 4) continue;
+  const raw = parts[0]!;
+  const query = raw.indexOf("?");
+  const route = query < 0 ? raw : raw.slice(0, query);
+  totals.set(route, (totals.get(route) ?? 0) + Number(parts[1]) + Number(parts[3]));
+}
+console.log([...totals.entries()].map(([route, total]) => route + "=" + total).join(";"));
diff --git a/tests/harness/corpus-costs/6950-string-field-fast-paths.ts.json b/tests/harness/corpus-costs/6950-string-field-fast-paths.ts.json
new file mode 100644
index 000000000..62a6540b9
--- /dev/null
+++ b/tests/harness/corpus-costs/6950-string-field-fast-paths.ts.json
@@ -0,0 +1 @@
+{ "plain": 3899, "san": 5479 }

From bbb37ae03ba82335a66da0b848ec2ff4682f3473 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 16:34:37 -0500
Subject: [PATCH 28/67] Read a spread's elements before an earlier argument
 converts

When the Math functions evaluate their arguments into temporaries before
converting (an earlier argument whose ToNumber can run valueOf), a spread
argument's array is now copied where it is evaluated. Before, the
temporary held the array itself and its elements were read after the
conversions, so a valueOf that changed the array changed the values
passed, while JavaScript reads a spread's elements during argument
evaluation.
---
 .../src/frontend/lowering/lower-exprs.ts      | 30 +++++++++++++++----
 tests/corpus/6906-tonumber-arguments.mjs      | 20 +++++++++++++
 2 files changed, 44 insertions(+), 6 deletions(-)

diff --git a/packages/compiler/src/frontend/lowering/lower-exprs.ts b/packages/compiler/src/frontend/lowering/lower-exprs.ts
index 23892d43e..e7a1b79a8 100644
--- a/packages/compiler/src/frontend/lowering/lower-exprs.ts
+++ b/packages/compiler/src/frontend/lowering/lower-exprs.ts
@@ -1429,9 +1429,12 @@ export function lowerToNumberArgument(lowerer: Lowerer, node: ts.Expression): Ir
  * any. When an argument's conversion can run program code (valueOf or
  * toString on a dynamic value) and a later argument follows, the arguments
  * evaluate into temporaries first and convert in order after. `lowerOther`
- * lowers an argument that takes no conversion (a spread), or returns null
- * for a ToNumber argument. Returns the temporaries' statements (empty when
- * none are needed) and the converted values. */
+ * lowers an argument that takes no conversion (a spread's array), or returns
+ * null for a ToNumber argument; with temporaries, such an array is copied
+ * where it is evaluated, since JavaScript reads a spread's elements then,
+ * before a later conversion's valueOf could change them. Returns the
+ * temporaries' statements (empty when none are needed) and the converted
+ * values. */
 export function lowerToNumberArguments(
   lowerer: Lowerer,
   nodes: readonly ts.Expression[],
@@ -1439,7 +1442,9 @@ export function lowerToNumberArguments(
 ): { stmts: IrStmt[]; values: IrExpr[] } {
   const operands = nodes.map((node): NumberOperand => {
     const other = lowerOther?.(node);
-    return other ? { value: other, convert: null, runsCode: false } : numberOperand(lowerer, node);
+    return other
+      ? { value: other, convert: null, runsCode: false, spread: true }
+      : numberOperand(lowerer, node);
   });
   const late = operands.slice(0, -1).some((operand) => operand.runsCode);
   if (!late) {
@@ -1451,7 +1456,18 @@ export function lowerToNumberArguments(
     if (operand.value.kind === "numLit") return operand.value;
     const temp = lowerer.declareHiddenLocal("%numberArgument", operand.value.type);
     const loc = operand.value.loc;
-    stmts.push({ kind: "varDecl", localId: temp.id, init: operand.value, loc });
+    const init: IrExpr =
+      operand.spread && operand.value.type.kind === "array"
+        ? {
+            kind: "arrIntrinsic",
+            method: "slice",
+            receiver: operand.value,
+            args: [numLit(0, loc), numLit(Infinity, loc)],
+            type: operand.value.type,
+            loc,
+          }
+        : operand.value;
+    stmts.push({ kind: "varDecl", localId: temp.id, init, loc });
     const read = varRef(temp.id, operand.value.type, loc);
     return operand.convert ? operand.convert(read) : read;
   });
@@ -1460,11 +1476,13 @@ export function lowerToNumberArguments(
 
 /** An argument a ToNumber site lowers: its evaluated value and the
  * conversion that makes it a number (null when the value already is one).
- * `runsCode`: the conversion can call program code. */
+ * `runsCode`: the conversion can call program code. `spread`: the value is
+ * a spread's array (lowerToNumberArguments' `lowerOther`). */
 interface NumberOperand {
   value: IrExpr;
   convert: ((value: IrExpr) => IrExpr) | null;
   runsCode: boolean;
+  spread?: boolean;
 }
 
 function numberOperand(lowerer: Lowerer, node: ts.Expression): NumberOperand {
diff --git a/tests/corpus/6906-tonumber-arguments.mjs b/tests/corpus/6906-tonumber-arguments.mjs
index 55da6bb1f..35589d07f 100644
--- a/tests/corpus/6906-tonumber-arguments.mjs
+++ b/tests/corpus/6906-tonumber-arguments.mjs
@@ -75,3 +75,23 @@ try {
 } catch (e) {
   console.log(e.message, order);
 }
+
+// A spread reads its elements where it is evaluated, before an earlier
+// argument's valueOf runs.
+const values = [1, 2];
+const mutator = {
+  valueOf() {
+    values[0] = 100;
+    values.push(50);
+    return 3;
+  },
+};
+console.log(Math.max(mutator, ...values), values.join(","));
+const more = [4];
+const resetter = {
+  valueOf() {
+    more[0] = -1;
+    return 0;
+  },
+};
+console.log(Math.hypot(resetter, ...more, 3), more.join(","));

From 228c64a282a71b13aded2b6f805a9242efead2ee Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 16:46:53 -0500
Subject: [PATCH 29/67] Record TypeScript 7 baselines for the string field
 corpus program

The TypeScript 7 parity lane checks every corpus program against a
recorded preflight and order baseline. 6950-string-field-fast-paths.ts
arrived without one; this records it from the current native lane.
---
 .../tests/corpus/6950-string-field-fast-paths.ts.json       | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6950-string-field-fast-paths.ts.json

diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6950-string-field-fast-paths.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6950-string-field-fast-paths.ts.json
new file mode 100644
index 000000000..db05994a9
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6950-string-field-fast-paths.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6950-string-field-fast-paths.ts"
+ ],
+ "diags": []
+}

From fa7aa2507889437b1e24466be1af9724530d0e1e Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 16:58:37 -0500
Subject: [PATCH 30/67] Call an observed prototype method through a bag that
 does not hold it

A dynamic method call on a class instance whose method name the program
also reads through a prototype (`X.prototype.map` anywhere) uses the
observed prototype slot: the callback descriptor read the method from the
instance's property bag, on the assumption that the bag answers every
read through the class prototype. An instance whose bag was built before
the class had prototype data reads as a fresh empty object, so the read
answered undefined and the call threw "... is not a function" (fast-check's
`integer({ min, max }).map(...)` once its result reaches the call through a
dynamic value).

The descriptor now reads the bag when the bag holds the name, own or
through its prototype, and otherwise the class's prototype data.
---
 .../lowering/class-dynamic-dispatch.ts        | 47 +++++++++++++------
 1 file changed, 33 insertions(+), 14 deletions(-)

diff --git a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts
index 7d00eb89e..c891c14cc 100644
--- a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts
+++ b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts
@@ -2568,6 +2568,27 @@ export class ClassDynamicDispatch {
             receiver,
           );
           const bag = this.readPropertyBagOrEmpty(lowerer, value, loc);
+          const methodKey: IrExpr = {
+            kind: "strLit",
+            value: dispatch.source.method,
+            type: STRING,
+            loc,
+          };
+          const bagHas: IrExpr = {
+            kind: "libCall",
+            fn: "dyn.hasKey",
+            args: [bag, methodKey],
+            type: BOOL,
+            loc,
+          };
+          // An observed prototype slot answers through the bag when the bag
+          // holds the name (own or through its prototype). A bag read as a
+          // fresh empty object (an instance with no own dynamic properties
+          // whose bag initializer predates the class's prototype data) does
+          // not, so the method then comes from the class's prototype data.
+          const prototype = prototypeMethod
+            ? classPrototypeData(lowerer, info, loc, receiver)
+            : null;
           dispatch.callback.body.unshift({
             kind: "if",
             cond: condition,
@@ -2576,18 +2597,7 @@ export class ClassDynamicDispatch {
                 kind: "return",
                 value: {
                   kind: "ternary",
-                  cond: prototypeMethod
-                    ? { kind: "boolLit", value: true, type: BOOL, loc }
-                    : {
-                        kind: "libCall",
-                        fn: "dyn.hasKey",
-                        args: [
-                          bag,
-                          { kind: "strLit", value: dispatch.source.method, type: STRING, loc },
-                        ],
-                        type: BOOL,
-                        loc,
-                      },
+                  cond: prototype ? { kind: "boolLit", value: true, type: BOOL, loc } : bagHas,
                   then: {
                     kind: "dynObjLit",
                     fields: [
@@ -2595,8 +2605,17 @@ export class ClassDynamicDispatch {
                         key: { kind: "strLit", value: "value", type: STRING, loc },
                         value: {
                           kind: "dynKeyGet",
-                          value: bag,
-                          key: { kind: "strLit", value: dispatch.source.method, type: STRING, loc },
+                          value: prototype
+                            ? {
+                                kind: "ternary",
+                                cond: bagHas,
+                                then: bag,
+                                else_: prototype,
+                                type: DYN,
+                                loc,
+                              }
+                            : bag,
+                          key: methodKey,
                           type: DYN,
                           loc,
                         },

From d6f857bb1d168118a08974f5114a58146cec6232 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 16:59:02 -0500
Subject: [PATCH 31/67] Keep class methods on structural views asserted from
 unknown

---
 .../src/frontend/lowering/class-protocols.ts  | 61 ++++++++++++++++++-
 .../6951-unknown-cast-class-methods.ts.json   |  6 ++
 .../corpus/6951-unknown-cast-class-methods.ts | 40 ++++++++++++
 .../6951-unknown-cast-class-methods.ts.json   |  1 +
 4 files changed, 105 insertions(+), 3 deletions(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6951-unknown-cast-class-methods.ts.json
 create mode 100644 tests/corpus/6951-unknown-cast-class-methods.ts
 create mode 100644 tests/harness/corpus-costs/6951-unknown-cast-class-methods.ts.json

diff --git a/packages/compiler/src/frontend/lowering/class-protocols.ts b/packages/compiler/src/frontend/lowering/class-protocols.ts
index 172224053..81aa90a1f 100644
--- a/packages/compiler/src/frontend/lowering/class-protocols.ts
+++ b/packages/compiler/src/frontend/lowering/class-protocols.ts
@@ -98,7 +98,11 @@ export class ClassProtocols {
    * could read a stale value. A view of readonly data that nothing
    * observes stays a native record. */
   private markIdentityFlows(protocols: Set<ts.Symbol>): void {
-    const sites: { source: ts.Expression; target: () => ts.Type | undefined }[] = [];
+    const sites: {
+      source: ts.Expression;
+      target: () => ts.Type | undefined;
+      assertion?: true;
+    }[] = [];
     /** Expressions whose values are observed as whole objects. */
     const observed: ts.Expression[] = [];
     /** Receivers whose type arguments or elements are observed (Set and Map
@@ -233,6 +237,7 @@ export class ClassProtocols {
         sites.push({
           source: node.expression,
           target: () => this.checker.getTypeFromTypeNode(typeNode),
+          assertion: true,
         });
       }
       if (ts.isArrowFunction(node) || ts.isFunctionExpression(node))
@@ -325,11 +330,29 @@ export class ClassProtocols {
     }
     this.facts = facts;
     const pending: { sourceType: ts.Type; target: () => ts.Type | undefined }[] = [];
+    /** Views a value of unknown origin is asserted to and that expose a
+     * method of a class the view accepts (see methodViewSources). */
+    const methodViews = new Set<ts.Symbol>();
     for (let i = 0; i < sites.length; i++) {
       const site = sites[i]!;
       const source = sourceNodes[i]!;
       const sourceType = attempt(() => this.checker.getTypeAtLocation(source));
-      if (sourceType !== undefined) pending.push({ sourceType, target: site.target });
+      if (sourceType === undefined) continue;
+      if (
+        site.assertion &&
+        (sourceType.flags & (ts.TypeFlags.Unknown | ts.TypeFlags.Any)) !== 0 &&
+        this.methods.size > 0
+      ) {
+        const target = attempt(site.target);
+        if (target !== undefined)
+          for (const { classType, view } of attempt(() => this.methodViewSources(target)) ?? []) {
+            pending.push({ sourceType: classType, target: () => view });
+            const symbol = view.getSymbol();
+            if (symbol !== undefined) methodViews.add(symbol);
+          }
+        continue;
+      }
+      pending.push({ sourceType, target: site.target });
     }
     for (const { fn, index, name } of callbackParams) {
       attempt(() => {
@@ -372,7 +395,12 @@ export class ClassProtocols {
     // Keep the marks a copy would be told apart from, and the marks whose
     // values flow into a kept view or another live protocol.
     const added = [...marked].filter((symbol) => !before.has(symbol));
-    const kept = new Set(added.filter((symbol) => this.needsView(symbol, marked, facts)));
+    // A copy of an instance drops the methods its class defines, so a view
+    // that exposes one of them stays live wherever such an instance may
+    // arrive.
+    const kept = new Set(
+      added.filter((symbol) => methodViews.has(symbol) || this.needsView(symbol, marked, facts)),
+    );
     let grew = true;
     while (grew) {
       grew = false;
@@ -391,6 +419,33 @@ export class ClassProtocols {
     this.facts = null;
   }
 
+  /** The program classes a value asserted from `unknown` or `any` to
+   * `target` may be an instance of while `target` exposes one of their
+   * methods: for each structural part of `target` with a callable member,
+   * the instance type of every class that declares a method of that name
+   * and is assignable to the part. A record copy of such an instance would
+   * drop the method, which Node reads from the instance's prototype. */
+  private methodViewSources(target: ts.Type): { classType: ts.Type; view: ts.Type }[] {
+    const parts = target.isUnionType() ? ts.constituentTypes(target) : [target];
+    const out: { classType: ts.Type; view: ts.Type }[] = [];
+    for (const part of parts) {
+      if (!this.isStructuralTarget(part)) continue;
+      for (const property of this.checker.getPropertiesOfType(part)) {
+        const memberType = this.checker.getNonNullableType(this.checker.getTypeOfSymbol(property));
+        if (this.checker.getCallSignatures(memberType).length === 0) continue;
+        for (const declaration of this.methods.get(ts.symbolName(property)) ?? []) {
+          const classSymbol = declaration.name
+            ? this.checker.getSymbolAtLocation(declaration.name)
+            : undefined;
+          if (classSymbol === undefined) continue;
+          const classType = this.checker.getDeclaredTypeOfSymbol(classSymbol);
+          if (this.checker.isTypeAssignableTo(classType, part)) out.push({ classType, view: part });
+        }
+      }
+    }
+    return out;
+  }
+
   /** The symbols of `type`'s object parts: union and intersection members,
    * and to `depth` levels the elements and type arguments they hold. */
   private collectSymbols(type: ts.Type, out: Set<ts.Symbol>, depth: number): void {
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6951-unknown-cast-class-methods.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6951-unknown-cast-class-methods.ts.json
new file mode 100644
index 000000000..281dcba85
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6951-unknown-cast-class-methods.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6951-unknown-cast-class-methods.ts"
+ ],
+ "diags": []
+}
diff --git a/tests/corpus/6951-unknown-cast-class-methods.ts b/tests/corpus/6951-unknown-cast-class-methods.ts
new file mode 100644
index 000000000..7585a8752
--- /dev/null
+++ b/tests/corpus/6951-unknown-cast-class-methods.ts
@@ -0,0 +1,40 @@
+// Methods of a class instance read through `unknown` cast to a structural
+// type: the read finds the prototype method, as Node's property lookup does.
+
+class Greeter {
+  label = "greeter";
+  readonly name: string;
+  constructor(name: string) {
+    this.name = name;
+  }
+  describe(): string {
+    return `${this.label}:${this.name}`;
+  }
+  shout(): string {
+    return this.describe().toUpperCase();
+  }
+}
+
+class LoudGreeter extends Greeter {
+  extra(): number {
+    return 42;
+  }
+}
+
+type Describable = { describe?: () => string; shout?: () => string; label?: string };
+
+function inspect(value: unknown): void {
+  const shaped = value as Describable;
+  console.log(typeof shaped.describe, typeof shaped.shout, shaped.label);
+  console.log(shaped.describe?.() ?? "no describe");
+  console.log(shaped.shout?.() ?? "no shout");
+}
+
+inspect(new Greeter("ada"));
+inspect(new LoudGreeter("grace"));
+inspect({ label: "plain", describe: () => "own function" });
+inspect({ label: "bare" });
+
+const loud: unknown = new LoudGreeter("lin");
+const withExtra = loud as { extra?: () => number; missing?: () => number };
+console.log(withExtra.extra?.(), withExtra.missing?.() ?? "no missing");
diff --git a/tests/harness/corpus-costs/6951-unknown-cast-class-methods.ts.json b/tests/harness/corpus-costs/6951-unknown-cast-class-methods.ts.json
new file mode 100644
index 000000000..49300a99a
--- /dev/null
+++ b/tests/harness/corpus-costs/6951-unknown-cast-class-methods.ts.json
@@ -0,0 +1 @@
+{ "plain": 2618, "san": 37588 }

From 238b08352b3b1f77c071116bc5dc6c1ff864bd4e Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 17:00:19 -0500
Subject: [PATCH 32/67] Keep named properties written to arrays through checked
 views

---
 .../src/backend/llvm/expr-stream-bridges.ts   |  3 +
 .../compiler/src/backend/llvm/lib-dispatch.ts |  1 +
 .../compiler/src/backend/llvm/lib-shared.ts   |  1 +
 .../src/backend/llvm/reference-writes.ts      |  1 +
 .../src/frontend/lowering/lower-stmts.ts      | 82 ++++++++++++++++++-
 .../compiler/src/ir/builtin-signatures.ts     |  3 +
 packages/compiler/src/ir/validate.ts          |  6 ++
 .../6987-array-view-named-properties.ts.json  |  6 ++
 packages/runtime/src/scr_array.c              | 64 ++++++++++++++-
 packages/runtime/src/scr_array.h              |  9 ++
 packages/runtime/src/scr_json.c               | 17 ++++
 .../6987-array-view-named-properties.ts       | 79 ++++++++++++++++++
 .../6987-array-view-named-properties.ts.json  |  1 +
 13 files changed, 266 insertions(+), 7 deletions(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6987-array-view-named-properties.ts.json
 create mode 100644 tests/corpus/6987-array-view-named-properties.ts
 create mode 100644 tests/harness/corpus-costs/6987-array-view-named-properties.ts.json

diff --git a/packages/compiler/src/backend/llvm/expr-stream-bridges.ts b/packages/compiler/src/backend/llvm/expr-stream-bridges.ts
index ce33aa2cd..b72875aaa 100644
--- a/packages/compiler/src/backend/llvm/expr-stream-bridges.ts
+++ b/packages/compiler/src/backend/llvm/expr-stream-bridges.ts
@@ -176,6 +176,7 @@ export function streamTypedRefCommitAdapter(
     const check = host.dyn.dynCheckHelper(t);
     host.declare(`declare void @scr_arr_release(ptr)`);
     host.declare(`declare void @scr_arr_outline(ptr)`);
+    host.declare(`declare void @scr_arr_adopt_view_properties(ptr, ptr, ptr)`);
     const lines = [
       `define internal void @${commit}(ptr %target, ptr %d) ${FN_ATTRS} { ; commit live stream element ${typeKey(t)}`,
       `entry:`,
@@ -183,6 +184,8 @@ export function streamTypedRefCommitAdapter(
       `  %missing = icmp eq ptr %next, null`,
       `  br i1 %missing, label %done, label %swap`,
       `swap:`,
+      // Properties move with the storage (in its out-of-line part).
+      `  call void @scr_arr_adopt_view_properties(ptr %next, ptr %d, ptr %target)`,
       // Inline slots live in each header's block; move them out first.
       `  call void @scr_arr_outline(ptr %target)`,
       `  call void @scr_arr_outline(ptr %next)`,
diff --git a/packages/compiler/src/backend/llvm/lib-dispatch.ts b/packages/compiler/src/backend/llvm/lib-dispatch.ts
index 924027ee2..1868ca402 100644
--- a/packages/compiler/src/backend/llvm/lib-dispatch.ts
+++ b/packages/compiler/src/backend/llvm/lib-dispatch.ts
@@ -864,6 +864,7 @@ export function emitLibCall(host: LlvmEmitterContext, e: LibCallExpr): LlValue {
     case "events":
     case "blob":
     case "wasm":
+    case "array":
     case "record":
     case "disposable":
     case "punycode":
diff --git a/packages/compiler/src/backend/llvm/lib-shared.ts b/packages/compiler/src/backend/llvm/lib-shared.ts
index feb499203..be7a4973b 100644
--- a/packages/compiler/src/backend/llvm/lib-shared.ts
+++ b/packages/compiler/src/backend/llvm/lib-shared.ts
@@ -1519,6 +1519,7 @@ export const LIB_FN_SYMS: Record<string, string> = {
   "regex.groupNumber": "scr_regex_group_number",
   "regex.groupParseInt": "scr_regex_group_parse_int",
   "regex.resultProp": "scr_regex_result_prop",
+  "array.namedKeys": "scr_arr_named_keys",
   // queueMicrotask's checked-dynamic form (borrowed dyn; a non-function
   // throws synchronously), the minted setImmediate value, and the
   // timers/promises immediate — all mark the loop live.
diff --git a/packages/compiler/src/backend/llvm/reference-writes.ts b/packages/compiler/src/backend/llvm/reference-writes.ts
index a0a153da1..c77a5a191 100644
--- a/packages/compiler/src/backend/llvm/reference-writes.ts
+++ b/packages/compiler/src/backend/llvm/reference-writes.ts
@@ -105,6 +105,7 @@ const INERT_LIB_CALLS = new Set([
   "regex.groupNumber",
   "regex.groupParseInt",
   "regex.resultProp",
+  "array.namedKeys",
   "process.cwd",
   "process.argv",
   "process.execArgv",
diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.ts b/packages/compiler/src/frontend/lowering/lower-stmts.ts
index b04ba0b09..0960b9d6a 100644
--- a/packages/compiler/src/frontend/lowering/lower-stmts.ts
+++ b/packages/compiler/src/frontend/lowering/lower-stmts.ts
@@ -11594,10 +11594,23 @@ function lowerForInArray(
   try {
     const arr = lowerer.declareHiddenLocal("%inarr", arrExpr.type);
     const len = lowerer.declareHiddenLocal("%inlen", F64);
+    const keysT: IrType = { kind: "array", elem: STRING };
+    const keys = lowerer.declareHiddenLocal("%inkeys", keysT);
+    const total = lowerer.declareHiddenLocal("%intotal", F64);
     const i = lowerer.declareHiddenLocal("%ini", F64);
     i.mutable = true;
     const arrRef = (): IrExpr => ({ kind: "varRef", localId: arr.id, type: arrExpr.type, loc });
+    const keysRef = (): IrExpr => ({ kind: "varRef", localId: keys.id, type: keysT, loc });
+    const lenRef = (): IrExpr => ({ kind: "varRef", localId: len.id, type: F64, loc });
     const iRef = (): IrExpr => ({ kind: "varRef", localId: i.id, type: F64, loc });
+    const isIndex = (): IrExpr => ({
+      kind: "bin",
+      op: "<",
+      left: iRef(),
+      right: lenRef(),
+      type: BOOL,
+      loc,
+    });
     const liveLen = (): IrExpr => ({
       kind: "arrIntrinsic",
       method: "length",
@@ -11606,7 +11619,44 @@ function lowerForInArray(
       type: F64,
       loc,
     });
-    const keyInit: IrExpr = { kind: "toString", operand: iRef(), type: STRING, loc };
+    // Indices first, then the named keys the array had when the loop began.
+    const keyInit: IrExpr = {
+      kind: "ternary",
+      cond: isIndex(),
+      then: { kind: "toString", operand: iRef(), type: STRING, loc },
+      else_: {
+        kind: "arrayGet",
+        arr: keysRef(),
+        index: { kind: "bin", op: "-", left: iRef(), right: lenRef(), type: F64, loc },
+        type: STRING,
+        loc,
+      },
+      type: STRING,
+      loc,
+    };
+    // An index is visited while it is below the live length and not a hole.
+    const visits: IrExpr = {
+      kind: "ternary",
+      cond: isIndex(),
+      then: {
+        kind: "logical",
+        op: "&&",
+        left: { kind: "bin", op: "<", left: iRef(), right: liveLen(), type: BOOL, loc },
+        right: {
+          kind: "bin",
+          op: "!==",
+          left: { kind: "arrayState", arr: arrRef(), index: iRef(), type: F64, loc },
+          right: { kind: "numLit", value: 0, type: F64, loc },
+          type: BOOL,
+          loc,
+        },
+        type: BOOL,
+        loc,
+      },
+      else_: { kind: "boolLit", value: true, type: BOOL, loc },
+      type: BOOL,
+      loc,
+    };
 
     // The three binding forms, sharing the per-visit key declaration.
     let keyDecl: IrStmt;
@@ -11670,6 +11720,32 @@ function lowerForInArray(
       body: [
         { kind: "varDecl", localId: arr.id, init: arrExpr, loc },
         { kind: "varDecl", localId: len.id, init: liveLen(), loc },
+        {
+          kind: "varDecl",
+          localId: keys.id,
+          init: { kind: "libCall", fn: "array.namedKeys", args: [arrRef()], type: keysT, loc },
+          loc,
+        },
+        {
+          kind: "varDecl",
+          localId: total.id,
+          init: {
+            kind: "bin",
+            op: "+",
+            left: lenRef(),
+            right: {
+              kind: "arrIntrinsic",
+              method: "length",
+              receiver: keysRef(),
+              args: [],
+              type: F64,
+              loc,
+            },
+            type: F64,
+            loc,
+          },
+          loc,
+        },
         {
           kind: "for",
           init: {
@@ -11682,7 +11758,7 @@ function lowerForInArray(
             kind: "bin",
             op: "<",
             left: iRef(),
-            right: { kind: "varRef", localId: len.id, type: F64, loc },
+            right: { kind: "varRef", localId: total.id, type: F64, loc },
             type: BOOL,
             loc,
           },
@@ -11702,7 +11778,7 @@ function lowerForInArray(
           body: [
             {
               kind: "if",
-              cond: { kind: "bin", op: "<", left: iRef(), right: liveLen(), type: BOOL, loc },
+              cond: visits,
               then: [keyDecl, ...writes, ...body],
               else_: null,
               loc,
diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts
index 9f383c695..1e6270366 100644
--- a/packages/compiler/src/ir/builtin-signatures.ts
+++ b/packages/compiler/src/ir/builtin-signatures.ts
@@ -3724,6 +3724,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
   "regex.groupParseInt": { argTypes: [arrayOf(STRING), F64, F64], result: F64 },
   // `.index` / `.input` (args[1]) of a match result. Borrowed; never throws.
   "regex.resultProp": { argTypes: [arrayOf(STRING), STRING], result: DYN },
+  // The string keys `for...in` visits on an array (args[0], any element
+  // type) after its indices. Borrowed; never throws.
+  "array.namedKeys": { argTypes: [null], result: arrayOf(STRING) },
   // node:events EventEmitter: receivers are emitter-hierarchy objects and
   // the chaining forms (on/off/removeAll/setMax) return the receiver's
   // own class — program-dependent object types, checked in the libCall
diff --git a/packages/compiler/src/ir/validate.ts b/packages/compiler/src/ir/validate.ts
index f562d20e0..0004be761 100644
--- a/packages/compiler/src/ir/validate.ts
+++ b/packages/compiler/src/ir/validate.ts
@@ -4262,6 +4262,12 @@ function validateFunction(
       if (!ok) err(`libCall dyn.objEntryPairs must return a [string, any] tuple array`, e.loc);
       return true;
     }
+    if (e.fn === "array.namedKeys") {
+      if (e.args[0]?.type.kind !== "array") {
+        err(`libCall array.namedKeys arg 0: expected an array, got ${e.args[0]?.type.kind}`, e.loc);
+      }
+      return true;
+    }
     if (e.fn === "fetch.streamFrom") {
       const t = e.args[0]?.type;
       const ok =
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6987-array-view-named-properties.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6987-array-view-named-properties.ts.json
new file mode 100644
index 000000000..c12126453
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6987-array-view-named-properties.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6987-array-view-named-properties.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/runtime/src/scr_array.c b/packages/runtime/src/scr_array.c
index f8b5813a2..fa98dd38a 100644
--- a/packages/runtime/src/scr_array.c
+++ b/packages/runtime/src/scr_array.c
@@ -4795,11 +4795,67 @@ void scr_arr_copy_metadata(ScrArr *a, ScrDyn *target) {
   if (metadata && metadata->kind == SCR_DYN_HANDLE && metadata->v.handle.tag == SCR_DYNH_MATCH_SOURCE &&
       scr_arr_match_copy(a, target))
     return;
-  if (!SCR_AX(a)->metadata) return;
-  for (size_t i = 0; i < SCR_AX(a)->metadata->v.obj.len; i++) {
-    ScrDynEntry *entry = &SCR_AX(a)->metadata->v.obj.entries[i];
+  metadata = SCR_AX(a)->metadata;
+  if (!metadata) return;
+  for (size_t i = 0; i < metadata->v.obj.len; i++) {
+    const ScrDynEntry *entry = &metadata->v.obj.entries[i];
     ScrStr *key = scr_str_new(entry->key, entry->key_len);
-    scr_dyn_key_set(target, key, entry->value);
+    if (!entry->accessor && entry->writable && entry->enumerable && entry->configurable) {
+      scr_dyn_key_set(target, key, entry->value);
+    } else {
+      /* Properties defined through a view keep their attributes. */
+      ScrDyn *name = scr_dyn_new_str(key);
+      ScrDyn *descriptor = scr_dyn_own_descriptor(metadata, key);
+      if (descriptor) scr_dyn_release(scr_dyn_define_property(target, name, descriptor));
+      scr_dyn_release(descriptor);
+      scr_dyn_release(name);
+    }
     scr_str_release(key);
   }
 }
+
+ScrArr *scr_arr_named_keys(ScrArr *a) {
+  /* Most arrays have no out-of-line storage: they share one immortal empty
+   * result, which `for...in` only reads. */
+  static ScrArr none = {.rc = SIZE_MAX, .elem = SCR_ELEM_STR};
+  const ScrArrExt *x = scr_arr_ext_of(a);
+  if (!x) return &none;
+  ScrArr *keys = scr_arr_new(SCR_ELEM_STR, 0);
+  for (size_t i = 0; i < x->prop_len; i++)
+    scr_arr_push_ref(keys, scr_str_new(x->props[i].key, x->props[i].key_len));
+  const ScrDyn *metadata = x->metadata;
+  if (metadata && metadata->kind == SCR_DYN_HANDLE && metadata->v.handle.tag == SCR_DYNH_MATCH_SOURCE) {
+    static const char *const names[] = {"index", "input", "groups"};
+    for (size_t i = 0; i < 3; i++) scr_arr_push_ref(keys, scr_str_new(names[i], strlen(names[i])));
+    return keys;
+  }
+  if (!metadata || metadata->kind != SCR_DYN_OBJ) return keys;
+  for (size_t i = 0; i < metadata->v.obj.len; i++) {
+    const ScrDynEntry *entry = &metadata->v.obj.entries[i];
+    if (!entry->enumerable || scr_arr_prop_index(a, entry->key, entry->key_len) != SIZE_MAX) continue;
+    scr_arr_push_ref(keys, scr_str_new(entry->key, entry->key_len));
+  }
+  return keys;
+}
+
+void scr_arr_adopt_view_properties(ScrArr *a, ScrDyn *view, ScrArr *target) {
+  ScrArrExt *from = scr_arr_ext_of(target);
+  if (from && from->prop_len) {
+    /* Both arrays have the same element type, so the slots keep their owner. */
+    ScrArrExt *x = scr_arr_ext(a);
+    ScrArrProp *props = x->props;
+    size_t len = x->prop_len, cap = x->prop_cap;
+    x->props = from->props;
+    x->prop_len = from->prop_len;
+    x->prop_cap = from->prop_cap;
+    from->props = props;
+    from->prop_len = len;
+    from->prop_cap = cap;
+  }
+  ScrDyn *named = view && view->kind == SCR_DYN_ARR ? view->v.arr.properties : NULL;
+  if (!named || named->v.obj.len == 0) return;
+  ScrArrExt *x = scr_arr_ext(a);
+  ScrDyn *old = x->metadata;
+  x->metadata = scr_dyn_retain(named);
+  scr_dyn_release(old);
+}
diff --git a/packages/runtime/src/scr_array.h b/packages/runtime/src/scr_array.h
index 2068a324d..d9f5f49bc 100644
--- a/packages/runtime/src/scr_array.h
+++ b/packages/runtime/src/scr_array.h
@@ -317,6 +317,15 @@ static inline ScrArr *scr_arr_retain(ScrArr *a) {
  * the candidate-root buffer like every headered type. */
 void scr_arr_release(ScrArr *a);
 void scr_arr_copy_metadata(ScrArr *a, struct ScrDyn *target);
+/* The commit of a live array view calls this on `a`, the array converted
+ * from `view`, before `target` takes its storage: `a` takes the view's named
+ * (non-index) properties as its metadata and the noncanonical numeric
+ * properties of `target`, so neither is lost when the storage is swapped. */
+void scr_arr_adopt_view_properties(ScrArr *a, struct ScrDyn *view, ScrArr *target);
+/* The enumerable string keys `for...in` visits after the indices: the
+ * noncanonical numeric properties, then the named properties in insertion
+ * order. +1. */
+ScrArr *scr_arr_named_keys(ScrArr *a);
 /* Installed by scr_regex.c when it records a pending match source; this
  * unit links without the regex runtime. Writes the pending metadata of
  * `a` into its dynamic copy or materializes it, answering whether it
diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c
index adcc96560..8577a96fb 100644
--- a/packages/runtime/src/scr_json.c
+++ b/packages/runtime/src/scr_json.c
@@ -10269,6 +10269,23 @@ void scr_dyn_key_delete(ScrDyn *recv, const ScrStr *key, bool strict) {
     }
     return;
   }
+  /* A live native array keeps its named properties in its metadata, so
+   * deleting one goes through the view and its commit. Elements and
+   * `length` keep the boundary below. */
+  size_t element;
+  if (recv->kind == SCR_DYN_TYPED_REF && recv->v.typed_ref.commit && scr_dyn_typed_ref_array_ops(recv) &&
+      !scr_typed_ref_is_length(key) && !scr_typed_ref_canonical_index(key->data, key->len, &element)) {
+    ScrDyn *view = scr_dyn_typed_ref_materialize(recv);
+    if (!scr_exc_pending() && view->kind == SCR_DYN_ARR) {
+      bool own = view->v.arr.properties && scr_dyn_obj_get(view->v.arr.properties, key->data, key->len);
+      if (own) scr_dyn_key_delete(view, key, strict);
+      if (own && !scr_exc_pending()) scr_dyn_typed_ref_commit(recv);
+      scr_dyn_release(view);
+      return;
+    }
+    scr_dyn_release(view);
+    if (scr_exc_pending()) return;
+  }
   if (recv->kind == SCR_DYN_FUNC) {
     if (scr_dyn_fn_property_fence(key)) return;
     ScrDyn *table = scr_dyn_fn_properties(recv);
diff --git a/tests/corpus/6987-array-view-named-properties.ts b/tests/corpus/6987-array-view-named-properties.ts
new file mode 100644
index 000000000..5cbea5a0a
--- /dev/null
+++ b/tests/corpus/6987-array-view-named-properties.ts
@@ -0,0 +1,79 @@
+// Named properties written to a typed array through an `unknown` view stay
+// on the array: later views read them, key walks list them after the
+// indices, and `for...in` over the typed array visits them. Holes are
+// skipped by `for...in`.
+
+type Bag = Record<string, unknown>;
+
+const numbers: number[] = [1, 2, 3];
+const numbersView = numbers as unknown as Bag;
+numbersView.extra = "named";
+console.log(numbersView.extra, (numbers as unknown as Bag).extra);
+console.log(Object.keys(numbersView), JSON.stringify(numbers), numbers.length);
+console.log("extra" in numbersView, Object.hasOwn(numbersView, "extra"));
+
+numbers.push(4);
+numbers[0] = 10;
+console.log((numbers as unknown as Bag).extra, numbers.join(","));
+console.log((numbers.slice() as unknown as Bag).extra);
+
+(numbers as unknown as Bag).extra = "again";
+(numbers as unknown as Bag).count = 2;
+console.log(Object.entries(numbers as unknown as Bag));
+for (const key in numbers) console.log("numbers key", key);
+
+delete (numbers as unknown as Bag).extra;
+console.log((numbers as unknown as Bag).extra, Object.keys(numbers as unknown as Bag));
+
+const words: string[] = ["a", "b"];
+(words as unknown as Bag).label = { nested: [1, 2] };
+const label = (words as unknown as Bag).label as { nested: number[] };
+console.log(label.nested.length, words.length);
+for (const key in words) console.log("words key", key);
+
+interface Point {
+  x: number;
+  y: number;
+}
+const points: Point[] = [{ x: 1, y: 2 }];
+(points as unknown as Bag).origin = "zero";
+console.log((points as unknown as Bag).origin, points[0]!.x);
+for (const key in points) console.log("points key", key);
+
+class Item {
+  name: string;
+  constructor(name: string) {
+    this.name = name;
+  }
+}
+const items: Item[] = [new Item("first")];
+(items as unknown as Bag).kind = "items";
+console.log((items as unknown as Bag).kind, items[0]!.name);
+
+const flags: boolean[] = [true, false];
+Object.defineProperty(flags as unknown as Bag, "hidden", { value: 1, enumerable: false });
+(flags as unknown as Bag).shown = 2;
+console.log((flags as unknown as Bag).hidden, (flags as unknown as Bag).shown);
+for (const key in flags) console.log("flags key", key);
+
+const holes: (number | undefined)[] = [1, , 3, undefined];
+for (const key in holes) console.log("holes key", key);
+(holes as unknown as Bag).tail = true;
+for (const key in holes) console.log("holes key after", key);
+
+const offsets: number[] = [1, 2];
+offsets[-1] = 5;
+offsets[1.5] = 6;
+(offsets as unknown as Bag).name = "offsets";
+console.log(offsets[-1], offsets[1.5], (offsets as unknown as Bag).name);
+for (const key in offsets) console.log("offsets key", key);
+
+const shrinking: number[] = [1, 2, 3, 4];
+(shrinking as unknown as Bag).after = "kept";
+for (const key in shrinking) {
+  console.log("shrinking key", key);
+  if (key === "1") shrinking.length = 2;
+}
+
+const match = /b(?<rest>c)?/.exec("abc");
+if (match) for (const key in match) console.log("match key", key);
diff --git a/tests/harness/corpus-costs/6987-array-view-named-properties.ts.json b/tests/harness/corpus-costs/6987-array-view-named-properties.ts.json
new file mode 100644
index 000000000..1e9e64ec5
--- /dev/null
+++ b/tests/harness/corpus-costs/6987-array-view-named-properties.ts.json
@@ -0,0 +1 @@
+{ "plain": 3300, "san": 4400 }

From d15e822d263203f3bc29cb43071b47d6f21be839 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 17:16:12 -0500
Subject: [PATCH 33/67] Hold any non-nullish value in an empty object type
 inferred from a literal

The type mapper lowered the type tsc infers from an empty object literal
(`const o = {}`) as the empty record, while a declared `{}` already lowered
as a checked-dynamic value. tsc's `{}` admits every non-nullish value in
both cases: union subtype reduction folds primitives into a literal's `{}`
(`["12", {}]` is `{}[]`, `flag ? "x" : {}` is `{}`), and `let o = {}`
accepts `o = "x"`. Such a program built and then threw a TypeError at run
time ("expected object at $[0], got string" in a JavaScript file, "a
'string' value is not representable in the target union" in TypeScript),
where Node prints the values.

An empty object type with no members, index signatures or signatures now
lowers as a checked-dynamic value, the same rule as `object` and `Object`.
As an arm of a union that keeps another non-nullish arm, which subtype
reduction would have removed, it holds only the literal's objects and
stays the empty record.

An assertion's scalar check (`as string`, `as number`, `as boolean`) on a
dynamic value whose result goes straight back into a dynamic slot keeps
the original value, since JavaScript erases assertions: passing `{} as
unknown as string` to process.loadEnvFile reports Node's
ERR_INVALID_ARG_TYPE instead of a TypeError from the check.

Object.assign's two-argument path for a dynamic target now applies the
same refusal as the general path when a class instance is copied into a
fresh object literal whose result the checker types as the class, so
`Object.assign({}, instance)` keeps its compile-time refusal now that the
literal lowers as a dynamic value.
---
 .../src/frontend/lowering/lower-calls.ts      | 45 ++++++-----
 .../compiler/src/frontend/lowering/lowerer.ts | 14 ++++
 packages/compiler/src/frontend/type-mapper.ts | 77 +++++++++++++++----
 .../6909-empty-object-type-values.ts.json     |  6 ++
 .../6910-empty-object-type-values-js.mjs.json |  6 ++
 tests/corpus/6909-empty-object-type-values.ts | 32 ++++++++
 .../6910-empty-object-type-values-js.mjs      | 14 ++++
 .../index-signature-values.ts.txt             | 20 +----
 ...ine-2104-computed-key-destructuring.ts.txt | 11 +--
 .../__snapshots__/utility-types.ts.txt        | 20 +----
 10 files changed, 164 insertions(+), 81 deletions(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6909-empty-object-type-values.ts.json
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6910-empty-object-type-values-js.mjs.json
 create mode 100644 tests/corpus/6909-empty-object-type-values.ts
 create mode 100644 tests/corpus/6910-empty-object-type-values-js.mjs

diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts
index ac7728838..fa90990e5 100644
--- a/packages/compiler/src/frontend/lowering/lower-calls.ts
+++ b/packages/compiler/src/frontend/lowering/lower-calls.ts
@@ -7668,6 +7668,10 @@ function lowerObjectStaticCall(
         const target = lowerer.lowerExpr(call.arguments.nodes[0]!);
         const rawSource = lowerer.lowerExpr(call.arguments.nodes[1]!);
         fenceSymbolFieldCopy(lowerer, call.arguments.nodes[1]!, rawSource.type);
+        let targetNode: ts.Expression = call.arguments.nodes[0]!;
+        while (ts.isParenthesizedExpression(targetNode)) targetNode = targetNode.expression;
+        if (ts.isObjectLiteralExpression(targetNode))
+          fenceClassCopyIntoFreshObject(lowerer, call, call.arguments.nodes[1]!, rawSource);
         const source = lowerer.coerceToExpected(rawSource, DYN);
         if (target.type.kind === "dyn" && source.type.kind === "dyn") {
           return { kind: "libCall", fn: "dyn.assign", args: [target, source], type: DYN, loc };
@@ -7821,25 +7825,8 @@ function lowerObjectStaticCall(
             const srcNode = spread ? argNode.expression : argNode;
             const rawSource = lowerer.lowerExpr(srcNode);
             fenceSymbolFieldCopy(lowerer, srcNode, rawSource.type, spread);
-            // A class instance copied into a fresh object
-            // (`Object.assign({}, instance)`): the result is a plain
-            // object holding the instance's own fields, never an
-            // instance, so a result the checker types as the class has
-            // no representation (the checked cast would throw).
-            if (
-              rawSource.type.kind === "object" &&
-              freshLiteralTarget &&
-              !ts.isExpressionStatement(call.parent)
-            ) {
-              const resultT = lowerer.mapTypeOf(lowerer.typeOf(call));
-              if (resultT !== null && resultT.kind === "object") {
-                lowerer.unsupported(
-                  "SC1090",
-                  srcNode,
-                  `Object.assign copying a '${lowerer.fmt(rawSource.type)}' instance into a fresh object typed as the class (the copy is a plain object holding the instance's own fields, not an instance — build the object literal from the fields you need)`,
-                );
-              }
-            }
+            if (freshLiteralTarget)
+              fenceClassCopyIntoFreshObject(lowerer, call, srcNode, rawSource);
             const src = lowerer.coerceToExpected(rawSource, DYN);
             if (src.type.kind !== "dyn") {
               ok = false;
@@ -10685,3 +10672,23 @@ function functionIntegrity(
     loc,
   };
 }
+
+/** A class instance copied into a fresh object (`Object.assign({},
+ * instance)`): the result is a plain object holding the instance's own
+ * fields, never an instance, so a result the checker types as the class has
+ * no representation (the checked cast would throw). */
+function fenceClassCopyIntoFreshObject(
+  lowerer: Lowerer,
+  call: ts.CallExpression,
+  srcNode: ts.Expression,
+  rawSource: IrExpr,
+): void {
+  if (rawSource.type.kind !== "object" || ts.isExpressionStatement(call.parent)) return;
+  const resultT = lowerer.mapTypeOf(lowerer.typeOf(call));
+  if (resultT === null || resultT.kind !== "object") return;
+  lowerer.unsupported(
+    "SC1090",
+    srcNode,
+    `Object.assign copying a '${lowerer.fmt(rawSource.type)}' instance into a fresh object typed as the class (the copy is a plain object holding the instance's own fields, not an instance — build the object literal from the fields you need)`,
+  );
+}
diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts
index c4d24cef1..e287bac3f 100644
--- a/packages/compiler/src/frontend/lowering/lowerer.ts
+++ b/packages/compiler/src/frontend/lowering/lowerer.ts
@@ -9786,6 +9786,20 @@ export class Lowerer {
    * directly when the expression was already lowered. */
   coerceInto(node: ts.Node, expr: IrExpr, expected: IrType): IrExpr {
     refuseInferredCallbackDrops(this, node, expr.type, expected);
+    // An assertion's scalar check whose value goes straight back into a
+    // checked-dynamic slot (`process.loadEnvFile({} as unknown as string)`)
+    // keeps the original value: JavaScript erases assertions, so the check
+    // could only add a TypeError Node does not throw, and the slot holds
+    // the value either way.
+    if (expected.kind === "dyn" && expr.kind === "dynCheck" && expr.value.type.kind === "dyn") {
+      let source = node;
+      while (ts.isParenthesizedExpression(source)) source = source.expression;
+      if (
+        (ts.isAsExpression(source) || ts.isTypeAssertion(source)) &&
+        (expr.type.kind === "string" || expr.type.kind === "f64" || expr.type.kind === "bool")
+      )
+        return expr.value;
+    }
     // A union destination can accept the binding's tagged storage directly.
     // The checker's single-arm flow type can be stale after a callback writes
     // the binding. Extracting that arm and wrapping it again would discard the
diff --git a/packages/compiler/src/frontend/type-mapper.ts b/packages/compiler/src/frontend/type-mapper.ts
index 3448545f8..6305a6b63 100644
--- a/packages/compiler/src/frontend/type-mapper.ts
+++ b/packages/compiler/src/frontend/type-mapper.ts
@@ -1108,6 +1108,11 @@ export type TypeParamTsResolver = (t: ts.Type) => ts.Type | null;
  * once per Lowerer and threaded through the recursion — adding a hook means
  * one new field here, not a new parameter at every call site. */
 export interface TypeMapperCtx {
+  /** Set only while a union maps an arm that is the type inferred from an
+   * empty object literal, beside another non-nullish arm: that arm holds
+   * only the literal's objects, so it maps to the empty record (see the
+   * empty object type rule in the object mapping). */
+  emptyLiteralArm?: boolean;
   checker: ts.TypeChecker;
   /** JavaScript declarations whose instance or object-literal types only
    * the checked-dynamic representation holds (js-dynamic-objects.ts).
@@ -4648,6 +4653,18 @@ function mapTypeInner(type: ts.Type, ctx: TypeMapperCtx): IrType | null {
         );
       };
       const hasArrayPart = parts.some((part) => checker.isArrayType(part) || matchArray(part));
+      // Subtype reduction removes every arm assignable to `{}`, so a union
+      // that keeps another non-nullish arm beside an empty literal's `{}`
+      // was not reduced: that `{}` arm holds only the literal's objects.
+      const nullish = ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void;
+      const literalEmptyArms =
+        parts.some((part) => isEmptyObjectLiteralType(part, ctx)) &&
+        parts.some(
+          (part) =>
+            (part.flags & nullish) === 0 &&
+            !checker.isNeverType(part) &&
+            !isEmptyObjectLiteralType(part, ctx),
+        );
       for (const part of parts) {
         if (hasArrayPart && emptyTuple(part)) continue;
         // TypeScript's client can retain impossible intersections in a
@@ -4666,7 +4683,17 @@ function mapTypeInner(type: ts.Type, ctx: TypeMapperCtx): IrType | null {
           byKey.set(typeKey(NULL_T), NULL_T);
           continue;
         }
-        const mapped = mapType(part, ctx);
+        let mapped: IrType | null;
+        if (literalEmptyArms && isEmptyObjectLiteralType(part, ctx)) {
+          ctx.emptyLiteralArm = true;
+          try {
+            mapped = mapType(part, ctx);
+          } finally {
+            ctx.emptyLiteralArm = false;
+          }
+        } else {
+          mapped = mapType(part, ctx);
+        }
 
         if (!mapped) {
           return null;
@@ -7496,25 +7523,29 @@ function mapRecordTypeInner(
     // An INDEX-SIGNATURE shape is exempt: `Record<string, T>` legitimately
     // has zero declared members — the signature is the shape.
     if (computed && props.length === 0 && !indexValue) return null;
-    // A DECLARED empty object type — `{}` (spelled or the checker's shared
-    // intrinsic), `interface Empty {}` — is tsc's TOP type over non-nullish
-    // values: every number, string, record, array, function, or class
-    // instance is assignable into the slot, so the exact-record stance
-    // cannot hold it. It lowers like `unknown` (the dyn), the same rule
-    // as `object` and the lib's `Object`: assignments convert at the site
-    // (sources outside the checked-dynamic tree fence there, exactly as unknown does), reads
-    // narrow back out through the same checked casts. The type INFERRED
-    // from an empty object literal (`const o = {}`) stays the empty record
-    // — it describes a value the program built, not an annotation that
-    // admits everything — and computed empties (`Partial<T>` in a generic
-    // body) returned null above. Empty shapes WITH an index signature
-    // (`Record<string, T>`) are not empty: the signature is the shape.
+    // An empty object type — `{}` (spelled, the checker's shared
+    // intrinsic, or inferred from an empty object literal), `interface
+    // Empty {}` — is tsc's TOP type over non-nullish values: every number,
+    // string, record, array, function, or class instance is assignable
+    // into the slot, so the exact-record stance cannot hold it. It lowers
+    // like `unknown` (the dyn), the same rule as `object` and the lib's
+    // `Object`: assignments convert at the site (sources outside the
+    // checked-dynamic tree fence there, exactly as unknown does), reads
+    // narrow back out through the same checked casts. A literal's inferred
+    // `{}` is no exception: union subtype reduction folds primitives into
+    // it (`["12", {}]` is `{}[]`, `flag ? "x" : {}` is `{}`), and `let o =
+    // {}` admits `o = "x"`. As an arm beside another non-nullish arm (the
+    // union was not reduced, `string | {} | DataView`) it holds only the
+    // literal's objects and stays the empty record (emptyLiteralArm).
+    // Computed empties (`Partial<T>` in a generic body) returned null
+    // above. Empty shapes WITH an index signature (`Record<string, T>`) are
+    // not empty: the signature is the shape.
     if (
       props.length === 0 &&
       indexValue === undefined &&
       checker.getCallSignatures(widened).length === 0 &&
       checker.getConstructSignatures(widened).length === 0 &&
-      !(anonSym !== undefined && anonSym.declarations.some((d) => ts.isObjectLiteralExpression(d)))
+      !(ctx.emptyLiteralArm && isEmptyObjectLiteralType(widened, ctx))
     ) {
       return DYN;
     }
@@ -8154,3 +8185,19 @@ function innerBlockedMember(
   }
   return here;
 }
+
+/** The type tsc infers from an empty object literal (`{}` written as a
+ * value): no members, index signatures or signatures, declared by an object
+ * literal expression. */
+function isEmptyObjectLiteralType(type: ts.Type, ctx: TypeMapperCtx): boolean {
+  const { checker } = ctx;
+  const symbol = type.getSymbol();
+  return (
+    symbol !== undefined &&
+    symbol.declarations.some((d) => ts.isObjectLiteralExpression(d)) &&
+    checker.getPropertiesOfType(type).length === 0 &&
+    checker.getIndexInfosOfType(type).length === 0 &&
+    checker.getCallSignatures(type).length === 0 &&
+    checker.getConstructSignatures(type).length === 0
+  );
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6909-empty-object-type-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6909-empty-object-type-values.ts.json
new file mode 100644
index 000000000..e94a525ad
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6909-empty-object-type-values.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6909-empty-object-type-values.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6910-empty-object-type-values-js.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6910-empty-object-type-values-js.mjs.json
new file mode 100644
index 000000000..1e07899f1
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6910-empty-object-type-values-js.mjs.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6910-empty-object-type-values-js.mjs"
+ ],
+ "diags": []
+}
diff --git a/tests/corpus/6909-empty-object-type-values.ts b/tests/corpus/6909-empty-object-type-values.ts
new file mode 100644
index 000000000..b539415fd
--- /dev/null
+++ b/tests/corpus/6909-empty-object-type-values.ts
@@ -0,0 +1,32 @@
+// The empty object type `{}` admits every non-nullish value, including when
+// tsc infers it from an empty object literal: union subtype reduction folds
+// primitives into it (`["12", {}]` is `{}[]`, `flag ? "x" : {}` is `{}`), and
+// a `let` initialized with `{}` takes any later non-nullish value.
+const flag = Math.random() < 2;
+
+const mixed = ["12", {}];
+console.log(mixed.length, typeof mixed[0], typeof mixed[1]);
+
+const marker = {};
+const list = [marker, "x", 3, true, [1]];
+console.log(list.length, list[0] === marker, list.map((x) => typeof x).join(","));
+
+const holder = { value: flag ? "x" : {} };
+const picked = flag ? "y" : {};
+console.log(typeof holder.value, typeof picked, holder.value, picked);
+
+let slot = {};
+console.log(JSON.stringify(slot));
+slot = "now a string";
+console.log(typeof slot, slot);
+slot = 42;
+console.log(typeof slot, slot);
+
+function choose(n: number) {
+  if (n > 0) return "positive";
+  return {};
+}
+console.log(typeof choose(1), typeof choose(-1));
+
+const empty = {};
+console.log(JSON.stringify(empty), Object.keys(empty).length, empty === empty, String(empty));
diff --git a/tests/corpus/6910-empty-object-type-values-js.mjs b/tests/corpus/6910-empty-object-type-values-js.mjs
new file mode 100644
index 000000000..3c6803556
--- /dev/null
+++ b/tests/corpus/6910-empty-object-type-values-js.mjs
@@ -0,0 +1,14 @@
+// In a JavaScript file, an array literal mixing strings, other primitives and
+// an empty object holds each value as written.
+const a = ["12", {}];
+console.log(a.length, typeof a[0], typeof a[1]);
+
+const b = ["12", "", true, null, undefined, [7], {}];
+console.log(b.length, b.map((x) => (x === null ? "null" : typeof x)).join(","));
+
+const options = [{}, "fallback"];
+for (const option of options) console.log(typeof option === "string" ? option : JSON.stringify(option));
+
+let current = {};
+current = "replaced";
+console.log(current);
diff --git a/tests/harness/__snapshots__/index-signature-values.ts.txt b/tests/harness/__snapshots__/index-signature-values.ts.txt
index d1e9395ed..bbbed7fe2 100644
--- a/tests/harness/__snapshots__/index-signature-values.ts.txt
+++ b/tests/harness/__snapshots__/index-signature-values.ts.txt
@@ -7,15 +7,6 @@ index-signature-values.ts:8:7 - error SC2006: values of type '{ [s: symbol]: num
 
   hint: string- and number-keyed index signatures over the supported value types compile directly; symbol keys and dual signatures with unequal value types have no lowering
 
-index-signature-values.ts:9:13 - error SC2004: uses of 'bySymbol' inherit the blocker on its declaration
-
-   8 | const bySymbol: { [s: symbol]: number } = {};
-   9 | console.log(bySymbol);
-     |             ^~~~~~~~
-  10 | 
-
-  hint: the declaration of 'bySymbol' did not compile — fix the diagnostic reported there and these sites clear with it
-
 index-signature-values.ts:13:13 - error SC1090: console.log of '{ [key: string]: Uint8Array }' values (Uint8Array and Buffer values inside composites have no inspect lowering yet (Buffer's <Buffer ..> form vs Uint8Array's is not recorded in the static type here)) are not supported yet
 
   12 | const buffers: Record<string, Uint8Array> = {};
@@ -30,13 +21,4 @@ index-signature-values.ts:18:7 - error SC2006: values of type '{ [k: string]: st
      |       ^~~~
   19 | console.log(dual);
 
-  hint: string- and number-keyed index signatures over the supported value types compile directly; symbol keys and dual signatures with unequal value types have no lowering
-
-index-signature-values.ts:19:13 - error SC2004: uses of 'dual' inherit the blocker on its declaration
-
-  18 | const dual: { [k: string]: string | number; [n: number]: number } = {};
-  19 | console.log(dual);
-     |             ^~~~
-  20 | 
-
-  hint: the declaration of 'dual' did not compile — fix the diagnostic reported there and these sites clear with it
\ No newline at end of file
+  hint: string- and number-keyed index signatures over the supported value types compile directly; symbol keys and dual signatures with unequal value types have no lowering
\ No newline at end of file
diff --git a/tests/harness/__snapshots__/retired-engine-2104-computed-key-destructuring.ts.txt b/tests/harness/__snapshots__/retired-engine-2104-computed-key-destructuring.ts.txt
index bb30cf581..b5417ae72 100644
--- a/tests/harness/__snapshots__/retired-engine-2104-computed-key-destructuring.ts.txt
+++ b/tests/harness/__snapshots__/retired-engine-2104-computed-key-destructuring.ts.txt
@@ -7,18 +7,11 @@ retired-engine-2104-computed-key-destructuring.ts:30:38 - error SC2009: values o
 
   hint: the outer shape is supported — the named component is the blocker; restate it inside the compilable set (number, string, boolean, arrays, Maps, Sets, RegExp, functions, classes, records, unions of those, and 'unknown')
 
-retired-engine-2104-computed-key-destructuring.ts:33:8 - error SC1031: destructuring with computed keys that do not fold to one property name is not supported yet
-
-  32 | traceS = "";
-  33 | let [{ [order(1)]: y } = order(0)] = [{}];
-     |        ^~~~~~~~~~~~~
-  34 | console.log(traceS);
-
-retired-engine-2104-computed-key-destructuring.ts:36:7 - error SC1031: destructuring with computed keys that do not fold to one property name is not supported yet
+retired-engine-2104-computed-key-destructuring.ts:36:58 - error SC1031: destructuring declaration from an `any` source whose expression spelling is unsupported (use a variable, ordinary property chain, or ordinary call) is not supported yet
 
   35 | traceS = "";
   36 | let { [order(0)]: { [order(2)]: z } = order(1), ...w } = {} as any;
-     |       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     |                                                          ^~~~~~~~~
   37 | console.log(traceS);
 
 retired-engine-2104-computed-key-destructuring.ts:39:8 - error SC1031: rest bindings whose packed type has no static mapping (only plain record types pack) is not supported yet
diff --git a/tests/harness/__snapshots__/utility-types.ts.txt b/tests/harness/__snapshots__/utility-types.ts.txt
index 71f4d3083..02595967b 100644
--- a/tests/harness/__snapshots__/utility-types.ts.txt
+++ b/tests/harness/__snapshots__/utility-types.ts.txt
@@ -7,15 +7,6 @@ utility-types.ts:15:7 - error SC2006: values of type '{ [s: symbol]: string; }'
 
   hint: string- and number-keyed index signatures over the supported value types compile directly; symbol keys and dual signatures with unequal value types have no lowering
 
-utility-types.ts:16:13 - error SC2004: uses of 'bySymbol' inherit the blocker on its declaration
-
-  15 | const bySymbol: { [s: symbol]: string } = {};
-  16 | console.log(bySymbol);
-     |             ^~~~~~~~
-  17 | 
-
-  hint: the declaration of 'bySymbol' did not compile — fix the diagnostic reported there and these sites clear with it
-
 utility-types.ts:18:7 - error SC2006: values of type '{ [k: string]: Date; }' cannot be compiled: this index signature is outside the supported shape (string or number keys; values limited to numbers, strings, booleans, records, classes, arrays, unions, functions, Maps, Sets, RegExps, Promises, or 'unknown')
 
   17 | 
@@ -23,13 +14,4 @@ utility-types.ts:18:7 - error SC2006: values of type '{ [k: string]: Date; }' ca
      |       ^~~~~~~
   19 | const boot = dateBag["boot"];
 
-  hint: string- and number-keyed index signatures over the supported value types compile directly; symbol keys and dual signatures with unequal value types have no lowering
-
-utility-types.ts:19:14 - error SC2004: uses of 'dateBag' inherit the blocker on its declaration
-
-  18 | const dateBag: { [k: string]: Date } = {};
-  19 | const boot = dateBag["boot"];
-     |              ^~~~~~~
-  20 | console.log(boot);
-
-  hint: the declaration of 'dateBag' did not compile — fix the diagnostic reported there and these sites clear with it
\ No newline at end of file
+  hint: string- and number-keyed index signatures over the supported value types compile directly; symbol keys and dual signatures with unequal value types have no lowering
\ No newline at end of file

From 70aed0f1339e455140c436fcfc158fe3d25a72ef Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 17:17:02 -0500
Subject: [PATCH 34/67] Walk a file once for the references of its function
 declarations

---
 .../src/frontend/lowering/var-hoisting.ts     | 47 +++++++++++++++++--
 1 file changed, 43 insertions(+), 4 deletions(-)

diff --git a/packages/compiler/src/frontend/lowering/var-hoisting.ts b/packages/compiler/src/frontend/lowering/var-hoisting.ts
index 6276ab671..3f950f3ca 100644
--- a/packages/compiler/src/frontend/lowering/var-hoisting.ts
+++ b/packages/compiler/src/frontend/lowering/var-hoisting.ts
@@ -41,7 +41,10 @@ export function earlyReadVarSymbols(
     if (sf.isDeclarationFile) continue;
     const bindings = new Map<ts.Symbol, Binding>();
     const names = new Set<string>();
+    const functionNames = new Set<string>();
     ts.walkPreorder(sf, (node) => {
+      if (ts.isFunctionDeclaration(node) && node.name !== undefined)
+        functionNames.add(node.name.text);
       if (!ts.isVariableDeclarationList(node)) return undefined;
       if ((node.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const | ts.NodeFlags.Using)) !== 0)
         return undefined;
@@ -66,7 +69,7 @@ export function earlyReadVarSymbols(
     });
     if (bindings.size === 0) continue;
     const refs = referencesByName(lowerer, sf, names);
-    const analysis = new ScopeAnalysis(lowerer, sf);
+    const analysis = new ScopeAnalysis(lowerer, sf, functionNames);
     for (const [symbol, binding] of bindings) {
       const settle = analysis.settleIndex(binding.scope, symbol);
       const early = (refs.get(symbol) ?? []).some(
@@ -151,6 +154,31 @@ function referencesByName(
     if (ts.isIdentifier(node) && names.has(node.text)) idents.push(node);
     return undefined;
   });
+  return referencesBySymbol(lowerer, idents);
+}
+
+/** The identifiers of `sf` named in `names`, by name, each list in source
+ * order. */
+function identifiersByName(
+  sf: ts.SourceFile,
+  names: ReadonlySet<string>,
+): Map<string, ts.Identifier[]> {
+  const out = new Map<string, ts.Identifier[]>();
+  ts.walkPreorder(sf, (node) => {
+    if (!ts.isIdentifier(node) || !names.has(node.text)) return undefined;
+    const list = out.get(node.text);
+    if (list) list.push(node);
+    else out.set(node.text, [node]);
+    return undefined;
+  });
+  return out;
+}
+
+/** `idents` by resolved symbol, each list in the order of `idents`. */
+function referencesBySymbol(
+  lowerer: Lowerer,
+  idents: readonly ts.Identifier[],
+): Map<ts.Symbol, ts.Identifier[]> {
   lowerer.checker.prefetchSymbolNodesExact(idents);
   const out = new Map<ts.Symbol, ts.Identifier[]>();
   for (const id of idents) {
@@ -173,10 +201,14 @@ class ScopeAnalysis {
    * its own body names is never called through that name). */
   private readonly functionMemo = new Map<string, boolean>();
   private readonly functionRefs = new Map<ts.Node, ts.Identifier[]>();
+  /** The file's identifiers named like one of its function declarations,
+   * by name, collected in one walk on first use. */
+  private functionNameIdents: Map<string, ts.Identifier[]> | null = null;
 
   constructor(
     private readonly lowerer: Lowerer,
     private readonly sf: ts.SourceFile,
+    private readonly functionNames: ReadonlySet<string>,
   ) {
     this.js = isJsSourceFile(sf);
   }
@@ -263,12 +295,19 @@ class ScopeAnalysis {
     const refs =
       symbol === undefined
         ? []
-        : (referencesByName(this.lowerer, this.sf, new Set([name.text])).get(symbol) ?? []).filter(
-            (ref) => ref !== name,
-          );
+        : (
+            referencesBySymbol(this.lowerer, this.identifiersNamed(name.text)).get(symbol) ?? []
+          ).filter((ref) => ref !== name);
     this.functionRefs.set(fn, refs);
     return refs;
   }
+
+  /** The identifiers named `text`, the name of a function declaration of
+   * the file. */
+  private identifiersNamed(text: string): readonly ts.Identifier[] {
+    this.functionNameIdents ??= identifiersByName(this.sf, this.functionNames);
+    return this.functionNameIdents.get(text) ?? [];
+  }
 }
 
 /** A loop statement that settles the binding settles the references in

From a7a42640dcaf6a9eb17fb1d5d4abe4bd4ce791ea Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 17:17:15 -0500
Subject: [PATCH 35/67] Stop the type-parameter walk at recursive aliases in
 signatures

mentionsTypeParameter walked union constituents and type arguments
without remembering the types on its path. A parameter typed with an
alias that reaches itself through its own type arguments, such as
`type Tree = string | Tree[]` in `function f<T>(x: T, ...trees:
Tree[])`, recursed until the compiler ran out of stack. The walk now
skips a type it has already entered; a type parameter reached through
any other path is still found.
---
 .../src/frontend/lowering/call-signatures.ts  | 12 ++++++--
 ...-recursive-alias-generic-signature.ts.json |  6 ++++
 .../6823-recursive-alias-generic-signature.ts | 29 +++++++++++++++++++
 ...-recursive-alias-generic-signature.ts.json |  1 +
 4 files changed, 46 insertions(+), 2 deletions(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6823-recursive-alias-generic-signature.ts.json
 create mode 100644 tests/corpus/6823-recursive-alias-generic-signature.ts
 create mode 100644 tests/harness/corpus-costs/6823-recursive-alias-generic-signature.ts.json

diff --git a/packages/compiler/src/frontend/lowering/call-signatures.ts b/packages/compiler/src/frontend/lowering/call-signatures.ts
index 4e1ece0e9..34343ad27 100644
--- a/packages/compiler/src/frontend/lowering/call-signatures.ts
+++ b/packages/compiler/src/frontend/lowering/call-signatures.ts
@@ -546,9 +546,17 @@ export function paramShapes(
 
 /** A declared type that is (or is a union over) a bare type parameter
  * or an instantiation of a generic alias/interface over type arguments. */
-function mentionsTypeParameter(lowerer: Lowerer, t: ts.Type): boolean {
+function mentionsTypeParameter(
+  lowerer: Lowerer,
+  t: ts.Type,
+  seen: Set<ts.Type> = new Set(),
+): boolean {
   if (t.flags & ts.TypeFlags.TypeParameter) return true;
-  const mentions = (part: ts.Type): boolean => mentionsTypeParameter(lowerer, part);
+  // A recursive alias (`type Child = string | Child[]`) reaches itself
+  // through its own type arguments; a type already on the walk adds nothing.
+  if (seen.has(t)) return false;
+  seen.add(t);
+  const mentions = (part: ts.Type): boolean => mentionsTypeParameter(lowerer, part, seen);
   if (t.isUnionType()) return ts.constituentTypes(t).some(mentions);
   if (t.getAliasTypeArguments().some(mentions)) return true;
   return (
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6823-recursive-alias-generic-signature.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6823-recursive-alias-generic-signature.ts.json
new file mode 100644
index 000000000..3185f3606
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6823-recursive-alias-generic-signature.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6823-recursive-alias-generic-signature.ts"
+ ],
+ "diags": []
+}
diff --git a/tests/corpus/6823-recursive-alias-generic-signature.ts b/tests/corpus/6823-recursive-alias-generic-signature.ts
new file mode 100644
index 000000000..1019371d7
--- /dev/null
+++ b/tests/corpus/6823-recursive-alias-generic-signature.ts
@@ -0,0 +1,29 @@
+// Generic functions whose parameters use a recursive type alias: the alias
+// reaches itself through its own type arguments (`Tree[]` inside `Tree`).
+type Tree = string | number | Tree[];
+type Json = null | boolean | number | string | Json[];
+
+function flatten<T>(label: T, ...trees: Tree[]): (T | string | number)[] {
+  const out: (T | string | number)[] = [label];
+  const visit = (tree: Tree): void => {
+    if (Array.isArray(tree)) tree.forEach(visit);
+    else out.push(tree);
+  };
+  trees.forEach(visit);
+  return out;
+}
+
+function tagged<K extends string>(key: K, value: Json): { key: K; text: string } {
+  return { key, text: JSON.stringify(value) };
+}
+
+function depth<T>(value: T, tree: Tree): [T, number] {
+  const measure = (node: Tree): number =>
+    Array.isArray(node) ? 1 + Math.max(0, ...node.map(measure)) : 0;
+  return [value, measure(tree)];
+}
+
+console.log(flatten("root", "a", [1, ["b", [2]]], []).join(","));
+console.log(flatten(7, [[["deep"]]]).join(","));
+console.log(tagged("config", [1, "two", null, [true, [false]]]));
+console.log(depth("x", [[1], [[2, [3]]]]), depth(0, "leaf"));
diff --git a/tests/harness/corpus-costs/6823-recursive-alias-generic-signature.ts.json b/tests/harness/corpus-costs/6823-recursive-alias-generic-signature.ts.json
new file mode 100644
index 000000000..cf7a32433
--- /dev/null
+++ b/tests/harness/corpus-costs/6823-recursive-alias-generic-signature.ts.json
@@ -0,0 +1 @@
+{ "plain": 2300, "san": 30000 }

From 8061060aff85fb8835be6060d36737a9a58e98ab Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 17:20:50 -0500
Subject: [PATCH 36/67] Lower a Buffer view of a dynamic typed-array value

---
 .../src/frontend/lowering/containers/bytes.ts |  3 +-
 ...2-js-buffer-view-of-declared-field.js.json |  6 +++
 .../6942-js-buffer-view-of-declared-field.js  | 39 +++++++++++++++++++
 ...2-js-buffer-view-of-declared-field.js.json |  1 +
 4 files changed, 48 insertions(+), 1 deletion(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6942-js-buffer-view-of-declared-field.js.json
 create mode 100644 tests/corpus/6942-js-buffer-view-of-declared-field.js
 create mode 100644 tests/harness/corpus-costs/6942-js-buffer-view-of-declared-field.js.json

diff --git a/packages/compiler/src/frontend/lowering/containers/bytes.ts b/packages/compiler/src/frontend/lowering/containers/bytes.ts
index 438c5e6c6..bf9821d31 100644
--- a/packages/compiler/src/frontend/lowering/containers/bytes.ts
+++ b/packages/compiler/src/frontend/lowering/containers/bytes.ts
@@ -1972,7 +1972,8 @@ function lowerBufferStaticValue(
       const srcNode = args[0].expression;
       const srcIr = lowerer.mapTypeOf(lowerer.typeOf(srcNode));
       if (srcIr?.kind === "bytes") {
-        const receiver = lowerer.lowerExpr(srcNode);
+        // A JavaScript field can hold the typed array as a dynamic value.
+        const receiver = lowerer.lowerExprExpecting(srcNode, srcIr);
         const idxArgs = args.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
         return {
           kind: "bytesIntrinsic",
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6942-js-buffer-view-of-declared-field.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6942-js-buffer-view-of-declared-field.js.json
new file mode 100644
index 000000000..f23e96cb8
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6942-js-buffer-view-of-declared-field.js.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6942-js-buffer-view-of-declared-field.js"
+ ],
+ "diags": []
+}
diff --git a/tests/corpus/6942-js-buffer-view-of-declared-field.js b/tests/corpus/6942-js-buffer-view-of-declared-field.js
new file mode 100644
index 000000000..521e39b76
--- /dev/null
+++ b/tests/corpus/6942-js-buffer-view-of-declared-field.js
@@ -0,0 +1,39 @@
+// A Buffer view over a typed array that a JavaScript class keeps in a
+// declared field without an initializer: the field holds a dynamic value,
+// and the view shares the array's storage.
+
+class Units {
+  text;
+  chars;
+  constructor(text, onDemand) {
+    this.text = text;
+    if (onDemand) this.chars = new Uint16Array(text.length + 4);
+    else this.chars = toUnits(text);
+  }
+  load(from, to) {
+    Buffer.from(this.chars.buffer, from * 2, (to - from) * 2).write(
+      this.text.substring(from, to),
+      "utf16le",
+    );
+    return this.chars[from];
+  }
+}
+
+function toUnits(text) {
+  const units = new Uint16Array(text.length + 4);
+  for (let i = 0; i < text.length; i++) units[i] = text.charCodeAt(i);
+  return units;
+}
+
+const lazy = new Units("hello", true);
+console.log(lazy.chars[1], lazy.load(1, 3), lazy.chars[2], lazy.chars[3]);
+const view = Buffer.from(lazy.chars.buffer, 2, 4);
+view[0] = 0x41;
+console.log(lazy.chars[1], view.length, view.toString("utf16le"));
+const eager = new Units("yo", false);
+console.log(eager.chars[0], eager.load(0, 2));
+try {
+  Buffer.from(lazy.chars.buffer, 64, 2);
+} catch (error) {
+  console.log(error.name);
+}
diff --git a/tests/harness/corpus-costs/6942-js-buffer-view-of-declared-field.js.json b/tests/harness/corpus-costs/6942-js-buffer-view-of-declared-field.js.json
new file mode 100644
index 000000000..be69de5f7
--- /dev/null
+++ b/tests/harness/corpus-costs/6942-js-buffer-view-of-declared-field.js.json
@@ -0,0 +1 @@
+{ "plain": 2200, "san": 2900 }

From 095072594971defdb9c82d78c8fcd993395758d1 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 17:24:17 -0500
Subject: [PATCH 37/67] Refuse elements on Array.prototype

---
 packages/runtime/src/scr_dyn.h        |  5 +++
 packages/runtime/src/scr_dyn_invoke.c |  4 +++
 packages/runtime/src/scr_json.c       | 12 +++++++
 tests/harness/errors.test.ts          | 50 +++++++++++++++++++++++++++
 4 files changed, 71 insertions(+)

diff --git a/packages/runtime/src/scr_dyn.h b/packages/runtime/src/scr_dyn.h
index 0783ff705..d36c0d263 100644
--- a/packages/runtime/src/scr_dyn.h
+++ b/packages/runtime/src/scr_dyn.h
@@ -997,6 +997,11 @@ ScrDyn *scr_dyn_get_own_property_descriptor(ScrDyn *target, ScrDyn *key);
 ScrDyn *scr_dyn_array_proto_call(ScrDyn *target, ScrStr *method, ScrDyn *args);
 ScrDyn *scr_dyn_array_prototype(void); /* +1, installs native method adapters */
 ScrDyn *scr_dyn_array_prototype_base(void); /* +1, shared native array identity */
+/* Native arrays read their holes as undefined without consulting
+ * Array.prototype, so storing an element on Array.prototype raises SC2020.
+ * True (with the error pending) when `recv` is Array.prototype. */
+bool scr_dyn_array_prototype_element_fence(const ScrDyn *recv);
+bool scr_dyn_is_array_prototype(const ScrDyn *d);
 /* The checked-dynamic keyed WRITE (`h.k = v` on a dyn receiver): OBJ sets
  * the member (JS: later writes win, insertion order); undefined/null and
  * non-object kinds throw Node's catchable TypeErrors (strict-mode
diff --git a/packages/runtime/src/scr_dyn_invoke.c b/packages/runtime/src/scr_dyn_invoke.c
index ffe1d0330..2a010f213 100644
--- a/packages/runtime/src/scr_dyn_invoke.c
+++ b/packages/runtime/src/scr_dyn_invoke.c
@@ -811,6 +811,10 @@ static ScrDyn *scr_dyn_invoke_impl(
   if (recv->kind == SCR_DYN_HANDLE) {
     return scr_dynh_dispatch(recv, method, args, argc, what);
   }
+  if (scr_dyn_is_array_prototype(recv) && dyn_arr_proto_mutates(method)) {
+    scr_dyn_array_prototype_element_fence(recv);
+    return NULL;
+  }
 
 
   if (recv->kind == SCR_DYN_PROXY) {
diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c
index adcc96560..9fae63ba7 100644
--- a/packages/runtime/src/scr_json.c
+++ b/packages/runtime/src/scr_json.c
@@ -674,6 +674,17 @@ void scr_dyn_from_leave(void) {
  */
 static SCR_TL ScrDyn *scr_builtin_array_prototype;
 
+bool scr_dyn_is_array_prototype(const ScrDyn *d) {
+  return d && d == scr_builtin_array_prototype;
+}
+
+bool scr_dyn_array_prototype_element_fence(const ScrDyn *recv) {
+  if (!scr_dyn_is_array_prototype(recv)) return false;
+  static const char message[] = "Elements on Array.prototype are not supported yet";
+  scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020");
+  return true;
+}
+
 /* Property names are immutable and often repeated across simultaneously live
  * objects. Entries own references to their bytes; this fixed weak table owns
  * none. Collisions only reduce sharing, and the final release removes a weak
@@ -8527,6 +8538,7 @@ void scr_dyn_key_set(ScrDyn *recv, ScrStr *key, ScrDyn *value) {
       else idx = idx * 10 + (size_t)(key->data[i] - '0');
     }
     if (is_index && idx < 4294967295ULL) {
+      if (scr_dyn_array_prototype_element_fence(recv)) return;
       if (recv->v.arr.frozen && idx < recv->v.arr.len) {
         static const char message[] = "Cannot assign to read only property";
         scr_throw_error_msg(SCR_ERR_TYPE, message, sizeof message - 1);
diff --git a/tests/harness/errors.test.ts b/tests/harness/errors.test.ts
index e1e2bb96c..8af6998ca 100644
--- a/tests/harness/errors.test.ts
+++ b/tests/harness/errors.test.ts
@@ -1727,3 +1727,53 @@ console.log(util.inspect(extra));
     );
   });
 });
+
+describe("elements on Array.prototype", () => {
+  // Holes of native arrays read undefined without consulting
+  // Array.prototype, so storing an element there refuses instead of
+  // letting later hole reads diverge from Node. Named members stay
+  // writable.
+  test("an index write is a named fence (TS lane)", async () => {
+    const r = await compileAndRun(
+      "array-prototype-element-ts",
+      `const proto = Array.prototype as unknown as Record<string, unknown>;
+proto.label = "named";
+console.log(proto.label);
+(Array.prototype as unknown as Record<number, unknown>)[1] = "proto";
+console.log("unreachable");
+`,
+    );
+    expect(r.exitCode).toBe(1);
+    expect(r.stdout).toBe("named\n");
+    expect(r.stderr).toMatch(
+      /^Uncaught Error: Elements on Array\.prototype are not supported yet \[SC2020[^\]]*\]\n$/,
+    );
+  });
+
+  test("an index write and a mutating method are named fences (JS lane)", async () => {
+    const write = await compileAndRun(
+      "array-prototype-element-js",
+      `Array.prototype[0] = "proto";
+console.log("unreachable");
+`,
+      "cjs",
+    );
+    expect(write.exitCode).toBe(1);
+    expect(write.stdout).toBe("");
+    expect(write.stderr).toMatch(
+      /^Uncaught Error: Elements on Array\.prototype are not supported yet \[SC2020[^\]]*\]\n$/,
+    );
+    const push = await compileAndRun(
+      "array-prototype-push-js",
+      `Array.prototype.push("proto");
+console.log("unreachable");
+`,
+      "cjs",
+    );
+    expect(push.exitCode).toBe(1);
+    expect(push.stdout).toBe("");
+    expect(push.stderr).toMatch(
+      /^Uncaught Error: Elements on Array\.prototype are not supported yet \[SC2020[^\]]*\]\n$/,
+    );
+  });
+});

From 79a7120e5fcf38505150488289fa36cb2765842a Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 17:31:02 -0500
Subject: [PATCH 38/67] Speed up JSON.parse and JSON.stringify scanning

- The number and whitespace scanners keep the cursor in locals and write
  p->pos once: the runtime builds without strict aliasing, so a loop on
  p->pos stored it after every byte.
- Typed arrays gather parsed elements in a 32-slot run and append them
  with scr_arr_push_many instead of one push per element.
- The string scan shared by parse and stringify takes the index of the
  first quote, backslash or control byte from the marked word on
  little-endian hosts, and checks the last 1-7 bytes of a string as one
  word, so a short plain string needs no byte loop.
- Typed record parsing computes once per record schema and parse which
  field names hold no byte JSON would escape, instead of testing the
  name on every direct key match.
- The mantissa converts to double through int64, and the positioned
  error report stays out of line.
---
 packages/runtime/src/scr_json.c | 196 ++++++++++++++++++++++----------
 1 file changed, 139 insertions(+), 57 deletions(-)

diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c
index 9fae63ba7..89c098fa6 100644
--- a/packages/runtime/src/scr_json.c
+++ b/packages/runtime/src/scr_json.c
@@ -311,9 +311,10 @@ void scr_jb_put_f64(ScrJsonBuf *b, double v) {
 
 /* Find the next quote, backslash or control byte. memcpy keeps the word
  * loads unaligned-safe, and the length guard never reads past the input.
- * The masks only decide whether to inspect a word byte by byte: borrow
- * propagation may mark extra lanes, so it must not determine a byte index.
- * High UTF-8 bytes are ordinary data, independent of host byte order. */
+ * Borrow propagation can mark extra lanes, but only above a lane that
+ * holds a special byte, so on little-endian hosts the lowest marked lane
+ * is the answer; other hosts inspect the marked word byte by byte. High
+ * UTF-8 bytes are ordinary data. */
 static size_t scr_json_plain_bytes(const char *data, size_t len) {
   const uint64_t ones = UINT64_C(0x0101010101010101);
   const uint64_t high = UINT64_C(0x8080808080808080);
@@ -326,9 +327,41 @@ static size_t scr_json_plain_bytes(const char *data, size_t len) {
     uint64_t special = ((quotes - ones) & ~quotes) |
                        ((slashes - ones) & ~slashes) |
                        ((word - ones * 0x20) & ~word);
-    if (special & high) break;
+    special &= high;
+    if (special) {
+#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+      /* A borrow only marks lanes above a lane that really matched, so
+       * the lowest marked lane is the first special byte. */
+      return i + (size_t)__builtin_ctzll(special) / 8;
+#else
+      break;
+#endif
+    }
     i += sizeof word;
   }
+  /* The last 1..7 bytes as one word: two overlapping 4-byte loads, or the
+   * first, middle and last byte of a shorter rest with the remaining lanes
+   * filled with a plain byte. A plain rest (the common case: most strings
+   * are short) ends the scan; otherwise the bytes are inspected one by one. */
+  size_t rest = len - i;
+  if (rest) {
+    uint64_t word;
+    if (rest >= 4) {
+      uint32_t lo, hi;
+      memcpy(&lo, data + i, sizeof lo);
+      memcpy(&hi, data + len - 4, sizeof hi);
+      word = (uint64_t)lo | (uint64_t)hi << 32;
+    } else {
+      word = (uint64_t)(unsigned char)data[i] | (uint64_t)(unsigned char)data[i + rest / 2] << 8 |
+             (uint64_t)(unsigned char)data[len - 1] << 16 | UINT64_C(0x4141414141000000);
+    }
+    uint64_t quotes = word ^ (ones * '"');
+    uint64_t slashes = word ^ (ones * '\\');
+    uint64_t special = ((quotes - ones) & ~quotes) |
+                       ((slashes - ones) & ~slashes) |
+                       ((word - ones * 0x20) & ~word);
+    if (!(special & high)) return len;
+  }
   while (i < len) {
     unsigned char c = (unsigned char)data[i];
     if (c < 0x20 || c == '"' || c == '\\') break;
@@ -9008,6 +9041,11 @@ typedef struct {
   ScrDynRegion *region; /* tags completed containers (ScrDynRegion); may be NULL */
   struct ScrJsonShape *shapes; /* key-sequence transitions (scr_json_object) */
   uint32_t nshapes, shape_cap;
+  /* Schema records whose plain field names are known (scr_jschema_plain):
+   * bit i of the mask is set when field i's name holds no byte JSON text
+   * would escape. */
+  const struct ScrJsonSchema *plain_schema[4];
+  uint64_t plain_mask[4];
 } ScrJsonP;
 
 static void scr_json_throw(const ScrJsonP *p, const char *msg) {
@@ -9015,7 +9053,10 @@ static void scr_json_throw(const ScrJsonP *p, const char *msg) {
   scr_throw_error_msg(SCR_ERR_SYNTAX, msg, strlen(msg));
 }
 
-static void scr_json_throw_pos(const ScrJsonP *p, const char *what, size_t pos) {
+/* Errors stay out of line so the scanners that report them keep their
+ * registers for the common path. */
+static __attribute__((noinline, cold)) void scr_json_throw_pos(const ScrJsonP *p, const char *what,
+                                                               size_t pos) {
   if (p->quiet) return;
   char buf[128];
   int n = snprintf(buf, sizeof buf, "%s in JSON at position %zu", what, pos);
@@ -9036,11 +9077,15 @@ static void scr_json_throw_token(const ScrJsonP *p) {
 }
 
 static void scr_json_ws(ScrJsonP *p) {
-  while (p->pos < p->len) {
-    char c = p->s[p->pos];
-    if (c == ' ' || c == '\t' || c == '\n' || c == '\r') p->pos++;
+  /* A local cursor, as in scr_json_number_value. */
+  const char *s = p->s;
+  size_t pos = p->pos;
+  while (pos < p->len) {
+    char c = s[pos];
+    if (c == ' ' || c == '\t' || c == '\n' || c == '\r') pos++;
     else break;
   }
+  p->pos = pos;
 }
 
 /* Append the WTF-8 encoding of a code point or lone surrogate unit; a low
@@ -9191,7 +9236,14 @@ static const double scr_json_pow10[23] = {
  * (thrown unless quiet). Shared by the dyn tree and the schema parser so
  * both produce bit-identical values. */
 static bool scr_json_number_value(ScrJsonP *p, double *out) {
-  size_t start = p->pos;
+  /* The cursor and text stay in locals: the runtime builds without strict
+   * aliasing, so a byte read through p->s could alias p->pos, and a loop
+   * on p->pos would store it on every digit. p->pos is written once, when
+   * the token ends. */
+  const char *s = p->s;
+  const size_t len = p->len;
+  const size_t start = p->pos;
+  size_t pos = start;
   /* Grammar validation and value accumulation in one pass. Clinger's fast
    * path: with at most 15 significant digits the mantissa is exact in a
    * double, and scaling by an exact power of ten (|exp| <= 22) rounds
@@ -9200,35 +9252,37 @@ static bool scr_json_number_value(ScrJsonP *p, double *out) {
   int ndig = 0;   /* significant digits folded into mant */
   int exp10 = 0;  /* decimal exponent (fraction shift + explicit exponent) */
   bool neg = false, precise = true;
-  if (p->s[p->pos] == '-') {
+  if (s[pos] == '-') {
     neg = true;
-    p->pos++;
-    if (p->pos >= p->len || p->s[p->pos] < '0' || p->s[p->pos] > '9') {
-      scr_json_throw_pos(p, "No number after minus sign", p->pos);
+    pos++;
+    if (pos >= len || s[pos] < '0' || s[pos] > '9') {
+      p->pos = pos;
+      scr_json_throw_pos(p, "No number after minus sign", pos);
       return false;
     }
   }
-  if (p->s[p->pos] == '0') {
-    p->pos++;
+  if (s[pos] == '0') {
+    pos++;
   } else {
-    while (p->pos < p->len && p->s[p->pos] >= '0' && p->s[p->pos] <= '9') {
+    while (pos < len && s[pos] >= '0' && s[pos] <= '9') {
       if (ndig < 15) {
-        mant = mant * 10 + (uint64_t)(p->s[p->pos] - '0');
+        mant = mant * 10 + (uint64_t)(s[pos] - '0');
         ndig++;
       } else {
         precise = false;
       }
-      p->pos++;
+      pos++;
     }
   }
-  if (p->pos < p->len && p->s[p->pos] == '.') {
-    p->pos++;
-    if (p->pos >= p->len || p->s[p->pos] < '0' || p->s[p->pos] > '9') {
-      scr_json_throw_pos(p, "Unterminated fractional number", p->pos);
+  if (pos < len && s[pos] == '.') {
+    pos++;
+    if (pos >= len || s[pos] < '0' || s[pos] > '9') {
+      p->pos = pos;
+      scr_json_throw_pos(p, "Unterminated fractional number", pos);
       return false;
     }
-    while (p->pos < p->len && p->s[p->pos] >= '0' && p->s[p->pos] <= '9') {
-      unsigned digit = (unsigned)(p->s[p->pos] - '0');
+    while (pos < len && s[pos] >= '0' && s[pos] <= '9') {
+      unsigned digit = (unsigned)(s[pos] - '0');
       if (mant == 0 && digit == 0) {
         exp10--; /* leading fractional zeros scale without a digit */
       } else if (ndig < 15) {
@@ -9238,29 +9292,33 @@ static bool scr_json_number_value(ScrJsonP *p, double *out) {
       } else {
         precise = false;
       }
-      p->pos++;
+      pos++;
     }
   }
-  if (p->pos < p->len && (p->s[p->pos] == 'e' || p->s[p->pos] == 'E')) {
-    p->pos++;
+  if (pos < len && (s[pos] == 'e' || s[pos] == 'E')) {
+    pos++;
     bool eneg = false;
-    if (p->pos < p->len && (p->s[p->pos] == '+' || p->s[p->pos] == '-')) {
-      eneg = p->s[p->pos] == '-';
-      p->pos++;
+    if (pos < len && (s[pos] == '+' || s[pos] == '-')) {
+      eneg = s[pos] == '-';
+      pos++;
     }
-    if (p->pos >= p->len || p->s[p->pos] < '0' || p->s[p->pos] > '9') {
-      scr_json_throw_pos(p, "Exponent part is missing a number", p->pos);
+    if (pos >= len || s[pos] < '0' || s[pos] > '9') {
+      p->pos = pos;
+      scr_json_throw_pos(p, "Exponent part is missing a number", pos);
       return false;
     }
     int ev = 0;
-    while (p->pos < p->len && p->s[p->pos] >= '0' && p->s[p->pos] <= '9') {
-      if (ev < 100000) ev = ev * 10 + (p->s[p->pos] - '0');
-      p->pos++;
+    while (pos < len && s[pos] >= '0' && s[pos] <= '9') {
+      if (ev < 100000) ev = ev * 10 + (s[pos] - '0');
+      pos++;
     }
     exp10 += eneg ? -ev : ev;
   }
+  p->pos = pos;
   if (precise && exp10 >= -22 && exp10 <= 22) {
-    double v = (double)mant; /* exact: mant < 10^15 < 2^53 */
+    /* exact: mant < 10^15 < 2^53; the signed conversion is one
+     * instruction on x86-64, the unsigned one a sequence */
+    double v = (double)(int64_t)mant;
     if (exp10 > 0) v *= scr_json_pow10[exp10];
     else if (exp10 < 0) v /= scr_json_pow10[-exp10];
     *out = neg ? -v : v;
@@ -9270,7 +9328,7 @@ static bool scr_json_number_value(ScrJsonP *p, double *out) {
    * grammar above is a strict subset of what strtod accepts). The ScrStr
    * data is NUL-terminated, and strtod stops at the first non-number char,
    * so parsing from `start` reads exactly the validated token. */
-  *out = strtod(p->s + start, NULL);
+  *out = strtod(s + start, NULL);
   return true;
 }
 
@@ -9867,26 +9925,38 @@ static __attribute__((noinline)) bool scr_jschema_absent(const ScrJsonSchema *s,
   return true;
 }
 
-/* The quoted key at p->pos when it is exactly `f`'s name, written without
- * escapes: the bytes consumed (name length + 2), else 0. Names of more
- * than eight bytes, and names holding a byte JSON text would escape,
- * take the general key scan. */
+/* Bit i set when field i's name (at most eight bytes) holds no quote,
+ * backslash or control byte, so text that spells it unescaped is exactly
+ * that key. Names are schema constants: each record schema computes its
+ * mask once per parse, in a four-entry table. */
+static uint64_t scr_jschema_plain(ScrJsonP *p, const ScrJsonSchema *s) {
+  size_t slot = ((uintptr_t)s >> 4) & 3;
+  if (p->plain_schema[slot] == s) return p->plain_mask[slot];
+  uint64_t mask = 0;
+  for (size_t i = 0; i < s->nfields && i < 64; i++) {
+    const ScrJsonSchemaField *f = &s->fields[i];
+    bool plain = f->name_len > 0 && f->name_len <= 8;
+    for (size_t k = 0; plain && k < f->name_len; k++) {
+      unsigned char c = (unsigned char)f->name[k];
+      plain = c >= 0x20 && c != '"' && c != '\\';
+    }
+    if (plain) mask |= (uint64_t)1 << i;
+  }
+  p->plain_schema[slot] = s;
+  p->plain_mask[slot] = mask;
+  return mask;
+}
+
+/* The quoted key at p->pos when it is exactly `f`'s name, a plain name of
+ * at most eight bytes (scr_jschema_plain): the bytes consumed (name
+ * length + 2), else 0. Other names take the general key scan. */
 static inline size_t scr_jschema_key_direct(const ScrJsonP *p, const ScrJsonSchemaField *f) {
   size_t len = f->name_len;
   size_t at = p->pos + 1;
-  if (len == 0 || len > 8 || len >= p->len - at) return 0;
+  if (len >= p->len - at) return 0;
   const char *text = p->s + at;
-  uint64_t word = scr_key_short_word(f->name, len);
-  if (text[len] != '"' || scr_key_short_word(text, len) != word) return 0;
-  /* The packed word holds every name byte (lengths one to three use its
-   * low three bytes). A quote, backslash or control byte sends the key to
-   * the general scan, as in scr_json_plain_bytes. */
-  const uint64_t ones = UINT64_C(0x0101010101010101), high = UINT64_C(0x8080808080808080);
-  uint64_t quotes = word ^ (ones * '"'), slashes = word ^ (ones * '\\');
-  uint64_t special = ((quotes - ones) & ~quotes) | ((slashes - ones) & ~slashes) |
-                     ((word - ones * 0x20) & ~word);
-  uint64_t bytes = len >= 4 ? ~UINT64_C(0) : UINT64_C(0xffffff);
-  return (special & high & bytes) ? 0 : len + 2;
+  if (text[len] != '"' || scr_key_short_word(text, len) != scr_key_short_word(f->name, len)) return 0;
+  return len + 2;
 }
 
 /* An undeclared member of a record with an index signature, after its
@@ -10014,6 +10084,7 @@ static bool scr_jschema_record(ScrJsonP *p, const ScrJsonSchema *s, ScrJsonSlot
   const uint64_t all = n == 64 ? ~(uint64_t)0 : (((uint64_t)1 << n) - 1);
   uint64_t seen = 0;
   size_t guess = 0;
+  const uint64_t plain = scr_jschema_plain(p, s);
   scr_json_ws(p);
   if (p->pos < p->len && p->s[p->pos] == '}') {
     p->pos++;
@@ -10025,7 +10096,8 @@ static bool scr_jschema_record(ScrJsonP *p, const ScrJsonSchema *s, ScrJsonSlot
     /* Members usually arrive in declaration order: try the successor of
      * the previous match, directly against the text, before scanning. */
     size_t idx = n;
-    size_t direct = guess < n ? scr_jschema_key_direct(p, &s->fields[guess]) : 0;
+    size_t direct =
+        guess < n && (plain >> guess & 1) ? scr_jschema_key_direct(p, &s->fields[guess]) : 0;
     if (direct) {
       idx = guess;
       p->pos += direct;
@@ -10104,13 +10176,21 @@ static bool scr_jschema_array(ScrJsonP *p, const ScrJsonSchema *s, ScrJsonSlot *
     out->ptr = arr;
     return true;
   }
+  /* Elements gather in a local run and append in bulk (scr_arr_push_many,
+   * which moves references in as scr_arr_push_ref does). */
+  uint64_t run[32];
+  size_t n = 0;
   for (;;) {
     ScrJsonSlot v;
     if (!scr_jschema_member(p, elem, &v)) goto fail;
     switch (elem->kind) {
-    case SCR_JSCHEMA_F64: scr_arr_push_f64(arr, v.f); break;
-    case SCR_JSCHEMA_BOOL: scr_arr_push_bool(arr, v.b); break;
-    default: scr_arr_push_ref(arr, v.ptr); break; /* moves in */
+    case SCR_JSCHEMA_F64: memcpy(&run[n++], &v.f, sizeof v.f); break;
+    case SCR_JSCHEMA_BOOL: run[n++] = v.b ? 1 : 0; break;
+    default: run[n++] = (uint64_t)(uintptr_t)v.ptr; break;
+    }
+    if (n == sizeof run / sizeof run[0]) {
+      scr_arr_push_many(arr, n, run);
+      n = 0;
     }
     scr_json_ws(p);
     if (p->pos >= p->len) goto fail;
@@ -10120,10 +10200,12 @@ static bool scr_jschema_array(ScrJsonP *p, const ScrJsonSchema *s, ScrJsonSlot *
     }
     if (p->s[p->pos] != ']') goto fail;
     p->pos++;
+    scr_arr_push_many(arr, n, run);
     out->ptr = arr;
     return true;
   }
 fail:
+  scr_arr_push_many(arr, n, run); /* the array releases what it holds */
   s->release(arr);
   return false;
 }

From dfdc610c59edeb89375e3a02789d51f7d7b7269a Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 17:36:58 -0500
Subject: [PATCH 39/67] Replace every match of a block in one-character replace
 chains

Chains of global one-character replacements (the HTML-escape idiom) run
as one scr_str_replace_chars call. It searched for the next match eight
bytes at a time and started the search over after each replacement.

It now reads 16-byte blocks with SSE2 or NEON (8-byte words elsewhere on
little-endian hosts) and replaces every match of a block before reading
the next one. The table of characters and replacements is kept for the
next call with the same immortal operands, which are the literals the
compiler passes, instead of being rebuilt from the replacement text on
every call.
---
 .../corpus/6960-replace-char-blocks.ts.json   |   6 +
 packages/runtime/src/scr_string.c             | 250 +++++++++++++-----
 tests/corpus/6960-replace-char-blocks.ts      |  63 +++++
 .../6960-replace-char-blocks.ts.json          |   1 +
 4 files changed, 249 insertions(+), 71 deletions(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6960-replace-char-blocks.ts.json
 create mode 100644 tests/corpus/6960-replace-char-blocks.ts
 create mode 100644 tests/harness/corpus-costs/6960-replace-char-blocks.ts.json

diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6960-replace-char-blocks.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6960-replace-char-blocks.ts.json
new file mode 100644
index 000000000..ccc217b7a
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6960-replace-char-blocks.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6960-replace-char-blocks.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/runtime/src/scr_string.c b/packages/runtime/src/scr_string.c
index 9b21dd722..58272cf67 100644
--- a/packages/runtime/src/scr_string.c
+++ b/packages/runtime/src/scr_string.c
@@ -2691,90 +2691,198 @@ ScrStr *scr_str_replace_bytes(ScrStr *s, const char *pat, size_t plen, ScrStr *r
   return out;
 }
 
-/* The first byte at or after `i` that is one of the replaced characters
- * (`which` maps them to k + 1), or len. Up to eight characters are tested
- * eight bytes at a time. */
-static size_t scr_replace_chars_next(const char *p, size_t i, size_t len, const uint8_t *which,
-                                     const char *chars, size_t n) {
-  if (n <= 8) {
-    const uint64_t ones = UINT64_C(0x0101010101010101);
-    const uint64_t highs = UINT64_C(0x8080808080808080);
-    for (; len - i >= 8; i += 8) {
-      uint64_t w;
-      memcpy(&w, p + i, 8);
-      uint64_t hit = 0;
-      for (size_t k = 0; k < n; k++) {
-        uint64_t x = w ^ (ones * (unsigned char)chars[k]);
-        hit |= (x - ones) & ~x & highs;
-      }
-      if (hit) break;
-    }
+/* replaceAll of single characters (scr_str_replace_chars): a mask of the
+ * bytes in one block of SCR_RC_LANES that equal a replaced character, with
+ * SCR_RC_BITS bits per byte, lowest byte first. Every flagged byte is
+ * confirmed against the character table, so the SWAR form may flag extra
+ * bytes above a true match (its zero-byte test has no false negatives).
+ * Without a vector unit or a little-endian word, the byte loop alone. */
+#if defined(__SSE2__)
+#define SCR_RC_LANES 16
+#define SCR_RC_BITS 1
+typedef __m128i ScrRcWant;
+static inline ScrRcWant scr_rc_want(unsigned char c) { return _mm_set1_epi8((char)c); }
+static inline uint64_t scr_rc_mask(const char *p, const ScrRcWant *want, size_t n) {
+  __m128i v = _mm_loadu_si128((const __m128i *)p);
+  __m128i eq = _mm_cmpeq_epi8(v, want[0]);
+  for (size_t k = 1; k < n; k++) eq = _mm_or_si128(eq, _mm_cmpeq_epi8(v, want[k]));
+  return (uint64_t)(uint32_t)_mm_movemask_epi8(eq);
+}
+#elif defined(__ARM_NEON) && defined(__aarch64__)
+#define SCR_RC_LANES 16
+#define SCR_RC_BITS 4
+typedef uint8x16_t ScrRcWant;
+static inline ScrRcWant scr_rc_want(unsigned char c) { return vdupq_n_u8(c); }
+static inline uint64_t scr_rc_mask(const char *p, const ScrRcWant *want, size_t n) {
+  uint8x16_t v = vld1q_u8((const uint8_t *)p);
+  uint8x16_t eq = vceqq_u8(v, want[0]);
+  for (size_t k = 1; k < n; k++) eq = vorrq_u8(eq, vceqq_u8(v, want[k]));
+  /* Narrowing each 16-bit pair by 4 leaves one nibble per byte. */
+  return vget_lane_u64(vreinterpret_u64_u8(vshrn_n_u16(vreinterpretq_u16_u8(eq), 4)), 0);
+}
+#elif defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#define SCR_RC_LANES 8
+#define SCR_RC_BITS 8
+typedef uint64_t ScrRcWant;
+static inline ScrRcWant scr_rc_want(unsigned char c) { return UINT64_C(0x0101010101010101) * c; }
+static inline uint64_t scr_rc_mask(const char *p, const ScrRcWant *want, size_t n) {
+  const uint64_t ones = UINT64_C(0x0101010101010101);
+  const uint64_t highs = UINT64_C(0x8080808080808080);
+  uint64_t w, hit = 0;
+  memcpy(&w, p, 8);
+  for (size_t k = 0; k < n; k++) {
+    uint64_t x = w ^ want[k];
+    hit |= (x - ones) & ~x & highs;
   }
-  for (; i < len; i++) {
-    unsigned char c = (unsigned char)p[i];
-    if (c < 0x80 && which[c]) return i;
+  return hit;
+}
+#else
+#define SCR_RC_LANES 0
+#endif
+
+/* The result being built: `from` is where the copied subject resumes. */
+typedef struct {
+  ScrStr *out;
+  size_t cap, used, from;
+  bool joins;
+} ScrRcOut;
+
+/* Copy the subject up to `i`, then `text` in place of the character at
+ * `i` (or nothing at the end, when i == len). */
+static inline __attribute__((always_inline)) void scr_rc_put(ScrRcOut *o, const char *p,
+                                                              size_t len, size_t i,
+                                                              const char *text, size_t text_len) {
+  size_t gap = i - o->from;
+  size_t need = gap + text_len;
+  if (need > o->cap - o->used) {
+    if (need > SCR_STR_MAX_CAP - o->used) scr_oom();
+    size_t rest = o->used + need + (len - o->from);
+    size_t want = o->cap * 2 < rest ? rest : o->cap * 2;
+    if (want > SCR_STR_MAX_CAP) want = SCR_STR_MAX_CAP;
+    o->out->len = o->used;
+    o->out = scr_str_regrow(o->out, want);
+    o->cap = want;
   }
-  return len;
+  scr_copy_bytes(o->out->data + o->used, p + o->from, gap);
+  o->used += gap;
+  if (i == len) return;
+  /* As in scr_str_replace_bytes: a seam can complete a surrogate pair. */
+  if (text_len) o->joins |= scr_wtf8_joins(o->out->data, o->used, text, text_len);
+  scr_copy_bytes(o->out->data + o->used, text, text_len);
+  o->used += text_len;
+  o->from = i + 1;
+  o->joins |= (unsigned char)p[o->from] == 0xED;
+}
+
+/* The characters (at most SCR_RC_MAX), their replacements and the tables
+ * that find them. */
+#define SCR_RC_MAX 16
+typedef struct {
+  const ScrStr *chars, *texts; /* the immortal operands it was built for, or NULL */
+  size_t n;
+  size_t grow; /* the longest replacement's growth, less one */
+  bool ascii;  /* every replacement is ASCII */
+  uint8_t which[128];
+  const char *text[SCR_RC_MAX];
+  size_t text_len[SCR_RC_MAX];
+#if SCR_RC_LANES
+  ScrRcWant want[SCR_RC_MAX];
+#endif
+} ScrRcTable;
+
+/* The compiler passes a chain's characters and replacements as immortal
+ * literals, so the last chain's table is kept for the next call with the
+ * same operands. */
+static SCR_TL ScrRcTable scr_rc_last;
+
+static const ScrRcTable *scr_rc_table(const ScrStr *chars, const ScrStr *texts,
+                                      ScrRcTable *local) {
+  bool keep = chars->rc == SIZE_MAX && texts->rc == SIZE_MAX;
+  if (keep && scr_rc_last.chars == chars && scr_rc_last.texts == texts) return &scr_rc_last;
+  ScrRcTable *table = keep ? &scr_rc_last : local;
+  table->chars = table->texts = NULL;
+  size_t n = chars->len < SCR_RC_MAX ? chars->len : SCR_RC_MAX;
+  size_t grow = 0;
+  bool ascii = true;
+  memset(table->which, 0, sizeof table->which);
+  const char *t = texts->data, *t_end = texts->data + texts->len;
+  for (size_t k = 0; k < n; k++) {
+    /* The replacements are short: find each terminator, and whether the
+     * replacement is ASCII, in one pass. */
+    const char *stop = t;
+    unsigned high = 0;
+    while (stop < t_end && *stop) high |= (unsigned char)*stop++;
+    table->text[k] = t;
+    table->text_len[k] = (size_t)(stop - t);
+    if (table->text_len[k] > grow) grow = table->text_len[k];
+    if (high & 0x80) ascii = false;
+    table->which[(unsigned char)chars->data[k] & 0x7F] = (uint8_t)(k + 1);
+#if SCR_RC_LANES
+    table->want[k] = scr_rc_want((unsigned char)chars->data[k]);
+#endif
+    t = stop < t_end ? stop + 1 : t_end;
+  }
+  table->n = n;
+  table->grow = grow > 1 ? grow - 1 : 0;
+  table->ascii = ascii;
+  if (keep) {
+    table->chars = chars;
+    table->texts = texts;
+  }
+  return table;
 }
 
 ScrStr *scr_str_replace_chars(ScrStr *s, ScrStr *chars, ScrStr *texts) {
-  enum { MAX = 16 };
-  size_t n = chars->len < MAX ? chars->len : MAX;
-  uint8_t which[128] = { 0 };
-  const char *text[MAX];
-  size_t text_len[MAX];
-  size_t grow = 0;
-  bool ascii = s->ascii;
-  const char *t = texts->data, *t_end = texts->data + texts->len;
-  for (size_t k = 0; k < n; k++) {
-    const char *stop = memchr(t, '\0', (size_t)(t_end - t));
-    if (!stop) stop = t_end;
-    text[k] = t;
-    text_len[k] = (size_t)(stop - t);
-    if (text_len[k] > grow) grow = text_len[k];
-    if (ascii && !scr_bytes_all_ascii(t, text_len[k])) ascii = false;
-    which[(unsigned char)chars->data[k] & 0x7F] = (uint8_t)(k + 1);
-    t = stop < t_end ? stop + 1 : t_end;
-  }
+  ScrRcTable local;
+  const ScrRcTable *table = scr_rc_table(chars, texts, &local);
+  size_t n = table->n, grow = table->grow;
+  const uint8_t *which = table->which;
+  const char *const *text = table->text;
+  const size_t *text_len = table->text_len;
+#if SCR_RC_LANES
+  const ScrRcWant *want = table->want;
+#endif
+  bool ascii = s->ascii && table->ascii;
   const char *p = s->data;
   size_t len = s->len;
-  size_t i = scr_replace_chars_next(p, 0, len, which, chars->data, n);
-  if (i == len) return scr_str_retain(s);
-  grow = grow > 1 ? grow - 1 : 0;
-  size_t cap = len + (grow < 64 ? 4 * grow : grow) + 16;
-  if (cap > SCR_STR_MAX_CAP) cap = SCR_STR_MAX_CAP;
-  ScrStr *out = scr_str_alloc_raw(0, cap);
-  cap = out->cap;
-  size_t used = 0, from = 0;
-  /* As in scr_str_replace_bytes: a seam can complete a surrogate pair. */
-  bool joins = false;
-  for (;;) {
-    size_t gap = i - from;
-    size_t k = i < len ? (size_t)which[(unsigned char)p[i]] - 1 : 0;
-    size_t need = gap + (i < len ? text_len[k] : 0);
-    if (need > cap - used) {
-      if (need > SCR_STR_MAX_CAP - used) scr_oom();
-      size_t want = cap * 2 < used + need + (len - from) ? used + need + (len - from) : cap * 2;
-      if (want > SCR_STR_MAX_CAP) want = SCR_STR_MAX_CAP;
-      out->len = used;
-      out = scr_str_regrow(out, want);
-      cap = want;
+  ScrRcOut o = { NULL, 0, 0, 0, false };
+  size_t i = 0;
+#define SCR_RC_HIT(at)                                                            \
+  do {                                                                            \
+    unsigned char c_ = (unsigned char)p[at];                                      \
+    if (c_ < 0x80 && which[c_]) {                                                 \
+      if (!o.out) {                                                               \
+        size_t cap_ = len + (grow < 64 ? 4 * grow : grow) + 16;                   \
+        if (cap_ > SCR_STR_MAX_CAP) cap_ = SCR_STR_MAX_CAP;                       \
+        o.out = scr_str_alloc_raw(0, cap_);                                       \
+        o.cap = o.out->cap;                                                       \
+      }                                                                           \
+      size_t k_ = (size_t)which[c_] - 1;                                          \
+      scr_rc_put(&o, p, len, (at), text[k_], text_len[k_]);                       \
+    }                                                                             \
+  } while (0)
+#if SCR_RC_LANES
+  /* Every match of a block is replaced before the next block is read. */
+  for (; len - i >= SCR_RC_LANES; i += SCR_RC_LANES) {
+    uint64_t mask = scr_rc_mask(p + i, want, n);
+    while (mask) {
+      size_t lane = (size_t)__builtin_ctzll(mask) / SCR_RC_BITS;
+      mask &= ~((((uint64_t)1 << SCR_RC_BITS) - 1) << (lane * SCR_RC_BITS));
+      SCR_RC_HIT(i + lane);
     }
-    scr_copy_bytes(out->data + used, p + from, gap);
-    used += gap;
-    if (i == len) break;
-    if (text_len[k]) joins |= scr_wtf8_joins(out->data, used, text[k], text_len[k]);
-    scr_copy_bytes(out->data + used, text[k], text_len[k]);
-    used += text_len[k];
-    from = i + 1;
-    joins |= (unsigned char)p[from] == 0xED;
-    i = scr_replace_chars_next(p, from, len, which, chars->data, n);
   }
+#endif
+  for (; i < len; i++) SCR_RC_HIT(i);
+#undef SCR_RC_HIT
+  if (!o.out) return scr_str_retain(s);
+  scr_rc_put(&o, p, len, len, NULL, 0);
+  ScrStr *out = o.out;
+  size_t used = o.used, cap = o.cap;
   out->len = used;
   if (cap - used > used / 4 + 64) out = scr_str_regrow(out, used);
   out->data[used] = '\0';
   scr_str_hash_forget(out);
-  if (joins && scr_wtf8_any()) scr_str_fuse_surrogates(out);
+  if (o.joins && scr_wtf8_any()) scr_str_fuse_surrogates(out);
   else if (ascii) scr_str_note_ascii(out);
   return out;
 }
diff --git a/tests/corpus/6960-replace-char-blocks.ts b/tests/corpus/6960-replace-char-blocks.ts
new file mode 100644
index 000000000..af95a8a67
--- /dev/null
+++ b/tests/corpus/6960-replace-char-blocks.ts
@@ -0,0 +1,63 @@
+// Chains of global one-character replacements over subjects of every
+// length up to 70: matches at each position (block edges included), runs
+// of matches, non-ASCII neighbors, empty and long replacements, chains of
+// up to ten characters, and lone surrogates meeting at a seam.
+function escapeHtml(text: string): string {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function strip(text: string): string {
+  return text.replace(/a/g, "").replace(/e/g, "").replace(/i/g, "");
+}
+function widen(text: string): string {
+  return text.replace(/x/g, "[a long replacement text that grows the result]").replace(/y/g, "é");
+}
+function many(text: string): string {
+  return text
+    .replace(/0/g, "zero")
+    .replace(/1/g, "one")
+    .replace(/2/g, "two")
+    .replace(/3/g, "three")
+    .replace(/4/g, "four")
+    .replace(/5/g, "five")
+    .replace(/6/g, "six")
+    .replace(/7/g, "seven")
+    .replace(/8/g, "eight")
+    .replace(/9/g, "nine");
+}
+
+let total = 0;
+let digest = 0;
+function note(text: string): void {
+  total += text.length;
+  for (let i = 0; i < text.length; i++) digest = (digest * 31 + text.charCodeAt(i)) % 1000000007;
+}
+for (let length = 0; length <= 70; length++) {
+  const base = "abcdefghij".repeat(8).slice(0, length);
+  note(escapeHtml(base));
+  note(strip(base));
+  for (let at = 0; at < length; at++) {
+    const marked = base.slice(0, at) + "&" + base.slice(at + 1);
+    note(escapeHtml(marked));
+    const pair = base.slice(0, at) + '<"' + base.slice(at + 2);
+    note(escapeHtml(pair));
+    note(widen(base.slice(0, at) + "x" + base.slice(at + 1)));
+  }
+  note(escapeHtml("&".repeat(length)));
+  note(escapeHtml('<>"&'.repeat(length).slice(0, length)));
+  note(many("0123456789".repeat(8).slice(0, length)));
+  note(strip("aei".repeat(length)));
+}
+console.log(total, digest);
+
+console.log(escapeHtml("héllo & wörld <ü> \"ç\" & 中文 <b>"));
+console.log(escapeHtml("ünïcödé ".repeat(5) + "&<>\"" + " ñ".repeat(9)));
+console.log(widen("xyxyxy"), widen("é x é y é"), strip("aeiaeiaei"), many("90210"));
+console.log(escapeHtml("x".repeat(15) + "&" + "y".repeat(16) + "<" + "z".repeat(17) + ">"));
+
+// A lone high surrogate before a replaced character and a lone low one in
+// its replacement form a pair at the seam.
+const high = "\uD83D";
+const joined = (high + "&").replace(/&/g, "\uDE00");
+console.log(joined.length, joined.codePointAt(0), joined === "😀");
+const longJoined = ("abcdefghijklmnop" + high + "&qrstuvwxyz").replace(/&/g, "\uDE00");
+console.log(longJoined.length, longJoined.codePointAt(16), longJoined.slice(16, 18) === "😀");
diff --git a/tests/harness/corpus-costs/6960-replace-char-blocks.ts.json b/tests/harness/corpus-costs/6960-replace-char-blocks.ts.json
new file mode 100644
index 000000000..2db0253c4
--- /dev/null
+++ b/tests/harness/corpus-costs/6960-replace-char-blocks.ts.json
@@ -0,0 +1 @@
+{ "plain": 2744, "san": 5875 }

From 4fee347ca0baf7cdcc4c0ac299865ea514e39e71 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 17:57:00 -0500
Subject: [PATCH 40/67] Address review feedback on array named properties

---
 .../compiler/src/backend/llvm/lib-shared.ts   |  1 +
 .../src/backend/llvm/reference-writes.ts      |  1 +
 .../src/frontend/lowering/lower-stmts.ts      | 26 ++++++++++------
 .../compiler/src/ir/builtin-signatures.ts     |  3 ++
 packages/compiler/src/ir/validate.ts          |  4 +--
 packages/runtime/src/scr_array.c              | 31 +++++++++++++++++++
 packages/runtime/src/scr_array.h              |  7 +++++
 packages/runtime/src/scr_json.c               | 12 +++++--
 .../6987-array-view-named-properties.ts       | 17 ++++++++++
 9 files changed, 89 insertions(+), 13 deletions(-)

diff --git a/packages/compiler/src/backend/llvm/lib-shared.ts b/packages/compiler/src/backend/llvm/lib-shared.ts
index be7a4973b..b7c6b8a21 100644
--- a/packages/compiler/src/backend/llvm/lib-shared.ts
+++ b/packages/compiler/src/backend/llvm/lib-shared.ts
@@ -1520,6 +1520,7 @@ export const LIB_FN_SYMS: Record<string, string> = {
   "regex.groupParseInt": "scr_regex_group_parse_int",
   "regex.resultProp": "scr_regex_result_prop",
   "array.namedKeys": "scr_arr_named_keys",
+  "array.hasNamedKey": "scr_arr_has_named_key",
   // queueMicrotask's checked-dynamic form (borrowed dyn; a non-function
   // throws synchronously), the minted setImmediate value, and the
   // timers/promises immediate — all mark the loop live.
diff --git a/packages/compiler/src/backend/llvm/reference-writes.ts b/packages/compiler/src/backend/llvm/reference-writes.ts
index c77a5a191..d31f14d12 100644
--- a/packages/compiler/src/backend/llvm/reference-writes.ts
+++ b/packages/compiler/src/backend/llvm/reference-writes.ts
@@ -106,6 +106,7 @@ const INERT_LIB_CALLS = new Set([
   "regex.groupParseInt",
   "regex.resultProp",
   "array.namedKeys",
+  "array.hasNamedKey",
   "process.cwd",
   "process.argv",
   "process.execArgv",
diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.ts b/packages/compiler/src/frontend/lowering/lower-stmts.ts
index 0960b9d6a..78f2f4189 100644
--- a/packages/compiler/src/frontend/lowering/lower-stmts.ts
+++ b/packages/compiler/src/frontend/lowering/lower-stmts.ts
@@ -11620,21 +11620,23 @@ function lowerForInArray(
       loc,
     });
     // Indices first, then the named keys the array had when the loop began.
+    const namedKey = (): IrExpr => ({
+      kind: "arrayGet",
+      arr: keysRef(),
+      index: { kind: "bin", op: "-", left: iRef(), right: lenRef(), type: F64, loc },
+      type: STRING,
+      loc,
+    });
     const keyInit: IrExpr = {
       kind: "ternary",
       cond: isIndex(),
       then: { kind: "toString", operand: iRef(), type: STRING, loc },
-      else_: {
-        kind: "arrayGet",
-        arr: keysRef(),
-        index: { kind: "bin", op: "-", left: iRef(), right: lenRef(), type: F64, loc },
-        type: STRING,
-        loc,
-      },
+      else_: namedKey(),
       type: STRING,
       loc,
     };
-    // An index is visited while it is below the live length and not a hole.
+    // An index is visited while it is below the live length and not a hole,
+    // a named key while the array still has it.
     const visits: IrExpr = {
       kind: "ternary",
       cond: isIndex(),
@@ -11653,7 +11655,13 @@ function lowerForInArray(
         type: BOOL,
         loc,
       },
-      else_: { kind: "boolLit", value: true, type: BOOL, loc },
+      else_: {
+        kind: "libCall",
+        fn: "array.hasNamedKey",
+        args: [arrRef(), namedKey()],
+        type: BOOL,
+        loc,
+      },
       type: BOOL,
       loc,
     };
diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts
index 1e6270366..e4bd83db7 100644
--- a/packages/compiler/src/ir/builtin-signatures.ts
+++ b/packages/compiler/src/ir/builtin-signatures.ts
@@ -3727,6 +3727,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
   // The string keys `for...in` visits on an array (args[0], any element
   // type) after its indices. Borrowed; never throws.
   "array.namedKeys": { argTypes: [null], result: arrayOf(STRING) },
+  // Whether the array (args[0]) still has the key (args[1]) from its
+  // namedKeys list. Borrowed; never throws.
+  "array.hasNamedKey": { argTypes: [null, STRING], result: BOOL },
   // node:events EventEmitter: receivers are emitter-hierarchy objects and
   // the chaining forms (on/off/removeAll/setMax) return the receiver's
   // own class — program-dependent object types, checked in the libCall
diff --git a/packages/compiler/src/ir/validate.ts b/packages/compiler/src/ir/validate.ts
index 0004be761..88ccbbc33 100644
--- a/packages/compiler/src/ir/validate.ts
+++ b/packages/compiler/src/ir/validate.ts
@@ -4262,9 +4262,9 @@ function validateFunction(
       if (!ok) err(`libCall dyn.objEntryPairs must return a [string, any] tuple array`, e.loc);
       return true;
     }
-    if (e.fn === "array.namedKeys") {
+    if (e.fn === "array.namedKeys" || e.fn === "array.hasNamedKey") {
       if (e.args[0]?.type.kind !== "array") {
-        err(`libCall array.namedKeys arg 0: expected an array, got ${e.args[0]?.type.kind}`, e.loc);
+        err(`libCall ${e.fn} arg 0: expected an array, got ${e.args[0]?.type.kind}`, e.loc);
       }
       return true;
     }
diff --git a/packages/runtime/src/scr_array.c b/packages/runtime/src/scr_array.c
index fa98dd38a..c64b85947 100644
--- a/packages/runtime/src/scr_array.c
+++ b/packages/runtime/src/scr_array.c
@@ -4790,6 +4790,22 @@ ScrStr *scr_str_raw(ScrArr *raw, ScrArr *subs) {
   return out;
 }
 
+bool scr_arr_numeric_key(const char *key, size_t len, double *out) {
+  char text[64];
+  if (len == 0 || len >= sizeof text) return false;
+  memcpy(text, key, len);
+  text[len] = '\0';
+  char *end;
+  double number = strtod(text, &end);
+  if (end != text + len) return false;
+  char spelled[64];
+  if (scr_f64_to_str(number, spelled) != len || memcmp(spelled, key, len) != 0) return false;
+  size_t index;
+  if (scr_arr_valid_index(number, &index)) return false;
+  *out = number;
+  return true;
+}
+
 void scr_arr_copy_metadata(ScrArr *a, ScrDyn *target) {
   const ScrDyn *metadata = SCR_AX(a)->metadata;
   if (metadata && metadata->kind == SCR_DYN_HANDLE && metadata->v.handle.tag == SCR_DYNH_MATCH_SOURCE &&
@@ -4838,6 +4854,21 @@ ScrArr *scr_arr_named_keys(ScrArr *a) {
   return keys;
 }
 
+bool scr_arr_has_named_key(ScrArr *a, ScrStr *key) {
+  const ScrArrExt *x = scr_arr_ext_of(a);
+  if (!x) return false;
+  if (scr_arr_prop_index(a, key->data, key->len) != SIZE_MAX) return true;
+  const ScrDyn *metadata = x->metadata;
+  if (metadata && metadata->kind == SCR_DYN_HANDLE && metadata->v.handle.tag == SCR_DYNH_MATCH_SOURCE)
+    return true; /* index, input and groups, the only keys a pending result lists */
+  if (!metadata || metadata->kind != SCR_DYN_OBJ) return false;
+  for (size_t i = 0; i < metadata->v.obj.len; i++) {
+    const ScrDynEntry *entry = &metadata->v.obj.entries[i];
+    if (entry->key_len == key->len && memcmp(entry->key, key->data, key->len) == 0) return true;
+  }
+  return false;
+}
+
 void scr_arr_adopt_view_properties(ScrArr *a, ScrDyn *view, ScrArr *target) {
   ScrArrExt *from = scr_arr_ext_of(target);
   if (from && from->prop_len) {
diff --git a/packages/runtime/src/scr_array.h b/packages/runtime/src/scr_array.h
index d9f5f49bc..6c41b3dbd 100644
--- a/packages/runtime/src/scr_array.h
+++ b/packages/runtime/src/scr_array.h
@@ -322,6 +322,13 @@ void scr_arr_copy_metadata(ScrArr *a, struct ScrDyn *target);
  * (non-index) properties as its metadata and the noncanonical numeric
  * properties of `target`, so neither is lost when the storage is swapped. */
 void scr_arr_adopt_view_properties(ScrArr *a, struct ScrDyn *view, ScrArr *target);
+/* True when `key` is the string spelling of a number that is not an array
+ * index ("-1", "1.5", "NaN", "Infinity"), with the number in *out. Arrays
+ * keep such properties in their noncanonical property table. */
+bool scr_arr_numeric_key(const char *key, size_t len, double *out);
+/* Whether the array still has the named or noncanonical numeric property
+ * `key`: `for...in` skips a key deleted before its turn. Borrows both. */
+bool scr_arr_has_named_key(ScrArr *a, ScrStr *key);
 /* The enumerable string keys `for...in` visits after the indices: the
  * noncanonical numeric properties, then the named properties in insertion
  * order. +1. */
diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c
index 8577a96fb..5d00f8b47 100644
--- a/packages/runtime/src/scr_json.c
+++ b/packages/runtime/src/scr_json.c
@@ -10270,9 +10270,17 @@ void scr_dyn_key_delete(ScrDyn *recv, const ScrStr *key, bool strict) {
     return;
   }
   /* A live native array keeps its named properties in its metadata, so
-   * deleting one goes through the view and its commit. Elements and
-   * `length` keep the boundary below. */
+   * deleting one goes through the view and its commit. Numeric properties
+   * are deleted natively. Elements and `length` keep the boundary below. */
   size_t element;
+  double number;
+  if (recv->kind == SCR_DYN_TYPED_REF && scr_dyn_typed_ref_array_ops(recv) &&
+      scr_arr_numeric_key(key->data, key->len, &number)) {
+    /* Noncanonical numeric properties ("-1", "1.5") live in the native
+     * array's property table. */
+    scr_arr_delete(recv->v.typed_ref.ptr, number);
+    return;
+  }
   if (recv->kind == SCR_DYN_TYPED_REF && recv->v.typed_ref.commit && scr_dyn_typed_ref_array_ops(recv) &&
       !scr_typed_ref_is_length(key) && !scr_typed_ref_canonical_index(key->data, key->len, &element)) {
     ScrDyn *view = scr_dyn_typed_ref_materialize(recv);
diff --git a/tests/corpus/6987-array-view-named-properties.ts b/tests/corpus/6987-array-view-named-properties.ts
index 5cbea5a0a..bd100b8b1 100644
--- a/tests/corpus/6987-array-view-named-properties.ts
+++ b/tests/corpus/6987-array-view-named-properties.ts
@@ -77,3 +77,20 @@ for (const key in shrinking) {
 
 const match = /b(?<rest>c)?/.exec("abc");
 if (match) for (const key in match) console.log("match key", key);
+
+// A numeric property deleted through a view is gone from the array.
+const numeric: number[] = [1, 2];
+numeric[-1] = 5;
+delete (numeric as unknown as Bag)["-1"];
+console.log(numeric[-1], "-1" in (numeric as unknown as Bag));
+for (const key in numeric) console.log("numeric key", key);
+
+// A named key deleted before its turn is not visited.
+const visited: number[] = [1];
+(visited as unknown as Bag).first = 1;
+(visited as unknown as Bag).second = 2;
+(visited as unknown as Bag).third = 3;
+for (const key in visited) {
+  console.log("visited key", key);
+  if (key === "first") delete (visited as unknown as Bag).second;
+}

From 982ef6dbefe5beb5c98ae64065a0b96dd94c4e01 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 18:11:33 -0500
Subject: [PATCH 41/67] Allow zlib callbacks to assign to their result

The error-path copy of a zlib callback reads its result from a hidden
local that was immutable, so a body that assigned a fallback Buffer to
the result (if (!out) out = Buffer.from("fallback")) failed to compile
with an internal compiler error. The local is now mutable, and an
assigned value is read back as a checked-dynamic value, as in Node.
---
 .../src/frontend/lowering/lower-functions.ts       |  4 +++-
 tests/corpus/6920-zlib-callback-error-result.ts    | 14 ++++++++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/packages/compiler/src/frontend/lowering/lower-functions.ts b/packages/compiler/src/frontend/lowering/lower-functions.ts
index 6fc083468..8f2c575a4 100644
--- a/packages/compiler/src/frontend/lowering/lower-functions.ts
+++ b/packages/compiler/src/frontend/lowering/lower-functions.ts
@@ -2,6 +2,7 @@ import { declareTypedArguments } from "./typed-arguments.js";
 import { dynUndefinedExpr, varRef } from "../../ir/build.js";
 import { everyStmtList, transformStmtList } from "../../ir/traverse.js";
 import { bindingNeverReassigned } from "./binding-analysis.js";
+import { declareContextLocal } from "./function-context.js";
 import { isErrorFirstErrorType } from "./builtins/arguments.js";
 import { InternalCompilerError } from "../../errors.js";
 import * as ts from "../ts7/adapter.js";
@@ -786,7 +787,8 @@ function lowerUndefinedResultBody(
       lowerer.suppressStats = stats;
     }
   };
-  const slot = lowerer.declareHiddenLocal("%result", DYN);
+  // Mutable: the body may assign to its result (`if (!out) out = ...`).
+  const slot = declareContextLocal(lowerer.ctx, "%result", DYN, true, undefined, undefined);
   const undefinedResult: IrStmt = {
     kind: "varDecl",
     localId: slot.id,
diff --git a/tests/corpus/6920-zlib-callback-error-result.ts b/tests/corpus/6920-zlib-callback-error-result.ts
index cc9128221..5016fa841 100644
--- a/tests/corpus/6920-zlib-callback-error-result.ts
+++ b/tests/corpus/6920-zlib-callback-error-result.ts
@@ -176,6 +176,19 @@ function namedRetry(): void {
   });
 }
 
+function fallbackResult(): void {
+  // The body assigns a fallback Buffer to its result.
+  zlib.inflate(bad, (err, out) => {
+    if (!out) out = Buffer.from("fallback");
+    console.log("fallback", err?.code, typeof out, out.toString());
+    zlib.inflate(good, (err2, out2) => {
+      if (err2) out2 = Buffer.alloc(0);
+      console.log("fallback nested", err2, out2.length);
+      step();
+    });
+  });
+}
+
 function functionValues(next: () => void): void {
   steps.push(
     () => zlib.inflate(good, named),
@@ -203,6 +216,7 @@ function functionValues(next: () => void): void {
     () => zlib.inflate(good, captures),
     nestedForward,
     namedRetry,
+    fallbackResult,
     () => {
       named(new Error("direct"), Buffer.from("both"));
     },

From 2054ea51bb6b52e3f149f92219b0e967d46a8fda Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 18:31:16 -0500
Subject: [PATCH 42/67] Give the sanitized Effect pilot tests a longer timeout

---
 tests/harness/npm-static.test.ts | 65 +++++++++++++++++++-------------
 1 file changed, 38 insertions(+), 27 deletions(-)

diff --git a/tests/harness/npm-static.test.ts b/tests/harness/npm-static.test.ts
index 54845ed05..df82efbcf 100644
--- a/tests/harness/npm-static.test.ts
+++ b/tests/harness/npm-static.test.ts
@@ -22,6 +22,9 @@ const fixturesRoot = join(repoRoot, "tests/fixtures");
 const pilotRoot = join(fixturesRoot, "npm-static");
 const cacheDir = join(repoRoot, "node_modules/.cache/scriptc-tests");
 const sanitize = process.env["SCRIPTC_SAN"] === "1";
+/* Sanitized builds of the published Effect pilots alone take 290 to 330 s on a 16-vCPU host, most of it in
+ * the sanitized native link: near or past the suite's 300 s default. */
+const effectBuildTimeout = sanitize ? 900_000 : undefined;
 // Measured milliseconds per test on a CI runner (scripts/ci-test-costs.mjs).
 const testCosts = (
   JSON.parse(readFileSync(new URL("./npm-static-costs.json", import.meta.url), "utf8")) as {
@@ -1135,34 +1138,42 @@ describe(`npm-static pilots${sanitize ? " (sanitized)" : ""}`, () => {
     expect(nativeRes.exitCode).toBe(nodeRes.exitCode);
   }, 180_000);
 
-  test("the published Effect generator logs and completes statically", async () => {
-    const entry = join(pilotRoot, "effect-gen-cli.ts");
-    const binary = await buildStatic(entry, ["effect"]);
-    const [reference, native] = await Promise.all([
-      runBinary(process.execPath, [entry]),
-      runBinary(binary, []),
-    ]);
-    const log =
-      /^timestamp=\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z level=INFO fiber=#0 message="Hello, world!"\n$/;
-    expect(reference.stdout.toString()).toMatch(log);
-    expect(native.stdout.toString()).toMatch(log);
-    expect(comparableStderr(native.stderr)).toEqual(reference.stderr);
-    expect(native.exitCode).toBe(reference.exitCode);
-    expect(native.exitCode).toBe(0);
-  });
+  test(
+    "the published Effect generator logs and completes statically",
+    async () => {
+      const entry = join(pilotRoot, "effect-gen-cli.ts");
+      const binary = await buildStatic(entry, ["effect"]);
+      const [reference, native] = await Promise.all([
+        runBinary(process.execPath, [entry]),
+        runBinary(binary, []),
+      ]);
+      const log =
+        /^timestamp=\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z level=INFO fiber=#0 message="Hello, world!"\n$/;
+      expect(reference.stdout.toString()).toMatch(log);
+      expect(native.stdout.toString()).toMatch(log);
+      expect(comparableStderr(native.stderr)).toEqual(reference.stderr);
+      expect(native.exitCode).toBe(reference.exitCode);
+      expect(native.exitCode).toBe(0);
+    },
+    effectBuildTimeout,
+  );
 
-  test("the published Effect generator has deterministic native results", async () => {
-    const entry = join(pilotRoot, "effect-gen-result-cli.ts");
-    const binary = await buildStatic(entry, ["effect"]);
-    const [reference, native] = await Promise.all([
-      runBinary(process.execPath, [entry]),
-      runBinary(binary, []),
-    ]);
-    expect(reference.stdout.toString()).toBe("Hello, world!\n42\n");
-    expect(native.stdout).toEqual(reference.stdout);
-    expect(comparableStderr(native.stderr)).toEqual(reference.stderr);
-    expect(native.exitCode).toBe(reference.exitCode);
-  });
+  test(
+    "the published Effect generator has deterministic native results",
+    async () => {
+      const entry = join(pilotRoot, "effect-gen-result-cli.ts");
+      const binary = await buildStatic(entry, ["effect"]);
+      const [reference, native] = await Promise.all([
+        runBinary(process.execPath, [entry]),
+        runBinary(binary, []),
+      ]);
+      expect(reference.stdout.toString()).toBe("Hello, world!\n42\n");
+      expect(native.stdout).toEqual(reference.stdout);
+      expect(comparableStderr(native.stderr)).toEqual(reference.stderr);
+      expect(native.exitCode).toBe(reference.exitCode);
+    },
+    effectBuildTimeout,
+  );
 
   test("inferred variadic factories preserve checked callable results", async () => {
     const entry = join(pilotRoot, "variadic-factory-cli.ts");

From 34f371f8295d1b5ffd664bc21355aeab4b886b6c Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 18:43:03 -0500
Subject: [PATCH 43/67] Address the second review round on array named
 properties

---
 packages/runtime/src/scr_json.c               | 38 +++++++++----------
 .../6987-array-view-named-properties.ts       |  8 ++++
 2 files changed, 27 insertions(+), 19 deletions(-)

diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c
index 5d00f8b47..f62ef0165 100644
--- a/packages/runtime/src/scr_json.c
+++ b/packages/runtime/src/scr_json.c
@@ -10269,30 +10269,30 @@ void scr_dyn_key_delete(ScrDyn *recv, const ScrStr *key, bool strict) {
     }
     return;
   }
-  /* A live native array keeps its named properties in its metadata, so
-   * deleting one goes through the view and its commit. Numeric properties
-   * are deleted natively. Elements and `length` keep the boundary below. */
+  /* A live native array keeps the noncanonical numeric properties written
+   * natively ("-1", "1.5") in its property table, and named properties,
+   * including numeric-looking keys written through a view, in its metadata,
+   * which the view and its commit hold. Deleting such a key removes it from
+   * both. Elements and `length` keep the boundary below. */
   size_t element;
-  double number;
   if (recv->kind == SCR_DYN_TYPED_REF && scr_dyn_typed_ref_array_ops(recv) &&
-      scr_arr_numeric_key(key->data, key->len, &number)) {
-    /* Noncanonical numeric properties ("-1", "1.5") live in the native
-     * array's property table. */
-    scr_arr_delete(recv->v.typed_ref.ptr, number);
-    return;
-  }
-  if (recv->kind == SCR_DYN_TYPED_REF && recv->v.typed_ref.commit && scr_dyn_typed_ref_array_ops(recv) &&
       !scr_typed_ref_is_length(key) && !scr_typed_ref_canonical_index(key->data, key->len, &element)) {
-    ScrDyn *view = scr_dyn_typed_ref_materialize(recv);
-    if (!scr_exc_pending() && view->kind == SCR_DYN_ARR) {
-      bool own = view->v.arr.properties && scr_dyn_obj_get(view->v.arr.properties, key->data, key->len);
-      if (own) scr_dyn_key_delete(view, key, strict);
-      if (own && !scr_exc_pending()) scr_dyn_typed_ref_commit(recv);
+    double number;
+    bool numeric = scr_arr_numeric_key(key->data, key->len, &number);
+    if (numeric) scr_arr_delete(recv->v.typed_ref.ptr, number);
+    if (recv->v.typed_ref.commit) {
+      ScrDyn *view = scr_dyn_typed_ref_materialize(recv);
+      if (!scr_exc_pending() && view->kind == SCR_DYN_ARR) {
+        bool own = view->v.arr.properties && scr_dyn_obj_get(view->v.arr.properties, key->data, key->len);
+        if (own) scr_dyn_key_delete(view, key, strict);
+        if (own && !scr_exc_pending()) scr_dyn_typed_ref_commit(recv);
+        scr_dyn_release(view);
+        return;
+      }
       scr_dyn_release(view);
-      return;
+      if (scr_exc_pending()) return;
     }
-    scr_dyn_release(view);
-    if (scr_exc_pending()) return;
+    if (numeric) return;
   }
   if (recv->kind == SCR_DYN_FUNC) {
     if (scr_dyn_fn_property_fence(key)) return;
diff --git a/tests/corpus/6987-array-view-named-properties.ts b/tests/corpus/6987-array-view-named-properties.ts
index bd100b8b1..faba7dc90 100644
--- a/tests/corpus/6987-array-view-named-properties.ts
+++ b/tests/corpus/6987-array-view-named-properties.ts
@@ -85,6 +85,14 @@ delete (numeric as unknown as Bag)["-1"];
 console.log(numeric[-1], "-1" in (numeric as unknown as Bag));
 for (const key in numeric) console.log("numeric key", key);
 
+// A numeric-looking key written through a view is deleted through a view too.
+const viewNumeric: string[] = ["a"];
+(viewNumeric as unknown as Bag)["-2"] = "view";
+console.log((viewNumeric as unknown as Bag)["-2"], "-2" in (viewNumeric as unknown as Bag));
+delete (viewNumeric as unknown as Bag)["-2"];
+console.log((viewNumeric as unknown as Bag)["-2"], "-2" in (viewNumeric as unknown as Bag));
+for (const key in viewNumeric) console.log("view numeric key", key);
+
 // A named key deleted before its turn is not visited.
 const visited: number[] = [1];
 (visited as unknown as Bag).first = 1;

From fa7bc7c7a0d73e55de132ea929b03257d7e51fd0 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 18:53:43 -0500
Subject: [PATCH 44/67] Warn about likely-hot functions that use untyped values

A build now names the functions of the program's own files that compile
to the dynamic tier and likely run often, so a slow program with a little
untyped code says where the time goes:

  warning SC6101: 3 functions that likely run often use untyped values, which runs slower than typed code:
    advance (nbody.js:22): untyped JavaScript file, in a loop
    ...

- The functions come from the tier assignment lowering already makes
  (Lowerer.dynamicFunctions). Without a profile, a function counts as
  likely hot when a dynamic operation runs inside one of its loops, when
  a loop calls it, or when it calls itself (lowering/dynamic-tier.ts).
- A function is named only when its source says why its values are
  untyped: an `any` (for a for...of variable, the value it iterates), an
  untyped JSON.parse result, or an untyped JavaScript file. Generated
  %dyn.* helpers, module top levels and functions that are dynamic for an
  operation without a static lowering are left out.
- At most five functions are named, most likely hot first, with the
  total; dynamic-tier code in npm packages is counted per package on one
  line. All of the warning's text is in diagnostics/dynamic-tier.ts.
- SC6101 opens the SC61xx band, performance notes, with a new
  "performance" category in the diagnostics envelope; SC60xx stay the
  divergences.
- scriptc build prints it after the divergence warnings, and the
  executable cache stores it with the entry, so a cached build (including
  the CLI's routed fast path) repeats it. scriptc coverage reports it, and
  a comment-only edit no longer replays a verdict that carries it, since
  its text holds line numbers.
- --no-dynamic-tier-warning leaves it out of build and coverage;
  coverage --fail-on=dynamic fails on it.
- Docs: coverage.mdx (Dynamic tier, Gating builds and CI, the envelope
  categories) and cli.mdx.
---
 .gitignore                                    |   1 +
 docs/content/docs/cli.mdx                     |   7 +-
 docs/content/docs/coverage.mdx                |  23 +-
 packages/cli/src/bootstrap.ts                 |   5 +
 .../cli/test/dynamic-tier-warning.test.ts     | 120 ++++++++
 packages/compiler/src/cli/command.ts          |  40 ++-
 packages/compiler/src/cli/usage.ts            |   9 +-
 packages/compiler/src/coverage/report.ts      |  24 +-
 .../compiler/src/coverage/verdict-cache.ts    |   3 +
 .../compiler/src/coverage/verdict-semantic.ts |   3 +
 .../compiler/src/diagnostics/diagnostic.ts    |   5 +-
 .../compiler/src/diagnostics/dynamic-tier.ts  |  99 ++++++
 packages/compiler/src/diagnostics/envelope.ts |   8 +-
 .../src/executable/executable-cache.ts        |  11 +
 packages/compiler/src/executable/prepare.ts   |   2 +-
 packages/compiler/src/frontend/analysis.ts    |   1 +
 .../src/frontend/lowering/dynamic-tier.ts     | 284 ++++++++++++++++++
 .../compiler/src/frontend/lowering/lowerer.ts |  13 +-
 packages/compiler/src/index.ts                |  18 ++
 packages/compiler/src/startup-cache.ts        |   1 +
 tests/coverage-fixtures/dynamic-tier/hot.js   |  36 +++
 .../dynamic-tier/package/main.ts              |  13 +
 .../node_modules/untyped-lib/index.d.ts       |   1 +
 .../package/node_modules/untyped-lib/index.js |   6 +
 .../node_modules/untyped-lib/package.json     |   1 +
 tests/coverage-fixtures/dynamic-tier/quiet.ts |  13 +
 .../dynamic-tier/typed-hot.ts                 |  21 ++
 .../__snapshots__/coverage-dynamic-tier.txt   |  13 +
 tests/harness/coverage.test.ts                |  42 +++
 29 files changed, 802 insertions(+), 21 deletions(-)
 create mode 100644 packages/cli/test/dynamic-tier-warning.test.ts
 create mode 100644 packages/compiler/src/diagnostics/dynamic-tier.ts
 create mode 100644 packages/compiler/src/frontend/lowering/dynamic-tier.ts
 create mode 100644 tests/coverage-fixtures/dynamic-tier/hot.js
 create mode 100644 tests/coverage-fixtures/dynamic-tier/package/main.ts
 create mode 100644 tests/coverage-fixtures/dynamic-tier/package/node_modules/untyped-lib/index.d.ts
 create mode 100644 tests/coverage-fixtures/dynamic-tier/package/node_modules/untyped-lib/index.js
 create mode 100644 tests/coverage-fixtures/dynamic-tier/package/node_modules/untyped-lib/package.json
 create mode 100644 tests/coverage-fixtures/dynamic-tier/quiet.ts
 create mode 100644 tests/coverage-fixtures/dynamic-tier/typed-hot.ts
 create mode 100644 tests/harness/__snapshots__/coverage-dynamic-tier.txt

diff --git a/.gitignore b/.gitignore
index fda9414aa..cd44fe11d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,6 +9,7 @@ node_modules/
 !tests/corpus/*/node_modules/
 !tests/fixtures/npm-static/node_modules/
 !tests/coverage-fixtures/wasm/node_modules/
+!tests/coverage-fixtures/dynamic-tier/package/node_modules/
 !tests/fixtures/npm-static/nested/inner/node_modules/
 !tests/fixtures/npm-static/node_modules/*/node_modules/
 !tests/fixtures/npm/store/*/node_modules/
diff --git a/docs/content/docs/cli.mdx b/docs/content/docs/cli.mdx
index efdb03d7d..8c57d2e2a 100644
--- a/docs/content/docs/cli.mdx
+++ b/docs/content/docs/cli.mdx
@@ -114,8 +114,8 @@ With `--sparse`, the profile leaves out the functions the runs never reached. Th
   <dt><code>--print &lt;native-link-info|diagnostics&gt;</code></dt>
   <dd><code>native-link-info</code>: build an object (equivalent to <code>--emit=obj</code>) and print its machine-readable external link recipe as JSON instead of printing the artifact path. The document names the exact installed precompiled runtime pack and all link inputs, but does not invoke a linker. <code>diagnostics</code>: for <code>build</code> and <code>coverage</code>, print the versioned JSON diagnostics document described in <a href="/docs/coverage#machine-readable-diagnostics">Coverage Reports</a> instead of the human output.</dd>
 
-  <dt><code>--fail-on &lt;blockers|divergences&gt;</code></dt>
-  <dd>Coverage only. Exit with status 1 when the entry has blockers that would fail a build, or with <code>divergences</code>, also when it has Node divergence warnings. See <a href="/docs/coverage#gating-builds-and-ci">Gating builds and CI</a>.</dd>
+  <dt><code>--fail-on &lt;blockers|divergences|dynamic&gt;</code></dt>
+  <dd>Coverage only. Exit with status 1 when the entry has blockers that would fail a build, with <code>divergences</code>, also when it has Node divergence warnings, or with <code>dynamic</code>, also when it has the <code>SC6101</code> warning for untyped code that likely runs often. See <a href="/docs/coverage#gating-builds-and-ci">Gating builds and CI</a>.</dd>
 
   <dt><code>--ffi &lt;file&gt;</code></dt>
   <dd>Bind signature-only TypeScript declarations to native C ABI symbols and link the manifest's archive, object, and system-library inputs. See <a href="/docs/ffi">Native FFI</a>.</dd>
@@ -156,6 +156,9 @@ With `--sparse`, the profile leaves out the functions the runs never reached. Th
   <dt><code>--explain-dynamic[=&lt;name&gt;]</code></dt>
   <dd>Coverage only. After the report, list the functions that already operate on values typed only at runtime and the bindings, fields, functions, classes and modules that unsupported constructs would move to the dynamic tier, each with the diagnostic behind it. With a name such as <code>x</code>, <code>Point</code>, or <code>Point.x</code>, show only the matching units. See <a href="/docs/coverage#dynamic-tier">Dynamic tier</a>.</dd>
 
+  <dt><code>--no-dynamic-tier-warning</code></dt>
+  <dd>Build and coverage. Leave out <code>SC6101</code>, the warning that names functions that likely run often and use untyped values. Not allowed with <code>--fail-on=dynamic</code>. See <a href="/docs/coverage#untyped-code-that-likely-runs-often">Untyped code that likely runs often</a>.</dd>
+
   <dt><code>--wasm &lt;file.wasm&gt;</code></dt>
   <dd>Coverage only. Report a WebAssembly module the program loads from a path its sources do not spell out. The report already lists modules whose paths the compiler resolves, modules inlined as base64 literals, and <code>.wasm</code> files shipped by packages that use WebAssembly; a <code>scriptc.wasm</code> array in <code>package.json</code> adds files the same way as this flag. Each module is listed with its size, whether it validates, and the WebAssembly proposals it uses. Builds translate the modules they find to native code; a build reads the <code>scriptc.wasm</code> array but not this flag. Repeatable.</dd>
 
diff --git a/docs/content/docs/coverage.mdx b/docs/content/docs/coverage.mdx
index 1bb645bd9..09f87bacd 100644
--- a/docs/content/docs/coverage.mdx
+++ b/docs/content/docs/coverage.mdx
@@ -62,6 +62,25 @@ Code that operates on values whose types are known only at runtime, such as `any
 
 `--tier=static-only` keeps every unsupported construct a blocker instead of moving it to the dynamic tier; code that already operates on runtime-typed values compiles as before. Today `auto`, the default, behaves the same way.
 
+### Untyped code that likely runs often
+
+When functions of the program's own files use untyped values and likely run often, `scriptc build` and coverage report them as an `SC6101` warning. For the Benchmarks Game n-body program in plain JavaScript:
+
+```console
+$ scriptc build nbody.js -o nbody
+warning SC6101: 3 functions that likely run often use untyped values, which runs slower than typed code:
+  advance (nbody.js:22): untyped JavaScript file, in a loop
+  energy (nbody.js:40): untyped JavaScript file, in a loop
+  offsetMomentum (nbody.js:12): untyped JavaScript file, in a loop
+  hint: add types to compile these statically; see scriptc coverage --explain-dynamic
+
+The program compiled. Adding types to these functions lets scriptc compile them to faster code.
+```
+
+Without a profile, a dynamic-tier function counts as likely to run often when a dynamic operation runs inside one of its loops, when a loop calls it, or when it calls itself. A function is named only when its source says why its values are untyped: a value typed `any` (for a `for...of` variable, the value it iterates), an untyped `JSON.parse` result, or an untyped JavaScript file. Dynamic code that runs once, such as setup code that reads an `any` configuration, is not reported, and neither are functions that are dynamic for an operation with no static lowering, which more types would not change.
+
+The warning names at most five functions, most likely to run often first, and gives the total. Dynamic-tier code in npm packages is summarized on one line with each package's function count. A build that comes from the cache repeats the warning. `--no-dynamic-tier-warning` leaves it out, and `--fail-on=dynamic` fails a coverage run on it.
+
 ## Diagnostic codes
 
 Coverage and `scriptc build` report the same diagnostic codes. Common ones include:
@@ -88,7 +107,7 @@ By default, `scriptc coverage` exits with status 0 whenever the program type-che
 $ scriptc coverage src/main.ts --fail-on=blockers
 ```
 
-`--fail-on=blockers` exits with status 1 when the program has blockers that would fail `scriptc build`. Blockers in unreached code and deferred operations don't count. `--fail-on=divergences` also fails on Node divergences. A program that doesn't type-check always exits with status 1.
+`--fail-on=blockers` exits with status 1 when the program has blockers that would fail `scriptc build`. Blockers in unreached code and deferred operations don't count. `--fail-on=divergences` also fails on Node divergences, and `--fail-on=dynamic` also fails on the `SC6101` warning for [untyped code that likely runs often](#untyped-code-that-likely-runs-often). A program that doesn't type-check always exits with status 1.
 
 Coverage caches its result. Running it again on an unchanged program, or after edits that only touch comments, reuses the previous verdict. Set `SCRIPTC_NO_CACHE=1` to turn the cache off.
 
@@ -174,7 +193,7 @@ For editors, CI annotations, and other tools, `scriptc coverage --print=diagnost
     </tr>
     <tr>
       <td><code>category</code></td>
-      <td><code>invalid-source</code> (the program has a TypeScript or JSON error), <code>unsupported</code> (valid code scriptc cannot compile yet), <code>divergence</code> (compiles, but can behave differently from Node.js), <code>environment</code> (project configuration, scriptc's type world, toolchain, or target), or <code>internal</code> (a compiler bug).</td>
+      <td><code>invalid-source</code> (the program has a TypeScript or JSON error), <code>unsupported</code> (valid code scriptc cannot compile yet), <code>divergence</code> (compiles, but can behave differently from Node.js), <code>performance</code> (compiles and behaves as under Node.js, but runs slower than typed code would), <code>environment</code> (project configuration, scriptc's type world, toolchain, or target), or <code>internal</code> (a compiler bug).</td>
     </tr>
     <tr>
       <td><code>severity</code></td>
diff --git a/packages/cli/src/bootstrap.ts b/packages/cli/src/bootstrap.ts
index 1a319f98d..242a7c6f7 100644
--- a/packages/cli/src/bootstrap.ts
+++ b/packages/cli/src/bootstrap.ts
@@ -160,6 +160,10 @@ async function tryFastPath(): Promise<number | null> {
   if (hit === null) return null;
   if (!values["keep-llvm"]) await rm(hit.llvmPath, { force: true });
   if (command === "build") {
+    // A cached build repeats its performance warning (SC6101).
+    const performance = hit.performance ?? [];
+    if (performance.length > 0 && values["dynamic-tier-warning"] !== false)
+      process.stderr.write(startup.renderPerformanceWarnings(performance) + "\n");
     process.stdout.write(`${outPath}\n`);
     return 0;
   }
@@ -217,6 +221,7 @@ async function coverageFastPath(
   const hit = await startup.readCoverageVerdict(resolve(inputArg), {}).catch(() => null);
   if (hit === null) return null;
   const { coverage, sourceTexts } = hit;
+  if (values["dynamic-tier-warning"] === false) delete coverage.performance;
   if (print === "diagnostics") {
     const envelope = startup.coverageEnvelope(coverage, {
       compilerVersion: packageVersion(),
diff --git a/packages/cli/test/dynamic-tier-warning.test.ts b/packages/cli/test/dynamic-tier-warning.test.ts
new file mode 100644
index 000000000..67de774d4
--- /dev/null
+++ b/packages/cli/test/dynamic-tier-warning.test.ts
@@ -0,0 +1,120 @@
+import { execFile } from "node:child_process";
+import { createRequire } from "node:module";
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { promisify } from "node:util";
+import { expect, test } from "vitest";
+
+const execFileAsync = promisify(execFile);
+const require = createRequire(import.meta.url);
+const repoRoot = join(import.meta.dirname, "../../..");
+const cliEntry = join(repoRoot, "packages/cli/src/main.ts");
+const tsxLoader = join(dirname(require.resolve("tsx/package.json")), "dist/loader.mjs");
+const fixtures = join(repoRoot, "tests/coverage-fixtures/dynamic-tier");
+
+const HEADER =
+  "warning SC6101: 3 functions that likely run often use untyped values, which runs slower than typed code:";
+const CLOSING =
+  "The program compiled. Adding types to these functions lets scriptc compile them to faster code.";
+
+async function cli(
+  args: string[],
+  cacheRoot: string,
+): Promise<{ code: number; stdout: string; stderr: string }> {
+  try {
+    const { stdout, stderr } = await execFileAsync(
+      process.execPath,
+      ["--import", tsxLoader, cliEntry, ...args],
+      {
+        env: { ...process.env, SCRIPTC_CACHE_DIR: cacheRoot, SCRIPTC_TIMING: "1" },
+        maxBuffer: 4 * 1024 * 1024,
+      },
+    );
+    return { code: 0, stdout, stderr };
+  } catch (err) {
+    const e = err as { code?: number; stdout?: string; stderr?: string };
+    return { code: e.code ?? 1, stdout: e.stdout ?? "", stderr: e.stderr ?? "" };
+  }
+}
+
+test("a build names its likely-hot untyped functions, also when it comes from the cache", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "scriptc-dynamic-tier-warning-"));
+  const cacheRoot = join(dir, "cache");
+  const outPath = join(dir, process.platform === "win32" ? "program.exe" : "program");
+  try {
+    await mkdir(cacheRoot, { mode: 0o700 });
+    const build = (extra: string[] = []) =>
+      cli(["build", join(fixtures, "hot.js"), "-o", outPath, ...extra], cacheRoot);
+
+    const first = await build();
+    expect(first.code).toBe(0);
+    expect(first.stderr).toContain("scriptc lowering");
+    expect(first.stderr).toContain(
+      [
+        HEADER,
+        "  centroid (hot.js:7): untyped JavaScript file, in a loop",
+        "  spread (hot.js:23): untyped JavaScript file, in a loop",
+        "  distance (hot.js:17): untyped JavaScript file, called in a loop",
+        "  hint: add types to compile these statically; see scriptc coverage --explain-dynamic",
+        "",
+        CLOSING,
+      ].join("\n"),
+    );
+
+    // The cache hit skips lowering and repeats the warning.
+    const cached = await build();
+    expect(cached.code).toBe(0);
+    expect(cached.stderr).not.toContain("scriptc lowering");
+    expect(cached.stderr).toContain(HEADER);
+    expect(cached.stderr).toContain(CLOSING);
+
+    const silenced = await build(["--no-dynamic-tier-warning"]);
+    expect(silenced.code).toBe(0);
+    expect(silenced.stderr).not.toContain("SC6101");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}, 300_000);
+
+test("untyped setup code builds without the warning", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "scriptc-dynamic-tier-quiet-"));
+  try {
+    await mkdir(join(dir, "cache"), { mode: 0o700 });
+    const result = await cli(
+      ["build", join(fixtures, "quiet.ts"), "-o", join(dir, "program")],
+      join(dir, "cache"),
+    );
+    expect(result.code).toBe(0);
+    expect(result.stderr).not.toContain("SC6101");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}, 300_000);
+
+test("coverage --fail-on=dynamic fails on the warning, and --no-dynamic-tier-warning cannot hide it", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "scriptc-dynamic-tier-fail-on-"));
+  try {
+    await mkdir(join(dir, "cache"), { mode: 0o700 });
+    const coverage = (file: string, extra: string[]) =>
+      cli(["coverage", join(fixtures, file), ...extra], join(dir, "cache"));
+
+    const hot = await coverage("hot.js", ["--fail-on=dynamic"]);
+    expect(hot.code).toBe(1);
+    expect(hot.stdout).toContain("untyped and likely hot");
+    expect((await coverage("hot.js", ["--fail-on=divergences"])).code).toBe(0);
+    expect((await coverage("quiet.ts", ["--fail-on=dynamic"])).code).toBe(0);
+
+    const silenced = await coverage("hot.js", ["--no-dynamic-tier-warning"]);
+    expect(silenced.code).toBe(0);
+    expect(silenced.stdout).not.toContain("untyped and likely hot");
+
+    const conflict = await coverage("hot.js", ["--fail-on=dynamic", "--no-dynamic-tier-warning"]);
+    expect(conflict.code).toBe(1);
+    expect(conflict.stderr).toContain(
+      "--fail-on=dynamic checks the warning --no-dynamic-tier-warning leaves out",
+    );
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}, 300_000);
diff --git a/packages/compiler/src/cli/command.ts b/packages/compiler/src/cli/command.ts
index 03160c6fa..3285aa7fa 100644
--- a/packages/compiler/src/cli/command.ts
+++ b/packages/compiler/src/cli/command.ts
@@ -13,6 +13,7 @@ import {
 import { TIER_MODES, type TierMode } from "../frontend/tier-analysis.js";
 import { buildEnvelope } from "../diagnostics/envelope.js";
 import { renderWarnings } from "../diagnostics/render.js";
+import { isPerformanceCode, renderPerformanceWarnings } from "../diagnostics/dynamic-tier.js";
 import { isNativeOptimization } from "../backend/optimization.js";
 import { setProvenanceSources } from "../frontend/provenance-registry.js";
 import type { CliHost, NativeCacheWarmProfile } from "./host.js";
@@ -284,8 +285,20 @@ async function main(args: string[], host: CliHost): Promise<number> {
     fail(`--print=diagnostics is a build/coverage option\n\n${USAGE}`);
   }
   const failOnRaw = values["fail-on"];
-  if (failOnRaw !== undefined && failOnRaw !== "blockers" && failOnRaw !== "divergences") {
-    fail(`unknown --fail-on value "${failOnRaw}" (supported: blockers, divergences)\n\n${USAGE}`);
+  if (
+    failOnRaw !== undefined &&
+    failOnRaw !== "blockers" &&
+    failOnRaw !== "divergences" &&
+    failOnRaw !== "dynamic"
+  ) {
+    fail(
+      `unknown --fail-on value "${failOnRaw}" (supported: blockers, divergences, dynamic)\n\n${USAGE}`,
+    );
+  }
+  // --no-dynamic-tier-warning leaves out SC6101 (diagnostics/dynamic-tier.ts).
+  const dynamicTierWarning = values["dynamic-tier-warning"] !== false;
+  if (failOnRaw === "dynamic" && !dynamicTierWarning) {
+    fail(`--fail-on=dynamic checks the warning --no-dynamic-tier-warning leaves out\n\n${USAGE}`);
   }
   if (failOnRaw !== undefined && command !== "coverage") {
     fail(`--fail-on is a coverage option (a build already fails on blockers)\n\n${USAGE}`);
@@ -430,6 +443,7 @@ async function main(args: string[], host: CliHost): Promise<number> {
       ...(explainDynamic !== undefined ? { explainDynamic: true } : {}),
       ...(wasmFiles.length > 0 ? { wasm: wasmFiles } : {}),
     });
+    if (!dynamicTierWarning) delete coverage.performance;
     if (printDiagnostics) {
       // Keep stdout pure JSON for tooling.
       const envelope = coverageEnvelope(coverage, {
@@ -517,7 +531,9 @@ async function main(args: string[], host: CliHost): Promise<number> {
       process.stderr.write(`\n${n} error${n === 1 ? "" : "s"}.\n`);
       throw new CliExit(1);
     }
-    const warnings = result.warnings ?? [];
+    const warnings = (result.warnings ?? []).filter(
+      (d) => dynamicTierWarning || !isPerformanceCode(d.code),
+    );
     if (printDiagnostics) {
       diagnosticsEnvelope = buildEnvelope({
         compilerVersion: host.version(),
@@ -530,12 +546,20 @@ async function main(args: string[], host: CliHost): Promise<number> {
       });
     } else if (warnings.length > 0 && command === "build") {
       // Divergence warnings never fail a build; they explain where the
-      // native program can behave differently from Node. `run` keeps
-      // stderr for the program's own output.
+      // native program can behave differently from Node. The performance
+      // warning names likely-hot functions that use untyped values. `run`
+      // keeps stderr for the program's own output.
       const color = process.stderr.isTTY ?? false;
-      process.stderr.write(
-        renderWarnings(warnings, result.sourceTexts ?? new Map(), { color }) + "\n",
-      );
+      const divergences = warnings.filter((d) => !isPerformanceCode(d.code));
+      const performance = warnings.filter((d) => isPerformanceCode(d.code));
+      if (divergences.length > 0)
+        process.stderr.write(
+          renderWarnings(divergences, result.sourceTexts ?? new Map(), { color }) + "\n",
+        );
+      if (performance.length > 0) {
+        if (divergences.length > 0) process.stderr.write("\n");
+        process.stderr.write(renderPerformanceWarnings(performance) + "\n");
+      }
     }
     if (result.artifact.kind === "exe") {
       if (!values["keep-llvm"]) rmSync(result.artifact.translationUnitPath, { force: true });
diff --git a/packages/compiler/src/cli/usage.ts b/packages/compiler/src/cli/usage.ts
index aa7408d2a..23e57c66f 100644
--- a/packages/compiler/src/cli/usage.ts
+++ b/packages/compiler/src/cli/usage.ts
@@ -31,10 +31,11 @@ Options:
                      (native-link-info implies --emit=obj and never links;
                      diagnostics prints the versioned JSON diagnostics
                      envelope for build and coverage)
-      --fail-on <blockers|divergences>
+      --fail-on <blockers|divergences|dynamic>
                      coverage only: exit 1 when the entry path has blockers
                      (a build would fail), or also when it has Node
-                     divergences
+                     divergences, or also when it has likely-hot functions
+                     that use untyped values (SC6101)
       --backend <b>  code generator (llvm)
       --optimization <release|dev|speed>
                      native optimization posture (default: release/-O2). dev
@@ -100,6 +101,9 @@ Options:
                      values and the bindings, fields, functions, classes and
                      modules the dynamic tier would take over, with the
                      refusal behind each; a name shows only that unit's chain
+      --no-dynamic-tier-warning
+                     build and coverage: leave out SC6101, the warning that
+                     names likely-hot functions that use untyped values
       --wasm <file.wasm>
                      coverage only: report a WebAssembly module the program
                      loads whose path its sources do not spell (repeatable;
@@ -131,6 +135,7 @@ export const CLI_OPTIONS = {
   "external-types": { type: "string", multiple: true },
   tier: { type: "string" },
   "explain-dynamic": { type: "string" },
+  "dynamic-tier-warning": { type: "boolean", default: true },
   wasm: { type: "string", multiple: true },
   lib: { type: "boolean", default: false },
   profile: { type: "string" },
diff --git a/packages/compiler/src/coverage/report.ts b/packages/compiler/src/coverage/report.ts
index 89733e255..37f77f4c6 100644
--- a/packages/compiler/src/coverage/report.ts
+++ b/packages/compiler/src/coverage/report.ts
@@ -42,6 +42,10 @@ export interface CoverageInput {
    * the program compiles, but these sites can behave differently natively.
    * Never blockers; `--fail-on=divergences` opts into failing on them. */
   divergences?: ScrDiagnostic[];
+  /** The performance warning (SC6101): likely-hot functions the source
+   * leaves untyped. Never blockers; `--fail-on=dynamic` opts into failing
+   * on it. */
+  performance?: ScrDiagnostic[];
   /** Each dependency's native compilation outcome, with the first refusal
    * reason for a refused package. */
   npmStatic?: NpmStaticStatus[];
@@ -333,6 +337,17 @@ export function renderCoverage(input: CoverageInput, opts: CoverageRenderOptions
     );
     renderRows(groupBlockers(divergences), YELLOW);
   };
+  // The performance warning: its message names the functions.
+  const performance = input.performance ?? [];
+  const renderPerformance = () => {
+    for (const d of performance) {
+      out.push("");
+      const [head, ...rest] = d.message.split("\n");
+      out.push(`  ${c(YELLOW, "untyped and likely hot")}   ${head}`);
+      for (const line of rest) out.push(`  ${line}`);
+      if (d.hint !== undefined) out.push(`    ${c(DIM, `hint: ${d.hint}`)}`);
+    }
+  };
 
   const unreachedDiags = [...(un?.diagnostics ?? []), ...(un?.runtimeFences ?? [])];
   if (failed === 0 && input.diagnostics.length === 0 && unreachedDiags.length === 0) {
@@ -341,6 +356,7 @@ export function renderCoverage(input: CoverageInput, opts: CoverageRenderOptions
       out.push("");
       renderDivergences();
     }
+    renderPerformance();
     return out.join("\n");
   }
 
@@ -381,6 +397,7 @@ export function renderCoverage(input: CoverageInput, opts: CoverageRenderOptions
     out.push("");
     renderDivergences();
   }
+  renderPerformance();
   return out.join("\n");
 }
 
@@ -449,8 +466,9 @@ function displayPath(file: string, root: string | undefined): string {
 }
 
 /** What `coverage --fail-on` checks: reached blockers (they fail a build)
- * and, optionally, divergences. Unreached blockers never fail. */
-export type CoverageFailOn = "blockers" | "divergences";
+ * and, optionally, divergences or the performance warning. Unreached
+ * blockers never fail. */
+export type CoverageFailOn = "blockers" | "divergences" | "dynamic";
 
 /** Whether the analysis passes the selected gate. Preflight failures
  * always fail; `failOn` undefined means only preflight fails (the report's
@@ -462,6 +480,7 @@ export function coveragePasses(input: CoverageInput, failOn?: CoverageFailOn): b
   // runtime fences build (the statement throws only if it executes).
   if (input.diagnostics.length > 0) return false;
   if (failOn === "divergences" && (input.divergences?.length ?? 0) > 0) return false;
+  if (failOn === "dynamic" && (input.performance?.length ?? 0) > 0) return false;
   return true;
 }
 
@@ -492,6 +511,7 @@ export function coverageEnvelope(
     add(input.unreached?.diagnostics, "unreached");
     add(input.unreached?.runtimeFences, "deferred");
     add(input.divergences, "reached");
+    add(input.performance, "reached");
   }
   const un = input.unreached;
   const total = input.stats.statementsTotal + (un?.stats.statementsTotal ?? 0);
diff --git a/packages/compiler/src/coverage/verdict-cache.ts b/packages/compiler/src/coverage/verdict-cache.ts
index 422bf5e4d..e5fa7242e 100644
--- a/packages/compiler/src/coverage/verdict-cache.ts
+++ b/packages/compiler/src/coverage/verdict-cache.ts
@@ -38,6 +38,7 @@ export interface CachedCoverage {
   runtimeFences?: ScrDiagnostic[];
   unreached?: { stats: LowerStats; diagnostics: ScrDiagnostic[]; runtimeFences?: ScrDiagnostic[] };
   divergences?: ScrDiagnostic[];
+  performance?: ScrDiagnostic[];
   npmStatic?: NpmStaticStatus[];
   wasmModules?: WasmModuleReport[];
   preflightFailed: boolean;
@@ -149,6 +150,7 @@ function cacheable(coverage: AnalyzeResult["coverage"]): CachedCoverage | null {
   if (coverage.runtimeFences !== undefined) out.runtimeFences = coverage.runtimeFences;
   if (coverage.unreached !== undefined) out.unreached = coverage.unreached;
   if (coverage.divergences !== undefined) out.divergences = coverage.divergences;
+  if (coverage.performance !== undefined) out.performance = coverage.performance;
   if (coverage.npmStatic !== undefined) out.npmStatic = coverage.npmStatic;
   if (coverage.wasmModules !== undefined) out.wasmModules = coverage.wasmModules;
   return out;
@@ -166,6 +168,7 @@ function restore(cached: CachedCoverage, sources: CachedSource[]): AnalyzeResult
   if (cached.runtimeFences !== undefined) coverage.runtimeFences = cached.runtimeFences;
   if (cached.unreached !== undefined) coverage.unreached = cached.unreached;
   if (cached.divergences !== undefined) coverage.divergences = cached.divergences;
+  if (cached.performance !== undefined) coverage.performance = cached.performance;
   if (cached.npmStatic !== undefined) coverage.npmStatic = cached.npmStatic;
   if (cached.wasmModules !== undefined) coverage.wasmModules = cached.wasmModules;
   return { coverage, sourceTexts };
diff --git a/packages/compiler/src/coverage/verdict-semantic.ts b/packages/compiler/src/coverage/verdict-semantic.ts
index cc1c1f414..ad2f4d180 100644
--- a/packages/compiler/src/coverage/verdict-semantic.ts
+++ b/packages/compiler/src/coverage/verdict-semantic.ts
@@ -7,6 +7,9 @@ import { rebaseSourceLocations, semanticallyEqualSource } from "../library/seman
 import type { SemanticReplay } from "./verdict-cache.js";
 
 export const commentOnlyReplay: SemanticReplay = (probes, sources, coverage) => {
+  // The performance warning's text names file:line positions, which moving
+  // its locations would not update: such a verdict is analyzed again.
+  if (coverage.performance !== undefined) return null;
   const previous = new Map<string, string>();
   for (const source of sources) previous.set(source.path, source.text);
   const match = frontendInputsSemanticallyMatch(probes, previous, semanticallyEqualSource);
diff --git a/packages/compiler/src/diagnostics/diagnostic.ts b/packages/compiler/src/diagnostics/diagnostic.ts
index e4d4006ca..17cb2efc0 100644
--- a/packages/compiler/src/diagnostics/diagnostic.ts
+++ b/packages/compiler/src/diagnostics/diagnostic.ts
@@ -61,7 +61,10 @@
  *            collation does not cover (SC6003), a call feeding an instance
  *            to a cast to an unrelated class (SC6004); SC6005 (Date strings
  *            outside the native parser's grammar) is retired — the runtime
- *            parses date strings with V8's grammar
+ *            parses date strings with V8's grammar. SC61xx are performance
+ *            notes, also warnings (coverage --fail-on=dynamic opts in):
+ *            likely-hot functions that use untyped values (SC6101,
+ *            diagnostics/dynamic-tier.ts)
  *   SC9xxx  internal compiler errors (still source-anchored)
  */
 import type { SrcLoc } from "../ir/ir.js";
diff --git a/packages/compiler/src/diagnostics/dynamic-tier.ts b/packages/compiler/src/diagnostics/dynamic-tier.ts
new file mode 100644
index 000000000..7970d3f42
--- /dev/null
+++ b/packages/compiler/src/diagnostics/dynamic-tier.ts
@@ -0,0 +1,99 @@
+/* SC6101, the dynamic-tier performance warning: its text and how it prints.
+ * All of the warning's wording is here. The functions it names come from
+ * frontend/lowering/dynamic-tier.ts; this module only formats them, and it
+ * imports nothing heavy so the CLI's routed cache hit can print a stored
+ * warning without loading the compiler. */
+import type { SrcLoc } from "../ir/ir.js";
+import type { ScrDiagnostic } from "./diagnostic.js";
+
+/** The code of the warning; SC61xx are performance notes, SC60xx divergences. */
+export const DYNAMIC_TIER_CODE = "SC6101";
+
+/** At most this many functions are named; the count covers all of them. */
+export const DYNAMIC_TIER_SHOWN = 5;
+
+/** Why a function counts as likely to run often. */
+export type HotReason = "loop" | "called-in-loop" | "recursive";
+
+const HOT_PHRASE: Record<HotReason, string> = {
+  loop: "in a loop",
+  "called-in-loop": "called in a loop",
+  recursive: "recursive",
+};
+
+/** Why a function's values are untyped, as the warning words it. */
+export type UntypedCause =
+  | { kind: "any"; name: string }
+  | { kind: "json-binding"; name: string }
+  | { kind: "json" }
+  | { kind: "javascript" };
+
+export function causePhrase(cause: UntypedCause): string {
+  switch (cause.kind) {
+    case "any":
+      return `\`${cause.name}\` is \`any\``;
+    case "json-binding":
+      return `\`${cause.name}\` holds an untyped \`JSON.parse\` result`;
+    case "json":
+      return "untyped `JSON.parse` result";
+    case "javascript":
+      return "untyped JavaScript file";
+  }
+}
+
+export interface DynamicTierEntry {
+  /** Display name (`advance`, `Parser.next`). */
+  name: string;
+  /** `file:line`, relative to the entry's directory. */
+  where: string;
+  cause: UntypedCause;
+  hot: HotReason;
+}
+
+export interface DynamicTierPackageCount {
+  name: string;
+  functions: number;
+}
+
+/** The SC6101 diagnostic for likely-hot functions with untyped values, or
+ * null when there are none. `loc` is the first function's declaration. */
+export function dynamicTierDiag(
+  entries: readonly DynamicTierEntry[],
+  packages: readonly DynamicTierPackageCount[],
+  loc: SrcLoc,
+): ScrDiagnostic | null {
+  const n = entries.length;
+  if (n === 0) return null;
+  const shown = entries.slice(0, DYNAMIC_TIER_SHOWN);
+  const lines = [
+    `${n} function${n === 1 ? "" : "s"} that likely run${n === 1 ? "s" : ""} often use${n === 1 ? "s" : ""} untyped values, which runs slower than typed code:`,
+    ...shown.map((e) => `  ${e.name} (${e.where}): ${causePhrase(e.cause)}, ${HOT_PHRASE[e.hot]}`),
+    ...(n > shown.length ? [`  and ${n - shown.length} more`] : []),
+    ...(packages.length === 0
+      ? []
+      : [
+          `  untyped code in npm packages: ${packages
+            .map((p) => `${p.name} (${p.functions} function${p.functions === 1 ? "" : "s"})`)
+            .join(", ")}`,
+        ]),
+  ];
+  return {
+    code: DYNAMIC_TIER_CODE,
+    message: lines.join("\n"),
+    loc,
+    hint: "add types to compile these statically; see scriptc coverage --explain-dynamic",
+  };
+}
+
+export function isPerformanceCode(code: string): boolean {
+  return /^SC61\d{2}$/.test(code);
+}
+
+/** The warning as a build prints it: no source excerpt (it names several
+ * functions), then its closing line. */
+export function renderPerformanceWarnings(diags: readonly ScrDiagnostic[]): string {
+  const blocks = diags.map(
+    (d) => `warning ${d.code}: ${d.message}${d.hint === undefined ? "" : `\n  hint: ${d.hint}`}`,
+  );
+  return `${blocks.join("\n\n")}\n\nThe program compiled. Adding types to these functions lets scriptc compile them to faster code.`;
+}
diff --git a/packages/compiler/src/diagnostics/envelope.ts b/packages/compiler/src/diagnostics/envelope.ts
index c986fc5b1..59c285ead 100644
--- a/packages/compiler/src/diagnostics/envelope.ts
+++ b/packages/compiler/src/diagnostics/envelope.ts
@@ -16,6 +16,7 @@
  * bumps it. */
 import { readFileSync } from "node:fs";
 import type { ScrDiagnostic } from "./diagnostic.js";
+import { isPerformanceCode } from "./dynamic-tier.js";
 import type { WasmModuleReport } from "../wasm/discover.js";
 
 export const DIAGNOSTICS_SCHEMA = "scriptc-diagnostics";
@@ -25,12 +26,14 @@ export const DIAGNOSTICS_SCHEMA_VERSION = 1;
  *  - invalid-source: the program itself is wrong (TypeScript errors, bad JSON modules)
  *  - unsupported: valid TypeScript/JavaScript scriptc cannot compile yet
  *  - divergence: compiles, but the native program behaves differently from Node
+ *  - performance: compiles and behaves as under Node, but runs slower than typed code would
  *  - environment: project configuration, scriptc's type world, toolchain or target
  *  - internal: a compiler bug */
 export type DiagnosticCategory =
   | "invalid-source"
   | "unsupported"
   | "divergence"
+  | "performance"
   | "environment"
   | "internal";
 
@@ -149,12 +152,13 @@ export interface DiagnosticsEnvelope {
 /** The divergence band: compiles, but the program can behave differently
  * from Node. Warnings, never build failures. */
 export function isDivergenceCode(code: string): boolean {
-  return /^SC6\d{3}$/.test(code);
+  return /^SC60\d{2}$/.test(code);
 }
 
 export function categoryOf(diag: ScrDiagnostic): DiagnosticCategory {
   const code = diag.code;
   if (isDivergenceCode(code)) return "divergence";
+  if (isPerformanceCode(code)) return "performance";
   if (code === "SC0001") return diag.typeWorld === true ? "environment" : "invalid-source";
   if (code === "SC0003") return "invalid-source";
   if (code === "SC0002" || code === "SC0004") return "environment";
@@ -274,7 +278,7 @@ export function locateDiagnostic(
   return {
     code: diag.code,
     category: categoryOf(diag),
-    severity: isDivergenceCode(diag.code) ? "warning" : "error",
+    severity: isDivergenceCode(diag.code) || isPerformanceCode(diag.code) ? "warning" : "error",
     scope,
     file: diag.loc.file,
     line: start.line,
diff --git a/packages/compiler/src/executable/executable-cache.ts b/packages/compiler/src/executable/executable-cache.ts
index c1e3d8725..2312f5e85 100644
--- a/packages/compiler/src/executable/executable-cache.ts
+++ b/packages/compiler/src/executable/executable-cache.ts
@@ -11,6 +11,7 @@ import {
   writeFile,
 } from "node:fs/promises";
 import { basename, dirname, join, resolve } from "node:path";
+import type { ScrDiagnostic } from "../diagnostics/diagnostic.js";
 import type { FrontendInputSnapshot } from "../frontend/input-tracker.js";
 import { frontendInputsStillMatch, validFrontendInputSnapshot } from "../frontend/input-tracker.js";
 import { compilerReleaseVersion } from "../library/sidecar.js";
@@ -112,6 +113,8 @@ interface EarlyExecutableCacheStamp {
   };
   nativeDependencies: NativeArtifactDependency[] | null;
   native: EarlyExecutableNativeFeatures;
+  /** The build's performance warnings (SC61xx), which a cache hit repeats. */
+  performance?: ScrDiagnostic[];
   integrity: string;
 }
 
@@ -181,6 +184,8 @@ export interface EarlyExecutableCacheHit {
   executableRestored: boolean;
   native: EarlyExecutableNativeFeatures;
   frontend: FrontendInputSnapshot;
+  /** The performance warnings the build reported (SC61xx), repeated on a hit. */
+  performance?: ScrDiagnostic[];
 }
 
 export interface EarlyExecutableCachePublish extends EarlyExecutableCacheHit {
@@ -610,6 +615,9 @@ async function readExecutableCache(
       native: stamp.native,
       executableRestored,
       frontend: stamp.frontend,
+      ...(Array.isArray(stamp.performance) && stamp.performance.length > 0
+        ? { performance: stamp.performance }
+        : {}),
       ...(ir === null ? {} : { irPath: paths.irPath }),
     };
   } catch {
@@ -793,6 +801,9 @@ export async function publishEarlyExecutableCache(
       },
       nativeDependencies: executable === null ? null : result.nativeDependencies!,
       native: result.native,
+      ...(result.performance === undefined || result.performance.length === 0
+        ? {}
+        : { performance: result.performance }),
     };
     const stamp: EarlyExecutableCacheStamp = { ...unsigned, integrity: stampIntegrity(unsigned) };
     await writeFile(join(stage, "stamp.json"), `${JSON.stringify(stamp)}\n`, { mode: 0o600 });
diff --git a/packages/compiler/src/executable/prepare.ts b/packages/compiler/src/executable/prepare.ts
index 4afae7c7d..1771f98f5 100644
--- a/packages/compiler/src/executable/prepare.ts
+++ b/packages/compiler/src/executable/prepare.ts
@@ -122,6 +122,6 @@ export function prepareExecutableModule(
     mod: lowered.module!,
     sourceTexts,
     stats: lowered.stats,
-    warnings: lowered.divergences ?? [],
+    warnings: [...(lowered.divergences ?? []), ...(lowered.performance ?? [])],
   };
 }
diff --git a/packages/compiler/src/frontend/analysis.ts b/packages/compiler/src/frontend/analysis.ts
index 43d0aa2bb..776492eb1 100644
--- a/packages/compiler/src/frontend/analysis.ts
+++ b/packages/compiler/src/frontend/analysis.ts
@@ -106,6 +106,7 @@ export function analyzeWithFrontend(
         diagnostics: [...preflight, ...lowered.diagnostics],
         ...(lowered.runtimeFences.length > 0 ? { runtimeFences: lowered.runtimeFences } : {}),
         ...(lowered.divergences !== undefined ? { divergences: lowered.divergences } : {}),
+        ...(lowered.performance !== undefined ? { performance: lowered.performance } : {}),
         ...(lowered.unreached ? { unreached: lowered.unreached } : {}),
         ...(fe.npmStatic.length > 0 ? { npmStatic: fe.npmStatic } : {}),
         // --provenance-sources: the per-package attribution inputs (the
diff --git a/packages/compiler/src/frontend/lowering/dynamic-tier.ts b/packages/compiler/src/frontend/lowering/dynamic-tier.ts
new file mode 100644
index 000000000..873b22343
--- /dev/null
+++ b/packages/compiler/src/frontend/lowering/dynamic-tier.ts
@@ -0,0 +1,284 @@
+/* Hot dynamic-tier functions (SC6101, diagnostics/dynamic-tier.ts): the
+ * functions of a program that compile to the dynamic tier (ir/tiers.ts) and
+ * likely run often, so a build can name them. Without a profile, a function
+ * counts as likely hot when a dynamic operation runs inside one of its
+ * loops, when a loop calls it, or when it calls itself. Dynamic code that
+ * runs once (setup code that reads an `any` configuration, for example)
+ * stays quiet.
+ *
+ * The tier assignment is the one lowering made (Lowerer.dynamicFunctions);
+ * this module ranks its functions and says why each one is dynamic, from
+ * the source at its dynamic operations. A function is named only when the
+ * source says why (an `any`, an untyped `JSON.parse` result, an untyped
+ * JavaScript file): functions dynamic for operations without a static
+ * lowering would stay dynamic with more types. */
+import { relative } from "node:path";
+import type { ScrDiagnostic } from "../../diagnostics/diagnostic.js";
+import {
+  dynamicTierDiag,
+  type DynamicTierPackageCount,
+  type HotReason,
+  type UntypedCause,
+} from "../../diagnostics/dynamic-tier.js";
+import type { IrExpr, IrFunction, IrModule, IrStmt, SrcLoc } from "../../ir/ir.js";
+import { dynamicOperationSites } from "../../ir/tiers.js";
+import { everyStmtList } from "../../ir/traverse.js";
+import * as ts from "../ts7/adapter.js";
+import { isCheckedJsSourceFile, isJsSourceFile } from "../program.js";
+import { isNodeModulesPath } from "../resolve.js";
+import type { Lowerer } from "./lowerer.js";
+
+export interface HotDynamicFunction {
+  /** The IR function name (`%Point.norm`, `parse`, ...). */
+  name: string;
+  loc: SrcLoc;
+  hot: HotReason;
+  /** Dynamic operations inside the function's loops. */
+  loopOperations: number;
+  cause: UntypedCause;
+}
+
+export interface DynamicTierReport {
+  /** Likely-hot dynamic functions in the program's own files, most likely
+   * hot first. */
+  hot: HotDynamicFunction[];
+  /** Dynamic-tier functions in npm packages, by package. */
+  packages: DynamicTierPackageCount[];
+}
+
+const LOOP_KINDS = new Set(["while", "doWhile", "for", "forOf"]);
+
+function within(loc: SrcLoc, spans: readonly SrcLoc[]): boolean {
+  return spans.some((s) => s.file === loc.file && s.start <= loc.start && loc.end <= s.end);
+}
+
+interface FunctionFacts {
+  loops: SrcLoc[];
+  /** Callee names of direct calls, with each call's location. */
+  calls: { callee: string; loc: SrcLoc }[];
+}
+
+function factsOf(fn: IrFunction): FunctionFacts {
+  const facts: FunctionFacts = { loops: [], calls: [] };
+  everyStmtList(fn.body, {
+    stmt: (s: IrStmt) => {
+      if (LOOP_KINDS.has(s.kind)) facts.loops.push(s.loc);
+      return true;
+    },
+    expr: (e: IrExpr) => {
+      if (e.kind === "call") facts.calls.push({ callee: e.callee, loc: e.loc });
+      return true;
+    },
+  });
+  return facts;
+}
+
+/** The package directory name of a node_modules path (`@scope/name` or `name`). */
+function packageOf(file: string): string {
+  const parts = file.split("/");
+  const at = parts.lastIndexOf("node_modules");
+  const first = parts[at + 1] ?? "";
+  return first.startsWith("@") ? `${first}/${parts[at + 2] ?? ""}` : first;
+}
+
+/** The innermost node spanning [start, end). */
+function nodeAt(sf: ts.SourceFile, start: number, end: number): ts.Node {
+  let node: ts.Node = sf;
+  for (;;) {
+    let next: ts.Node | undefined;
+    ts.forEachChild(node, (child) => {
+      if (ts.tokenStartOfNode(child) <= start && end <= child.end) {
+        next = child;
+        return true;
+      }
+      return undefined;
+    });
+    if (next === undefined) return node;
+    node = next;
+  }
+}
+
+/** The identifier an operand reads through (`items` in `items[i].x`). */
+function rootIdentifier(node: ts.Node): ts.Identifier | null {
+  let n: ts.Node = node;
+  for (;;) {
+    if (ts.isIdentifier(n)) return n;
+    if (
+      ts.isPropertyAccessExpression(n) ||
+      ts.isElementAccessExpression(n) ||
+      ts.isCallExpression(n)
+    )
+      n = n.expression;
+    else if (ts.isParenthesizedExpression(n) || ts.isNonNullExpression(n)) n = n.expression;
+    else return null;
+  }
+}
+
+function isJsonParse(node: ts.Node | undefined): boolean {
+  if (node === undefined || !ts.isCallExpression(node)) return false;
+  const callee = node.expression;
+  return (
+    ts.isPropertyAccessExpression(callee) &&
+    ts.isIdentifier(callee.expression) &&
+    callee.expression.text === "JSON" &&
+    callee.name.text === "parse"
+  );
+}
+
+/** Why an identifier holds a value without a static type, or null. */
+function identifierCause(lowerer: Lowerer, id: ts.Identifier, depth = 0): UntypedCause | null {
+  const symbol = lowerer.checker.getSymbolAtLocation(id);
+  const decl = symbol?.declarations?.[0];
+  // An unannotated `for (const item of items)` variable: name `items`.
+  if (
+    depth < 4 &&
+    decl !== undefined &&
+    ts.isVariableDeclaration(decl) &&
+    decl.type === undefined &&
+    ts.isVariableDeclarationList(decl.parent) &&
+    ts.isForOfStatement(decl.parent.parent)
+  ) {
+    const iterated = rootIdentifier(decl.parent.parent.expression);
+    if (iterated !== null) {
+      const cause = identifierCause(lowerer, iterated, depth + 1);
+      if (cause !== null) return cause;
+    }
+  }
+  if (decl !== undefined && ts.isVariableDeclaration(decl) && isJsonParse(decl.initializer))
+    return { kind: "json-binding", name: id.text };
+  const type = lowerer.checker.getTypeAtLocation(id);
+  if ((type.flags & ts.TypeFlags.Any) !== 0) return { kind: "any", name: id.text };
+  return null;
+}
+
+/** Why a node's value has no static type, or null. */
+function nodeCause(lowerer: Lowerer, n: ts.Node): UntypedCause | null {
+  if (isJsonParse(n)) return { kind: "json" };
+  const id = rootIdentifier(n);
+  return id === null ? null : identifierCause(lowerer, id);
+}
+
+/** Why the dynamic operation at `loc` has no static type, or null when
+ * the source does not say. The site's own subexpressions are asked first
+ * (the operand of a dynamic `for...of`), then its ancestors. */
+function causeAt(lowerer: Lowerer, loc: SrcLoc): UntypedCause | null {
+  const sf = lowerer.program.getSourceFile(loc.file);
+  if (sf === undefined) return null;
+  if (isJsSourceFile(sf) && !isCheckedJsSourceFile(sf, lowerer.projectCheckJs))
+    return { kind: "javascript" };
+  const node = nodeAt(sf, loc.start, loc.end);
+  let found: UntypedCause | null = null;
+  const descend = (n: ts.Node, depth: number): void => {
+    if (found !== null || depth > 3) return;
+    found = nodeCause(lowerer, n);
+    if (found === null)
+      ts.forEachChild(n, (child) => (descend(child, depth + 1), found !== null || undefined));
+  };
+  descend(node, 0);
+  for (
+    let n: ts.Node | undefined = node.parent;
+    found === null && n !== undefined && n !== sf;
+    n = n.parent
+  )
+    found = nodeCause(lowerer, n);
+  return found;
+}
+
+/** The first cause the function's dynamic operations name, loop sites
+ * first, or null when none names one. */
+function causeOf(lowerer: Lowerer, sites: readonly { loc: SrcLoc }[]): UntypedCause | null {
+  for (const site of sites) {
+    const cause = causeAt(lowerer, site.loc);
+    if (cause !== null) return cause;
+  }
+  return null;
+}
+
+/** The likely-hot dynamic-tier functions of `module` (see the header). */
+export function scanDynamicTier(lowerer: Lowerer, module: IrModule): DynamicTierReport {
+  const facts = new Map<string, FunctionFacts>();
+  for (const fn of module.functions) facts.set(fn.name, factsOf(fn));
+  // Functions some loop calls directly.
+  const calledInLoop = new Set<string>();
+  for (const fn of module.functions) {
+    const f = facts.get(fn.name)!;
+    for (const call of f.calls) if (within(call.loc, f.loops)) calledInLoop.add(call.callee);
+  }
+  const hot: HotDynamicFunction[] = [];
+  const packages = new Map<string, number>();
+  for (const fn of module.functions) {
+    // Generated `%dyn.*` helpers are dynamic operations lowered out of line,
+    // and `%init.*` is a module's top level: neither is a function to name.
+    if (fn.tier !== "dynamic" || fn.name.startsWith("%dyn.") || fn.name.startsWith("%init."))
+      continue;
+    if (isNodeModulesPath(fn.loc.file)) {
+      const name = packageOf(fn.loc.file);
+      packages.set(name, (packages.get(name) ?? 0) + 1);
+      continue;
+    }
+    const f = facts.get(fn.name)!;
+    const sites = dynamicOperationSites(fn);
+    const inLoops = sites.filter((s) => within(s.loc, f.loops));
+    const recursive = f.calls.some((c) => c.callee === fn.name);
+    const reason: HotReason | null =
+      inLoops.length > 0
+        ? "loop"
+        : calledInLoop.has(fn.name)
+          ? "called-in-loop"
+          : recursive
+            ? "recursive"
+            : null;
+    if (reason === null) continue;
+    // Only functions the source makes dynamic are named: ones dynamic for
+    // operations without a static lowering would stay dynamic with more types.
+    const cause = causeOf(lowerer, [...inLoops, ...sites.filter((s) => !inLoops.includes(s))]);
+    if (cause === null) continue;
+    hot.push({
+      name: fn.name,
+      loc: fn.loc,
+      hot: reason,
+      loopOperations: inLoops.length,
+      cause,
+    });
+  }
+  const rank = { loop: 0, "called-in-loop": 1, recursive: 2 } as const;
+  hot.sort((a, b) => rank[a.hot] - rank[b.hot] || b.loopOperations - a.loopOperations);
+  return {
+    hot,
+    packages: [...packages]
+      .map(([name, functions]) => ({ name, functions }))
+      .sort((a, b) => b.functions - a.functions || (a.name < b.name ? -1 : 1)),
+  };
+}
+
+/** `%%m144.Session.finish` → `Session.finish`, `m163.find` → `find`. */
+function displayName(name: string): string {
+  return name.replace(/^%+/, "").replace(/^m\d+\./, "");
+}
+
+/** SC6101 for the program lowering produced, or null (see the header).
+ * Paths are relative to `root`, the entry's directory. */
+export function dynamicTierWarning(
+  lowerer: Lowerer,
+  module: IrModule,
+  root: string,
+): ScrDiagnostic | null {
+  const report = scanDynamicTier(lowerer, module);
+  const first = report.hot[0];
+  if (first === undefined) return null;
+  const where = (loc: SrcLoc): string => {
+    const sf = lowerer.program.getSourceFile(loc.file);
+    const line = sf === undefined ? 0 : ts.getLineAndCharacterOfPosition(sf, loc.start).line + 1;
+    return `${relative(root, loc.file) || loc.file}:${line}`;
+  };
+  return dynamicTierDiag(
+    report.hot.map((f) => ({
+      name: displayName(f.name),
+      where: where(f.loc),
+      cause: f.cause,
+      hot: f.hot,
+    })),
+    report.packages,
+    first.loc,
+  );
+}
diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts
index c4d24cef1..2bd527285 100644
--- a/packages/compiler/src/frontend/lowering/lowerer.ts
+++ b/packages/compiler/src/frontend/lowering/lowerer.ts
@@ -148,6 +148,7 @@ import { ClassProtocols } from "./class-protocols.js";
 import { earlyReadVarSymbols } from "./var-hoisting.js";
 import { recordTextCodecClass } from "../../ir/ir.js";
 import { assignLegacyTiers, type DynamicFunction } from "../../ir/tiers.js";
+import { dynamicTierWarning } from "./dynamic-tier.js";
 import { promoteJsvals } from "../../ir/jsval.js";
 import {
   analyzeTiers,
@@ -176,7 +177,7 @@ export { newFnCtx, type FnCtx } from "./function-context.js";
  * - Lexical scoping is resolved here: locals get function-unique ids
  *   ("x.0", "x.1" for shadowing); the IR is scope-flat.
  */
-import { resolve } from "node:path";
+import { dirname, resolve } from "node:path";
 import { bindingSource } from "../binding-source.js";
 import { tsgoPath } from "../dts-paths.js";
 import * as ts from "../ts7/adapter.js";
@@ -786,6 +787,9 @@ export interface LowerResult {
   /** Compile-time-detectable behavior differences from Node (SC6xxx
    * divergence warnings) in the program's own modules. Never failures. */
   divergences?: ScrDiagnostic[];
+  /** Performance warnings (SC61xx): the likely-hot functions the source
+   * leaves untyped (lowering/dynamic-tier.ts). Never failures. */
+  performance?: ScrDiagnostic[];
   /** Functions lowering placed in the dynamic tier (ir/tiers.ts), present
    * when there are any. */
   dynamicFunctions?: DynamicFunction[];
@@ -1162,6 +1166,13 @@ export function lowerToIr(
   const divergences = scanDivergences(resultLowerer, moduleOrder);
   timing("divergence-scan", { found: divergences.length });
   if (divergences.length > 0) result = { ...result, divergences };
+  // The performance warning (SC6101): likely-hot functions of the program
+  // that compile to the dynamic tier because the source leaves them untyped.
+  if (result.module !== null && resultLowerer.dynamicFunctions.length > 0) {
+    const hotDynamic = dynamicTierWarning(resultLowerer, result.module, dirname(entry.fileName));
+    timing("dynamic-tier-scan", { found: hotDynamic === null ? 0 : 1 });
+    if (hotDynamic !== null) result = { ...result, performance: [hotDynamic] };
+  }
   // Contract types (@scriptc/types): written annotations, checked against
   // the IR by the compile pipeline (contracts/check.ts).
   // Acyclic object types name the IR unit the program lowered them to; a
diff --git a/packages/compiler/src/index.ts b/packages/compiler/src/index.ts
index a1f8601cc..92ee6b75e 100644
--- a/packages/compiler/src/index.ts
+++ b/packages/compiler/src/index.ts
@@ -157,6 +157,7 @@ import {
   type EarlyExecutableNativeFeatures,
 } from "./executable/executable-cache.js";
 import { compilerImplementationIdentity } from "./library/compiler-self-identity.js";
+import { isPerformanceCode } from "./diagnostics/dynamic-tier.js";
 
 export const VERSION = "0.0.1";
 
@@ -454,6 +455,15 @@ interface CompileWarningSink {
   sourceTexts: Map<string, string> | null;
 }
 
+/** The build's performance warnings (SC61xx), stored with its cache entry
+ * so a cache hit repeats them. */
+function performanceWarnings(sink: CompileWarningSink | undefined): {
+  performance?: ScrDiagnostic[];
+} {
+  const performance = (sink?.warnings ?? []).filter((d) => isPerformanceCode(d.code));
+  return performance.length === 0 ? {} : { performance };
+}
+
 function withCompileWarnings<T extends CompileRequestResult>(
   result: T,
   sink: CompileWarningSink,
@@ -1406,6 +1416,12 @@ async function compileTracked(
     if (earlyCacheOptions === null) {
       throw new InternalCompilerError("executable cache hit without executable cache options");
     }
+    // A cached build repeats its performance warning (SC6101): the code it
+    // names is just as untyped as when it was built.
+    if (warningSink !== undefined && earlyHit.performance !== undefined) {
+      warningSink.warnings = earlyHit.performance;
+      warningSink.sourceTexts = new Map();
+    }
     const executableCacheOptions = earlyCacheOptions;
     // Route/proof metadata is independently evictable. A full-compiler
     // fallback that still finds the validated payload repairs that lightweight
@@ -1595,6 +1611,7 @@ async function compileTracked(
               nativeDependencies: dependencies,
               frontend: frontendInputs.snapshot(),
               ...(irPath === undefined ? {} : { irPath }),
+              ...performanceWarnings(warningSink),
             });
             publishedExecutable = true;
           },
@@ -1636,6 +1653,7 @@ async function compileTracked(
       executableRestored: false,
       frontend: frontendInputs.snapshot(),
       ...(irPath === undefined ? {} : { irPath }),
+      ...performanceWarnings(warningSink),
     }).catch(() => undefined);
   }
   await pruneBuildCache(cacheRoot);
diff --git a/packages/compiler/src/startup-cache.ts b/packages/compiler/src/startup-cache.ts
index c2f82fdad..1bc74bef0 100644
--- a/packages/compiler/src/startup-cache.ts
+++ b/packages/compiler/src/startup-cache.ts
@@ -25,3 +25,4 @@ export function precompiledRuntimePackTarget(
 export { checkerCacheIdentity } from "./frontend/ts7/checker-backend.js";
 export { readCoverageVerdict } from "./coverage/verdict-startup.js";
 export { coverageEnvelope, coveragePasses, renderCoverage } from "./coverage/report.js";
+export { renderPerformanceWarnings } from "./diagnostics/dynamic-tier.js";
diff --git a/tests/coverage-fixtures/dynamic-tier/hot.js b/tests/coverage-fixtures/dynamic-tier/hot.js
new file mode 100644
index 000000000..af2afac07
--- /dev/null
+++ b/tests/coverage-fixtures/dynamic-tier/hot.js
@@ -0,0 +1,36 @@
+// Untyped JavaScript whose functions loop over their arguments: the build
+// names them (SC6101). `scale` runs once and stays quiet.
+function scale(points, factor) {
+  return { points, factor };
+}
+
+function centroid(points) {
+  let x = 0;
+  let y = 0;
+  for (const p of points) {
+    x += p.x;
+    y += p.y;
+  }
+  return { x: x / points.length, y: y / points.length };
+}
+
+function distance(a, b) {
+  const dx = a.x - b.x;
+  const dy = a.y - b.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+
+function spread(points) {
+  const c = centroid(points);
+  let total = 0;
+  for (let i = 0; i < points.length; i++) total += distance(points[i], c);
+  return total;
+}
+
+const points = [
+  { x: 0, y: 0 },
+  { x: 4, y: 0 },
+  { x: 0, y: 3 },
+];
+const scaled = scale(points, 2);
+console.log(scaled.factor, spread(points).toFixed(3));
diff --git a/tests/coverage-fixtures/dynamic-tier/package/main.ts b/tests/coverage-fixtures/dynamic-tier/package/main.ts
new file mode 100644
index 000000000..3acd390da
--- /dev/null
+++ b/tests/coverage-fixtures/dynamic-tier/package/main.ts
@@ -0,0 +1,13 @@
+// A program whose own hot function uses an `any` value, and which calls an
+// untyped npm package: the warning names the function and summarizes the
+// package's dynamic-tier code.
+import { tally } from "untyped-lib";
+
+function sumAmounts(rows: any): number {
+  let total = 0;
+  for (const row of rows) total += row.amount;
+  return total;
+}
+
+const rows = [{ amount: 2 }, { amount: 5 }];
+console.log(sumAmounts(rows), tally(["a", "b", "a"]).a);
diff --git a/tests/coverage-fixtures/dynamic-tier/package/node_modules/untyped-lib/index.d.ts b/tests/coverage-fixtures/dynamic-tier/package/node_modules/untyped-lib/index.d.ts
new file mode 100644
index 000000000..c8871efd0
--- /dev/null
+++ b/tests/coverage-fixtures/dynamic-tier/package/node_modules/untyped-lib/index.d.ts
@@ -0,0 +1 @@
+export function tally(values: any): any;
diff --git a/tests/coverage-fixtures/dynamic-tier/package/node_modules/untyped-lib/index.js b/tests/coverage-fixtures/dynamic-tier/package/node_modules/untyped-lib/index.js
new file mode 100644
index 000000000..5695b6df2
--- /dev/null
+++ b/tests/coverage-fixtures/dynamic-tier/package/node_modules/untyped-lib/index.js
@@ -0,0 +1,6 @@
+// Counts each value: untyped JavaScript in a package.
+exports.tally = function tally(values) {
+  const counts = {};
+  for (const v of values) counts[v] = (counts[v] || 0) + 1;
+  return counts;
+};
diff --git a/tests/coverage-fixtures/dynamic-tier/package/node_modules/untyped-lib/package.json b/tests/coverage-fixtures/dynamic-tier/package/node_modules/untyped-lib/package.json
new file mode 100644
index 000000000..a81ea84d4
--- /dev/null
+++ b/tests/coverage-fixtures/dynamic-tier/package/node_modules/untyped-lib/package.json
@@ -0,0 +1 @@
+{"name": "untyped-lib", "version": "1.0.0", "main": "index.js", "types": "index.d.ts"}
diff --git a/tests/coverage-fixtures/dynamic-tier/quiet.ts b/tests/coverage-fixtures/dynamic-tier/quiet.ts
new file mode 100644
index 000000000..d045a9392
--- /dev/null
+++ b/tests/coverage-fixtures/dynamic-tier/quiet.ts
@@ -0,0 +1,13 @@
+// An untyped configuration read once at startup: dynamic, but not hot, so
+// the build names nothing. The hot loop is typed.
+const config: any = JSON.parse('{"scale": 3, "label": "sum"}');
+const scale: number = config.scale;
+const label: string = config.label;
+
+function sum(values: number[]): number {
+  let total = 0;
+  for (const v of values) total += v * scale;
+  return total;
+}
+
+console.log(label, sum([1, 2, 3]));
diff --git a/tests/coverage-fixtures/dynamic-tier/typed-hot.ts b/tests/coverage-fixtures/dynamic-tier/typed-hot.ts
new file mode 100644
index 000000000..e72a7ca7a
--- /dev/null
+++ b/tests/coverage-fixtures/dynamic-tier/typed-hot.ts
@@ -0,0 +1,21 @@
+// TypeScript functions that loop over untyped values: an `any` parameter
+// and an untyped JSON.parse result (SC6101 names both).
+function regionTotals(items: any): Map<string, number> {
+  const out = new Map<string, number>();
+  for (const item of items) out.set(item.region, (out.get(item.region) ?? 0) + item.amount);
+  return out;
+}
+
+function countRegions(text: string): number {
+  const parsed = JSON.parse(text);
+  let n = 0;
+  for (let i = 0; i < parsed.length; i++) if (parsed[i].region !== "") n++;
+  return n;
+}
+
+const rows = [
+  { amount: 3, region: "eu" },
+  { amount: 4, region: "us" },
+];
+for (const [region, total] of regionTotals(rows)) console.log(region, total);
+console.log(countRegions(JSON.stringify(rows)));
diff --git a/tests/harness/__snapshots__/coverage-dynamic-tier.txt b/tests/harness/__snapshots__/coverage-dynamic-tier.txt
new file mode 100644
index 000000000..8072021e3
--- /dev/null
+++ b/tests/harness/__snapshots__/coverage-dynamic-tier.txt
@@ -0,0 +1,13 @@
+scriptc coverage tests/coverage-fixtures/dynamic-tier/hot.js
+
+  statements analyzed   18
+  compile statically    18  (100%)
+    in dynamic tier     14  (operate on values typed only at runtime; --explain-dynamic lists them)
+
+  fully static — all analyzed statements compile to native code.
+
+  untyped and likely hot   3 functions that likely run often use untyped values, which runs slower than typed code:
+    centroid (hot.js:7): untyped JavaScript file, in a loop
+    spread (hot.js:23): untyped JavaScript file, in a loop
+    distance (hot.js:17): untyped JavaScript file, called in a loop
+    hint: add types to compile these statically; see scriptc coverage --explain-dynamic
\ No newline at end of file
diff --git a/tests/harness/coverage.test.ts b/tests/harness/coverage.test.ts
index cc91c0922..ca62352b1 100644
--- a/tests/harness/coverage.test.ts
+++ b/tests/harness/coverage.test.ts
@@ -113,6 +113,48 @@ test("ordinary code reports no divergence", () => {
   expect(coverage.divergences ?? []).toEqual([]);
 });
 
+test("likely-hot functions with untyped values report as a performance warning", async () => {
+  const { coverage } = analyze(fixture("dynamic-tier/hot.js"));
+  expect(coverage.diagnostics).toEqual([]);
+  expect(coverage.divergences ?? []).toEqual([]);
+  expect((coverage.performance ?? []).map((d) => d.code)).toEqual(["SC6101"]);
+  // Not a blocker or a divergence: only --fail-on=dynamic fails on it.
+  expect(coveragePasses(coverage, "divergences")).toBe(true);
+  expect(coveragePasses(coverage, "dynamic")).toBe(false);
+  const envelope = coverageEnvelope(coverage, { compilerVersion: "test" });
+  expect(envelope.diagnostics.map((d) => [d.code, d.category, d.severity])).toEqual([
+    ["SC6101", "performance", "warning"],
+  ]);
+  await expect(report(fixture("dynamic-tier/hot.js"))).toMatchFileSnapshot(
+    "__snapshots__/coverage-dynamic-tier.txt",
+  );
+});
+
+test("the performance warning names the untyped value of each function", () => {
+  const { coverage } = analyze(fixture("dynamic-tier/typed-hot.ts"));
+  expect(coverage.performance?.[0]?.message.split("\n")).toEqual([
+    "2 functions that likely run often use untyped values, which runs slower than typed code:",
+    "  regionTotals (typed-hot.ts:3): `items` is `any`, in a loop",
+    "  countRegions (typed-hot.ts:9): `parsed` holds an untyped `JSON.parse` result, in a loop",
+  ]);
+});
+
+test("untyped setup code that runs once reports no performance warning", () => {
+  const { coverage } = analyze(fixture("dynamic-tier/quiet.ts"));
+  expect(coverage.diagnostics).toEqual([]);
+  expect(coverage.performance).toBeUndefined();
+  expect(coveragePasses(coverage, "dynamic")).toBe(true);
+});
+
+test("dynamic-tier code in npm packages is summarized by package", () => {
+  const { coverage } = analyze(fixture("dynamic-tier/package/main.ts"));
+  expect(coverage.performance?.[0]?.message.split("\n")).toEqual([
+    "1 function that likely runs often uses untyped values, which runs slower than typed code:",
+    "  sumAmounts (main.ts:6): `rows` is `any`, in a loop",
+    "  untyped code in npm packages: untyped-lib (1 function)",
+  ]);
+});
+
 test("statements of a signature-blocked function count as not static", () => {
   const { coverage } = analyze(fixture("blocked-signature.ts"));
   const un = coverage.unreached?.stats;

From 5a3fbcc1ef74eebdb4118e638f6df0d72c6c9fa6 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 18:57:17 -0500
Subject: [PATCH 45/67] Hold class values in structural constructor types
 declared in the program

A constructor type whose instances are not one program class's, such as
`new () => unknown`, a type that also names static members (`{ readonly
schema: unknown; new (): unknown }`), an abstract constructor type over a
record, or construct overloads, did not map and refused with SC2001. Such
a type declared in the program now lowers as a checked-dynamic value, as
an `unknown` slot already holds a class value: the value keeps its class
identity, `new` through it constructs that class, static reads see that
class's statics, and the constructed value checks into the signature's
instance type. Library and package constructor types keep their fences.

Refs #1372

Co-authored-by: blurname <50226652+blurname@users.noreply.github.com>
---
 packages/compiler/src/frontend/type-mapper.ts | 16 +++++
 .../6911-structural-constructor-types.ts.json |  6 ++
 .../6911-structural-constructor-types.ts      | 59 +++++++++++++++++++
 3 files changed, 81 insertions(+)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6911-structural-constructor-types.ts.json
 create mode 100644 tests/corpus/6911-structural-constructor-types.ts

diff --git a/packages/compiler/src/frontend/type-mapper.ts b/packages/compiler/src/frontend/type-mapper.ts
index 3448545f8..b0e3a6dc9 100644
--- a/packages/compiler/src/frontend/type-mapper.ts
+++ b/packages/compiler/src/frontend/type-mapper.ts
@@ -2459,6 +2459,22 @@ function mapTypeInner(type: ts.Type, ctx: TypeMapperCtx): IrType | null {
         return { kind: "classval", className: inst.className };
       }
     }
+    // A constructable declared in the program whose instances are not one
+    // program class's (`new () => unknown`, `abstract new () => S` over a
+    // record, a type that also names static members such as `{ readonly
+    // schema: unknown; new (): unknown }`, construct overloads): the class
+    // value rides the checked-dynamic tree, as an `unknown` slot already
+    // holds one. `new` through it and static reads dispatch at run time,
+    // and the constructed value checks into the signature's instance type.
+    // Lib and package constructables keep their fences.
+    if (
+      ctorSigs.length > 0 &&
+      checker.getCallSignatures(widened).length === 0 &&
+      (widened.getSymbol()?.declarations.length ?? 0) > 0 &&
+      widened.getSymbol()!.declarations.every((d) => ctx.isProgramFile(ts.getSourceFileOfNode(d)))
+    ) {
+      return DYN;
+    }
   }
   // Map<K, V>: a reference to the standard library's Map interface —
   // provenance, not the name (a user's own `interface Map` maps as a record
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6911-structural-constructor-types.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6911-structural-constructor-types.ts.json
new file mode 100644
index 000000000..3d1438687
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6911-structural-constructor-types.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6911-structural-constructor-types.ts"
+ ],
+ "diags": []
+}
diff --git a/tests/corpus/6911-structural-constructor-types.ts b/tests/corpus/6911-structural-constructor-types.ts
new file mode 100644
index 000000000..e8df74dfa
--- /dev/null
+++ b/tests/corpus/6911-structural-constructor-types.ts
@@ -0,0 +1,59 @@
+// Values typed by a structural constructor type: `new () => unknown`, a type
+// that also names static members, abstract constructor types and arrays of
+// constructors. The class value keeps its identity; `new` through it builds
+// an instance of the class it holds, and static reads see that class's
+// statics.
+type DescribedClass = { readonly schema: unknown; new (): unknown };
+class Item {
+  static readonly schema = { name: true };
+  value = 42;
+}
+class Other {
+  static readonly schema = { name: false, extra: 1 };
+  value = 7;
+}
+function classOf(flag: boolean): DescribedClass {
+  return flag ? Item : Other;
+}
+console.log(JSON.stringify(classOf(true).schema), JSON.stringify(classOf(false).schema));
+const C = classOf(true);
+const made = new C();
+console.log(made instanceof Item, (made as Item).value, C === Item);
+
+type Ctor = new () => unknown;
+const ctors: Ctor[] = [Item, Other];
+console.log(ctors.length, ctors.map((c) => (new c() as { value: number }).value).join(","));
+
+class Point {
+  readonly x: number;
+  readonly y: number;
+  constructor(x: number, y: number) {
+    this.x = x;
+    this.y = y;
+  }
+  static origin = "0,0";
+}
+type PointLike = { readonly origin: string; new (x: number, y: number): { x: number; y: number } };
+const P: PointLike = Point;
+const p = new P(3, 4);
+console.log(p.x + p.y, P.origin);
+
+abstract class Shape {
+  abstract area(): number;
+  describe(): string {
+    return `area ${this.area()}`;
+  }
+}
+class Square extends Shape {
+  area(): number {
+    return 4;
+  }
+}
+type ShapeCtor = abstract new () => Shape;
+const sc: ShapeCtor = Square;
+console.log(sc === Square, new (sc as new () => Shape)().describe());
+
+function make<T>(c: new () => T): T {
+  return new c();
+}
+console.log((make(Item) as Item).value, (make(Other) as Other).value);

From be23f71266e2482b5ce75d47be896c36cf54c2b0 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 19:02:52 -0500
Subject: [PATCH 46/67] Compile TypeScript's UMD module wrapper as the module
 body

---
 .../src/frontend/npm-static-umd.test.ts       | 109 +++++++++++
 .../compiler/src/frontend/npm-static-umd.ts   | 178 ++++++++++++++++++
 packages/compiler/src/frontend/npm-static.ts  |   5 +
 packages/compiler/src/frontend/services.ts    |   8 +
 .../7000-umd-package-entry/main.ts.json       |   6 +
 tests/corpus/7000-umd-package-entry/main.ts   |  10 +
 .../umd-shapes/lib/impl/measure.js            |  22 +++
 .../node_modules/umd-shapes/lib/main.d.ts     |  12 ++
 .../node_modules/umd-shapes/lib/main.js       |  29 +++
 .../node_modules/umd-shapes/package.json      |   1 +
 .../7000-umd-package-entry/main.ts.json       |   1 +
 11 files changed, 381 insertions(+)
 create mode 100644 packages/compiler/src/frontend/npm-static-umd.test.ts
 create mode 100644 packages/compiler/src/frontend/npm-static-umd.ts
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7000-umd-package-entry/main.ts.json
 create mode 100644 tests/corpus/7000-umd-package-entry/main.ts
 create mode 100644 tests/corpus/7000-umd-package-entry/node_modules/umd-shapes/lib/impl/measure.js
 create mode 100644 tests/corpus/7000-umd-package-entry/node_modules/umd-shapes/lib/main.d.ts
 create mode 100644 tests/corpus/7000-umd-package-entry/node_modules/umd-shapes/lib/main.js
 create mode 100644 tests/corpus/7000-umd-package-entry/node_modules/umd-shapes/package.json
 create mode 100644 tests/harness/corpus-costs/7000-umd-package-entry/main.ts.json

diff --git a/packages/compiler/src/frontend/npm-static-umd.test.ts b/packages/compiler/src/frontend/npm-static-umd.test.ts
new file mode 100644
index 000000000..5280ecb17
--- /dev/null
+++ b/packages/compiler/src/frontend/npm-static-umd.test.ts
@@ -0,0 +1,109 @@
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, expect, test } from "vitest";
+import { nodeFrontendServices } from "./services-node.js";
+
+const dirs: string[] = [];
+afterAll(() => {
+  for (const dir of dirs) rmSync(dir, { recursive: true, force: true });
+});
+
+function unwrap(source: string): string | null {
+  return nodeFrontendServices().umdFactory(source, "/pkg/index.js");
+}
+
+/** TypeScript's UMD wrapper around `body`. */
+function umd(body: string, params = "require, exports"): string {
+  return `(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (${params}) {
+${body}
+});
+`;
+}
+
+const probe = `
+console.log(JSON.stringify(module.exports), Object.keys(module.exports).join(","));
+`;
+
+function run(file: string): string {
+  const result = spawnSync(process.execPath, [file], { encoding: "utf8" });
+  expect(result.status).toBe(0);
+  return result.stdout;
+}
+
+/** The unwrapped module exports what the original exports. */
+function expectSameModule(source: string): string {
+  const result = unwrap(source);
+  expect(typeof result).toBe("string");
+  const dir = mkdtempSync(join(tmpdir(), "scriptc-umd-"));
+  dirs.push(dir);
+  const original = join(dir, "original.cjs");
+  const unwrapped = join(dir, "unwrapped.cjs");
+  writeFileSync(original, source + probe);
+  writeFileSync(unwrapped, result! + probe);
+  const answer = run(original);
+  expect(run(unwrapped)).toBe(answer);
+  return result!;
+}
+
+test("the factory body runs at the top level with its positions kept", () => {
+  const source = umd(`    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.twice = twice;
+    const path = require("path");
+    exports.sep = path.sep;
+    function twice(n) {
+        return n * 2;
+    }`);
+  const result = expectSameModule(source);
+  expect(result.length).toBe(source.length);
+  expect(result.split("\n").length).toBe(source.split("\n").length);
+  expect(result.indexOf("exports.twice = twice;")).toBe(source.indexOf("exports.twice = twice;"));
+  expect(result).not.toContain("define.amd");
+  expect(result).not.toContain("factory");
+});
+
+test("TypeScript's helper probes of this keep their fallback", () => {
+  expectSameModule(
+    umd(`    "use strict";
+    var __importDefault = (this && this.__importDefault) || function (mod) {
+        return (mod && mod.__esModule) ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const os_1 = __importDefault(require("os"));
+    exports.eol = os_1.default.EOL;`),
+  );
+});
+
+test("nested functions keep their own return, arguments and this", () => {
+  expectSameModule(
+    umd(`    "use strict";
+    exports.first = function () { return arguments[0]; };
+    exports.self = { get() { return this; } };
+    exports.arrow = () => { return 1; };`),
+  );
+});
+
+test("other shapes keep the original text", () => {
+  // `export =` returns the module value from the factory.
+  expect(unwrap(umd(`    "use strict";\n    return { a: 1 };`))).toBeNull();
+  // The body's own `this` and `arguments` differ from the module's.
+  expect(unwrap(umd(`    exports.self = this;`))).toBeNull();
+  expect(unwrap(umd(`    exports.count = arguments.length;`))).toBeNull();
+  // Other factory parameters.
+  expect(unwrap(umd(`    exports.a = 1;`, "require, exports, module"))).toBeNull();
+  expect(unwrap(umd(`    exports.a = 1;`, "req, exp"))).toBeNull();
+  // Code after the wrapper.
+  expect(unwrap(umd(`    exports.a = 1;`) + "exports.b = 2;\n")).toBeNull();
+  // Not a UMD wrapper.
+  expect(unwrap(`exports.a = 1;\n`)).toBeNull();
+});
diff --git a/packages/compiler/src/frontend/npm-static-umd.ts b/packages/compiler/src/frontend/npm-static-umd.ts
new file mode 100644
index 000000000..88400e046
--- /dev/null
+++ b/packages/compiler/src/frontend/npm-static-umd.ts
@@ -0,0 +1,178 @@
+/* TypeScript's UMD module emit in a compiled package: the module body is a
+ * factory function that the wrapper calls with the CommonJS module's own
+ * `require` and `exports`.
+ *
+ *   (function (factory) {
+ *       if (typeof module === "object" && typeof module.exports === "object") {
+ *           var v = factory(require, exports);
+ *           if (v !== undefined) module.exports = v;
+ *       }
+ *       else if (typeof define === "function" && define.amd) {
+ *           define(["require", "exports", "./dep"], factory);
+ *       }
+ *   })(function (require, exports) {
+ *       "use strict";
+ *       const dep = require("./dep");
+ *       exports.f = f;
+ *   });
+ *
+ * Under Node the CommonJS branch runs: the factory body runs once with the
+ * module's `require` and `exports`, and a body without a `return` leaves
+ * `module.exports` as it was. That is the module's own body, so the wrapper
+ * is blanked out (line breaks kept, so positions stay) and the body runs at
+ * the module's top level, where its requires and export assignments are the
+ * module's own.
+ *
+ * Accepted: the wrapper is the file's only statement, its CommonJS branch
+ * calls the factory as `factory(require, exports)`, the factory's
+ * parameters are exactly `require` and `exports`, and the body uses no
+ * `return` or `arguments` of its own. `this` in the body is the factory's
+ * receiver, not the module's: it may appear only in TypeScript's helper
+ * probes (`this && this.__importDefault`), which find no helper on either
+ * receiver. Any other shape keeps the original text. */
+import * as ts from "./ts7/syntax.js";
+import { tokenStartOfNode } from "./ts7/node-functions.js";
+import { applyEdits } from "./npm-static-bundled-chunks.js";
+
+/** True when the text may hold a UMD wrapper (a cheap probe). */
+export function mayHoldUmdWrapper(source: string): boolean {
+  return source.includes("define.amd") && source.includes("(require, exports)");
+}
+
+/** The module text with a UMD wrapper's factory body at the top level, or
+ * null when the file is not one. */
+export function unwrapUmdFactory(sf: ts.SourceFile): string | null {
+  const stmts = sf.statements.nodes;
+  if (stmts.length !== 1) return null;
+  const stmt = stmts[0]!;
+  if (!ts.isExpressionStatement(stmt) || !ts.isCallExpression(stmt.expression)) return null;
+  const call = stmt.expression;
+  if (call.arguments.nodes.length !== 1) return null;
+  const wrapper = unparenthesized(call.expression);
+  const factory = call.arguments.nodes[0]!;
+  if (!ts.isFunctionExpression(wrapper) || !ts.isFunctionExpression(factory)) return null;
+  const wrapperParams = wrapper.parameters.nodes;
+  if (wrapperParams.length !== 1 || !isPlainParameter(wrapperParams[0]!)) return null;
+  const factoryName = (wrapperParams[0]!.name as ts.Identifier).text;
+  if (!callsFactoryForCommonJs(wrapper, factoryName)) return null;
+  const params = factory.parameters.nodes;
+  if (
+    params.length !== 2 ||
+    !params.every(isPlainParameter) ||
+    (params[0]!.name as ts.Identifier).text !== "require" ||
+    (params[1]!.name as ts.Identifier).text !== "exports"
+  )
+    return null;
+  const body = factory.body;
+  if (body === undefined || !ownBodyKeepsModuleSemantics(body)) return null;
+  const open = tokenStartOfNode(body) + 1;
+  const close = body.end - 1;
+  return applyEdits(sf.text, 0, sf.text.length, [
+    { start: tokenStartOfNode(stmt), end: open, text: "" },
+    { start: close, end: stmt.end, text: "" },
+  ]);
+}
+
+function unparenthesized(e: ts.Expression): ts.Expression {
+  while (ts.isParenthesizedExpression(e)) e = e.expression;
+  return e;
+}
+
+/** A parameter that is a bare identifier: no default, rest or pattern. */
+function isPlainParameter(p: ts.ParameterDeclaration): boolean {
+  return ts.isIdentifier(p.name) && p.initializer === undefined && p.dotDotDotToken === undefined;
+}
+
+/** True when the wrapper's first statement is TypeScript's CommonJS test,
+ * `if (typeof module === "object" && typeof module.exports === "object")`,
+ * whose branch starts by calling the factory as `factory(require, exports)`. */
+function callsFactoryForCommonJs(wrapper: ts.FunctionExpression, factoryName: string): boolean {
+  const first = wrapper.body?.statements.nodes[0];
+  if (first === undefined || !ts.isIfStatement(first)) return false;
+  const sf = ts.getSourceFileOfNode(wrapper);
+  const condition = sf.text.slice(tokenStartOfNode(first.expression), first.expression.end);
+  if (
+    condition.replace(/\s+/g, " ") !==
+    'typeof module === "object" && typeof module.exports === "object"'
+  )
+    return false;
+  const branch = first.thenStatement;
+  const call = ts.isBlock(branch) ? branch.statements.nodes[0] : undefined;
+  if (call === undefined || !ts.isVariableStatement(call)) return false;
+  const declarations = call.declarationList.declarations.nodes;
+  const init = declarations.length === 1 ? declarations[0]!.initializer : undefined;
+  if (init === undefined || !ts.isCallExpression(init)) return false;
+  const args = init.arguments.nodes;
+  return (
+    ts.isIdentifier(init.expression) &&
+    init.expression.text === factoryName &&
+    args.length === 2 &&
+    ts.isIdentifier(args[0]!) &&
+    args[0].text === "require" &&
+    ts.isIdentifier(args[1]!) &&
+    args[1].text === "exports"
+  );
+}
+
+/** True when the factory body behaves the same as the module's top level:
+ * no `return` or `arguments` of its own, and `this` only in TypeScript's
+ * helper probes. */
+function ownBodyKeepsModuleSemantics(body: ts.Block): boolean {
+  let keeps = true;
+  ts.walkPreorder(body, (n) => {
+    if (!keeps) return "stop";
+    // Nested functions have their own `return`, `arguments` and `this`;
+    // arrow functions only their own `return`.
+    if (
+      ts.isFunctionDeclaration(n) ||
+      ts.isFunctionExpression(n) ||
+      ts.isMethodDeclaration(n) ||
+      ts.isGetAccessorDeclaration(n) ||
+      ts.isSetAccessorDeclaration(n) ||
+      ts.isConstructorDeclaration(n)
+    )
+      return "skip";
+    if (ts.isClassDeclaration(n) || ts.isClassExpression(n)) return "skip";
+    if (ts.isReturnStatement(n) && !insideArrow(n, body)) keeps = false;
+    else if (ts.isIdentifier(n) && n.text === "arguments") keeps = false;
+    else if (n.kind === ts.SyntaxKind.ThisKeyword && !isHelperProbe(n)) keeps = false;
+    return undefined;
+  });
+  return keeps;
+}
+
+/** True when `node` sits inside an arrow function nested in `body`. */
+function insideArrow(node: ts.Node, body: ts.Block): boolean {
+  for (let p = node.parent; p !== undefined && p !== body; p = p.parent)
+    if (ts.isArrowFunction(p)) return true;
+  return false;
+}
+
+/** `this` in TypeScript's helper probe `this && this.__name`: the left
+ * operand, or the receiver of the right operand's `__` member. */
+function isHelperProbe(node: ts.Node): boolean {
+  const parent = node.parent;
+  if (parent === undefined) return false;
+  const probe =
+    ts.isBinaryExpression(parent) && parent.left === node
+      ? parent
+      : ts.isPropertyAccessExpression(parent) &&
+          parent.expression === node &&
+          ts.isIdentifier(parent.name) &&
+          parent.name.text.startsWith("__") &&
+          parent.parent !== undefined &&
+          ts.isBinaryExpression(parent.parent) &&
+          parent.parent.right === parent
+        ? parent.parent
+        : undefined;
+  if (probe === undefined || probe.operatorToken.kind !== ts.SyntaxKind.AmpersandAmpersandToken)
+    return false;
+  const right = probe.right;
+  return (
+    probe.left.kind === ts.SyntaxKind.ThisKeyword &&
+    ts.isPropertyAccessExpression(right) &&
+    right.expression.kind === ts.SyntaxKind.ThisKeyword &&
+    ts.isIdentifier(right.name) &&
+    right.name.text.startsWith("__")
+  );
+}
diff --git a/packages/compiler/src/frontend/npm-static.ts b/packages/compiler/src/frontend/npm-static.ts
index bc9fc2abd..56edafc48 100644
--- a/packages/compiler/src/frontend/npm-static.ts
+++ b/packages/compiler/src/frontend/npm-static.ts
@@ -452,6 +452,10 @@ export function npmStaticFsShadow(services: FrontendServices): NpmStaticFsShadow
           } else if (esm !== null) {
             original = esm;
           }
+          // TypeScript's UMD wrapper calls its factory with the module's own
+          // require and exports: the factory body is the module body.
+          const umd = original === null ? null : services.umdFactory(original, path);
+          if (umd !== null) original = umd;
           // Polyfill packages that ARE a Node builtin compile as the builtin.
           const aliased = original === null ? null : services.builtinAliasRequires(original, path);
           if (aliased !== null) original = aliased;
@@ -472,6 +476,7 @@ export function npmStaticFsShadow(services: FrontendServices): NpmStaticFsShadow
           if (exportsVar !== null) original = exportsVar;
           const respelled =
             split !== null ||
+            umd !== null ||
             tscHelpers !== null ||
             esm !== null ||
             aliased !== null ||
diff --git a/packages/compiler/src/frontend/services.ts b/packages/compiler/src/frontend/services.ts
index 10931ab29..19728d6ce 100644
--- a/packages/compiler/src/frontend/services.ts
+++ b/packages/compiler/src/frontend/services.ts
@@ -12,6 +12,7 @@ import {
   mayRequireBuiltinAlias,
   rewriteBuiltinAliasRequires,
 } from "./npm-static-builtin-aliases.js";
+import { mayHoldUmdWrapper, unwrapUmdFactory } from "./npm-static-umd.js";
 import { mayHoldEnumIife, rewriteEnumIifes } from "./npm-static-enum-iife.js";
 import { mayHoldTscBuiltinImport, unwrapTscBuiltinImports } from "./npm-static-tsc-helpers.js";
 import { builtinPackageAliasFor } from "./package-shims.js";
@@ -114,6 +115,13 @@ export class FrontendServices {
     if (!mayHoldTscBuiltinImport(source)) return null;
     return unwrapTscBuiltinImports(this.parse(path, source, "js"));
   }
+  /** A package module written as TypeScript's UMD wrapper with its
+   * factory body at the top level (null: not one). */
+  umdFactory(source: string, path: string): string | null {
+    this.ensureOpen();
+    if (!mayHoldUmdWrapper(source)) return null;
+    return unwrapUmdFactory(this.parse(path, source, "js"));
+  }
   /** A package module with its literal-valued TypeScript enum IIFEs
    * respelled as object literals (null: none). */
   enumIifes(source: string, path: string): string | null {
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7000-umd-package-entry/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7000-umd-package-entry/main.ts.json
new file mode 100644
index 000000000..0c6cbd9d1
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7000-umd-package-entry/main.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/7000-umd-package-entry/main.ts"
+ ],
+ "diags": []
+}
diff --git a/tests/corpus/7000-umd-package-entry/main.ts b/tests/corpus/7000-umd-package-entry/main.ts
new file mode 100644
index 000000000..4b8b3e246
--- /dev/null
+++ b/tests/corpus/7000-umd-package-entry/main.ts
@@ -0,0 +1,10 @@
+// A package whose main entry is TypeScript's UMD emit: each module's body is
+// a factory the wrapper calls with the module's own require and exports, so
+// its requires and export assignments sit inside a function. Node runs the
+// CommonJS branch, and the named imports read the factory's exports.
+import { Shape, area, describe, label, unitCount } from "umd-shapes";
+
+console.log(label, unitCount);
+console.log(area({ kind: Shape.Square, size: 3 }), area({ kind: Shape.Circle, size: 1 }).toFixed(4));
+console.log(describe({ kind: Shape.Square, size: 2 }));
+console.log(Shape.Circle, Shape[Shape.Square]);
diff --git a/tests/corpus/7000-umd-package-entry/node_modules/umd-shapes/lib/impl/measure.js b/tests/corpus/7000-umd-package-entry/node_modules/umd-shapes/lib/impl/measure.js
new file mode 100644
index 000000000..0ea89b34e
--- /dev/null
+++ b/tests/corpus/7000-umd-package-entry/node_modules/umd-shapes/lib/impl/measure.js
@@ -0,0 +1,22 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.units = void 0;
+    exports.square = square;
+    exports.circle = circle;
+    exports.units = ["cm", "m"];
+    function square(size) {
+        return size * size;
+    }
+    function circle(radius) {
+        return Math.PI * radius * radius;
+    }
+});
diff --git a/tests/corpus/7000-umd-package-entry/node_modules/umd-shapes/lib/main.d.ts b/tests/corpus/7000-umd-package-entry/node_modules/umd-shapes/lib/main.d.ts
new file mode 100644
index 000000000..0982da9ef
--- /dev/null
+++ b/tests/corpus/7000-umd-package-entry/node_modules/umd-shapes/lib/main.d.ts
@@ -0,0 +1,12 @@
+export declare enum Shape {
+    Square = 0,
+    Circle = 1
+}
+export interface Figure {
+    kind: Shape;
+    size: number;
+}
+export declare const label: string;
+export declare const unitCount: number;
+export declare function area(figure: Figure): number;
+export declare function describe(figure: Figure): string;
diff --git a/tests/corpus/7000-umd-package-entry/node_modules/umd-shapes/lib/main.js b/tests/corpus/7000-umd-package-entry/node_modules/umd-shapes/lib/main.js
new file mode 100644
index 000000000..26162fbd9
--- /dev/null
+++ b/tests/corpus/7000-umd-package-entry/node_modules/umd-shapes/lib/main.js
@@ -0,0 +1,29 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./impl/measure"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.unitCount = exports.label = exports.Shape = void 0;
+    exports.area = area;
+    exports.describe = describe;
+    const measure = require("./impl/measure");
+    var Shape;
+    (function (Shape) {
+        Shape[Shape["Square"] = 0] = "Square";
+        Shape[Shape["Circle"] = 1] = "Circle";
+    })(Shape || (exports.Shape = Shape = {}));
+    exports.label = "shapes";
+    exports.unitCount = measure.units.length;
+    function area(figure) {
+        return figure.kind === Shape.Square ? measure.square(figure.size) : measure.circle(figure.size);
+    }
+    function describe(figure) {
+        return `${Shape[figure.kind]} of ${figure.size} ${measure.units[0]}: ${area(figure)}`;
+    }
+});
diff --git a/tests/corpus/7000-umd-package-entry/node_modules/umd-shapes/package.json b/tests/corpus/7000-umd-package-entry/node_modules/umd-shapes/package.json
new file mode 100644
index 000000000..e827ecc41
--- /dev/null
+++ b/tests/corpus/7000-umd-package-entry/node_modules/umd-shapes/package.json
@@ -0,0 +1 @@
+{ "name": "umd-shapes", "version": "1.0.0", "main": "./lib/main.js", "types": "./lib/main.d.ts" }
diff --git a/tests/harness/corpus-costs/7000-umd-package-entry/main.ts.json b/tests/harness/corpus-costs/7000-umd-package-entry/main.ts.json
new file mode 100644
index 000000000..782707a3a
--- /dev/null
+++ b/tests/harness/corpus-costs/7000-umd-package-entry/main.ts.json
@@ -0,0 +1 @@
+{ "plain": 3911, "san": 3835 }

From 220199dfec1483bd7122c29de032f2f37aa59bd4 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 19:17:07 -0500
Subject: [PATCH 47/67] Evaluate an fs argument inside satisfies once after a
 URL path

The arguments after a URL path that are evaluated ahead of the
conversion were keyed by the expression without its parentheses. When
the fs lowering read through a satisfies wrapper, it lowered the inner
expression again, so fs.chmodSync(url, mode() satisfies number) called
mode() twice. The saved arguments are now keyed and looked up without
their type-only wrappers (satisfies, as, type assertions, !), so each
runs once.
---
 .../src/frontend/lowering/builtins/fs-paths.ts         |  6 ++++--
 packages/compiler/src/frontend/lowering/lowerer.ts     |  8 ++++----
 tests/corpus/6931-fs-url-paths.ts                      | 10 ++++++++++
 3 files changed, 18 insertions(+), 6 deletions(-)

diff --git a/packages/compiler/src/frontend/lowering/builtins/fs-paths.ts b/packages/compiler/src/frontend/lowering/builtins/fs-paths.ts
index 181e27e34..38583025d 100644
--- a/packages/compiler/src/frontend/lowering/builtins/fs-paths.ts
+++ b/packages/compiler/src/frontend/lowering/builtins/fs-paths.ts
@@ -15,6 +15,7 @@ import * as ts from "../../ts7/adapter.js";
 import { type Lowerer } from "../lowerer.js";
 import { locOf } from "../../program.js";
 import { sideEffectFreeOptionValue } from "../surfaces.js";
+import { stripTypeWrappers } from "../typed-arguments.js";
 import { type IrExpr, type IrStmt, STRING, URL_T } from "../../../ir/ir.js";
 
 /** The fs functions whose path parameters accept a URL: the path
@@ -142,8 +143,9 @@ function checkUrlPaths(
   for (let i = first + 1; i < args.length; i++) if (!sideEffectFreeOptionValue(args[i]!)) last = i;
   const staged: ts.Expression[] = [];
   for (let i = first + 1; i <= last; i++) {
-    let e = args[i]!;
-    while (ts.isParenthesizedExpression(e)) e = e.expression;
+    // Keyed without type-only wrappers (`satisfies`, `as`, `!`), so a
+    // lowering that reads through them finds the saved value.
+    const e = stripTypeWrappers(args[i]!);
     // Literals are read by their members, so a whole-value slot cannot
     // hold them.
     if (ts.isObjectLiteralExpression(e) || ts.isArrayLiteralExpression(e)) {
diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts
index 80b2a5938..38d3ca8d3 100644
--- a/packages/compiler/src/frontend/lowering/lowerer.ts
+++ b/packages/compiler/src/frontend/lowering/lowerer.ts
@@ -1,4 +1,4 @@
-import { onlyForwarded } from "./typed-arguments.js";
+import { onlyForwarded, stripTypeWrappers } from "./typed-arguments.js";
 import {
   needsGeneralNodeStreams,
   noteUntypedStreamFlow,
@@ -12046,11 +12046,11 @@ export class Lowerer {
     return this.stagedArgument(expr) ?? lowerExpr(this, expr);
   }
 
-  /** The saved value of a staged fs argument (stagedArguments), or null for
-   * every other expression. */
+  /** The saved value of a staged fs argument (stagedArguments, keyed
+   * without type-only wrappers), or null for every other expression. */
   private stagedArgument(node: ts.Expression): IrExpr | null {
     if (this.stagedArguments.size === 0) return null;
-    while (ts.isParenthesizedExpression(node)) node = node.expression;
+    node = stripTypeWrappers(node);
     if (!this.stagedArguments.has(node)) return null;
     const slot = this.stagedArguments.get(node);
     if (!slot)
diff --git a/tests/corpus/6931-fs-url-paths.ts b/tests/corpus/6931-fs-url-paths.ts
index cf6889066..effe64207 100644
--- a/tests/corpus/6931-fs-url-paths.ts
+++ b/tests/corpus/6931-fs-url-paths.ts
@@ -103,6 +103,16 @@ console.log("uid", uid);
 uid = -1;
 attempt("chown order scheme", () => fs.chownSync(new URL("http://a/"), uid, bumpUid()));
 console.log("uid", uid);
+// A later argument with effects inside a type-only wrapper runs once.
+let modeCalls = 0;
+function countedMode(): number {
+  modeCalls++;
+  return 0o600;
+}
+attempt("satisfies", () => fs.chmodSync(file, countedMode() satisfies number));
+attempt("as", () => fs.chmodSync(file, countedMode() as number));
+attempt("non-null", () => fs.chmodSync(file, countedMode()!));
+console.log("mode calls", modeCalls);
 
 fs.rmSync(dir, { recursive: true, force: true });
 console.log("done", fs.existsSync(dir));

From 3447e9a1c13e6801ac6c3b9a455f70ed2f43d503 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 19:20:54 -0500
Subject: [PATCH 48/67] Unwrap a UMD wrapper only when its body is exactly
 TypeScript's emit

The wrapper is dropped when its factory body moves to the top level, so
any other statement in the wrapper, in its CommonJS branch or in its AMD
branch would be lost. The check now matches the whole wrapper body and
keeps the original text for any other shape.
---
 .../src/frontend/npm-static-umd.test.ts       | 12 ++++
 .../compiler/src/frontend/npm-static-umd.ts   | 72 +++++++++++--------
 2 files changed, 55 insertions(+), 29 deletions(-)

diff --git a/packages/compiler/src/frontend/npm-static-umd.test.ts b/packages/compiler/src/frontend/npm-static-umd.test.ts
index 5280ecb17..14e0d5ea9 100644
--- a/packages/compiler/src/frontend/npm-static-umd.test.ts
+++ b/packages/compiler/src/frontend/npm-static-umd.test.ts
@@ -104,6 +104,18 @@ test("other shapes keep the original text", () => {
   expect(unwrap(umd(`    exports.a = 1;`, "req, exp"))).toBeNull();
   // Code after the wrapper.
   expect(unwrap(umd(`    exports.a = 1;`) + "exports.b = 2;\n")).toBeNull();
+  // Other statements in the wrapper, which unwrapping would drop.
+  const wrapped = umd(`    exports.a = 1;`);
+  const call = "        var v = factory(require, exports);\n";
+  expect(unwrap(wrapped.replace(call, call + "        exports.b = 2;\n"))).toBeNull();
+  expect(unwrap(wrapped.replace(call, "        exports.b = 2;\n" + call))).toBeNull();
+  expect(unwrap(wrapped.replace("    }\n})(", "    }\n    exports.b = 2;\n})("))).toBeNull();
+  expect(
+    unwrap(wrapped.replace("define.amd) {", "define.amd) {\n        exports.b = 2;")),
+  ).toBeNull();
+  expect(
+    unwrap(wrapped.replace("define(", "exports.b = 2;\n    }\n    else {\n        define(")),
+  ).toBeNull();
   // Not a UMD wrapper.
   expect(unwrap(`exports.a = 1;\n`)).toBeNull();
 });
diff --git a/packages/compiler/src/frontend/npm-static-umd.ts b/packages/compiler/src/frontend/npm-static-umd.ts
index 88400e046..4a5db5065 100644
--- a/packages/compiler/src/frontend/npm-static-umd.ts
+++ b/packages/compiler/src/frontend/npm-static-umd.ts
@@ -23,8 +23,8 @@
  * the module's top level, where its requires and export assignments are the
  * module's own.
  *
- * Accepted: the wrapper is the file's only statement, its CommonJS branch
- * calls the factory as `factory(require, exports)`, the factory's
+ * Accepted: the wrapper is the file's only statement, the wrapper's body is
+ * exactly the emit above (so dropping it drops nothing else), the factory's
  * parameters are exactly `require` and `exports`, and the body uses no
  * `return` or `arguments` of its own. `this` in the body is the factory's
  * receiver, not the module's: it may appear only in TypeScript's helper
@@ -54,7 +54,7 @@ export function unwrapUmdFactory(sf: ts.SourceFile): string | null {
   const wrapperParams = wrapper.parameters.nodes;
   if (wrapperParams.length !== 1 || !isPlainParameter(wrapperParams[0]!)) return null;
   const factoryName = (wrapperParams[0]!.name as ts.Identifier).text;
-  if (!callsFactoryForCommonJs(wrapper, factoryName)) return null;
+  if (!isTypeScriptUmdWrapper(wrapper, factoryName)) return null;
   const params = factory.parameters.nodes;
   if (
     params.length !== 2 ||
@@ -83,35 +83,49 @@ function isPlainParameter(p: ts.ParameterDeclaration): boolean {
   return ts.isIdentifier(p.name) && p.initializer === undefined && p.dotDotDotToken === undefined;
 }
 
-/** True when the wrapper's first statement is TypeScript's CommonJS test,
- * `if (typeof module === "object" && typeof module.exports === "object")`,
- * whose branch starts by calling the factory as `factory(require, exports)`. */
-function callsFactoryForCommonJs(wrapper: ts.FunctionExpression, factoryName: string): boolean {
-  const first = wrapper.body?.statements.nodes[0];
-  if (first === undefined || !ts.isIfStatement(first)) return false;
+/** True when the wrapper body is exactly TypeScript's emit and nothing else:
+ * one `if` statement whose CommonJS branch holds only the factory call and
+ * the `module.exports` assignment, and whose `else`, when present, is only
+ * the AMD branch:
+ *
+ *   if (typeof module === "object" && typeof module.exports === "object") {
+ *       var v = factory(require, exports);
+ *       if (v !== undefined) module.exports = v;
+ *   }
+ *   else if (typeof define === "function" && define.amd) {
+ *       define([...], factory);
+ *   }
+ *
+ * Unwrapping drops the wrapper, so any other statement in it would be lost. */
+function isTypeScriptUmdWrapper(wrapper: ts.FunctionExpression, factoryName: string): boolean {
+  const stmts = wrapper.body?.statements.nodes ?? [];
+  if (stmts.length !== 1 || !ts.isIfStatement(stmts[0]!)) return false;
+  const test = stmts[0];
   const sf = ts.getSourceFileOfNode(wrapper);
-  const condition = sf.text.slice(tokenStartOfNode(first.expression), first.expression.end);
-  if (
-    condition.replace(/\s+/g, " ") !==
-    'typeof module === "object" && typeof module.exports === "object"'
-  )
+  const text = (n: ts.Node): string =>
+    sf.text.slice(tokenStartOfNode(n), n.end).replace(/\s+/g, " ");
+  if (text(test.expression) !== 'typeof module === "object" && typeof module.exports === "object"')
     return false;
-  const branch = first.thenStatement;
-  const call = ts.isBlock(branch) ? branch.statements.nodes[0] : undefined;
-  if (call === undefined || !ts.isVariableStatement(call)) return false;
+  const branch = test.thenStatement;
+  if (!ts.isBlock(branch) || branch.statements.nodes.length !== 2) return false;
+  const [call, assign] = branch.statements.nodes as [ts.Statement, ts.Statement];
+  if (!ts.isVariableStatement(call)) return false;
   const declarations = call.declarationList.declarations.nodes;
-  const init = declarations.length === 1 ? declarations[0]!.initializer : undefined;
-  if (init === undefined || !ts.isCallExpression(init)) return false;
-  const args = init.arguments.nodes;
-  return (
-    ts.isIdentifier(init.expression) &&
-    init.expression.text === factoryName &&
-    args.length === 2 &&
-    ts.isIdentifier(args[0]!) &&
-    args[0].text === "require" &&
-    ts.isIdentifier(args[1]!) &&
-    args[1].text === "exports"
-  );
+  const name = declarations.length === 1 ? declarations[0]!.name : undefined;
+  if (name === undefined || !ts.isIdentifier(name)) return false;
+  const result = name.text;
+  if (text(call) !== `var ${result} = ${factoryName}(require, exports);`) return false;
+  if (text(assign) !== `if (${result} !== undefined) module.exports = ${result};`) return false;
+  const amd = test.elseStatement;
+  if (amd === undefined) return true;
+  if (!ts.isIfStatement(amd) || amd.elseStatement !== undefined) return false;
+  if (text(amd.expression) !== 'typeof define === "function" && define.amd') return false;
+  const define = ts.isBlock(amd.thenStatement) ? amd.thenStatement.statements.nodes : [];
+  if (define.length !== 1 || !ts.isExpressionStatement(define[0]!)) return false;
+  const defineCall = define[0].expression;
+  if (!ts.isCallExpression(defineCall) || text(defineCall.expression) !== "define") return false;
+  const last = defineCall.arguments.nodes.at(-1);
+  return last !== undefined && ts.isIdentifier(last) && last.text === factoryName;
 }
 
 /** True when the factory body behaves the same as the module's top level:

From c29ce641b2d2aba99ae56129450956e128454c08 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 19:26:00 -0500
Subject: [PATCH 49/67] Count only the repeated parts of loops as likely-hot
 work

A `for` loop's initializer and a `for...of` loop's iterable run once, but
SC6101 counted any dynamic operation inside a loop statement's span, so
untyped setup there produced the warning and failed --fail-on=dynamic.
Loop work is now found by walking the IR: a loop's condition, update and
body repeat, its initializer and iterable do not. Locations could not
tell them apart, because lowering gives the index loop of a `for...of`
the whole statement's span.
---
 docs/content/docs/coverage.mdx                |   2 +-
 .../src/frontend/lowering/dynamic-tier.ts     | 103 +++++++++++++-----
 tests/coverage-fixtures/dynamic-tier/quiet.ts |  16 ++-
 3 files changed, 90 insertions(+), 31 deletions(-)

diff --git a/docs/content/docs/coverage.mdx b/docs/content/docs/coverage.mdx
index 09f87bacd..d2fc345ad 100644
--- a/docs/content/docs/coverage.mdx
+++ b/docs/content/docs/coverage.mdx
@@ -77,7 +77,7 @@ warning SC6101: 3 functions that likely run often use untyped values, which runs
 The program compiled. Adding types to these functions lets scriptc compile them to faster code.
 ```
 
-Without a profile, a dynamic-tier function counts as likely to run often when a dynamic operation runs inside one of its loops, when a loop calls it, or when it calls itself. A function is named only when its source says why its values are untyped: a value typed `any` (for a `for...of` variable, the value it iterates), an untyped `JSON.parse` result, or an untyped JavaScript file. Dynamic code that runs once, such as setup code that reads an `any` configuration, is not reported, and neither are functions that are dynamic for an operation with no static lowering, which more types would not change.
+Without a profile, a dynamic-tier function counts as likely to run often when a dynamic operation runs on every iteration of one of its loops (a `for` loop's initializer and a `for...of` loop's iterable run once), when a loop calls it, or when it calls itself. A function is named only when its source says why its values are untyped: a value typed `any` (for a `for...of` variable, the value it iterates), an untyped `JSON.parse` result, or an untyped JavaScript file. Dynamic code that runs once, such as setup code that reads an `any` configuration, is not reported, and neither are functions that are dynamic for an operation with no static lowering, which more types would not change.
 
 The warning names at most five functions, most likely to run often first, and gives the total. Dynamic-tier code in npm packages is summarized on one line with each package's function count. A build that comes from the cache repeats the warning. `--no-dynamic-tier-warning` leaves it out, and `--fail-on=dynamic` fails a coverage run on it.
 
diff --git a/packages/compiler/src/frontend/lowering/dynamic-tier.ts b/packages/compiler/src/frontend/lowering/dynamic-tier.ts
index 873b22343..72cba9942 100644
--- a/packages/compiler/src/frontend/lowering/dynamic-tier.ts
+++ b/packages/compiler/src/frontend/lowering/dynamic-tier.ts
@@ -1,8 +1,8 @@
 /* Hot dynamic-tier functions (SC6101, diagnostics/dynamic-tier.ts): the
  * functions of a program that compile to the dynamic tier (ir/tiers.ts) and
  * likely run often, so a build can name them. Without a profile, a function
- * counts as likely hot when a dynamic operation runs inside one of its
- * loops, when a loop calls it, or when it calls itself. Dynamic code that
+ * counts as likely hot when a dynamic operation runs on every iteration of
+ * one of its loops, when a loop calls it, or when it calls itself. Dynamic code that
  * runs once (setup code that reads an `any` configuration, for example)
  * stays quiet.
  *
@@ -21,8 +21,12 @@ import {
   type UntypedCause,
 } from "../../diagnostics/dynamic-tier.js";
 import type { IrExpr, IrFunction, IrModule, IrStmt, SrcLoc } from "../../ir/ir.js";
-import { dynamicOperationSites } from "../../ir/tiers.js";
-import { everyStmtList } from "../../ir/traverse.js";
+import {
+  dynamicOperationOf,
+  dynamicOperationSites,
+  type DynamicOperationSite,
+} from "../../ir/tiers.js";
+import { everyExprChild, everyStmtChild } from "../../ir/traverse.js";
 import * as ts from "../ts7/adapter.js";
 import { isCheckedJsSourceFile, isJsSourceFile } from "../program.js";
 import { isNodeModulesPath } from "../resolve.js";
@@ -46,30 +50,73 @@ export interface DynamicTierReport {
   packages: DynamicTierPackageCount[];
 }
 
-const LOOP_KINDS = new Set(["while", "doWhile", "for", "forOf"]);
-
-function within(loc: SrcLoc, spans: readonly SrcLoc[]): boolean {
-  return spans.some((s) => s.file === loc.file && s.start <= loc.start && loc.end <= s.end);
-}
-
 interface FunctionFacts {
-  loops: SrcLoc[];
-  /** Callee names of direct calls, with each call's location. */
-  calls: { callee: string; loc: SrcLoc }[];
+  /** Dynamic operations in the parts of the function's loops that run on
+   * every iteration. */
+  loopSites: DynamicOperationSite[];
+  /** Callee names of direct calls, and whether each runs on every
+   * iteration of a loop. */
+  calls: { callee: string; inLoop: boolean }[];
 }
 
+/** Walks a function body by structure: a loop's condition, update and body
+ * repeat, while a `for` loop's initializer and a `for...of` loop's iterable
+ * run once. (Locations cannot tell them apart: lowering may give a loop's
+ * repeated parts the whole statement's span.) */
 function factsOf(fn: IrFunction): FunctionFacts {
-  const facts: FunctionFacts = { loops: [], calls: [] };
-  everyStmtList(fn.body, {
-    stmt: (s: IrStmt) => {
-      if (LOOP_KINDS.has(s.kind)) facts.loops.push(s.loc);
-      return true;
-    },
-    expr: (e: IrExpr) => {
-      if (e.kind === "call") facts.calls.push({ callee: e.callee, loc: e.loc });
-      return true;
-    },
-  });
+  const facts: FunctionFacts = { loopSites: [], calls: [] };
+  const expr = (e: IrExpr, inLoop: boolean): void => {
+    if (inLoop) {
+      const operation = dynamicOperationOf(e);
+      if (operation !== null) facts.loopSites.push({ operation, loc: e.loc });
+    }
+    if (e.kind === "call") facts.calls.push({ callee: e.callee, inLoop });
+    everyExprChild(
+      e,
+      (child) => {
+        expr(child, inLoop);
+        return true;
+      },
+      (child) => {
+        stmt(child, inLoop);
+        return true;
+      },
+    );
+  };
+  const children = (s: IrStmt, inLoop: boolean): void => {
+    everyStmtChild(
+      s,
+      (child) => {
+        expr(child, inLoop);
+        return true;
+      },
+      (child) => {
+        stmt(child, inLoop);
+        return true;
+      },
+    );
+  };
+  const stmt = (s: IrStmt, inLoop: boolean): void => {
+    switch (s.kind) {
+      case "for":
+        if (s.init !== null) stmt(s.init, inLoop);
+        if (s.cond !== null) expr(s.cond, true);
+        if (s.update !== null) stmt(s.update, true);
+        for (const b of s.body) stmt(b, true);
+        return;
+      case "forOf":
+        expr(s.iterable, inLoop);
+        for (const b of s.body) stmt(b, true);
+        return;
+      case "while":
+      case "doWhile":
+        children(s, true);
+        return;
+      default:
+        children(s, inLoop);
+    }
+  };
+  for (const s of fn.body) stmt(s, false);
   return facts;
 }
 
@@ -202,7 +249,7 @@ export function scanDynamicTier(lowerer: Lowerer, module: IrModule): DynamicTier
   const calledInLoop = new Set<string>();
   for (const fn of module.functions) {
     const f = facts.get(fn.name)!;
-    for (const call of f.calls) if (within(call.loc, f.loops)) calledInLoop.add(call.callee);
+    for (const call of f.calls) if (call.inLoop) calledInLoop.add(call.callee);
   }
   const hot: HotDynamicFunction[] = [];
   const packages = new Map<string, number>();
@@ -218,7 +265,7 @@ export function scanDynamicTier(lowerer: Lowerer, module: IrModule): DynamicTier
     }
     const f = facts.get(fn.name)!;
     const sites = dynamicOperationSites(fn);
-    const inLoops = sites.filter((s) => within(s.loc, f.loops));
+    const inLoops = f.loopSites;
     const recursive = f.calls.some((c) => c.callee === fn.name);
     const reason: HotReason | null =
       inLoops.length > 0
@@ -231,7 +278,9 @@ export function scanDynamicTier(lowerer: Lowerer, module: IrModule): DynamicTier
     if (reason === null) continue;
     // Only functions the source makes dynamic are named: ones dynamic for
     // operations without a static lowering would stay dynamic with more types.
-    const cause = causeOf(lowerer, [...inLoops, ...sites.filter((s) => !inLoops.includes(s))]);
+    const looped = new Set(inLoops.map((s) => `${s.loc.file}:${s.loc.start}:${s.loc.end}`));
+    const rest = sites.filter((s) => !looped.has(`${s.loc.file}:${s.loc.start}:${s.loc.end}`));
+    const cause = causeOf(lowerer, [...inLoops, ...rest]);
     if (cause === null) continue;
     hot.push({
       name: fn.name,
diff --git a/tests/coverage-fixtures/dynamic-tier/quiet.ts b/tests/coverage-fixtures/dynamic-tier/quiet.ts
index d045a9392..1b0a212ea 100644
--- a/tests/coverage-fixtures/dynamic-tier/quiet.ts
+++ b/tests/coverage-fixtures/dynamic-tier/quiet.ts
@@ -1,5 +1,6 @@
-// An untyped configuration read once at startup: dynamic, but not hot, so
-// the build names nothing. The hot loop is typed.
+// Untyped values read once (a configuration at startup, a loop's
+// initializer, a for...of iterable): dynamic, but not hot, so the build
+// names nothing. The loops repeat only typed work.
 const config: any = JSON.parse('{"scale": 3, "label": "sum"}');
 const scale: number = config.scale;
 const label: string = config.label;
@@ -10,4 +11,13 @@ function sum(values: number[]): number {
   return total;
 }
 
-console.log(label, sum([1, 2, 3]));
+// Untyped values read once, in a loop's initializer and in a for...of
+// iterable: the loops repeat only typed work.
+function offsets(raw: any): number {
+  let total = 0;
+  for (let i: number = raw.start; i < 3; i++) total += i;
+  for (const n of raw.extra as number[]) total += n;
+  return total;
+}
+
+console.log(label, sum([1, 2, 3]), offsets({ start: 1, extra: [4, 5] }));

From 5bcd68f1aec0783a468d2053e146a86b70f52eb8 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 19:31:44 -0500
Subject: [PATCH 50/67] Address the third review round on array named
 properties

---
 packages/runtime/src/scr_json.c               | 19 ++++++++++++++-----
 .../6987-array-view-named-properties.ts       | 10 ++++++++++
 2 files changed, 24 insertions(+), 5 deletions(-)

diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c
index f62ef0165..89007a6ac 100644
--- a/packages/runtime/src/scr_json.c
+++ b/packages/runtime/src/scr_json.c
@@ -10279,20 +10279,29 @@ void scr_dyn_key_delete(ScrDyn *recv, const ScrStr *key, bool strict) {
       !scr_typed_ref_is_length(key) && !scr_typed_ref_canonical_index(key->data, key->len, &element)) {
     double number;
     bool numeric = scr_arr_numeric_key(key->data, key->len, &number);
-    if (numeric) scr_arr_delete(recv->v.typed_ref.ptr, number);
     if (recv->v.typed_ref.commit) {
       ScrDyn *view = scr_dyn_typed_ref_materialize(recv);
       if (!scr_exc_pending() && view->kind == SCR_DYN_ARR) {
-        bool own = view->v.arr.properties && scr_dyn_obj_get(view->v.arr.properties, key->data, key->len);
-        if (own) scr_dyn_key_delete(view, key, strict);
-        if (own && !scr_exc_pending()) scr_dyn_typed_ref_commit(recv);
+        ScrDynEntry *own = view->v.arr.properties ? scr_dyn_entry(view->v.arr.properties, key) : NULL;
+        /* A non-configurable property refuses the delete before either
+         * store changes. */
+        if (own && !own->configurable) {
+          scr_dyn_key_delete(view, key, strict);
+        } else {
+          if (numeric) scr_arr_delete(recv->v.typed_ref.ptr, number);
+          if (own) scr_dyn_key_delete(view, key, strict);
+          if (own && !scr_exc_pending()) scr_dyn_typed_ref_commit(recv);
+        }
         scr_dyn_release(view);
         return;
       }
       scr_dyn_release(view);
       if (scr_exc_pending()) return;
     }
-    if (numeric) return;
+    if (numeric) {
+      scr_arr_delete(recv->v.typed_ref.ptr, number);
+      return;
+    }
   }
   if (recv->kind == SCR_DYN_FUNC) {
     if (scr_dyn_fn_property_fence(key)) return;
diff --git a/tests/corpus/6987-array-view-named-properties.ts b/tests/corpus/6987-array-view-named-properties.ts
index faba7dc90..ee357d072 100644
--- a/tests/corpus/6987-array-view-named-properties.ts
+++ b/tests/corpus/6987-array-view-named-properties.ts
@@ -102,3 +102,13 @@ for (const key in visited) {
   console.log("visited key", key);
   if (key === "first") delete (visited as unknown as Bag).second;
 }
+
+// A non-configurable numeric-looking property refuses the delete and stays.
+const fixed: string[] = ["a"];
+Object.defineProperty(fixed as unknown as Bag, "-3", { value: "kept", enumerable: true });
+try {
+  delete (fixed as unknown as Bag)["-3"];
+} catch (e) {
+  console.log((e as Error).name);
+}
+console.log((fixed as unknown as Bag)["-3"], "-3" in (fixed as unknown as Bag));

From 62ddc2fd352c6f0dadb9cb80b531201cbc7ec3b2 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 19:31:56 -0500
Subject: [PATCH 51/67] Read a class branch's own-property bag from its
 receiver

---
 .../lowering/class-dynamic-dispatch.test.ts   |  82 +++++++++
 .../lowering/class-dynamic-dispatch.ts        | 169 +++++++++++++++---
 .../corpus/6943-js-class-branch-bags.js.json  |   6 +
 tests/corpus/6943-js-class-branch-bags.js     |  67 +++++++
 .../6943-js-class-branch-bags.js.json         |   1 +
 5 files changed, 296 insertions(+), 29 deletions(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6943-js-class-branch-bags.js.json
 create mode 100644 tests/corpus/6943-js-class-branch-bags.js
 create mode 100644 tests/harness/corpus-costs/6943-js-class-branch-bags.js.json

diff --git a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.test.ts b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.test.ts
index dfb8bd7a5..6923841bd 100644
--- a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.test.ts
+++ b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.test.ts
@@ -475,3 +475,85 @@ test("normalizes base capsules before dispatching each derived member once", ()
     ],
   });
 });
+
+test("class branches read their exact class's bag, also for classes with subclasses", () => {
+  const { lowerer, liftedFns } = context();
+  const base = {
+    def: { name: "Base", fields: [{ name: "value", type: F64 }], tracksOwnFields: true },
+    fields: new Map([["value", F64]]),
+    methods: new Map(),
+    base: null,
+    subclasses: [],
+  } as unknown as ClassInfo;
+  const child = {
+    def: {
+      name: "Child",
+      base: "Base",
+      fields: [{ name: "value", type: F64 }],
+      tracksOwnFields: true,
+    },
+    fields: new Map([["value", F64]]),
+    methods: new Map(),
+    base,
+    subclasses: [],
+  } as unknown as ClassInfo;
+  base.subclasses.push(child);
+  lowerer.classes.set("Base", base);
+  lowerer.classes.set("Child", child);
+  lowerer.classCanBeConstructed = () => true;
+  lowerer.isSubclassOf = (name, parent) => name === "Child" && parent === "Base";
+  lowerer.coerceToExpected = (value, type) =>
+    type.kind === "dyn" ? { kind: "dynFrom", value, type, loc } : value;
+  const boxes = fn(
+    "boxes",
+    [base, child].map((info) =>
+      statement({
+        kind: "dynFrom",
+        value: {
+          kind: "varRef",
+          localId: info.def.name,
+          type: { kind: "object", className: info.def.name },
+          loc,
+        },
+        type: DYN,
+        loc,
+      }),
+    ),
+  );
+  const read = fn("read", [
+    statement({
+      kind: "dynKeyGet",
+      value: variable("value"),
+      key: literal("value"),
+      type: DYN,
+      loc,
+    }),
+  ]);
+  const dispatch = new ClassDynamicDispatch();
+  for (let pass = 0; pass < 4 && dispatch.process(lowerer, [boxes, read, ...liftedFns]); pass++);
+  dispatch.finalize(lowerer);
+  const property = liftedFns.find((helper) => helper.name.startsWith("%dyn.class.property."))!;
+  // The class branches; the fallback for other receivers keeps the
+  // dispatch over every class.
+  const branches = property.body.filter(
+    (statement) =>
+      statement.kind === "if" &&
+      statement.cond.kind === "libCall" &&
+      statement.cond.fn === "dyn.typedRefIs",
+  );
+  expect(branches).toHaveLength(2);
+  const text = JSON.stringify(branches);
+  expect(text).toContain('"callee":"%class.branchPropertiesOrEmpty:Base"');
+  expect(text).toContain('"callee":"%class.branchPropertiesOrEmpty:Child"');
+  expect(text).not.toContain('"callee":"%dyn.class.readPropertiesOrEmpty"');
+  const bag = liftedFns.find((helper) => helper.name === "%class.branchPropertiesOrEmpty:Base")!;
+  // The bag is the receiver's own field; an absent bag reads as a fresh,
+  // unstored empty object.
+  expect(bag.params[0]!.type).toEqual({ kind: "object", className: "Base" });
+  expect(JSON.stringify(bag.body)).toContain('"className":"Base","field":"%dynProperties"');
+  expect(JSON.stringify(bag.body)).not.toContain('"kind":"fieldSet"');
+  expect(bag.body[0]).toMatchObject({
+    kind: "if",
+    then: [{ kind: "return", value: { kind: "dynObjLit", fields: [] } }],
+  });
+});
diff --git a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts
index c891c14cc..9dd7681a6 100644
--- a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts
+++ b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts
@@ -386,6 +386,26 @@ function readOnlyBagBody(body: IrStmt[], orEmpty = false): IrStmt[] {
   return body;
 }
 
+/** `value` with the class branch's checked receiver (`p.0` as a dynamic
+ * value, possibly cast to the branch's class) replaced by `receiver`, the
+ * typed receiver of a per-class helper. */
+function withTypedReceiver(value: IrExpr, receiver: IrExpr): IrExpr {
+  const checked = (e: IrExpr): boolean =>
+    e.kind === "dynCheck" && e.value.kind === "varRef" && e.value.localId === "p.0";
+  return transformExpr(value, {
+    stmt: (stmt) => stmt,
+    expr: (expr) =>
+      (expr.kind === "downcast" &&
+        checked(expr.value) &&
+        expr.type.kind === "object" &&
+        receiver.type.kind === "object" &&
+        expr.type.className === receiver.type.className) ||
+      checked(expr)
+        ? receiver
+        : expr,
+  });
+}
+
 export function classPropertiesHelper(lowerer: Lowerer, loc: SrcLoc, readOnly = false): IrFunction {
   const name = readOnly ? READ_PROPERTIES : "%dyn.class.properties";
   const existing = lowerer.liftedFnNamed(name);
@@ -728,7 +748,11 @@ export class ClassDynamicDispatch {
   private readonly readPropertyBags: {
     helper: IrFunction;
     initialize: Extract<IrStmt, { kind: "fieldSet" }>;
+    orEmpty?: boolean;
   }[] = [];
+  /** Read-only bags of exactly one class (exactPropertyBag), by class and
+   * whether an absent bag reads as a fresh empty object. */
+  private readonly exactPropertyBags = new Map<string, IrFunction>();
   private readonly generated = new Set<IrFunction>();
   /** Protocol dispatch helpers and callee reads whose receivers normalize. */
   private readonly protocols: IrFunction[] = [];
@@ -2557,7 +2581,6 @@ export class ClassDynamicDispatch {
         if (dispatch.classes.has(plan.key) || !matching!.has(info)) continue;
         dispatch.classes.add(plan.key);
         const loc = dispatch.source.loc;
-        const value = varRef("p.0", DYN, loc);
         const { receiver, condition } = this.propertyReceiver(plan, loc);
         if (isClassCallback(lowerer, info, dispatch.source.method)) {
           const prototypeMethod = observedPrototypeMethod(
@@ -2567,7 +2590,7 @@ export class ClassDynamicDispatch {
             loc,
             receiver,
           );
-          const bag = this.readPropertyBagOrEmpty(lowerer, value, loc);
+          const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
           const methodKey: IrExpr = {
             kind: "strLit",
             value: dispatch.source.method,
@@ -2825,10 +2848,19 @@ export class ClassDynamicDispatch {
         dispatch.classes.add(plan.key);
         const loc = dispatch.fn.loc;
         const { receiver, condition } = this.propertyReceiver(plan, loc);
+        // The branch checks its receiver once: each use of the checked
+        // receiver would repeat the check.
+        const local = `receiver.${dispatch.fn.locals.length}`;
+        dispatch.fn.locals.push({
+          id: local,
+          name: "receiver",
+          type: receiver.type,
+          mutable: false,
+        });
         const before = lowerer.diags.length;
         let branch: IrStmt[];
         try {
-          branch = this.propertyBody(lowerer, dispatch, info, receiver);
+          branch = this.propertyBody(lowerer, dispatch, info, varRef(local, receiver.type, loc));
         } catch (error) {
           if (!(error instanceof PoisonError) || !info.decl) throw error;
           const fence = lowerer.deferToRuntimeFence(before, info.decl, { kind: "statement" });
@@ -2838,7 +2870,7 @@ export class ClassDynamicDispatch {
         dispatch.fn.body.unshift({
           kind: "if",
           cond: condition,
-          then: branch,
+          then: [{ kind: "varDecl", localId: local, init: receiver, loc }, ...branch],
           else_: null,
           loc,
         });
@@ -2938,11 +2970,7 @@ export class ClassDynamicDispatch {
             !info.fields.has(name) && observedPrototypeMethod(lowerer, info, name, loc, receiver);
           if (info.fields.has(name) || (dispatch.probe === "in" && !prototypeMethod)) {
             if (info.fields.has(name) && info.def.tracksOwnFields) {
-              const bag = this.readPropertyBagOrEmpty(
-                lowerer,
-                lowerer.coerceToExpected(receiver, DYN),
-                loc,
-              );
+              const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
               const symbol = symbolMemberKey(lowerer, info, name, loc);
               const fn =
                 dispatch.probe === "in"
@@ -2968,11 +2996,7 @@ export class ClassDynamicDispatch {
               { kind: "return", value: { kind: "boolLit", value: true, type: BOOL, loc }, loc },
             ];
           }
-          const bag = this.readPropertyBagOrEmpty(
-            lowerer,
-            lowerer.coerceToExpected(receiver, DYN),
-            loc,
-          );
+          const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
           const symbol = name.startsWith("sym:") || name.startsWith("%symbol:");
           const fn =
             dispatch.probe === "in"
@@ -3042,9 +3066,8 @@ export class ClassDynamicDispatch {
           }
           const branches: IrStmt[] = [];
           if (!dispatch.write && !dispatch.reflect && !info.def.tracksOwnFields) {
-            const value = varRef("p.0", DYN, loc);
             const key = varRef("p.key", DYN, loc);
-            const bag = this.readPropertyBagOrEmpty(lowerer, value, loc);
+            const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
             branches.push({
               kind: "if",
               cond: {
@@ -4070,6 +4093,98 @@ export class ClassDynamicDispatch {
     return helper;
   }
 
+  /** The read-only bag a class branch reads for its receiver: the
+   * receiver's own field when the branch selected the receiver's exact
+   * class, otherwise the dispatch over every class (readPropertyBag, or
+   * readPropertyBagOrEmpty with `orEmpty`). */
+  private branchPropertyBag(
+    lowerer: Lowerer,
+    info: ClassInfo,
+    receiver: IrExpr,
+    orEmpty: boolean,
+    loc: SrcLoc,
+  ): IrExpr {
+    const helper = this.exactPropertyBag(lowerer, info, receiver, orEmpty, loc);
+    if (helper) return { kind: "call", callee: helper.name, args: [receiver], type: DYN, loc };
+    return orEmpty
+      ? this.readPropertyBagOrEmpty(lowerer, lowerer.coerceToExpected(receiver, DYN), loc)
+      : this.readPropertyBag(lowerer, receiver, loc);
+  }
+
+  /** `%class.branchProperties[OrEmpty]:<class>(receiver)`: the read-only bag of
+   * an instance of exactly `info`. A class branch of the dispatch helpers
+   * selects a canonical receiver (normalizeDispatches gives an instance its
+   * actual class's capsule), so its branch for `info` sees only instances
+   * of `info`; instances of its subclasses take their own branches. Such a
+   * receiver needs neither the dispatch over every class nor a boxed copy of
+   * itself. Null
+   * when `receiver` is not typed as `info`, when a runtime or builtin class
+   * in the family keeps its own property contract, or before the class has
+   * a bag. */
+  private exactPropertyBag(
+    lowerer: Lowerer,
+    info: ClassInfo,
+    receiver: IrExpr,
+    orEmpty: boolean,
+    loc: SrcLoc,
+  ): IrFunction | null {
+    const type = receiver.type;
+    if (type.kind !== "object" || type.className !== info.def.name) return null;
+    for (let current: ClassInfo | null = info; current; current = current.base)
+      if (
+        current.def.runtime ||
+        current.builtinEmitter ||
+        current.builtinStream ||
+        current.builtinError
+      )
+        return null;
+    const key = `${type.className}:${orEmpty}`;
+    const existing = this.exactPropertyBags.get(key);
+    if (existing) return existing;
+    const initializers = this.bagInitializers.get(type.className);
+    if (!initializers) return null;
+    const self = varRef("p.0", type, loc);
+    const bag: IrExpr = {
+      kind: "fieldGet",
+      obj: self,
+      className: type.className,
+      field: PROPERTY_BAG,
+      type: DYN,
+      loc,
+    };
+    const initialize: Extract<IrStmt, { kind: "fieldSet" }> = {
+      ...initializers[0]!,
+      obj: self,
+      value: withTypedReceiver(initializers[0]!.value, self),
+      loc,
+    };
+    const helper: IrFunction = {
+      name: `%class.branchProperties${orEmpty ? "OrEmpty" : ""}:${type.className}`,
+      params: [{ localId: "p.0", name: "value", type }],
+      returnType: DYN,
+      locals: [{ id: "p.0", name: "value", type, mutable: false }],
+      loc,
+      body: [
+        {
+          kind: "if",
+          cond: { kind: "dynTest", test: "undefined", value: bag, type: BOOL, loc },
+          then: [initialize],
+          else_: null,
+          loc,
+        },
+        { kind: "return", value: bag, loc },
+      ],
+    };
+    // Initializers gain their prototype as subclasses become constructible;
+    // finalize then turns the lazy store into the read's result.
+    initializers.push(initialize);
+    this.exactPropertyBags.set(key, helper);
+    this.readPropertyBags.push({ helper, initialize, orEmpty });
+    this.generated.add(helper);
+    lowerer.liftedFns.push(helper);
+    return helper;
+  }
+
   /** The prototype a new property bag of `current` (or of the subclass the
    * receiver is) starts from, or null when `current` has no prototype data.
    * A class with constructible subclasses that have prototype data selects
@@ -4149,9 +4264,9 @@ export class ClassDynamicDispatch {
    * prototype-backed bag is produced for this read only. A published object
    * cannot take the store, and Node's reads never write. */
   finalize(lowerer?: Lowerer): void {
-    for (const { helper, initialize } of this.readPropertyBags) {
+    for (const { helper, initialize, orEmpty } of this.readPropertyBags) {
       const absent = helper.body[0];
-      if (isEmptyBag(initialize.value)) helper.body.shift();
+      if (isEmptyBag(initialize.value) && !orEmpty) helper.body.shift();
       else if (absent?.kind === "if")
         absent.then = [{ kind: "return", value: initialize.value, loc: initialize.loc }];
     }
@@ -4733,7 +4848,7 @@ export class ClassDynamicDispatch {
                 cond: this.readBagHas(
                   lowerer,
                   "dyn.hasKey",
-                  this.readPropertyBag(lowerer, receiver, loc),
+                  this.branchPropertyBag(lowerer, info, receiver, false, loc),
                   key,
                   loc,
                 ),
@@ -4748,7 +4863,7 @@ export class ClassDynamicDispatch {
           { kind: "return", value: null, loc },
         ];
       }
-      const bag = this.readPropertyBag(lowerer, receiver, loc);
+      const bag = this.branchPropertyBag(lowerer, info, receiver, false, loc);
       return [
         {
           kind: "return",
@@ -4816,7 +4931,7 @@ export class ClassDynamicDispatch {
       ) {
         this.constructors.set(info.def.name, info);
         const cls = lowerer.coerceToExpected(classValueRef(lowerer, info, info.decl), DYN);
-        const bag = this.readPropertyBag(lowerer, receiver, loc);
+        const bag = this.branchPropertyBag(lowerer, info, receiver, false, loc);
         const key: IrExpr = { kind: "strLit", value: name, type: STRING, loc };
         return [
           {
@@ -4894,7 +5009,7 @@ export class ClassDynamicDispatch {
           if (symbol || (isClassOwnEnumerableFieldName(name) && !name.startsWith("sym:"))) {
             const prototypeMethod = observedPrototypeMethod(lowerer, info, name, loc, receiver);
             // Selecting the method must not give the object own storage.
-            const bag = this.readPropertyBag(lowerer, receiver, loc);
+            const bag = this.branchPropertyBag(lowerer, info, receiver, false, loc);
             const key: IrExpr = symbol ?? { kind: "strLit", value: name, type: STRING, loc };
             body.push({
               kind: "if",
@@ -4962,7 +5077,7 @@ export class ClassDynamicDispatch {
       }
       if (!field && !accessor) {
         const instance = lowerer.coerceToExpected(receiver, DYN);
-        const bag = this.readPropertyBagOrEmpty(lowerer, instance, loc);
+        const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
         const key: IrExpr = { kind: "strLit", value: name, type: STRING, loc };
         const own: IrExpr = {
           kind: "libCall",
@@ -5009,11 +5124,7 @@ export class ClassDynamicDispatch {
         (t.kind === "union" && (getUnion(t.unionId)?.arms.some(mutable) ?? false));
       if (boxed.kind === "dynFrom" && mutable(boxed.value.type)) boxed.liveRef = true;
       if (accessor) {
-        const bag = this.readPropertyBagOrEmpty(
-          lowerer,
-          lowerer.coerceToExpected(receiver, DYN),
-          loc,
-        );
+        const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
         const key: IrExpr = { kind: "strLit", value: name, type: STRING, loc };
         return [
           {
@@ -5040,7 +5151,7 @@ export class ClassDynamicDispatch {
       }
       if (field && info.def.tracksOwnFields) {
         const instance = lowerer.coerceToExpected(receiver, DYN);
-        const bag = this.readPropertyBagOrEmpty(lowerer, instance, loc);
+        const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
         const symbol = symbolMemberKey(lowerer, info, name, loc);
         const key: IrExpr = symbol ?? { kind: "strLit", value: name, type: STRING, loc };
         return [
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6943-js-class-branch-bags.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6943-js-class-branch-bags.js.json
new file mode 100644
index 000000000..31675c66e
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6943-js-class-branch-bags.js.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6943-js-class-branch-bags.js"
+ ],
+ "diags": []
+}
diff --git a/tests/corpus/6943-js-class-branch-bags.js b/tests/corpus/6943-js-class-branch-bags.js
new file mode 100644
index 000000000..b3f91f8d8
--- /dev/null
+++ b/tests/corpus/6943-js-class-branch-bags.js
@@ -0,0 +1,67 @@
+// Untyped reads of class instances in a hierarchy: own properties added at
+// runtime shadow methods and accessors, prototype data answers while an
+// instance has no own properties, and computed keys and key probes see the
+// same members, for the base class and for each subclass.
+
+class Shape {
+  constructor(name) {
+    this.name = name;
+    this.sides = 0;
+  }
+  area() {
+    return 0;
+  }
+  get label() {
+    return `${this.name}/${this.sides}`;
+  }
+}
+class Square extends Shape {
+  constructor(size) {
+    super("square");
+    this.sides = 4;
+    this.size = size;
+  }
+  area() {
+    return this.size * this.size;
+  }
+}
+class Tile extends Square {
+  constructor(size, color) {
+    super(size);
+    this.color = color;
+  }
+}
+Shape.prototype.kind = "shape";
+Square.prototype.corner = "right";
+
+function read(value, key) {
+  return value[key];
+}
+function describe(value) {
+  const parts = [];
+  for (const key of ["name", "sides", "size", "color", "kind", "corner", "label", "missing"])
+    parts.push(`${key}=${String(read(value, key))}`);
+  parts.push(`in:${"area" in value},${"kind" in value},${"extra" in value}`);
+  parts.push(`own:${Object.hasOwn(value, "kind")},${Object.hasOwn(value, "size")}`);
+  return parts.join(" ");
+}
+
+const shapes = [new Shape("dot"), new Square(3), new Tile(2, "red")];
+for (const shape of shapes) console.log(describe(shape), shape.area(), shape.label);
+
+const untyped = shapes.map((shape) => /** @type {any} */ (shape));
+untyped[1].area = () => -1;
+untyped[2].kind = "tile";
+untyped[2].extra = 7;
+try {
+  untyped[0].label = "plain";
+} catch (error) {
+  console.log(error.name);
+}
+Object.defineProperty(untyped[0], "label", { value: "plain", enumerable: true });
+for (const shape of untyped) {
+  console.log(describe(shape), typeof shape.area, shape.area(), shape.kind, shape.extra);
+  console.log(read(shape, "area") === Shape.prototype.area, read(shape, "label"));
+}
+const area = untyped[2].area;
+console.log(area.call(new Tile(5, "blue")), Object.keys(untyped[2]).join(","));
diff --git a/tests/harness/corpus-costs/6943-js-class-branch-bags.js.json b/tests/harness/corpus-costs/6943-js-class-branch-bags.js.json
new file mode 100644
index 000000000..9a69600b1
--- /dev/null
+++ b/tests/harness/corpus-costs/6943-js-class-branch-bags.js.json
@@ -0,0 +1 @@
+{ "plain": 4400, "san": 4900 }

From ed5f54c93684b4dbfa87f6e3b6903b4ffd9d1a7b Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 19:51:21 -0500
Subject: [PATCH 52/67] Keep constructor types of fetched provenance sources
 unmapped

Constructor types declared in the program hold class values as
checked-dynamic values since #1725. A fetched provenance source counts as
a program file, so the unused `@__PURE__` const typed `{ new (): any }` in
the provenance fixture now had a mapping, no longer elided, and its
initializer refused (SC1090). Fetched sources keep their constructor types
unmapped, as before #1725.
---
 packages/compiler/src/frontend/type-mapper.ts | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/packages/compiler/src/frontend/type-mapper.ts b/packages/compiler/src/frontend/type-mapper.ts
index b0e3a6dc9..37d6a5807 100644
--- a/packages/compiler/src/frontend/type-mapper.ts
+++ b/packages/compiler/src/frontend/type-mapper.ts
@@ -46,6 +46,7 @@ import { literalValues } from "./literal-values.js";
 import { remapUnionDiscriminant } from "./union-discriminants.js";
 
 import { isJsSourceFile, isNodeTypesPath } from "./program.js";
+import { isProvenanceSourceFile } from "./provenance-registry.js";
 import { functionCanReturnUndefined } from "./function-completion.js";
 import { accessorSlotProp, recordTextCodecClass } from "../ir/ir.js";
 // typeKey moved to ir/ir.ts (the backend needs it too, for per-type
@@ -2466,12 +2467,17 @@ function mapTypeInner(type: ts.Type, ctx: TypeMapperCtx): IrType | null {
     // value rides the checked-dynamic tree, as an `unknown` slot already
     // holds one. `new` through it and static reads dispatch at run time,
     // and the constructed value checks into the signature's instance type.
-    // Lib and package constructables keep their fences.
+    // Lib and package constructables keep their fences, and so do those of
+    // fetched provenance sources (third-party code under its own policies:
+    // an unused `@__PURE__` const typed `{ new (): any }` elides there).
     if (
       ctorSigs.length > 0 &&
       checker.getCallSignatures(widened).length === 0 &&
       (widened.getSymbol()?.declarations.length ?? 0) > 0 &&
-      widened.getSymbol()!.declarations.every((d) => ctx.isProgramFile(ts.getSourceFileOfNode(d)))
+      widened.getSymbol()!.declarations.every((d) => {
+        const sf = ts.getSourceFileOfNode(d);
+        return ctx.isProgramFile(sf) && !isProvenanceSourceFile(sf.fileName);
+      })
     ) {
       return DYN;
     }

From e7f3b205c3d3fda06412fedf9a12bd0ed2096998 Mon Sep 17 00:00:00 2001
From: Malte Ubl <malte@vercel.com>
Date: Wed, 21 Oct 2026 17:53:28 -0700
Subject: [PATCH 53/67] Fetch the CI dev libnode from scriptc's mirror first

The prerelease libnode-dev-24.22.1 mirrors the dockfries v24.22.1 libnode,
Node's v24.22.1 headers and Node's license byte for byte, as CI-only inputs
(not a scriptc release). dev-pack.json lists the mirror first and the
original locations after it; fetch-dev-pack.mjs takes the first source
whose bytes match the pinned sha256 and logs which one it used.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 packages/libnode-common/dev-pack.json      | 12 ++++++--
 packages/libnode-common/fetch-dev-pack.mjs | 35 ++++++++++++++++------
 2 files changed, 35 insertions(+), 12 deletions(-)

diff --git a/packages/libnode-common/dev-pack.json b/packages/libnode-common/dev-pack.json
index 7544d44c4..6c521cbb6 100644
--- a/packages/libnode-common/dev-pack.json
+++ b/packages/libnode-common/dev-pack.json
@@ -1,14 +1,20 @@
 {
-  "comment": "Temporary libnode source for CI until the NI-13 packs (@scriptc/libnode-<platform>) exist: the community dockfries/libnode build of the newest patch of the pinned Node line (its v24.22.0 asset was withdrawn when v24.22.1 shipped), plus Node's official headers for the bridge. fetch-dev-pack.mjs verifies both hashes.",
+  "comment": "Temporary libnode source for CI until the NI-13 packs (@scriptc/libnode-<platform>) exist: the community dockfries/libnode build of Node 24.22.1 and Node's official headers for the bridge. The first URL is scriptc's CI-only mirror (prerelease libnode-dev-24.22.1), the others the original locations; fetch-dev-pack.mjs tries them in order and verifies the sha256.",
   "nodeVersion": "24.22.1",
   "linux-x64": {
     "libnode": {
-      "url": "https://github.com/dockfries/libnode/releases/download/v24.22.1/libnode-linux-x64.tar.gz",
+      "urls": [
+        "https://github.com/vercel-labs/scriptc/releases/download/libnode-dev-24.22.1/libnode-linux-x64.tar.gz",
+        "https://github.com/dockfries/libnode/releases/download/v24.22.1/libnode-linux-x64.tar.gz"
+      ],
       "sha256": "b02809c5d332516cc72890fec0cbbca404bac526bd0f841e00a8a6056ec1ff54",
       "file": "libnode.so.137"
     },
     "headers": {
-      "url": "https://nodejs.org/dist/v24.22.1/node-v24.22.1-headers.tar.gz",
+      "urls": [
+        "https://github.com/vercel-labs/scriptc/releases/download/libnode-dev-24.22.1/node-v24.22.1-headers.tar.gz",
+        "https://nodejs.org/dist/v24.22.1/node-v24.22.1-headers.tar.gz"
+      ],
       "sha256": "322e0a27db9088093ab8347bdc8c7e0aaa21dc9ed548390bf06b394494c09267",
       "dir": "node-v24.22.1/include/node"
     }
diff --git a/packages/libnode-common/fetch-dev-pack.mjs b/packages/libnode-common/fetch-dev-pack.mjs
index 78b7b13fe..5c4bafc90 100644
--- a/packages/libnode-common/fetch-dev-pack.mjs
+++ b/packages/libnode-common/fetch-dev-pack.mjs
@@ -29,15 +29,32 @@ if (pins === undefined) {
 
 const work = mkdtempSync(join(tmpdir(), "scriptc-libnode-dev-"));
 
-async function fetchVerified({ url, sha256 }, name) {
-  const response = await fetch(url);
-  if (!response.ok) throw new Error(`${url}: HTTP ${response.status}`);
-  const bytes = Buffer.from(await response.arrayBuffer());
-  const actual = createHash("sha256").update(bytes).digest("hex");
-  if (actual !== sha256) throw new Error(`${url}: sha256 ${actual}, expected ${sha256}`);
-  const path = join(work, name);
-  writeFileSync(path, bytes);
-  execFileSync("tar", ["-xzf", path, "-C", work]);
+/** Downloads from the first URL that answers with the pinned bytes: the
+ * mirror, then the original locations. */
+async function fetchVerified({ urls, sha256 }, name) {
+  const failures = [];
+  for (const url of urls) {
+    let bytes;
+    try {
+      const response = await fetch(url);
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      bytes = Buffer.from(await response.arrayBuffer());
+    } catch (error) {
+      failures.push(`${url}: ${error.message}`);
+      continue;
+    }
+    const actual = createHash("sha256").update(bytes).digest("hex");
+    if (actual !== sha256) {
+      failures.push(`${url}: sha256 ${actual}, expected ${sha256}`);
+      continue;
+    }
+    console.log(`fetched ${name} from ${url} (sha256 ${sha256})`);
+    const path = join(work, name);
+    writeFileSync(path, bytes);
+    execFileSync("tar", ["-xzf", path, "-C", work]);
+    return;
+  }
+  throw new Error(`no source for ${name} matched its pin:\n${failures.join("\n")}`);
 }
 
 await fetchVerified(pins.libnode, "libnode.tar.gz");

From 1c03c0c17f5ea2c190d12075662345b440e991cf Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 20:07:00 -0500
Subject: [PATCH 54/67] Skip the pending test after callbacks that cannot throw

An array helper specialized for its callback calls the callback's
function directly once the closure's entry matches it, and falls back to
the entry otherwise. Both paths were followed by the pending-exception
test. When the direct target is outside the may-throw set, only the
fallback can leave an exception pending, so the test now runs behind a
guard that is true on that path alone; a known closure called directly
skips it. Worker programs keep the test on every path, where it also
observes termination.
---
 packages/compiler/src/backend/llvm/emitter.ts | 25 +++++++-
 .../compiler/src/backend/llvm/expr-calls.ts   | 17 +++++-
 .../test/callback-pending-emission.test.ts    | 57 +++++++++++++++++++
 3 files changed, 95 insertions(+), 4 deletions(-)
 create mode 100644 packages/compiler/test/callback-pending-emission.test.ts

diff --git a/packages/compiler/src/backend/llvm/emitter.ts b/packages/compiler/src/backend/llvm/emitter.ts
index 1dcd1f6c8..4504ae58e 100644
--- a/packages/compiler/src/backend/llvm/emitter.ts
+++ b/packages/compiler/src/backend/llvm/emitter.ts
@@ -2496,8 +2496,14 @@ export class LlEmitter {
    * releases the dummy (NULL for refcounted kinds) harmlessly. A scalar
    * call result of the function's return type may be passed as the unwind's
    * dummy value (see emitUnwind). `poll` marks a worker termination poll
-   * (function entry or loop budget), whose test must stay ordered. */
-  emitPendingCheck(passThrough?: { name: string; type: IrType }, poll = false): void {
+   * (function entry or loop budget), whose test must stay ordered. A
+   * `guard` (an i1) limits the test to the paths where it is true: false
+   * where the joined call could not have left anything pending. */
+  emitPendingCheck(
+    passThrough?: { name: string; type: IrType },
+    poll = false,
+    guard?: string,
+  ): void {
     const through =
       passThrough !== undefined &&
       this.llType(passThrough.type) === this.llType(this.currentReturnType) &&
@@ -2506,6 +2512,13 @@ export class LlEmitter {
         : undefined;
     const B = this.B;
     if (B.isTerminated()) return;
+    let skip: string | undefined;
+    if (guard !== undefined) {
+      const test = B.newLabel("exc.t");
+      skip = B.newLabel("exc.n");
+      B.condBr(guard, test, skip);
+      B.startBlock(test);
+    }
     if (this.mod.lib !== undefined) {
       this.declare(`declare zeroext i1 @scr_exc_pending()`);
       const p = B.tmp();
@@ -2516,6 +2529,10 @@ export class LlEmitter {
       B.startBlock(lu);
       this.emitUnwind(through);
       B.startBlock(lk);
+      if (skip !== undefined) {
+        B.br(skip);
+        B.startBlock(skip);
+      }
       return;
     }
     // Executables test the active exception cell's kind inline (its first
@@ -2588,6 +2605,10 @@ export class LlEmitter {
     B.startBlock(lu);
     this.emitUnwind(through);
     B.startBlock(lk);
+    if (skip !== undefined) {
+      B.br(skip);
+      B.startBlock(skip);
+    }
   }
 
   /** After a runtime call that ALWAYS leaves an exception pending (the
diff --git a/packages/compiler/src/backend/llvm/expr-calls.ts b/packages/compiler/src/backend/llvm/expr-calls.ts
index d02c43c32..81c44d5a6 100644
--- a/packages/compiler/src/backend/llvm/expr-calls.ts
+++ b/packages/compiler/src/backend/llvm/expr-calls.ts
@@ -921,9 +921,18 @@ export function emitCallExpr(
             ? `@${mangleBorrowedFunction(known!.name)}`
             : `@${mangleBorrowingWrapper(known!.name)}`
           : undefined;
+      // A known target outside the may-throw set leaves nothing pending, so
+      // only the entry through the closure's own pointer needs the test.
+      // Worker programs keep it on every path: there it also observes
+      // termination, which loops count on (callTestsPending).
+      const quiet =
+        known !== undefined && !host.mayThrow.has(known.name) && host.mod.workers !== true;
+      let pending = host.indirectMayThrow;
+      let pendingGuard: string | undefined;
       let t: string;
       if (direct && e.callee.kind === "closure") {
         t = invoke(lending ?? direct, !host.receiverReaders.ignores(known!));
+        if (quiet) pending = false;
       } else {
         const fnp = B.tmp(),
           fn = B.tmp();
@@ -983,17 +992,21 @@ export function emitCallExpr(
             B.line(
               `${t} = phi ${host.llType(e.type)} [ ${specialized}, %${fastEnd} ], [ ${indirect}, %${fallbackEnd} ]`,
             );
+          if (quiet && pending) {
+            pendingGuard = B.tmp();
+            B.line(`${pendingGuard} = phi i1 [ false, %${fastEnd} ], [ true, %${fallbackEnd} ]`);
+          }
         }
       }
       if (e.type.kind === "void") {
-        if (host.indirectMayThrow) host.emitPendingCheck();
+        if (pending) host.emitPendingCheck(undefined, false, pendingGuard);
         if (lent) host.releaseTemps(host.frames.pop()!);
         return { name: "", type: e.type };
       }
       // The check runs AFTER the result temp joins the frame: an unwind
       // releases it (the dummy is NULL for refcounted returns).
       const out = host.own({ name: t, type: e.type });
-      if (host.indirectMayThrow) host.emitPendingCheck();
+      if (pending) host.emitPendingCheck(undefined, false, pendingGuard);
       if (lent) {
         host.toFrame(out);
         host.releaseTemps(host.frames.pop()!);
diff --git a/packages/compiler/test/callback-pending-emission.test.ts b/packages/compiler/test/callback-pending-emission.test.ts
new file mode 100644
index 000000000..9dcbbf0a1
--- /dev/null
+++ b/packages/compiler/test/callback-pending-emission.test.ts
@@ -0,0 +1,57 @@
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { expect, test } from "vitest";
+import { compile, deserializeModule, validateModule } from "../src/index.js";
+import { emitLlvmModule } from "../src/backend/llvm/emitter.js";
+
+// A specialized array helper calls its known callback directly after
+// checking the closure's entry. A callback that cannot throw skips the
+// pending test on that path, and the fallback through the closure's own
+// entry keeps it; a callback that can throw keeps it on both paths.
+test("known callbacks outside the may-throw set test the pending flag only on the fallback", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "scriptc-callback-pending-"));
+  try {
+    const entry = join(dir, "main.ts");
+    const output = join(dir, "main.ir.json");
+    writeFileSync(
+      entry,
+      `const values = [1, 2, 3, 4];
+console.log(values.every((v) => v > 0));
+console.log(values.map((v) => v * 2).join(","));
+try {
+  console.log(values.every((v) => {
+    if (v > 2) throw new Error("stop at " + v);
+    return true;
+  }));
+} catch (error) {
+  console.log("caught", (error as Error).message);
+}
+`,
+    );
+    const lowered = await compile(entry, { outputKind: "ir", outDir: dir, outPath: output });
+    if (!lowered.ok) throw new Error(JSON.stringify(lowered.diagnostics));
+    const module = deserializeModule(readFileSync(output, "utf8"));
+    expect(validateModule(module)).toEqual([]);
+    const llvm = emitLlvmModule(module, {});
+    const guards = [
+      ...llvm.matchAll(
+        /(%t\d+) = phi i1 \[ false, %callback\.direct\d+ \], \[ true, %callback\.indirect\d+ \]/g,
+      ),
+    ];
+    // The quiet every and map callbacks; not the throwing one.
+    expect(guards.length).toBe(2);
+    for (const [, guard] of guards)
+      expect(llvm).toMatch(new RegExp(`br i1 ${guard}, label %exc\\.t\\d+`));
+    const helpers = llvm.split(/\n(?=define )/).filter((fn) => fn.includes("callback.direct"));
+    expect(helpers.filter((fn) => !/phi i1 \[ false, %callback\.direct/.test(fn))).toHaveLength(1);
+
+    const exe = join(dir, "main");
+    const built = await compile(entry, { outputKind: "exe", outDir: dir, outPath: exe });
+    if (!built.ok) throw new Error(JSON.stringify(built.diagnostics));
+    expect(execFileSync(exe, { encoding: "utf8" })).toBe("true\n2,4,6,8\ncaught stop at 3\n");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

From 143c80eb1c360c192ef2c914a9304d3350ce1495 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 20:10:43 -0500
Subject: [PATCH 55/67] Print class instances with their class name when
 instanceof sees unknown values

---
 .../compiler/src/backend/llvm/lib-shared.ts   |  1 +
 .../src/frontend/lowering/class-prototypes.ts | 13 +++++++
 .../compiler/src/ir/builtin-signatures.ts     |  3 ++
 ...6991-inspect-class-name-instanceof.ts.json |  6 +++
 packages/runtime/src/scr_dyn.h                |  3 ++
 packages/runtime/src/scr_json.c               | 38 ++++++++++++-------
 .../6991-inspect-class-name-instanceof.ts     | 31 +++++++++++++++
 ...6991-inspect-class-name-instanceof.ts.json |  1 +
 8 files changed, 82 insertions(+), 14 deletions(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6991-inspect-class-name-instanceof.ts.json
 create mode 100644 tests/corpus/6991-inspect-class-name-instanceof.ts
 create mode 100644 tests/harness/corpus-costs/6991-inspect-class-name-instanceof.ts.json

diff --git a/packages/compiler/src/backend/llvm/lib-shared.ts b/packages/compiler/src/backend/llvm/lib-shared.ts
index b7c6b8a21..8bb8bc3aa 100644
--- a/packages/compiler/src/backend/llvm/lib-shared.ts
+++ b/packages/compiler/src/backend/llvm/lib-shared.ts
@@ -1493,6 +1493,7 @@ export const LIB_FN_SYMS: Record<string, string> = {
   "dyn.bagGet": "scr_dyn_bag_get",
   "dyn.bagSet": "scr_dyn_bag_set",
   "dyn.objCreate": "scr_dyn_obj_create",
+  "dyn.nameClassPrototype": "scr_dyn_name_class_prototype",
   "dyn.objCreateWithProperties": "scr_dyn_obj_create_with_properties",
   "dyn.getPrototype": "scr_dyn_get_prototype",
   "dyn.setPrototype": "scr_dyn_set_prototype",
diff --git a/packages/compiler/src/frontend/lowering/class-prototypes.ts b/packages/compiler/src/frontend/lowering/class-prototypes.ts
index d2919e202..e65c679c6 100644
--- a/packages/compiler/src/frontend/lowering/class-prototypes.ts
+++ b/packages/compiler/src/frontend/lowering/class-prototypes.ts
@@ -6,6 +6,7 @@ import {
   DYN,
   STRING,
   SYMBOL_T,
+  VOID,
   isUnitType,
   type IrExpr,
   type IrFunction,
@@ -155,6 +156,18 @@ export function classPrototypeData(
                 : { kind: "dynObjLit", fields: [], type: DYN, loc },
               loc,
             },
+            // util.inspect prints an instance with its class's name.
+            {
+              kind: "exprStmt",
+              expr: {
+                kind: "libCall",
+                fn: "dyn.nameClassPrototype",
+                args: [value, { kind: "strLit", value: className, type: STRING, loc }],
+                type: VOID,
+                loc,
+              },
+              loc,
+            },
             {
               kind: "assign",
               localId: readyId,
diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts
index e4bd83db7..b79b5ebe9 100644
--- a/packages/compiler/src/ir/builtin-signatures.ts
+++ b/packages/compiler/src/ir/builtin-signatures.ts
@@ -3666,6 +3666,9 @@ export const LIB_FN_SIGS = defineLibFnSignatures({
   "dyn.bagGet": { argTypes: [DYN, STRING, DYN], result: DYN },
   "dyn.bagSet": { argTypes: [DYN, STRING, DYN, DYN], result: VOID },
   "dyn.objCreate": { argTypes: [DYN], result: DYN },
+  // Names a compiled class's prototype object (args[0]) after the class
+  // (args[1]) for util.inspect.
+  "dyn.nameClassPrototype": { argTypes: [DYN, STRING], result: VOID },
   "dyn.objCreateWithProperties": { argTypes: [DYN, DYN], result: DYN },
   "dyn.getPrototype": { argTypes: [DYN], result: DYN },
   "dyn.setPrototype": { argTypes: [DYN, DYN], result: DYN },
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6991-inspect-class-name-instanceof.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6991-inspect-class-name-instanceof.ts.json
new file mode 100644
index 000000000..a6629e2a9
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6991-inspect-class-name-instanceof.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6991-inspect-class-name-instanceof.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/runtime/src/scr_dyn.h b/packages/runtime/src/scr_dyn.h
index d36c0d263..37e9eacce 100644
--- a/packages/runtime/src/scr_dyn.h
+++ b/packages/runtime/src/scr_dyn.h
@@ -997,6 +997,9 @@ ScrDyn *scr_dyn_get_own_property_descriptor(ScrDyn *target, ScrDyn *key);
 ScrDyn *scr_dyn_array_proto_call(ScrDyn *target, ScrStr *method, ScrDyn *args);
 ScrDyn *scr_dyn_array_prototype(void); /* +1, installs native method adapters */
 ScrDyn *scr_dyn_array_prototype_base(void); /* +1, shared native array identity */
+/* Names the prototype object of a compiled class `name` for util.inspect
+ * (Node prints the constructor's name), unless it already has a name. */
+void scr_dyn_name_class_prototype(ScrDyn *prototype, const ScrStr *name);
 /* Native arrays read their holes as undefined without consulting
  * Array.prototype, so storing an element on Array.prototype raises SC2020.
  * True (with the error pending) when `recv` is Array.prototype. */
diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c
index 21ccfaa16..2787fe728 100644
--- a/packages/runtime/src/scr_json.c
+++ b/packages/runtime/src/scr_json.c
@@ -4669,6 +4669,24 @@ static void scr_dyn_named_prototypes_cleanup(void) {
   scr_dyn_named_count = scr_dyn_named_cap = 0;
 }
 
+/* Stamps prototype `p` with a copy of `name` (len bytes) and keeps it alive. */
+static void scr_dyn_stamp_prototype_name(ScrDyn *p, const char *name, size_t len) {
+  if (scr_dyn_named_count == scr_dyn_named_cap) {
+    if (scr_dyn_named_cap == 0) scr_atexit(scr_dyn_named_prototypes_cleanup);
+    size_t cap = scr_dyn_named_cap ? scr_dyn_named_cap * 2 : 8;
+    ScrDynNamedPrototype *grown = realloc(scr_dyn_named_prototypes, cap * sizeof *grown);
+    if (!grown) scr_json_oom();
+    scr_dyn_named_prototypes = grown;
+    scr_dyn_named_cap = cap;
+  }
+  char *copy = malloc(len + 1);
+  if (!copy) scr_json_oom();
+  memcpy(copy, name, len);
+  copy[len] = '\0';
+  p->v.obj.class_name = copy;
+  scr_dyn_named_prototypes[scr_dyn_named_count++] = (ScrDynNamedPrototype){ scr_dyn_retain(p), copy };
+}
+
 static void scr_dyn_name_prototype_chain(const ScrDyn *object) {
   for (ScrDyn *p = object->prototype; p; p = p->prototype) {
     if (p->kind != SCR_DYN_OBJ || p->v.obj.class_name) return;
@@ -4676,24 +4694,16 @@ static void scr_dyn_name_prototype_chain(const ScrDyn *object) {
     if (!entry || entry->accessor || !entry->value || entry->value->kind != SCR_DYN_FUNC) continue;
     const char *name = entry->value->v.fn.name;
     if (!name || !name[0]) continue;
-    if (scr_dyn_named_count == scr_dyn_named_cap) {
-      if (scr_dyn_named_cap == 0) scr_atexit(scr_dyn_named_prototypes_cleanup);
-      size_t cap = scr_dyn_named_cap ? scr_dyn_named_cap * 2 : 8;
-      ScrDynNamedPrototype *grown = realloc(scr_dyn_named_prototypes, cap * sizeof *grown);
-      if (!grown) scr_json_oom();
-      scr_dyn_named_prototypes = grown;
-      scr_dyn_named_cap = cap;
-    }
-    size_t len = strlen(name);
-    char *copy = malloc(len + 1);
-    if (!copy) scr_json_oom();
-    memcpy(copy, name, len + 1);
-    p->v.obj.class_name = copy;
-    scr_dyn_named_prototypes[scr_dyn_named_count++] = (ScrDynNamedPrototype){ scr_dyn_retain(p), copy };
+    scr_dyn_stamp_prototype_name(p, name, strlen(name));
     return;
   }
 }
 
+void scr_dyn_name_class_prototype(ScrDyn *prototype, const ScrStr *name) {
+  if (prototype->kind != SCR_DYN_OBJ || prototype->v.obj.class_name || name->len == 0) return;
+  scr_dyn_stamp_prototype_name(prototype, name->data, name->len);
+}
+
 /* Ordinary native function constructors retain their live prototype table.
  * A constructor may replace the fresh receiver with another object. */
 ScrDyn *scr_dyn_construct(const ScrDyn *callee, const ScrDyn *args, const ScrStr *what) {
diff --git a/tests/corpus/6991-inspect-class-name-instanceof.ts b/tests/corpus/6991-inspect-class-name-instanceof.ts
new file mode 100644
index 000000000..5354048c9
--- /dev/null
+++ b/tests/corpus/6991-inspect-class-name-instanceof.ts
@@ -0,0 +1,31 @@
+// util.inspect prints a class instance with its class's name, also when
+// the program tests `instanceof` on unknown values (which gives the class
+// a runtime prototype object).
+
+class Leaf {
+  x = 1;
+  twin: Leaf | undefined = undefined;
+}
+class Branch extends Leaf {
+  label = "b";
+  describe(): string {
+    return `branch ${this.label}`;
+  }
+}
+class Plain {
+  y = 2;
+}
+
+const solo = new Leaf();
+const branch = new Branch();
+console.log(solo);
+console.log(branch, branch.describe());
+console.log([solo, branch], { solo });
+console.log(new Plain());
+
+const boxed: unknown[] = [solo, branch, new Plain(), 3];
+console.log(boxed.map((v) => (v instanceof Leaf ? "L" : String(v instanceof Plain))).join(","));
+console.log(boxed.map((v) => (v instanceof Branch ? "B" : "-")).join(","));
+
+solo.twin = branch;
+console.log(solo);
diff --git a/tests/harness/corpus-costs/6991-inspect-class-name-instanceof.ts.json b/tests/harness/corpus-costs/6991-inspect-class-name-instanceof.ts.json
new file mode 100644
index 000000000..b39c9d973
--- /dev/null
+++ b/tests/harness/corpus-costs/6991-inspect-class-name-instanceof.ts.json
@@ -0,0 +1 @@
+{ "plain": 4000, "san": 5400 }

From 9b165aa0449778fa57fa5715c04cb8e4ca026148 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 20:12:26 -0500
Subject: [PATCH 56/67] Lower a super() call that leads an if condition's comma
 chain

---
 .../src/frontend/lowering/lower-classes.ts    | 27 ++++++++++++
 .../src/frontend/lowering/lower-stmts.ts      | 29 +++++++------
 ...6944-js-super-call-in-if-condition.js.json |  6 +++
 .../6944-js-super-call-in-if-condition.js     | 41 +++++++++++++++++++
 ...6944-js-super-call-in-if-condition.js.json |  1 +
 5 files changed, 92 insertions(+), 12 deletions(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6944-js-super-call-in-if-condition.js.json
 create mode 100644 tests/corpus/6944-js-super-call-in-if-condition.js
 create mode 100644 tests/harness/corpus-costs/6944-js-super-call-in-if-condition.js.json

diff --git a/packages/compiler/src/frontend/lowering/lower-classes.ts b/packages/compiler/src/frontend/lowering/lower-classes.ts
index 17b22f0d4..790efe988 100644
--- a/packages/compiler/src/frontend/lowering/lower-classes.ts
+++ b/packages/compiler/src/frontend/lowering/lower-classes.ts
@@ -8538,6 +8538,10 @@ function superCallInStatementPosition(call: ts.CallExpression): boolean {
   for (;;) {
     const parent = node.parent;
     if (ts.isExpressionStatement(parent)) return true;
+    if (ts.isIfStatement(parent)) {
+      const lead = superConditionLead(parent.expression);
+      return lead !== null && call.pos >= lead.left.pos && call.end <= lead.left.end;
+    }
     const comma =
       ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.CommaToken;
     if (!comma && !ts.isParenthesizedExpression(parent)) return false;
@@ -8545,6 +8549,29 @@ function superCallInStatementPosition(call: ts.CallExpression): boolean {
   }
 }
 
+/** The comma chain of an `if` condition whose leading operands hold a
+ * super() call (`if (super(), r === 0) throw ...`, as minifiers join a
+ * super statement with the next test), or null. The if statement runs the
+ * chain's left operand as a statement first and tests its right operand,
+ * which is what the comma evaluates. */
+export function superConditionLead(cond: ts.Expression): ts.BinaryExpression | null {
+  let expr = cond;
+  while (ts.isParenthesizedExpression(expr)) expr = expr.expression;
+  if (!ts.isBinaryExpression(expr) || expr.operatorToken.kind !== ts.SyntaxKind.CommaToken)
+    return null;
+  const holdsSuperCall = (operand: ts.Expression): boolean => {
+    let e = operand;
+    while (ts.isParenthesizedExpression(e)) e = e.expression;
+    if (ts.isCallExpression(e)) return e.expression.kind === ts.SyntaxKind.SuperKeyword;
+    return (
+      ts.isBinaryExpression(e) &&
+      e.operatorToken.kind === ts.SyntaxKind.CommaToken &&
+      (holdsSuperCall(e.left) || holdsSuperCall(e.right))
+    );
+  };
+  return holdsSuperCall(expr.left) ? expr : null;
+}
+
 /** Super statements initialize the base and then the derived fields on
  * whichever control-flow path executes. Repeated calls are explicitly
  * refused until native layouts can allocate a second receiver. */
diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.ts b/packages/compiler/src/frontend/lowering/lower-stmts.ts
index 78f2f4189..e3480cf9c 100644
--- a/packages/compiler/src/frontend/lowering/lower-stmts.ts
+++ b/packages/compiler/src/frontend/lowering/lower-stmts.ts
@@ -159,7 +159,7 @@ import { classStaticDataFor } from "./class-static-data.js";
 import { objectFactorySignature } from "./object-factory-new.js";
 import { isClassCallback, lowerClassCallbackAssign } from "./class-callbacks.js";
 import { classForInHasKey, classPropertiesHelper } from "./class-dynamic-dispatch.js";
-import { genericIfaceBindingKeepsClass } from "./lower-classes.js";
+import { genericIfaceBindingKeepsClass, superConditionLead } from "./lower-classes.js";
 import { lowerStreamUnderscoreAssign, streamClassAliasDecl } from "./lower-stream.js";
 import { staticAssertInstanceDecl } from "./assert-instances.js";
 import {
@@ -1537,43 +1537,48 @@ export function lowerStmt(lowerer: Lowerer, stmt: ts.Statement): IrStmt | IrStmt
     return lowerer.lowerDefaultExport(stmt);
   }
   if (ts.isIfStatement(stmt)) {
-    const cond = lowerer.lowerCondition(stmt.expression);
+    // `if (super(), test)`: the super call runs as a statement, then the
+    // test decides.
+    const lead = superConditionLead(stmt.expression);
+    const leading = lead ? lowerer.lowerExprStatement(lead.left) : null;
+    const test = lead ? lead.right : stmt.expression;
+    const cond = lowerer.lowerCondition(test);
     // A global-detection condition (static-typeof.ts) folds; its untaken
     // arm is code Node never runs and does not lower, unless it declares a
     // hoisted binding.
-    const decided = staticCondition(lowerer, stmt.expression);
+    const decided = staticCondition(lowerer, test);
     if (decided !== null) {
       const taken = decided ? stmt.thenStatement : stmt.elseStatement;
       const untaken = decided ? stmt.elseStatement : stmt.thenStatement;
       if (untaken === undefined || !declaresHoistedBinding(untaken)) {
         const arm = taken === undefined ? [] : lowerer.lowerScopedBlock(taken);
-        return decided
+        const folded: IrStmt = decided
           ? { kind: "if", cond, then: arm, else_: null, loc: locOf(stmt) }
           : { kind: "if", cond, then: [], else_: arm, loc: locOf(stmt) };
+        return leading ? { kind: "block", body: [leading, folded], loc: locOf(stmt) } : folded;
       }
     }
     // Aliased-typeof narrows (ms's `var type = typeof val` guard): the
     // then-branch lowers under what a TRUE condition proves, the
     // else-branch under a FALSE one — the var/let alias narrowing the
     // checker only performs for consts (aliasTypeofNarrows).
-    const then = lowerer.narrowingAliases(aliasTypeofNarrows(lowerer, stmt.expression, true), () =>
-      withRuntimeOptionalNarrowed(lowerer, runtimeOptionalTrueIds(lowerer, stmt.expression), () =>
+    const then = lowerer.narrowingAliases(aliasTypeofNarrows(lowerer, test, true), () =>
+      withRuntimeOptionalNarrowed(lowerer, runtimeOptionalTrueIds(lowerer, test), () =>
         lowerer.lowerScopedBlock(stmt.thenStatement),
       ),
     );
     const else_ = stmt.elseStatement
-      ? lowerer.narrowingAliases(aliasTypeofNarrows(lowerer, stmt.expression, false), () =>
-          withRuntimeOptionalNarrowed(
-            lowerer,
-            runtimeOptionalGuardIds(lowerer, stmt.expression, false),
-            () => lowerer.lowerScopedBlock(stmt.elseStatement!),
+      ? lowerer.narrowingAliases(aliasTypeofNarrows(lowerer, test, false), () =>
+          withRuntimeOptionalNarrowed(lowerer, runtimeOptionalGuardIds(lowerer, test, false), () =>
+            lowerer.lowerScopedBlock(stmt.elseStatement!),
           ),
         )
       : null;
     for (const local of falsyExitRuntimeOptionalLocals(lowerer, stmt)) {
       lowerer.runtimeOptionalLocals.delete(lowerer.runtimeOptionalRootOf(local));
     }
-    return { kind: "if", cond, then, else_, loc: locOf(stmt) };
+    const lowered: IrStmt = { kind: "if", cond, then, else_, loc: locOf(stmt) };
+    return leading ? { kind: "block", body: [leading, lowered], loc: locOf(stmt) } : lowered;
   }
   if (ts.isWhileStatement(stmt)) {
     const labels = lowerer.takeLabels();
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6944-js-super-call-in-if-condition.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6944-js-super-call-in-if-condition.js.json
new file mode 100644
index 000000000..ba20299f2
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6944-js-super-call-in-if-condition.js.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6944-js-super-call-in-if-condition.js"
+ ],
+ "diags": []
+}
diff --git a/tests/corpus/6944-js-super-call-in-if-condition.js b/tests/corpus/6944-js-super-call-in-if-condition.js
new file mode 100644
index 000000000..8fdc8022b
--- /dev/null
+++ b/tests/corpus/6944-js-super-call-in-if-condition.js
@@ -0,0 +1,41 @@
+// A derived constructor whose super() call leads an if condition's comma
+// chain, as minifiers join `super(...); if (test) ...`: the base and the
+// derived fields initialize first, then the test decides.
+
+let count = 0;
+class Base {
+  constructor(name) {
+    this.name = name;
+    this.created = count++;
+  }
+}
+
+class Checked extends Base {
+  limit = 3;
+  constructor(name, size) {
+    if ((super(name), size > this.limit)) throw new RangeError(`${name}: ${size} > ${this.limit}`);
+    else this.size = size;
+  }
+}
+
+class Tagged extends Base {
+  constructor(name, tag) {
+    if ((super(name), (this.tag = tag), tag === undefined)) this.tag = "none";
+  }
+}
+
+class Plain extends Base {
+  constructor(name, flag) {
+    if ((super(name), flag)) this.flag = "set";
+    this.done = true;
+  }
+}
+
+const made = [new Checked("a", 2), new Tagged("b", "x"), new Tagged("c"), new Plain("d", 1)];
+for (const value of made) console.log(JSON.stringify(value));
+try {
+  new Checked("e", 9);
+} catch (error) {
+  console.log(error.name, error.message, count);
+}
+console.log(new Plain("f", 0).flag, count);
diff --git a/tests/harness/corpus-costs/6944-js-super-call-in-if-condition.js.json b/tests/harness/corpus-costs/6944-js-super-call-in-if-condition.js.json
new file mode 100644
index 000000000..5904670c9
--- /dev/null
+++ b/tests/harness/corpus-costs/6944-js-super-call-in-if-condition.js.json
@@ -0,0 +1 @@
+{ "plain": 1700, "san": 2600 }

From 6f0d047e8ea39b8cf9e89715917145e82ee90517 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 20:21:31 -0500
Subject: [PATCH 57/67] Pass a reassigned zlib callback result on to typed
 functions

On the error path, a callback's result reads from a checked-dynamic
slot. Passing it on into a Buffer parameter still handed over the
adapter's original value, so after `if (!out) out = Buffer.from(...)`
a typed callee received the absent Buffer instead of the fallback and
crashed. The forward now tests the slot: while it holds undefined the
callee gets the absent Buffer, and otherwise the Buffer the slot holds.
---
 .../src/frontend/lowering/lower-functions.ts  | 65 ++++++++++++-------
 .../corpus/6920-zlib-callback-error-result.ts | 13 +++-
 2 files changed, 51 insertions(+), 27 deletions(-)

diff --git a/packages/compiler/src/frontend/lowering/lower-functions.ts b/packages/compiler/src/frontend/lowering/lower-functions.ts
index 8f2c575a4..cd8dc31d1 100644
--- a/packages/compiler/src/frontend/lowering/lower-functions.ts
+++ b/packages/compiler/src/frontend/lowering/lower-functions.ts
@@ -751,31 +751,35 @@ function lowerUndefinedResultBody(
     lowerer.suppressStats = true;
     lowerer.errorPathCopies++;
     try {
-      // Passed on into a Buffer slot, the result stays what the adapter
-      // passed: the Buffer, or the absent Buffer, which a callee with this
-      // entry test reads as undefined. (The copy that serves both paths
-      // reaches this with a Buffer.)
-      const body = transformStmtList(withKnownError(knownError, lowerBody), {
-        expr: (e) =>
-          e.kind === "dynCheck" &&
-          e.value.kind === "varRef" &&
-          e.value.localId === slot.id &&
-          e.type.kind === "bytes" &&
-          e.type.elem === "u8"
-            ? {
-                kind: "ternary",
-                cond: absent(),
-                then: { kind: "libCall", fn: "bytes.absent", args: [], type: e.type, loc: e.loc },
-                else_: varRef(param.id, param.type, e.loc),
-                type: e.type,
-                loc: e.loc,
-              }
-            : e,
+      const lowered = withKnownError(knownError, lowerBody);
+      if (lowerer.diags.length > diags || !readsSlotDynamically(lowered, slot.id))
+        throw new PoisonError();
+      // Passed on into a Buffer slot, the result is the Buffer it holds
+      // (the adapter's, or one the body assigned), or, while it holds
+      // undefined, the absent Buffer, which a callee with this entry test
+      // reads as undefined.
+      const guarded = new Set<IrExpr>();
+      return transformStmtList(lowered, {
+        expr: (e) => {
+          if (!isBufferCheckOf(e, slot.id) || guarded.has(e)) return e;
+          guarded.add(e);
+          return {
+            kind: "ternary",
+            cond: {
+              kind: "dynTest",
+              test: "undefined",
+              value: varRef(slot.id, DYN, e.loc),
+              type: BOOL,
+              loc: e.loc,
+            },
+            then: { kind: "libCall", fn: "bytes.absent", args: [], type: e.type, loc: e.loc },
+            else_: e,
+            type: e.type,
+            loc: e.loc,
+          };
+        },
         stmt: (stmt) => stmt,
       });
-      if (lowerer.diags.length > diags || !readsSlotDynamically(body, slot.id))
-        throw new PoisonError();
-      return body;
     } catch (error) {
       if (error instanceof InternalCompilerError) throw error;
       lowerer.diags.length = diags;
@@ -831,15 +835,26 @@ function lowerUndefinedResultBody(
 
 /** Whether the error-path copy reads the checked-dynamic result slot only as
  * a checked-dynamic value, never converted into a static slot (where Node
- * would hold undefined). */
+ * would hold undefined) other than a Buffer one. */
 function readsSlotDynamically(body: IrStmt[], slotId: string): boolean {
   const isSlot = (e: IrExpr): boolean => e.kind === "varRef" && e.localId === slotId;
   return everyStmtList(body, {
     expr: (e) => {
       if (isSlot(e)) return e.type.kind === "dyn";
-      if (e.kind === "dynCheck" && isSlot(e.value)) return false;
+      if (e.kind === "dynCheck" && isSlot(e.value)) return isBufferCheckOf(e, slotId);
       return true;
     },
     stmt: () => true,
   });
 }
+
+/** Whether `e` converts the result slot into a Buffer slot. */
+function isBufferCheckOf(e: IrExpr, slotId: string): boolean {
+  return (
+    e.kind === "dynCheck" &&
+    e.value.kind === "varRef" &&
+    e.value.localId === slotId &&
+    e.type.kind === "bytes" &&
+    e.type.elem === "u8"
+  );
+}
diff --git a/tests/corpus/6920-zlib-callback-error-result.ts b/tests/corpus/6920-zlib-callback-error-result.ts
index 5016fa841..44803333b 100644
--- a/tests/corpus/6920-zlib-callback-error-result.ts
+++ b/tests/corpus/6920-zlib-callback-error-result.ts
@@ -176,15 +176,24 @@ function namedRetry(): void {
   });
 }
 
+function shown(label: string, out: Buffer): void {
+  console.log(label, typeof out, out.toString());
+}
 function fallbackResult(): void {
-  // The body assigns a fallback Buffer to its result.
+  // The body assigns a fallback Buffer to its result, then passes the
+  // result on to typed functions.
   zlib.inflate(bad, (err, out) => {
     if (!out) out = Buffer.from("fallback");
     console.log("fallback", err?.code, typeof out, out.toString());
+    shown("fallback passed", out);
     zlib.inflate(good, (err2, out2) => {
       if (err2) out2 = Buffer.alloc(0);
       console.log("fallback nested", err2, out2.length);
-      step();
+      shown("fallback nested passed", out2);
+      zlib.inflate(bad, (err3, out3) => {
+        if (err3) out3 = Buffer.from("inner fallback");
+        sink(null, out3);
+      });
     });
   });
 }

From 37cdd927557a56750581c74561bcc86f34aa55f9 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 20:23:53 -0500
Subject: [PATCH 58/67] Keep properties untyped code adds to typed object
 literals

---
 .../src/backend/llvm/expr-stream-bridges.ts   |  7 ++
 .../6990-record-writes-from-js/main.ts.json   |  7 ++
 packages/runtime/src/scr_dyn.h                |  5 ++
 packages/runtime/src/scr_json.c               | 77 ++++++++++++++++---
 .../6990-record-writes-from-js/helpers.js     | 13 ++++
 .../corpus/6990-record-writes-from-js/main.ts | 23 ++++++
 .../6990-record-writes-from-js/main.ts.json   |  1 +
 7 files changed, 123 insertions(+), 10 deletions(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6990-record-writes-from-js/main.ts.json
 create mode 100644 tests/corpus/6990-record-writes-from-js/helpers.js
 create mode 100644 tests/corpus/6990-record-writes-from-js/main.ts
 create mode 100644 tests/harness/corpus-costs/6990-record-writes-from-js/main.ts.json

diff --git a/packages/compiler/src/backend/llvm/expr-stream-bridges.ts b/packages/compiler/src/backend/llvm/expr-stream-bridges.ts
index b72875aaa..a4f2ed749 100644
--- a/packages/compiler/src/backend/llvm/expr-stream-bridges.ts
+++ b/packages/compiler/src/backend/llvm/expr-stream-bridges.ts
@@ -36,6 +36,7 @@ import type { LlvmEmitterContext, LlStreamTypedRefAdapter } from "./expr-context
 import type { NullableRefField } from "./nullable-fields.js";
 import { emitUnionPeek, emitUnionTag } from "./union-repr.js";
 import { inlineUnionCopyLines } from "./inline-unions.js";
+import { recordMayKeepSource } from "./record-sources.js";
 
 /** An owned (+1) union value for a nullable-pointer class field slot `p`
  * (the unit arm's immortal instance, or a fresh box around a retained
@@ -539,6 +540,12 @@ export function streamTypedRefCommitAdapter(
       `  store ${member.type} %old${index}, ptr %np${index}`,
     );
   });
+  // The conversion kept the view's undeclared properties for %next. Shapes
+  // with accessor slots keep their accessors in the view instead.
+  if (recordMayKeepSource(shape) && !shapeHasAccessorSlots(shape)) {
+    host.declare(`declare void @scr_record_source_move(ptr, ptr)`);
+    lines.push(`  call void @scr_record_source_move(ptr %next, ptr %target)`);
+  }
   lines.push(
     `  call void ${releaseSym(host.shapeHost, t)}(ptr %next)`,
     `  br label %done`,
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6990-record-writes-from-js/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6990-record-writes-from-js/main.ts.json
new file mode 100644
index 000000000..8eeecc9dd
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6990-record-writes-from-js/main.ts.json
@@ -0,0 +1,7 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6990-record-writes-from-js/helpers.js",
+  "<repo>/tests/corpus/6990-record-writes-from-js/main.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/runtime/src/scr_dyn.h b/packages/runtime/src/scr_dyn.h
index 37e9eacce..02c4d828f 100644
--- a/packages/runtime/src/scr_dyn.h
+++ b/packages/runtime/src/scr_dyn.h
@@ -892,6 +892,11 @@ void scr_dyn_typed_ref_bind_record(ScrDyn *d, const ScrDynTypedRecordOps *ops);
 void scr_record_source_note(void *rec, const ScrDyn *src, const char *const *names,
                             const size_t *lens, size_t count);
 bool scr_record_source_has(const void *rec);
+/* The commit of a live record view converts the view into a new record
+ * `from`, whose conversion keeps the view's undeclared properties, then
+ * moves its fields into `to`: this moves the kept properties to `to` too,
+ * replacing any `to` had. */
+void scr_record_source_move(void *from, void *to);
 ScrDyn *scr_record_source_view(const void *rec);
 ScrDyn *scr_record_source_apply(ScrDyn *snapshot, const void *rec);
 /* Attach the prototype member names of a class instance capsule
diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c
index 2787fe728..bd9bc2cc2 100644
--- a/packages/runtime/src/scr_json.c
+++ b/packages/runtime/src/scr_json.c
@@ -2724,20 +2724,24 @@ bool scr_record_source_has(const void *rec) {
   return scr_record_source_count && scr_record_source_find(rec) != NULL;
 }
 
-static void scr_record_source_disposed(void *rec) {
-  size_t bit = scr_record_source_filter_bit(rec);
-  if (!(scr_record_source_filter[bit >> 6] & (UINT64_C(1) << (bit & 63)))) return;
-  ScrRecordSource *found = scr_record_source_find(rec);
-  if (!found) return;
+/* Drops the entry at `found` from the table, releasing its view. The table
+ * no longer refers to the view first, so a nested disposal that re-enters
+ * the dispose hook sees a consistent table. */
+static void scr_record_source_drop(ScrRecordSource *found) {
   ScrDyn *view = found->view;
   *found = (ScrRecordSource){ .rec = SCR_RECORD_SOURCE_DELETED };
   scr_record_source_count--;
   scr_record_source_deleted++;
-  /* The table no longer refers to the view, so a nested disposal that
-   * re-enters this hook sees a consistent table. */
   scr_dyn_release(view);
 }
 
+static void scr_record_source_disposed(void *rec) {
+  size_t bit = scr_record_source_filter_bit(rec);
+  if (!(scr_record_source_filter[bit >> 6] & (UINT64_C(1) << (bit & 63)))) return;
+  ScrRecordSource *found = scr_record_source_find(rec);
+  if (found) scr_record_source_drop(found);
+}
+
 /* The single native dispose hook serves weak collections and the table
  * above; each observer runs only while it has entries to forget. */
 static void scr_dispose_observers(void *object) {
@@ -2878,6 +2882,20 @@ void scr_record_source_note(void *rec, const ScrDyn *src, const char *const *nam
   scr_record_source_put(&probe);
 }
 
+void scr_record_source_move(void *from, void *to) {
+  if (!scr_record_source_count) return;
+  ScrRecordSource *old = scr_record_source_find(to);
+  if (old) scr_record_source_drop(old);
+  ScrRecordSource *found = scr_record_source_find(from);
+  if (!found) return;
+  ScrRecordSource moved = *found;
+  *found = (ScrRecordSource){ .rec = SCR_RECORD_SOURCE_DELETED };
+  scr_record_source_count--;
+  scr_record_source_deleted++;
+  moved.rec = to;
+  scr_record_source_put(&moved);
+}
+
 /* Refreshes a retained record view: the view's own-key order, declared
  * values from the native snapshot (a declared key the record no longer has
  * drops), every other property as the view holds it, then declared fields
@@ -2961,6 +2979,34 @@ static bool scr_jb_put_source_field(ScrJsonBuf *b, void *rec, const ScrRecordSou
 
 /* The same in one lookup: writes the record and answers true when it kept
  * a source, otherwise writes nothing and answers false. */
+static bool scr_dyn_key_is_index(const char *key, size_t len, double *out);
+
+/* The entry indexes of `view` in JavaScript's own-key order: integer keys
+ * ascending, then the other keys in insertion order. `out` holds len. */
+static void scr_record_source_key_order(const ScrDyn *view, size_t *out) {
+  size_t integers = 0;
+  for (size_t i = 0; i < view->v.obj.len; i++) {
+    double index;
+    const ScrDynEntry *entry = &view->v.obj.entries[i];
+    if (!scr_dyn_key_is_index(entry->key, entry->key_len, &index)) continue;
+    size_t at = integers++;
+    for (; at > 0; at--) {
+      double before;
+      const ScrDynEntry *previous = &view->v.obj.entries[out[at - 1]];
+      scr_dyn_key_is_index(previous->key, previous->key_len, &before);
+      if (before < index) break;
+      out[at] = out[at - 1];
+    }
+    out[at] = i;
+  }
+  size_t next = integers;
+  for (size_t i = 0; i < view->v.obj.len; i++) {
+    double index;
+    const ScrDynEntry *entry = &view->v.obj.entries[i];
+    if (!scr_dyn_key_is_index(entry->key, entry->key_len, &index)) out[next++] = i;
+  }
+}
+
 bool scr_jb_try_record_source(ScrJsonBuf *b, void *rec,
                               bool (*field)(ScrJsonBuf *, void *, size_t, bool)) {
   ScrRecordSource *found = scr_record_source_find(rec);
@@ -2981,13 +3027,24 @@ bool scr_jb_try_record_source(ScrJsonBuf *b, void *rec,
   bool small[64] = { false };
   bool *seen = count <= 64 ? small : calloc(count, sizeof *seen);
   if (!seen) scr_json_oom();
+  /* Integer keys come first in JavaScript's own-key order; a view without
+   * any walks in insertion order. */
+  size_t order_small[64];
+  size_t *order = NULL;
+  for (size_t k = 0; k < view->v.obj.len && !order; k++) {
+    double index;
+    if (!scr_dyn_key_is_index(view->v.obj.entries[k].key, view->v.obj.entries[k].key_len, &index)) continue;
+    order = view->v.obj.len <= 64 ? order_small : malloc(view->v.obj.len * sizeof *order);
+    if (!order) scr_json_oom();
+    scr_record_source_key_order(view, order);
+  }
   /* Members whose writing cannot run program code are written in place.
    * The first member that can (an accessor, a toJSON method, a getter below
    * it) ends that loop: the remaining keys are taken first, as
    * SerializeJSONObject takes them before reading any value. */
   size_t i = 0;
   for (; i < view->v.obj.len && !scr_exc_pending(); i++) {
-    const ScrDynEntry *entry = &view->v.obj.entries[i];
+    const ScrDynEntry *entry = &view->v.obj.entries[order ? order[i] : i];
     size_t index = scr_record_source_index(&source, entry->key, entry->key_len);
     if (index < count) {
       if (!seen[index] && scr_jb_put_source_field(b, rec, &source, index, first, on_stack, field))
@@ -3007,7 +3064,7 @@ bool scr_jb_try_record_source(ScrJsonBuf *b, void *rec,
   if (i < view->v.obj.len && !scr_exc_pending()) {
     ScrDyn *rest = scr_dyn_new_arr();
     for (size_t j = i; j < view->v.obj.len; j++) {
-      const ScrDynEntry *entry = &view->v.obj.entries[j];
+      const ScrDynEntry *entry = &view->v.obj.entries[order ? order[j] : j];
       if (!entry->enumerable && !scr_record_source_declared(&source, entry->key, entry->key_len)) continue;
       ScrStr *name = scr_str_new(entry->key, entry->key_len);
       scr_dyn_arr_push(rest, scr_dyn_new_str(name));
@@ -3032,6 +3089,7 @@ bool scr_jb_try_record_source(ScrJsonBuf *b, void *rec,
       first = false;
   }
   if (seen != small) free(seen);
+  if (order && order != order_small) free(order);
   scr_dyn_release(view);
   scr_jb_putc(b, '}');
   if (entered) scr_jb_leave(b);
@@ -4552,7 +4610,6 @@ bool scr_dyn_same_value(const ScrDyn *left, const ScrDyn *right) {
 static void scr_dyn_descriptor_fields_drop(ScrDyn **fields) {
   for (size_t i = 0; i < 6; i++) scr_dyn_release(fields[i]);
 }
-static bool scr_dyn_key_is_index(const char *key, size_t len, double *out);
 static void scr_error_sync_cause(ScrDyn *view, const ScrStr *key);
 static void scr_error_sync_slots(const ScrDyn *view, ScrDyn *obj, const ScrStr *key);
 
diff --git a/tests/corpus/6990-record-writes-from-js/helpers.js b/tests/corpus/6990-record-writes-from-js/helpers.js
new file mode 100644
index 000000000..6f43a90ce
--- /dev/null
+++ b/tests/corpus/6990-record-writes-from-js/helpers.js
@@ -0,0 +1,13 @@
+// Untyped helpers that add, replace and remove properties of the objects
+// they receive.
+export function write(target, key, value) {
+  target[key] = value;
+}
+
+export function remove(target, key) {
+  delete target[key];
+}
+
+export function keysOf(target) {
+  return Object.keys(target).join(",");
+}
diff --git a/tests/corpus/6990-record-writes-from-js/main.ts b/tests/corpus/6990-record-writes-from-js/main.ts
new file mode 100644
index 000000000..2b343efc5
--- /dev/null
+++ b/tests/corpus/6990-record-writes-from-js/main.ts
@@ -0,0 +1,23 @@
+// A typed object literal passed to untyped JavaScript keeps the properties
+// that code adds: JSON.stringify, Object.keys, later untyped reads and
+// console.log see them, in JavaScript's own-key order (integer keys first).
+import { keysOf, remove, write } from "./helpers.js";
+
+const numbered = { 0: "zero", 1.5: "x" };
+write(numbered, 2, "two");
+console.log(JSON.stringify(numbered), keysOf(numbered), Object.keys(numbered));
+
+const point = { x: 1, y: 2 };
+write(point, "label", "origin");
+write(point, "x", 10);
+console.log(JSON.stringify(point), point.x, keysOf(point));
+write(point, "label", "moved");
+console.log(JSON.stringify(point));
+remove(point, "label");
+console.log(JSON.stringify(point), keysOf(point));
+
+const config = { name: "app", retries: 3 };
+write(config, "debug", true);
+write(config, "tags", ["a", "b"]);
+console.log(JSON.stringify(config), keysOf(config));
+console.log(config);
diff --git a/tests/harness/corpus-costs/6990-record-writes-from-js/main.ts.json b/tests/harness/corpus-costs/6990-record-writes-from-js/main.ts.json
new file mode 100644
index 000000000..b8b8cc39d
--- /dev/null
+++ b/tests/harness/corpus-costs/6990-record-writes-from-js/main.ts.json
@@ -0,0 +1 @@
+{ "plain": 4300, "san": 3700 }

From 3b5e23361805adb155264c016f091b9799d3dd72 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 20:28:16 -0500
Subject: [PATCH 59/67] Lower to the same IR whatever order reachable bodies
 lower in

---
 package.json                                  |   1 +
 .../lowering/caught-value-dispatch.ts         |  47 +-
 .../lowering/class-dynamic-dispatch.test.ts   |   1 +
 .../lowering/class-dynamic-dispatch.ts        |  19 +
 .../src/frontend/lowering/class-prototypes.ts |   1 +
 .../src/frontend/lowering/error-methods.ts    |   4 +
 .../lowering/generator-dynamic-dispatch.ts    |   3 +
 .../frontend/lowering/lower-event-emitter.ts  |   8 +-
 .../src/frontend/lowering/lower-modules.ts    |   3 +-
 .../compiler/src/frontend/lowering/lowerer.ts | 166 +++++-
 .../test/format-float-arguments.test.ts       |   5 +-
 scripts/lowering-order.mjs                    | 564 ++++++++++++++++++
 12 files changed, 792 insertions(+), 30 deletions(-)
 create mode 100644 scripts/lowering-order.mjs

diff --git a/package.json b/package.json
index ff4c84dc2..5cc30d9f8 100644
--- a/package.json
+++ b/package.json
@@ -20,6 +20,7 @@
     "test:test262": "tsx tests/test262/run.ts",
     "test:test262:fetch": "node tests/test262/fetch.mjs",
     "test:cache-identity": "node tests/harness/cache-identity.mjs",
+    "test:lowering-order": "node scripts/lowering-order.mjs --fail-on content",
     "test:sandbox": "node scripts/sandbox-test.mjs",
     "test:sandbox:image": "node scripts/sandbox-image.mjs",
     "test:watch": "vitest",
diff --git a/packages/compiler/src/frontend/lowering/caught-value-dispatch.ts b/packages/compiler/src/frontend/lowering/caught-value-dispatch.ts
index 645ff8d2c..606d10d56 100644
--- a/packages/compiler/src/frontend/lowering/caught-value-dispatch.ts
+++ b/packages/compiler/src/frontend/lowering/caught-value-dispatch.ts
@@ -5,6 +5,7 @@ import {
   DYN,
   type IrExpr,
   type IrFunction,
+  type IrStmt,
   type IrType,
   type SrcLoc,
 } from "../../ir/ir.js";
@@ -59,28 +60,48 @@ export class CaughtValueDispatch {
         loc,
       };
       lowerer.liftedFns.push(this.helper);
+      lowerer.shareHelper(this.helper);
       changed = true;
     }
     const helper = this.helper;
+    let added = false;
     for (const className of this.thrownClasses) {
       if (this.convertedClasses.has(className)) continue;
       this.convertedClasses.add(className);
+      added = true;
+    }
+    if (added) {
+      // A subclass is tested before its ancestors, and classes of one depth
+      // by name, so the tests do not depend on the order the census met them.
+      const depth = (className: string): number => {
+        let count = 0;
+        for (let info = lowerer.classes.get(className)?.base; info; info = info.base) count++;
+        return count;
+      };
+      const ordered = [...this.convertedClasses].sort(
+        (left, right) => depth(right) - depth(left) || (left < right ? -1 : left > right ? 1 : 0),
+      );
       const loc = helper.loc;
       const value = varRef("caught", CAUGHT, loc);
-      const type: IrType = { kind: "object", className };
-      helper.body.unshift({
-        kind: "if",
-        cond: { kind: "caughtTest", value, test: "instanceof", className, type: BOOL, loc },
-        then: [
-          {
-            kind: "return",
-            value: lowerer.coerceToExpected({ kind: "caughtNarrow", value, type, loc }, DYN),
+      helper.body = [
+        ...ordered.map((className): IrStmt => {
+          const type: IrType = { kind: "object", className };
+          return {
+            kind: "if",
+            cond: { kind: "caughtTest", value, test: "instanceof", className, type: BOOL, loc },
+            then: [
+              {
+                kind: "return",
+                value: lowerer.coerceToExpected({ kind: "caughtNarrow", value, type, loc }, DYN),
+                loc,
+              },
+            ],
+            else_: null,
             loc,
-          },
-        ],
-        else_: null,
-        loc,
-      });
+          };
+        }),
+        helper.body[helper.body.length - 1]!,
+      ];
       changed = true;
     }
     for (const fn of consumers) {
diff --git a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.test.ts b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.test.ts
index 6923841bd..b717452c2 100644
--- a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.test.ts
+++ b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.test.ts
@@ -33,6 +33,7 @@ function context() {
     classes: new Map(),
     liftedFns,
     liftedFnNamed: (name: string | undefined) => liftedFns.find((fn) => fn.name === name),
+    shareHelper: () => {},
     subclassLinks: 0,
     constructedClassCount: () => -1,
     diags: [],
diff --git a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts
index 9dd7681a6..a41751f01 100644
--- a/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts
+++ b/packages/compiler/src/frontend/lowering/class-dynamic-dispatch.ts
@@ -281,6 +281,7 @@ export function classInstanceOf(
   classValue?: IrExpr,
 ): IrExpr {
   const name = `%dyn.class.${classValue ? "valueInstanceof" : "instanceof"}:${info.def.name}`;
+  lowerer.shareHelper(name);
   const params = [
     { localId: "value", name: "value", type: DYN },
     ...(classValue ? [{ localId: "class", name: "class", type: classValue.type }] : []),
@@ -406,8 +407,16 @@ function withTypedReceiver(value: IrExpr, receiver: IrExpr): IrExpr {
   });
 }
 
+/** Re-adds the entries of `set` after the first `from` sorted. */
+function sortAdded(set: Set<string>, from: number): void {
+  const added = [...set].slice(from).sort();
+  for (const name of added) set.delete(name);
+  for (const name of added) set.add(name);
+}
+
 export function classPropertiesHelper(lowerer: Lowerer, loc: SrcLoc, readOnly = false): IrFunction {
   const name = readOnly ? READ_PROPERTIES : "%dyn.class.properties";
+  lowerer.shareHelper(name);
   const existing = lowerer.liftedFnNamed(name);
   if (existing) return existing;
   const helper: IrFunction = {
@@ -447,6 +456,8 @@ export function classForInHasKey(
   loc: SrcLoc,
 ): IrExpr {
   const name = "%dyn.class.forInHasKey";
+  lowerer.shareHelper(name);
+  lowerer.shareHelper("%dyn.class.forInBagHas");
   if (!lowerer.liftedFns.some((fn) => fn.name === name)) {
     // The read-only table: a recheck never creates an instance's table, which
     // is undefined while the instance has no own dynamic properties.
@@ -825,6 +836,8 @@ export class ClassDynamicDispatch {
       else if (type.kind === "func") discover(type.ret);
       else if (type.kind === "promise") discover(type.inner);
     };
+    const boxedBefore = this.boxed.size;
+    const boxedConstructorsBefore = this.boxedConstructors.size;
     for (const fn of functions)
       everyStmtList(fn.body, {
         stmt: (statement) => {
@@ -919,6 +932,10 @@ export class ClassDynamicDispatch {
           return true;
         },
       });
+    // The classes this pass found join the tables by name, not in the order
+    // the scan met them.
+    sortAdded(this.boxed, boxedBefore);
+    sortAdded(this.boxedConstructors, boxedConstructorsBefore);
     changed = this.caughtDispatch.dynamicPayloads(lowerer, caughtSites, this.boxed) || changed;
     if (this.boxed.size === 0 && rewrite.size === 0) return changed;
     const converting = this.convertingHints(lowerer);
@@ -4264,6 +4281,8 @@ export class ClassDynamicDispatch {
    * prototype-backed bag is produced for this read only. A published object
    * cannot take the store, and Node's reads never write. */
   finalize(lowerer?: Lowerer): void {
+    // Each table serves every site that reaches it.
+    if (lowerer) for (const fn of this.generated) lowerer.shareHelper(fn);
     for (const { helper, initialize, orEmpty } of this.readPropertyBags) {
       const absent = helper.body[0];
       if (isEmptyBag(initialize.value) && !orEmpty) helper.body.shift();
diff --git a/packages/compiler/src/frontend/lowering/class-prototypes.ts b/packages/compiler/src/frontend/lowering/class-prototypes.ts
index e65c679c6..4cbd8e5cf 100644
--- a/packages/compiler/src/frontend/lowering/class-prototypes.ts
+++ b/packages/compiler/src/frontend/lowering/class-prototypes.ts
@@ -122,6 +122,7 @@ export function classPrototypeData(
     const globalId = `%g.${name}`;
     const readyId = `${globalId}.ready`;
     info.def.prototypeDataHelper = name;
+    lowerer.shareHelper(name);
     const className = info.def.jsName ?? info.def.name;
     lowerer.globalsList.push({
       id: globalId,
diff --git a/packages/compiler/src/frontend/lowering/error-methods.ts b/packages/compiler/src/frontend/lowering/error-methods.ts
index 979cf4814..b545f4147 100644
--- a/packages/compiler/src/frontend/lowering/error-methods.ts
+++ b/packages/compiler/src/frontend/lowering/error-methods.ts
@@ -24,6 +24,7 @@ export function errorPropertyRead(
 ): IrExpr {
   const name = `%error.${property}.read`,
     loc = receiver.loc;
+  lowerer.shareHelper(name);
   if (!lowerer.liftedFns.some((fn) => fn.name === name))
     lowerer.liftedFns.push({
       name,
@@ -50,6 +51,7 @@ export function errorPropertyWrite(
 ): IrStmt {
   const name = `%error.${property}.write`,
     loc = receiver.loc;
+  lowerer.shareHelper(name);
   if (!lowerer.liftedFns.some((fn) => fn.name === name))
     lowerer.liftedFns.push({
       name,
@@ -392,6 +394,7 @@ export function errorToStringMethod(
   receiver: IrExpr,
 ): Extract<IrExpr, { kind: "call" }> {
   const loc = receiver.loc;
+  lowerer.shareHelper(helperName);
   if (!lowerer.liftedFns.some((fn) => fn.name === helperName)) {
     lowerer.liftedFns.push({
       name: helperName,
@@ -415,6 +418,7 @@ export function errorToStringCall(lowerer: Lowerer, receiver: IrExpr): IrExpr {
   const loc = receiver.loc;
   const method = errorToStringMethod(lowerer, receiver);
   const name = "%error.toString.virtual";
+  lowerer.shareHelper(name);
   if (!lowerer.liftedFns.some((fn) => fn.name === name)) {
     const value = varRef("error.0", errorType, loc);
     lowerer.liftedFns.push({
diff --git a/packages/compiler/src/frontend/lowering/generator-dynamic-dispatch.ts b/packages/compiler/src/frontend/lowering/generator-dynamic-dispatch.ts
index ca6a5ecdc..3f43e5e05 100644
--- a/packages/compiler/src/frontend/lowering/generator-dynamic-dispatch.ts
+++ b/packages/compiler/src/frontend/lowering/generator-dynamic-dispatch.ts
@@ -68,8 +68,10 @@ export class GeneratorDynamicDispatch {
     this.properties.set(method, { fn, types: new Set() });
     this.generated.add(fn);
     lowerer.liftedFns.push(fn);
+    lowerer.shareHelper(fn);
     // The runtime's own helper functions answer the helper methods.
     if (HELPER_METHODS.has(method)) return fn;
+    lowerer.shareHelper(`%dyn.generator.method.${method}`);
     lowerer.liftedFns.push({
       name: `%dyn.generator.method.${method}`,
       params: [{ localId: "arg", name: "arg", type: DYN }],
@@ -209,6 +211,7 @@ export class GeneratorDynamicDispatch {
             this.dispatches.set(key, dispatch);
             this.generated.add(helper);
             lowerer.liftedFns.push(helper);
+            lowerer.shareHelper(helper);
             changed = true;
           }
           return {
diff --git a/packages/compiler/src/frontend/lowering/lower-event-emitter.ts b/packages/compiler/src/frontend/lowering/lower-event-emitter.ts
index d84f84f4e..f472672b2 100644
--- a/packages/compiler/src/frontend/lowering/lower-event-emitter.ts
+++ b/packages/compiler/src/frontend/lowering/lower-event-emitter.ts
@@ -2128,8 +2128,12 @@ function ensureEmitSpec(lowerer: Lowerer, info: ClassInfo, event: string, tuple:
       params: tuple.map((t) => ({ type: t, mode: "required" as const })),
       ret: BOOL,
     });
-    if (info.def.methods) info.def.methods.push(mName);
-    else info.def.methods = [mName];
+    // Specializations sit in the method list sorted by event name, so the
+    // class table does not depend on which body asked for one first.
+    const methods = (info.def.methods ??= []);
+    const after = methods.findIndex((m) => m.startsWith("emit:") && m > mName);
+    if (after < 0) methods.push(mName);
+    else methods.splice(after, 0, mName);
   }
   const ordinal = lowerer.emitSpecQueue.filter((q) => q.info === info).length;
   lowerer.emitSpecQueue.push({ info, event, tuple, ordinal });
diff --git a/packages/compiler/src/frontend/lowering/lower-modules.ts b/packages/compiler/src/frontend/lowering/lower-modules.ts
index 6ca21ddaa..d1f276d44 100644
--- a/packages/compiler/src/frontend/lowering/lower-modules.ts
+++ b/packages/compiler/src/frontend/lowering/lower-modules.ts
@@ -1048,7 +1048,8 @@ export function moduleArtifacts(
   }
   const reachable = lowerer.reachableForArtifacts ?? lowerer.reachable;
   return {
-    classes: [...lowerer.classes.values()]
+    classes: lowerer
+      .classesInTableOrder()
       .map((c) => c.def)
       .filter((def) => classNames.has(def.name))
       .map((def): IrClassDef => {
diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts
index 383143c97..29f807336 100644
--- a/packages/compiler/src/frontend/lowering/lowerer.ts
+++ b/packages/compiler/src/frontend/lowering/lowerer.ts
@@ -959,6 +959,33 @@ function directExternalTypeSpecifiersByFile(
   return out;
 }
 
+/** Debugging aid: SCRIPTC_LOWER_SHUFFLE_SEED=<n> lowers each wave of
+ * reachable bodies in an order drawn from that seed instead of discovery
+ * order. Output assembly is ordered independently of it, so any IR
+ * difference between seeds is state one body's lowering leaves for another
+ * (scripts/lowering-order.mjs). */
+function lowerShuffle(): ((wave: string[]) => void) | null {
+  const raw = process.env["SCRIPTC_LOWER_SHUFFLE_SEED"];
+  if (raw === undefined || raw === "") return null;
+  // mulberry32
+  let state = Number.parseInt(raw, 10) >>> 0;
+  const next = (): number => {
+    state = (state + 0x6d2b79f5) >>> 0;
+    let t = state;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+  return (wave) => {
+    for (let index = wave.length - 1; index > 0; index--) {
+      const other = Math.floor(next() * (index + 1));
+      const swap = wave[index]!;
+      wave[index] = wave[other]!;
+      wave[other] = swap;
+    }
+  };
+}
+
 /** Build lowering runs as a reachability worklist over the ts.Program:
  *
  * 1. REACHABLE EMIT — a worklist computes the set of reachable bodies.
@@ -1841,6 +1868,13 @@ function monomorphizedImplicit(
   return true;
 }
 
+/** `fns` sorted by name; functions of one name keep their order. */
+function byName(fns: readonly IrFunction[]): IrFunction[] {
+  return [...fns].sort((left, right) =>
+    left.name < right.name ? -1 : left.name > right.name ? 1 : 0,
+  );
+}
+
 export class Lowerer {
   readonly frontendServices: FrontendServices | undefined;
   readonly checker: ts.TypeChecker;
@@ -2027,6 +2061,40 @@ export class Lowerer {
     this.genericClassInstances.splice(from, tail.length, ...tail);
   }
 
+  /** The classes in table order. Generic instances are added as bodies
+   * demand them, so they keep the slots they hold and fill them in the
+   * order of their settled demand ranks. */
+  classesInTableOrder(): ClassInfo[] {
+    const all = [...this.classes.values()];
+    const slots = all.flatMap((info, index) =>
+      this.genericClassDemandPriority.has(info) ? [index] : [],
+    );
+    const ranked = slots
+      .map((index) => all[index]!)
+      .sort((left, right) => {
+        const a = this.genericClassDemandPriority.get(left)!.rank;
+        const b = this.genericClassDemandPriority.get(right)!.rank;
+        return a[0]! - b[0]! || a[1]! - b[1]!;
+      });
+    slots.forEach((slot, index) => (all[slot] = ranked[index]!));
+    return all;
+  }
+
+  /** The globals in table order. A class's prototype data globals are
+   * added when a body first reads that prototype, so they keep the slots
+   * they hold and fill them in id order. */
+  private globalsInTableOrder(): IrGlobal[] {
+    const all = [...this.globalsList];
+    const prototypeData = (global: IrGlobal): boolean =>
+      global.id.startsWith("%g.%prototype.data.");
+    const slots = all.flatMap((global, index) => (prototypeData(global) ? [index] : []));
+    const sorted = slots
+      .map((index) => all[index]!)
+      .sort((left, right) => (left.id < right.id ? -1 : left.id > right.id ? 1 : 0));
+    slots.forEach((slot, index) => (all[slot] = sorted[index]!));
+    return all;
+  }
+
   private settleGenericDemandPriorities(): void {
     const functionQueue: GenericInstance[] = [];
     const classQueue: ClassInfo[] = [];
@@ -3187,6 +3255,60 @@ export class Lowerer {
   constructedClassCount(): number {
     return this.constructedClasses?.size ?? -1;
   }
+  /** Helpers that every site asking for them shares (shareHelper). */
+  private readonly sharedHelpers = new Set<IrFunction>();
+  private readonly sharedHelperNames = new Set<string>();
+  /** Marks a helper, or the lifted helpers of a name, as shared by every
+   * site that asks for it. A shared helper is built for whichever site asks
+   * first, so once lowering finishes its locations are replaced by one that
+   * names no site. */
+  shareHelper(helper: IrFunction | string): void {
+    if (typeof helper === "string") this.sharedHelperNames.add(helper);
+    else this.sharedHelpers.add(helper);
+  }
+  /** Gives each shared helper the location of the entry file's start: the
+   * helpers marked by shareHelper, and those interned by key in the helper
+   * tables. */
+  private settleSharedHelperLocations(): void {
+    const loc: SrcLoc = { file: this.entry.fileName, start: 0, end: 0 };
+    const interned = new Set<string>([...this.sharedHelperNames, ...this.classMethodValueHelpers]);
+    for (const table of [
+      this.equalityHelpers,
+      this.arrHofHelpers,
+      this.unionCallHelpers,
+      this.valueHelpers,
+      this.assertHelpers,
+      this.inspectHelpers,
+      this.iterDrainHelpers,
+      this.mapHofHelpers,
+      this.setHofHelpers,
+      this.spHofHelpers,
+      this.primitiveCtorFns,
+      this.builtinCallableValueFns,
+      this.regionRunHelpers,
+      this.internTableHelpers,
+      this.coercions.retags,
+      this.coercions.narrows,
+    ])
+      for (const name of table.values()) interned.add(name);
+    for (const fn of [...this.liftedFns, ...this.implicitFns])
+      if (interned.has(fn.name)) this.sharedHelpers.add(fn);
+    const seen = new Set<object>();
+    const visit = (node: unknown): void => {
+      if (typeof node !== "object" || node === null || seen.has(node)) return;
+      seen.add(node);
+      if (Array.isArray(node)) {
+        for (const item of node) visit(item);
+        return;
+      }
+      const record = node as Record<string, unknown>;
+      for (const key of Object.keys(record)) {
+        if (key === "loc") record[key] = loc;
+        else if (key !== "type") visit(record[key]);
+      }
+    };
+    for (const fn of this.sharedHelpers) visit(fn);
+  }
   /** The first lifted function named `name`, the one
    * `liftedFns.find((fn) => fn.name === name)` returns. */
   liftedFnNamed(name: string | undefined): IrFunction | undefined {
@@ -7279,6 +7401,7 @@ export class Lowerer {
     // Lambdas lifted while lowering any of the above (plus synthetic
     // array-HOF loop functions, which ride the same list), and the
     // implicit-any instances lowered eagerly at their first call sites.
+    this.settleSharedHelperLocations();
     functions.push(...this.liftedFns);
     functions.push(...this.implicitFns);
     functions.push(...runtimeClassConstructs(this, functions));
@@ -7412,7 +7535,7 @@ export class Lowerer {
             classes: artifacts.classes,
             records: artifacts.records,
             unions: artifacts.unions,
-            globals: this.globalsList,
+            globals: this.globalsInTableOrder(),
             entry: ENTRY_NAME,
             ...(this.usesWorkers ? { workers: true } : {}),
             ...(this.usesLifetimeRegions ? { lifetimeRegions: true as const } : {}),
@@ -7859,6 +7982,15 @@ export class Lowerer {
         // exactly like generic instances.
         while (specLowered < this.emitSpecQueue.length) {
           const waveEnd = this.emitSpecQueue.length;
+          // A wave's specializations lower by class and event, not in the
+          // order bodies asked for them.
+          const wave = this.emitSpecQueue.slice(specLowered, waveEnd);
+          const specKey = ({ info, event }: EmitSpecRequest): string =>
+            `${info.def.name}\0${event}`;
+          wave.sort((left, right) =>
+            specKey(left) < specKey(right) ? -1 : specKey(left) > specKey(right) ? 1 : 0,
+          );
+          this.emitSpecQueue.splice(specLowered, wave.length, ...wave);
           this.checker.prefetchRoots(
             this.emitSpecQueue
               .slice(specLowered, waveEnd)
@@ -7908,9 +8040,11 @@ export class Lowerer {
     // seed the worklist beside the init bodies. Unknown names are inert
     // (the export-map resolution reports them as SC4002 later).
     for (const root of extraRoots ?? []) this.onEdge?.(root);
+    const shuffle = lowerShuffle();
     const drainUnits = (): void => {
       while (queue.length > 0) {
         const wave = queue.splice(0);
+        shuffle?.(wave);
         this.checker.prefetchRoots(wave.flatMap((name) => units.get(name)!.roots));
         for (const name of wave) {
           // A body-level poison outside the per-statement catches (a fenced
@@ -7940,21 +8074,28 @@ export class Lowerer {
     // queue above is the only portion whose discovery order differed from
     // historical emit order.
     const classDispatch = new ClassDynamicDispatch(extraRoots !== undefined);
+    // Units in declaration order, so the passes below meet functions, and the
+    // classes they collect, in an order that does not depend on lowering order.
+    const unitsInOrder = (): IrFunction[] =>
+      [...loweredUnits]
+        .sort(([left], [right]) => units.get(left)!.order - units.get(right)!.order)
+        .map(([, fn]) => fn);
     for (;;) {
       drainInstances();
+      const declared = unitsInOrder();
       const initializerChanged = this.deferredModuleInitializers.process(this, [
-        ...loweredUnits.values(),
+        ...declared,
         ...initFunctions,
         ...instanceFunctions,
-        ...this.liftedFns,
-        ...this.implicitFns,
+        ...byName(this.liftedFns),
+        ...byName(this.implicitFns),
       ]);
       const dispatchChanged = classDispatch.process(this, [
-        ...loweredUnits.values(),
+        ...declared,
         ...initFunctions,
         ...instanceFunctions,
-        ...this.liftedFns,
-        ...this.implicitFns,
+        ...byName(this.liftedFns),
+        ...byName(this.implicitFns),
       ]);
       if (queue.length === 0 && !dispatchChanged && !initializerChanged) break;
       drainUnits();
@@ -7962,9 +8103,7 @@ export class Lowerer {
       this.restoreGenericClassInstanceOrder(clsInstLowered);
     }
     classDispatch.finalize(this);
-    const orderedUnits = [...loweredUnits]
-      .sort(([left], [right]) => units.get(left)!.order - units.get(right)!.order)
-      .map(([, fn]) => fn);
+    const orderedUnits = unitsInOrder();
     this.settleGenericDemandPriorities();
     this.shapes.settleDeclaredOrderPriorities();
     for (const finalize of this.shapeOrderMetadataFinalizers) finalize();
@@ -7977,13 +8116,16 @@ export class Lowerer {
     ]);
     observeRecordLiteralRebuilds(null);
     for (const finalize of this.shapeOrderHelperFinalizers) finalize();
+    this.settleSharedHelperLocations();
+    // Lifted and implicit functions are created in lowering order; they
+    // are assembled by name.
     const functions = [
       ...orderedUnits,
       ...initFunctions,
       this.buildMain(),
       ...instanceFunctions,
-      ...this.liftedFns,
-      ...this.implicitFns,
+      ...byName(this.liftedFns),
+      ...byName(this.implicitFns),
     ];
     functions.push(...runtimeClassConstructs(this, functions));
     if (this.regexGroupResults) for (const fn of functions) foldRegexSpanReads(this, fn);
diff --git a/packages/compiler/test/format-float-arguments.test.ts b/packages/compiler/test/format-float-arguments.test.ts
index 8aa08469d..e59e023ca 100644
--- a/packages/compiler/test/format-float-arguments.test.ts
+++ b/packages/compiler/test/format-float-arguments.test.ts
@@ -27,8 +27,9 @@ test("util.format %f lowers a boolean argument once", async () => {
     const helpers = mod.functions
       .map((f) => f.name)
       .filter((name) => name.startsWith("%arr."))
-      .map((name) => name.replace(/\.\d+$/, ""));
-    expect(helpers).toEqual(["%arr.some", "%arr.every"]);
+      .map((name) => name.replace(/\.\d+$/, ""))
+      .sort();
+    expect(helpers).toEqual(["%arr.every", "%arr.some"]);
   } finally {
     await rm(dir, { recursive: true, force: true });
   }
diff --git a/scripts/lowering-order.mjs b/scripts/lowering-order.mjs
new file mode 100644
index 000000000..ecfc20955
--- /dev/null
+++ b/scripts/lowering-order.mjs
@@ -0,0 +1,564 @@
+#!/usr/bin/env node
+/* Finds lowering state whose result depends on the order reachable bodies
+ * lower in.
+ *
+ * Each program is lowered to IR in discovery order and with every seed of
+ * SCRIPTC_LOWER_SHUFFLE_SEED (lowerer.ts), and the IR is compared function
+ * by function. Output assembly does not depend on the order, so every
+ * difference is state one body's lowering leaves for another. The
+ * discovery-order run also audits the lowerer's Map and Set fields: a key
+ * that two bodies touch, at least one of them writing it, makes the field
+ * order-sensitive for both bodies. A function whose IR differs between
+ * orders is attributed to the order-sensitive fields of the body that
+ * produced it.
+ *
+ *   node scripts/lowering-order.mjs [--stride 7] [--offset 0] [--limit N]
+ *     [--seeds 1,2,3] [--jobs 8] [--entry <file.ts>]... [--out <dir>]
+ *     [--fail-on names|content]
+ *
+ * Needs a built compiler (pnpm build). Writes <out>/results.json and prints
+ * a ranking of fields by the programs whose IR they change. With --fail-on,
+ * it exits with status 1 when some program's IR differs between orders:
+ * in any way (names), or beyond names and ids (content). */
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { cpus, tmpdir } from "node:os";
+import { basename, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { parseArgs } from "node:util";
+
+const root = fileURLToPath(new URL("..", import.meta.url));
+const dist = join(root, "packages/compiler/dist");
+
+if (process.argv[2] === "--child") {
+  const [, , , entry, irPath, seed, auditPath, snapshotPath] = process.argv;
+  if (seed !== "-") process.env["SCRIPTC_LOWER_SHUFFLE_SEED"] = seed;
+  const module = (path) => import(pathToFileURL(join(dist, path)).href);
+  const audit =
+    auditPath === "-"
+      ? null
+      : installAudit(
+          await module("frontend/lowering/lowerer.js"),
+          await module("frontend/lowering/class-dynamic-dispatch.js"),
+          await module("frontend/lowering/deferred-module-initializers.js"),
+        );
+  const snapshots = installSnapshot(await module("frontend/lowering/lowerer.js"));
+  const { compile } = await import(pathToFileURL(join(dist, "index.js")).href);
+  const outDir = join(tmpdir(), `scriptc-lowering-order-${process.pid}`);
+  const result = await compile(entry, {
+    outDir,
+    outPath: irPath,
+    backend: "llvm",
+    outputKind: "ir",
+  });
+  if (audit !== null) writeFileSync(auditPath, JSON.stringify(audit.report()));
+  writeFileSync(snapshotPath, JSON.stringify(snapshots.at(-1) ?? {}));
+  process.exit(result.ok ? 0 : 3);
+}
+
+/** Records the contents of the lowerer's Map and Set fields once reachable
+ * emit finishes, under keys that do not depend on the process: syntax
+ * nodes by file and span, symbols by name and declaration, IR values by id
+ * or name. Values are digested to a bounded depth. */
+function installSnapshot({ Lowerer }) {
+  const snapshots = [];
+  const nodeKey = (node) => {
+    try {
+      return `node:${node.getSourceFile().fileName}:${node.kind}:${node.pos}:${node.end}`;
+    } catch {
+      return `node:?:${node.kind}:${node.pos}:${node.end}`;
+    }
+  };
+  const isNode = (value) =>
+    typeof value.kind === "number" &&
+    typeof value.pos === "number" &&
+    typeof value.end === "number" &&
+    typeof value.getSourceFile === "function";
+  const isSymbol = (value) =>
+    typeof value.escapedName === "string" && Array.isArray(value.declarationHandles);
+  const symbolKey = (symbol) => {
+    let declaration = "";
+    try {
+      const first = symbol.declarations[0];
+      if (first !== undefined) declaration = nodeKey(first);
+    } catch {}
+    return `symbol:${symbol.escapedName}:${declaration}`;
+  };
+  const key = (value) => {
+    if (value === null || (typeof value !== "object" && typeof value !== "function"))
+      return `${typeof value}:${String(value)}`;
+    if (isNode(value)) return nodeKey(value);
+    if (isSymbol(value)) return symbolKey(value);
+    for (const field of ["name", "id", "localId"])
+      if (typeof value[field] === "string" || typeof value[field] === "number")
+        return `${value.constructor?.name}:${field}:${value[field]}`;
+    if (value.def && typeof value.def.name === "string")
+      return `${value.constructor?.name}:def:${value.def.name}`;
+    return null;
+  };
+  const digest = (value, depth) => {
+    if (value === null || value === undefined || typeof value !== "object")
+      return typeof value === "function" ? "fn" : (JSON.stringify(value) ?? "undefined");
+    const stable = key(value);
+    if (depth === 0) return stable ?? `<${value.constructor?.name}>`;
+    if (isNode(value) || isSymbol(value)) return stable;
+    if (Array.isArray(value)) return `[${value.map((item) => digest(item, depth - 1)).join(",")}]`;
+    if (value instanceof Map)
+      return `Map{${[...value]
+        .map(([k, v]) => `${key(k) ?? "?"}=>${digest(v, depth - 1)}`)
+        .sort()
+        .join(",")}}`;
+    if (value instanceof Set)
+      return `Set{${[...value]
+        .map((item) => key(item) ?? digest(item, depth - 1))
+        .sort()
+        .join(",")}}`;
+    const fields = Object.keys(value).sort();
+    return `${value.constructor?.name ?? "Object"}{${fields.map((field) => `${field}:${digest(value[field], depth - 1)}`).join(",")}}`;
+  };
+  const emitReachable = Lowerer.prototype.emitReachable;
+  Lowerer.prototype.emitReachable = function (...args) {
+    const result = emitReachable.apply(this, args);
+    const snapshot = {};
+    for (const [field, value] of Object.entries(this)) {
+      if (!(value instanceof Map) && !(value instanceof Set)) continue;
+      const entries = {};
+      const unkeyed = [];
+      for (const item of value instanceof Map ? value : [...value].map((v) => [v, true])) {
+        const [k, v] = item;
+        const stable = key(k);
+        const text = digest(v, 3);
+        if (stable === null) unkeyed.push(text);
+        else entries[stable] = text;
+      }
+      snapshot[field] = { entries, unkeyed: unkeyed.sort() };
+    }
+    snapshots.push(snapshot);
+    return result;
+  };
+  return snapshots;
+}
+
+/** Wraps the lowering methods that produce bodies and the lowerer's Map and
+ * Set fields; records which bodies touch which keys. */
+function installAudit({ Lowerer }, { ClassDynamicDispatch }, { DeferredModuleInitializers }) {
+  const proto = Lowerer.prototype;
+  const tokens = [];
+  const stack = [];
+  const fields = new Map();
+  const objectIds = new Map();
+  const keyId = (key) => {
+    if (key === null || (typeof key !== "object" && typeof key !== "function"))
+      return `${typeof key}:${String(key)}`;
+    let id = objectIds.get(key);
+    if (id === undefined) objectIds.set(key, (id = objectIds.size));
+    return `object:${id}`;
+  };
+  const current = () => (stack.length === 0 ? null : stack[stack.length - 1]);
+  const touch = (field, key, write) => {
+    const token = current();
+    if (token === null) return;
+    let keys = fields.get(field);
+    if (keys === undefined) fields.set(field, (keys = new Map()));
+    const id = key === ITERATE ? "*" : keyId(key);
+    let entry = keys.get(id);
+    if (entry === undefined) keys.set(id, (entry = { readers: new Set(), writers: new Set() }));
+    (write ? entry.writers : entry.readers).add(token.id);
+  };
+  const ITERATE = Symbol("iterate");
+  const instrument = (field, value) => {
+    const read = (key) => touch(field, key, false);
+    const write = (key) => {
+      touch(field, key, true);
+      // A write changes what every iteration of the field observes.
+      touch(field, ITERATE, true);
+    };
+    const iterate = () => touch(field, ITERATE, false);
+    const base = value instanceof Map ? Map.prototype : Set.prototype;
+    for (const name of ["get", "has"]) {
+      if (!(name in base)) continue;
+      const original = base[name];
+      value[name] = function (key) {
+        read(key);
+        return original.call(this, key);
+      };
+    }
+    for (const name of ["set", "add", "delete"]) {
+      if (!(name in base)) continue;
+      const original = base[name];
+      value[name] = function (key, ...rest) {
+        write(key);
+        return original.call(this, key, ...rest);
+      };
+    }
+    for (const name of ["forEach", "keys", "values", "entries", Symbol.iterator]) {
+      const original = base[name];
+      value[name] = function (...args) {
+        iterate();
+        return original.apply(this, args);
+      };
+    }
+    const size = Object.getOwnPropertyDescriptor(base, "size").get;
+    Object.defineProperty(value, "size", {
+      get() {
+        iterate();
+        return size.call(this);
+      },
+    });
+  };
+  const emitReachable = proto.emitReachable;
+  proto.emitReachable = function (...args) {
+    for (const [field, value] of Object.entries(this))
+      if (value instanceof Map || value instanceof Set) instrument(field, value);
+    return emitReachable.apply(this, args);
+  };
+  const produced = (result, into) => {
+    if (result === null || result === undefined) return;
+    if (Array.isArray(result)) for (const fn of result) produced(fn, into);
+    else if (typeof result === "object" && typeof result.name === "string") into.add(result.name);
+  };
+  // Passes over the lowered bodies after the worklist: the functions they
+  // create belong to the pass.
+  const passes = new Map();
+  const wrapPass = (owner, label, method) => {
+    const original = owner.prototype[method];
+    owner.prototype[method] = function (lowerer, ...rest) {
+      const implicit = lowerer.implicitFns?.length ?? 0;
+      const lifted = lowerer.liftedFns?.length ?? 0;
+      try {
+        return original.call(this, lowerer, ...rest);
+      } finally {
+        let names = passes.get(label);
+        if (names === undefined) passes.set(label, (names = new Set()));
+        for (const fn of (lowerer.implicitFns ?? []).slice(implicit)) names.add(fn.name);
+        for (const fn of (lowerer.liftedFns ?? []).slice(lifted)) names.add(fn.name);
+      }
+    };
+  };
+  wrapPass(ClassDynamicDispatch, "ClassDynamicDispatch.process", "process");
+  wrapPass(ClassDynamicDispatch, "ClassDynamicDispatch.finalize", "finalize");
+  wrapPass(DeferredModuleInitializers, "DeferredModuleInitializers.process", "process");
+  for (const name of [
+    "lowerFunction",
+    "lowerClassCtor",
+    "lowerClassMethodMember",
+    "lowerClassMembers",
+    "lowerFileInit",
+    "lowerGenericInstance",
+    "throwingSetterFn",
+  ]) {
+    const original = proto[name];
+    if (typeof original !== "function") continue;
+    proto[name] = function (...args) {
+      const token = { id: tokens.length, names: new Set() };
+      tokens.push(token);
+      const implicit = this.implicitFns?.length ?? 0;
+      const lifted = this.liftedFns?.length ?? 0;
+      stack.push(token);
+      try {
+        const result = original.apply(this, args);
+        produced(result, token.names);
+        return result;
+      } finally {
+        stack.pop();
+        for (const fn of (this.implicitFns ?? []).slice(implicit)) token.names.add(fn.name);
+        for (const fn of (this.liftedFns ?? []).slice(lifted)) token.names.add(fn.name);
+      }
+    };
+  }
+  return {
+    report() {
+      const out = {};
+      for (const [field, keys] of fields) {
+        const involved = new Set();
+        let sensitive = 0;
+        for (const { readers, writers } of keys.values()) {
+          const all = new Set([...readers, ...writers]);
+          if (writers.size === 0 || all.size < 2) continue;
+          sensitive++;
+          for (const id of all) for (const fn of tokens[id].names) involved.add(fn);
+        }
+        if (sensitive > 0) out[field] = { sensitiveKeys: sensitive, functions: [...involved] };
+      }
+      for (const [label, names] of passes)
+        if (names.size > 0) out[`pass ${label}`] = { sensitiveKeys: 0, functions: [...names] };
+      return out;
+    },
+  };
+}
+
+const { values } = parseArgs({
+  options: {
+    stride: { type: "string", default: "7" },
+    offset: { type: "string", default: "0" },
+    limit: { type: "string", default: "100000" },
+    seeds: { type: "string", default: "1,2,3" },
+    jobs: { type: "string", default: String(Math.max(1, Math.floor(cpus().length / 2))) },
+    entry: { type: "string", multiple: true, default: [] },
+    out: { type: "string", default: join(tmpdir(), "scriptc-lowering-order") },
+    "no-audit": { type: "boolean", default: false },
+    "fail-on": { type: "string" },
+  },
+});
+if (values["fail-on"] !== undefined && !["names", "content"].includes(values["fail-on"]))
+  throw new Error(`--fail-on takes names or content, not ${values["fail-on"]}`);
+const out = resolve(values.out);
+mkdirSync(out, { recursive: true });
+const seeds = values.seeds.split(",").filter(Boolean);
+const corpus = join(root, "tests/corpus");
+const programs = [
+  ...readdirSync(corpus)
+    .filter((name) => /^\d+-.*\.ts$/.test(name))
+    .filter((name) => Number.parseInt(name, 10) % Number(values.stride) === Number(values.offset))
+    .sort((a, b) => Number.parseInt(a, 10) - Number.parseInt(b, 10))
+    .slice(0, Number(values.limit))
+    .map((name) => join(corpus, name)),
+  ...values.entry.map((entry) => resolve(entry)),
+];
+
+const child = (entry, irPath, seed, auditPath, snapshotPath) =>
+  new Promise((done) => {
+    const proc = spawn(
+      process.execPath,
+      [
+        "--max-old-space-size=8192",
+        fileURLToPath(import.meta.url),
+        "--child",
+        entry,
+        irPath,
+        seed,
+        auditPath,
+        snapshotPath,
+      ],
+      { stdio: ["ignore", "ignore", "pipe"], env: { ...process.env, SCRIPTC_NO_CACHE: "1" } },
+    );
+    let stderr = "";
+    proc.stderr.on("data", (chunk) => (stderr += chunk));
+    proc.on("close", (code) => done({ ok: code === 0, stderr: stderr.slice(-2000) }));
+  });
+
+const loadIr = (path) => JSON.parse(readFileSync(path, "utf8"));
+const firstDiff = (x, y, path = "") => {
+  if (JSON.stringify(x) === JSON.stringify(y)) return null;
+  if (typeof x !== "object" || typeof y !== "object" || x === null || y === null) return path;
+  for (const key of new Set([...Object.keys(x), ...Object.keys(y)])) {
+    const found = firstDiff(x[key], y[key], `${path}/${key}`);
+    if (found !== null) return found;
+  }
+  return path;
+};
+const differingFunctions = (a, b) => {
+  const left = new Map(a.functions.map((fn) => [fn.name, fn]));
+  const right = new Map(b.functions.map((fn) => [fn.name, fn]));
+  const names = new Set();
+  const paths = {};
+  for (const [name, fn] of left) {
+    const other = right.get(name);
+    if (other === undefined) names.add(name);
+    else if (JSON.stringify(other) !== JSON.stringify(fn)) {
+      names.add(name);
+      paths[name] = firstDiff(fn, other).replace(/\/\d+/g, "/#");
+    }
+  }
+  for (const name of right.keys()) if (!left.has(name)) names.add(name);
+  const topLevel = [];
+  for (const key of new Set([...Object.keys(a), ...Object.keys(b)]))
+    if (key !== "functions" && JSON.stringify(a[key]) !== JSON.stringify(b[key]))
+      topLevel.push(key);
+  if (a.functions.map((fn) => fn.name).join("\n") !== b.functions.map((fn) => fn.name).join("\n"))
+    topLevel.push("function order");
+  return { functions: [...names], topLevel, paths };
+};
+
+/** The module with every numbered function, record and union renamed by a
+ * hash of its own definition (digits stripped), other numbered strings by
+ * first use within their function or table entry, source locations
+ * dropped, and tables sorted. Orders whose canonical modules match differ
+ * only in names and ids numbered in creation order. */
+const canonicalModule = (mod) => {
+  const strip = (v) => JSON.stringify(v).replace(/\d+/g, "#");
+  const hash = (text) => createHash("sha256").update(text).digest("hex").slice(0, 12);
+  const m = JSON.parse(
+    JSON.stringify(mod, (k, v) => (k === "loc" || k === "source" ? undefined : v)),
+  );
+  const rename = new Map();
+  for (const fn of m.functions ?? []) {
+    if (!/\d/.test(fn.name)) continue;
+    const { name, ...rest } = fn;
+    rename.set(name, `${name.replace(/\d+/g, "#")}~${hash(strip(rest))}`);
+  }
+  for (const key of ["records", "unions"])
+    for (const item of m[key] ?? []) {
+      const { id, ...rest } = item;
+      if (typeof id === "string" && /\d/.test(id))
+        rename.set(id, `${id.replace(/\d+/g, "#")}~${hash(strip(rest))}`);
+    }
+  const walk = (v, scope) => {
+    if (typeof v === "string") {
+      const renamed = rename.get(v);
+      if (renamed !== undefined) return renamed;
+      if (!/\d/.test(v)) return v;
+      let id = scope.get(v);
+      if (id === undefined) scope.set(v, (id = scope.size));
+      return `${v.replace(/\d+/g, "#")}@${id}`;
+    }
+    if (Array.isArray(v)) return v.map((x) => walk(x, scope));
+    if (v && typeof v === "object")
+      return Object.fromEntries(Object.keys(v).map((k) => [k, walk(v[k], scope)]));
+    return v;
+  };
+  const out = {};
+  for (const key of Object.keys(m))
+    out[key] = Array.isArray(m[key])
+      ? m[key].map((item) => JSON.stringify(walk(item, new Map()))).sort()
+      : JSON.stringify(walk(m[key], new Map()));
+  return out;
+};
+/** Canonical entries present in one order only, by table. */
+const contentDifferences = (a, b) => {
+  const found = {};
+  for (const key of new Set([...Object.keys(a), ...Object.keys(b)])) {
+    if (JSON.stringify(a[key]) === JSON.stringify(b[key])) continue;
+    if (!Array.isArray(a[key]) || !Array.isArray(b[key])) {
+      found[key] = ["(differs)"];
+      continue;
+    }
+    const other = new Set(b[key]);
+    found[key] = a[key]
+      .filter((item) => !other.has(item))
+      .map((item) => JSON.parse(item).name ?? JSON.parse(item).id ?? "?");
+  }
+  return found;
+};
+
+/** Fields whose contents after reachable emit differ between two orders. */
+const differingState = (a, b) => {
+  const fields = [];
+  for (const field of new Set([...Object.keys(a), ...Object.keys(b)])) {
+    const x = a[field] ?? { entries: {}, unkeyed: [] };
+    const y = b[field] ?? { entries: {}, unkeyed: [] };
+    const keys = new Set([...Object.keys(x.entries), ...Object.keys(y.entries)]);
+    let differs = [...keys].some((k) => x.entries[k] !== y.entries[k]);
+    if (!differs) differs = JSON.stringify(x.unkeyed) !== JSON.stringify(y.unkeyed);
+    if (differs) fields.push(field);
+  }
+  return fields;
+};
+
+const results = [];
+let next = 0;
+await Promise.all(
+  Array.from({ length: Number(values.jobs) }, async () => {
+    while (next < programs.length) {
+      const entry = programs[next++];
+      const name = basename(entry).replace(/\.ts$/, "");
+      const dir = join(out, name);
+      mkdirSync(dir, { recursive: true });
+      const audit = values["no-audit"] ? "-" : join(dir, "audit.json");
+      const base = await child(
+        entry,
+        join(dir, "base.ir.json"),
+        "-",
+        audit,
+        join(dir, "base.state.json"),
+      );
+      if (!base.ok) {
+        results.push({ program: name, status: "does not compile" });
+        continue;
+      }
+      const diffs = {};
+      const stateDiffs = {};
+      let baseCanonical = null;
+      for (const seed of seeds) {
+        const run = await child(
+          entry,
+          join(dir, `seed${seed}.ir.json`),
+          seed,
+          "-",
+          join(dir, `seed${seed}.state.json`),
+        );
+        if (!run.ok) {
+          diffs[seed] = { failed: run.stderr };
+          continue;
+        }
+        const diff = differingFunctions(
+          loadIr(join(dir, "base.ir.json")),
+          loadIr(join(dir, `seed${seed}.ir.json`)),
+        );
+        const state = differingState(
+          loadIr(join(dir, "base.state.json")),
+          loadIr(join(dir, `seed${seed}.state.json`)),
+        );
+        if (state.length > 0) stateDiffs[seed] = state;
+        if (diff.functions.length > 0 || diff.topLevel.length > 0) {
+          baseCanonical ??= canonicalModule(loadIr(join(dir, "base.ir.json")));
+          diff.content = contentDifferences(
+            baseCanonical,
+            canonicalModule(loadIr(join(dir, `seed${seed}.ir.json`))),
+          );
+          diffs[seed] = diff;
+        }
+      }
+      const auditReport = audit === "-" ? {} : JSON.parse(readFileSync(audit, "utf8"));
+      const changed = new Set(Object.values(diffs).flatMap((diff) => diff.functions ?? []));
+      const attribution = {};
+      for (const fn of changed) {
+        const fields = Object.entries(auditReport)
+          .filter(([, entry]) => entry.functions.includes(fn))
+          .map(([field]) => field);
+        attribution[fn] = fields;
+      }
+      results.push({
+        program: name,
+        status:
+          Object.keys(diffs).length === 0
+            ? "order-independent"
+            : Object.values(diffs).some((diff) => Object.keys(diff.content ?? {}).length > 0)
+              ? "order-dependent content"
+              : "order-dependent names",
+        diffs,
+        attribution,
+        sensitiveFields: Object.keys(auditReport),
+        stateFields: [...new Set(Object.values(stateDiffs).flat())],
+      });
+      process.stderr.write(
+        `${results.length}/${programs.length} ${name}: ${results.at(-1).status}\n`,
+      );
+    }
+  }),
+);
+writeFileSync(join(out, "results.json"), JSON.stringify(results, null, 2));
+
+const dependent = results.filter((r) => r.status.startsWith("order-dependent"));
+const content = results.filter((r) => r.status === "order-dependent content");
+const byField = new Map();
+let unattributed = 0;
+for (const r of dependent) {
+  const fields = new Set(Object.values(r.attribution).flat());
+  if (fields.size === 0) unattributed++;
+  for (const field of fields) byField.set(field, (byField.get(field) ?? 0) + 1);
+}
+console.log(
+  `programs ${results.length}: ${dependent.length} order-dependent (${content.length} beyond names and ids), ${results.filter((r) => r.status === "does not compile").length} do not compile`,
+);
+for (const r of content)
+  console.log(
+    `  ${r.program}: ${Object.values(r.diffs)
+      .flatMap((diff) =>
+        Object.entries(diff.content ?? {}).map(
+          ([table, items]) => `${table}: ${items.slice(0, 4).join(", ")}`,
+        ),
+      )
+      .slice(0, 3)
+      .join("; ")}`,
+  );
+for (const [field, count] of [...byField].sort((a, b) => b[1] - a[1]))
+  console.log(`${String(count).padStart(5)}  ${field}`);
+console.log(`${String(unattributed).padStart(5)}  (no audited field)`);
+const failing =
+  values["fail-on"] === "names" ? dependent : values["fail-on"] === "content" ? content : [];
+if (failing.length > 0) {
+  console.log(`${failing.length} programs lower to different IR in another order`);
+  process.exitCode = 1;
+}

From 3b7f33c22393afe56700a48feebc4a091a975840 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 20:35:09 -0500
Subject: [PATCH 60/67] Leave SC6101 out of the native compiler's self-builds

The compiler's own source has 24 likely-hot functions that use untyped
values, so its self-builds now print SC6101. The native bootstrap
contracts compare stderr exactly; the rebuilds of the compiler entry pass
--no-dynamic-tier-warning, which changes no IR or LLVM output.
---
 .../self-hosting-native-driver.test.ts        | 31 +++++++++++++++++--
 1 file changed, 28 insertions(+), 3 deletions(-)

diff --git a/tests/harness/self-hosting-native-driver.test.ts b/tests/harness/self-hosting-native-driver.test.ts
index 722c3fede..1cc920bd2 100644
--- a/tests/harness/self-hosting-native-driver.test.ts
+++ b/tests/harness/self-hosting-native-driver.test.ts
@@ -185,6 +185,10 @@ test(
         return result.stdout;
       };
       const entry = join(root, "packages/compiler/src/native/cli.ts");
+      // The compiler's own source has untyped functions that SC6101 reports
+      // (diagnostics/dynamic-tier.ts). The contracts compare stderr exactly,
+      // so its self-builds leave that performance note out.
+      const quiet = "--no-dynamic-tier-warning";
       const ffi = join(directory, ".scriptc/distribution-seed/compiler.ffi.json");
       const rebuilt = executable("scriptc-rebuilt");
       const checkProgram = async (compiler: string, source: string, extra: string[] = []) => {
@@ -541,7 +545,18 @@ test(
         const self = await bootstrapStep("production CLI rebuilds itself", () =>
           invoke(
             seed,
-            ["build", entry, "-o", rebuilt, "--strip", "--keep-llvm", "--emit-ir", "--ffi", ffi],
+            [
+              "build",
+              entry,
+              "-o",
+              rebuilt,
+              "--strip",
+              "--keep-llvm",
+              "--emit-ir",
+              "--ffi",
+              ffi,
+              quiet,
+            ],
             "scriptc: warning: --emit-ir is deprecated; use --emit=ir for IR as the primary output\n",
           ),
         );
@@ -554,7 +569,16 @@ test(
           const seedLlvm = join(directory, "cli.ll");
           const rebuiltLlvm = join(directory, "rebuilt.ll");
           await bootstrapStep("rebuilt compiler emits itself", () =>
-            invoke(rebuilt, ["build", entry, "--emit=llvm", "-o", rebuiltLlvm, "--ffi", ffi]),
+            invoke(rebuilt, [
+              "build",
+              entry,
+              "--emit=llvm",
+              "-o",
+              rebuiltLlvm,
+              "--ffi",
+              ffi,
+              quiet,
+            ]),
           );
           // Executable output adds a runtime ABI check; textual LLVM emission
           // omits it. Compare all other output without changing either mode.
@@ -585,7 +609,7 @@ test(
       const rebuildFrontend = async () => {
         const lowered = join(directory, "cli.ir.json");
         const output = await bootstrapStep("sanitized native frontend lowers the compiler", () =>
-          invoke(seed, ["build", entry, "--emit=ir", "-o", lowered, "--ffi", ffi]),
+          invoke(seed, ["build", entry, "--emit=ir", "-o", lowered, "--ffi", ffi, quiet]),
         );
         expect(output.trim()).toBe(lowered);
         await compareArtifacts({ ir: true, llvm: false });
@@ -605,6 +629,7 @@ test(
               ffi,
               "--sanitize",
               "--optimization=dev",
+              quiet,
             ],
             "",
             { SCRIPTC_BOOTSTRAP_IR_INPUT: seedIr },

From 388523cee4936f1c1c1243d87c5174ccd14dce43 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 21:09:39 -0500
Subject: [PATCH 61/67] Address review feedback on the lowering-order check

---
 scripts/lowering-order.mjs | 83 +++++++++++++++++++++++++++-----------
 1 file changed, 60 insertions(+), 23 deletions(-)

diff --git a/scripts/lowering-order.mjs b/scripts/lowering-order.mjs
index ecfc20955..81611e6a4 100644
--- a/scripts/lowering-order.mjs
+++ b/scripts/lowering-order.mjs
@@ -371,17 +371,55 @@ const differingFunctions = (a, b) => {
   return { functions: [...names], topLevel, paths };
 };
 
+/** Keys whose strings name functions, locals, globals, shapes, unions,
+ * classes and labels. Lowering numbers these in creation order; every other
+ * string (literal values, field names, library functions) is compared as
+ * is. A `name` names a function, record or union when it is one of the
+ * module's numbered definitions or starts with `%`. */
+const ID_KEYS = new Set([
+  "base",
+  "callee",
+  "captures",
+  "catchLocalId",
+  "className",
+  "fnName",
+  "fromId",
+  "globalId",
+  "id",
+  "int32Locals",
+  "int32Params",
+  "label",
+  "labels",
+  "localId",
+  "retag",
+  "shapeId",
+  "targets",
+  "unionId",
+]);
+
 /** The module with every numbered function, record and union renamed by a
- * hash of its own definition (digits stripped), other numbered strings by
- * first use within their function or table entry, source locations
- * dropped, and tables sorted. Orders whose canonical modules match differ
- * only in names and ids numbered in creation order. */
+ * hash of its own definition (ids with their digits stripped), other
+ * numbered ids by first use within their function or table entry, source
+ * locations dropped, and tables sorted. Orders whose canonical modules
+ * match differ only in names and ids numbered in creation order. */
 const canonicalModule = (mod) => {
-  const strip = (v) => JSON.stringify(v).replace(/\d+/g, "#");
   const hash = (text) => createHash("sha256").update(text).digest("hex").slice(0, 12);
-  const m = JSON.parse(
-    JSON.stringify(mod, (k, v) => (k === "loc" || k === "source" ? undefined : v)),
-  );
+  const m = JSON.parse(JSON.stringify(mod, (k, v) => (k === "loc" ? undefined : v)));
+  const definitions = new Set([
+    ...(m.functions ?? []).map((fn) => fn.name),
+    ...["records", "unions"].flatMap((key) => (m[key] ?? []).map((item) => item.id)),
+  ]);
+  const isId = (key, value) =>
+    ID_KEYS.has(key) || (key === "name" && (definitions.has(value) || value.startsWith("%")));
+  /** `v` with the strings under id keys passed through `id`. */
+  const mapIds = (v, id, key) => {
+    if (typeof v === "string") return isId(key, v) ? id(v) : v;
+    if (Array.isArray(v)) return v.map((x) => mapIds(x, id, key));
+    if (v && typeof v === "object")
+      return Object.fromEntries(Object.keys(v).map((k) => [k, mapIds(v[k], id, k)]));
+    return v;
+  };
+  const strip = (v) => JSON.stringify(mapIds(v, (id) => id.replace(/\d+/g, "#")));
   const rename = new Map();
   for (const fn of m.functions ?? []) {
     if (!/\d/.test(fn.name)) continue;
@@ -394,25 +432,22 @@ const canonicalModule = (mod) => {
       if (typeof id === "string" && /\d/.test(id))
         rename.set(id, `${id.replace(/\d+/g, "#")}~${hash(strip(rest))}`);
     }
-  const walk = (v, scope) => {
-    if (typeof v === "string") {
-      const renamed = rename.get(v);
+  const canonical = (item) => {
+    const scope = new Map();
+    return mapIds(item, (value) => {
+      const renamed = rename.get(value);
       if (renamed !== undefined) return renamed;
-      if (!/\d/.test(v)) return v;
-      let id = scope.get(v);
-      if (id === undefined) scope.set(v, (id = scope.size));
-      return `${v.replace(/\d+/g, "#")}@${id}`;
-    }
-    if (Array.isArray(v)) return v.map((x) => walk(x, scope));
-    if (v && typeof v === "object")
-      return Object.fromEntries(Object.keys(v).map((k) => [k, walk(v[k], scope)]));
-    return v;
+      if (!/\d/.test(value)) return value;
+      let id = scope.get(value);
+      if (id === undefined) scope.set(value, (id = scope.size));
+      return `${value.replace(/\d+/g, "#")}@${id}`;
+    });
   };
   const out = {};
   for (const key of Object.keys(m))
     out[key] = Array.isArray(m[key])
-      ? m[key].map((item) => JSON.stringify(walk(item, new Map()))).sort()
-      : JSON.stringify(walk(m[key], new Map()));
+      ? m[key].map((item) => JSON.stringify(canonical(item))).sort()
+      : JSON.stringify(canonical(m[key]));
   return out;
 };
 /** Canonical entries present in one order only, by table. */
@@ -479,7 +514,9 @@ await Promise.all(
           join(dir, `seed${seed}.state.json`),
         );
         if (!run.ok) {
-          diffs[seed] = { failed: run.stderr };
+          // A program that lowers in discovery order but not in this one
+          // differs in content.
+          diffs[seed] = { failed: run.stderr, content: { lowering: ["fails in this order"] } };
           continue;
         }
         const diff = differingFunctions(

From 4a5ddadd3dd1418da78047d42cbca38df2eb4e9a Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 21:28:27 -0500
Subject: [PATCH 62/67] Memoize an empty literal's type separately as a union
 arm

The type mapper maps the type inferred from an empty object literal to the
empty record as an arm of an unreduced union and to a checked-dynamic
value elsewhere, but both answers shared one memo entry. Once the type had
been mapped on its own, a union such as `typeof empty | DataView` reused
the dynamic answer for its arm and refused (SC2009). The memo key now
includes whether the mapping is for such an arm.
---
 packages/compiler/src/frontend/type-mapper.ts | 5 ++++-
 tests/corpus/6909-empty-object-type-values.ts | 8 ++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/packages/compiler/src/frontend/type-mapper.ts b/packages/compiler/src/frontend/type-mapper.ts
index 6305a6b63..c171c5c4b 100644
--- a/packages/compiler/src/frontend/type-mapper.ts
+++ b/packages/compiler/src/frontend/type-mapper.ts
@@ -1655,7 +1655,10 @@ export function mapType(type: ts.Type, ctx: TypeMapperCtx): IrType | null {
   const topLevel = mapTypeDepth === 0;
   const typeId = (type as { id?: number }).id;
   const memoizable = typeId !== undefined && (ctx.canMemoizeType?.() ?? true);
-  const memoKey = memoizable ? `${0}:${typeId}` : null;
+  // An empty literal's type maps to the empty record as an unreduced union's
+  // arm (emptyLiteralArm) and to the checked-dynamic value elsewhere: the two
+  // answers keep separate memo entries.
+  const memoKey = memoizable ? `${ctx.emptyLiteralArm ? 1 : 0}:${typeId}` : null;
   if (memoKey !== null) {
     const memo = ctx.typeMemo?.get(memoKey);
     if (memo !== undefined) return memo;
diff --git a/tests/corpus/6909-empty-object-type-values.ts b/tests/corpus/6909-empty-object-type-values.ts
index b539415fd..f845e19a6 100644
--- a/tests/corpus/6909-empty-object-type-values.ts
+++ b/tests/corpus/6909-empty-object-type-values.ts
@@ -30,3 +30,11 @@ console.log(typeof choose(1), typeof choose(-1));
 
 const empty = {};
 console.log(JSON.stringify(empty), Object.keys(empty).length, empty === empty, String(empty));
+
+// An empty literal's type beside a typed arm of an unreduced union, after
+// the type was already used on its own.
+const viewed = {};
+console.log(JSON.stringify(viewed));
+const views: (typeof viewed | DataView)[] = [viewed, new DataView(new ArrayBuffer(2))];
+for (const view of views)
+  console.log(view instanceof DataView ? `view ${view.byteLength}` : JSON.stringify(view));

From 487f536a2908ae4bb4c755bd1b57768f502c674c Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 21:28:46 -0500
Subject: [PATCH 63/67] Keep int32 fields of classes whose prototypes are named
 for inspection

dyn.nameClassPrototype sets the class name on a class's runtime prototype
object and stores no property. The int32 field analysis did not list it as
read-only, so every program that gave a class a runtime prototype counted a
dynamic store that can name any property, and the number fields of every
class reaching dynamic code were stored as doubles.
---
 packages/compiler/src/ir/int32-slots.test.ts  |  4 +-
 packages/compiler/src/ir/int32-slots.ts       |  1 +
 .../test/int32-dynamic-exposure.test.ts       | 84 +++++++++++++++++++
 3 files changed, 88 insertions(+), 1 deletion(-)
 create mode 100644 packages/compiler/test/int32-dynamic-exposure.test.ts

diff --git a/packages/compiler/src/ir/int32-slots.test.ts b/packages/compiler/src/ir/int32-slots.test.ts
index 446b3512d..be933ab38 100644
--- a/packages/compiler/src/ir/int32-slots.test.ts
+++ b/packages/compiler/src/ir/int32-slots.test.ts
@@ -262,7 +262,8 @@ test("dynamic stores disqualify the field names they can reach", () => {
   expect([readOnly.isField("C", "a"), readOnly.isField("C", "b")]).toEqual([true, true]);
   // Reflection that only reads the view (Object.keys/values/entries, for-in,
   // own-key lists, typeof, toString and inspection) stores nothing, nor does
-  // creating an object from a prototype or reading a prototype.
+  // creating an object from a prototype, reading a prototype or naming a
+  // class prototype for inspection.
   for (const reader of [
     "dyn.objKeys",
     "dyn.objKeyStrings",
@@ -282,6 +283,7 @@ test("dynamic stores disqualify the field names they can reach", () => {
     "insp.dynS",
     "dyn.objCreate",
     "dyn.getPrototype",
+    "dyn.nameClassPrototype",
     // Registering or removing a process event listener stores nothing either.
     "process.onSignal",
     "process.offSignal",
diff --git a/packages/compiler/src/ir/int32-slots.ts b/packages/compiler/src/ir/int32-slots.ts
index 781fa86bd..6ff148c55 100644
--- a/packages/compiler/src/ir/int32-slots.ts
+++ b/packages/compiler/src/ir/int32-slots.ts
@@ -376,6 +376,7 @@ const DYN_READ_ONLY = new Set<string>([
   "dyn.collectionIteratorIndex",
   "dyn.mapSeedEntries",
   "dyn.mapSeedEntry",
+  "dyn.nameClassPrototype",
   "dyn.numberConstructor",
   "dyn.objCreate",
   "dyn.objEntries",
diff --git a/packages/compiler/test/int32-dynamic-exposure.test.ts b/packages/compiler/test/int32-dynamic-exposure.test.ts
new file mode 100644
index 000000000..09330e057
--- /dev/null
+++ b/packages/compiler/test/int32-dynamic-exposure.test.ts
@@ -0,0 +1,84 @@
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { expect, test } from "vitest";
+import { compile, deserializeModule } from "../src/index.js";
+import { analyzeInt32Slots, dynamicFieldStores } from "../src/ir/int32-slots.js";
+import type { IrModule } from "../src/ir/ir.js";
+
+// Instances of these classes reach checked-dynamic code (an unknown[] array,
+// instanceof, inspection, JSON and string conversion), but the program never
+// stores a property through a dynamic value. The helpers the compiler emits
+// for those reads (prototype objects, inspection names) store nothing, so the
+// classes keep their int32 fields.
+const source = `
+import { inspect } from "node:util";
+
+class Node {
+  kind: number;
+  flags = 0;
+  constructor(kind: number) {
+    this.kind = kind;
+  }
+}
+class Identifier extends Node {
+  text = "id";
+}
+class Type {
+  constructor(
+    public flags: number,
+    public id: number,
+  ) {}
+}
+
+const values: unknown[] = [new Node(1), new Identifier(2), new Type(4, 7), "s", 3];
+let total = 0;
+for (const value of values) {
+  if (value instanceof Identifier) total += value.kind | value.flags;
+  else if (value instanceof Node) total += value.kind;
+  else if (value instanceof Type) total += value.flags & 6;
+}
+console.log(total, values, inspect(new Type(1, 2)));
+console.log(JSON.stringify(values), String(values[0]), typeof values[2]);
+`;
+
+async function lowered(): Promise<IrModule> {
+  const dir = await mkdtemp(join(tmpdir(), "scriptc-int32-dynamic-"));
+  try {
+    const entry = join(dir, "main.ts");
+    await writeFile(entry, source);
+    const outPath = join(dir, "main.ir.json");
+    const result = await compile(entry, { outDir: dir, outPath, outputKind: "ir" });
+    if (!result.ok)
+      throw new Error(result.diagnostics.map((d) => `${d.code}: ${d.message}`).join("\n"));
+    return deserializeModule(await readFile(outPath, "utf8"));
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+test("classes that only reach dynamic reads keep their int32 fields", async () => {
+  const mod = await lowered();
+  // Name the functions whose dynamic helpers count as stores that can name
+  // any property: such a helper either stores into the value or is missing
+  // from the analysis's read-only list (DYN_READ_ONLY in int32-slots.ts).
+  const storing = mod.functions
+    .filter((fn) => dynamicFieldStores({ ...mod, functions: [fn] }).all)
+    .map((fn) => fn.name);
+  expect(storing).toEqual([]);
+  expect(dynamicFieldStores(mod).names.size).toBe(0);
+
+  const slots = analyzeInt32Slots(mod);
+  const className = (jsName: string): string =>
+    mod.classes!.find((c) => (c.jsName ?? c.name) === jsName || c.name.endsWith(`.${jsName}`))!
+      .name;
+  expect([
+    slots.isField(className("Node"), "kind"),
+    slots.isField(className("Node"), "flags"),
+    slots.isField(className("Identifier"), "kind"),
+    slots.isField(className("Type"), "flags"),
+    slots.isField(className("Type"), "id"),
+  ]).toEqual([true, true, true, true, true]);
+  // The program reaches the helper that names class prototypes for inspection.
+  expect(mod.functions.some((fn) => fn.name.startsWith("%prototype.data."))).toBe(true);
+});

From c0014f683d15672058569def9a5c5195a6fad58a Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 21:29:59 -0500
Subject: [PATCH 64/67] Convert unions of primitives with unary +

---
 .../frontend/lowering/expressions/updates.ts  |  9 +++-
 .../src/frontend/lowering/lower-calls.ts      | 14 ++++++
 .../6860-unary-plus-primitive-unions.ts.json  |  6 +++
 .../6861-unary-plus-optional-values.js.json   |  6 +++
 .../6860-unary-plus-primitive-unions.ts       | 48 ++++++++++++++++++
 .../corpus/6861-unary-plus-optional-values.js | 49 +++++++++++++++++++
 .../6860-unary-plus-primitive-unions.ts.json  |  1 +
 .../6861-unary-plus-optional-values.js.json   |  1 +
 8 files changed, 132 insertions(+), 2 deletions(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6860-unary-plus-primitive-unions.ts.json
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6861-unary-plus-optional-values.js.json
 create mode 100644 tests/corpus/6860-unary-plus-primitive-unions.ts
 create mode 100644 tests/corpus/6861-unary-plus-optional-values.js
 create mode 100644 tests/harness/corpus-costs/6860-unary-plus-primitive-unions.ts.json
 create mode 100644 tests/harness/corpus-costs/6861-unary-plus-optional-values.js.json

diff --git a/packages/compiler/src/frontend/lowering/expressions/updates.ts b/packages/compiler/src/frontend/lowering/expressions/updates.ts
index 7269f6b52..13baca7d2 100644
--- a/packages/compiler/src/frontend/lowering/expressions/updates.ts
+++ b/packages/compiler/src/frontend/lowering/expressions/updates.ts
@@ -30,6 +30,7 @@ import {
 } from "../../../ir/ir.js";
 import { isJsSourceFile, locOf } from "../../program.js";
 import { classToNumberConversion } from "../class-to-primitive.js";
+import { lowerPrimitiveUnionNumber } from "../lower-calls.js";
 import { dynUndefinedExpr, nodeThrowExpr, numLit, varRef } from "../../../ir/build.js";
 import { fenceNodeModuleMutation } from "../lower-node-module.js";
 import { staticFieldWriteTarget } from "../lower-classes.js";
@@ -132,8 +133,12 @@ export function lowerPrefixUnary(lowerer: Lowerer, expr: ts.PrefixUnaryExpressio
       const classNumber = classToNumberConversion(lowerer, raw, expr.operand, "unary plus");
       if (classNumber) return classNumber;
       const operand = lowerOptionalNumber(lowerer, raw, loc, expr.operand);
-      if (operand.type.kind !== "f64") operatorUnsupported(lowerer, expr, "+", [raw.type]);
-      return operand;
+      if (operand.type.kind === "f64") return operand;
+      // `+process.argv[2]`: a `string | undefined` (or other primitive
+      // union) converts as Number(value) does.
+      const unionNumber = lowerPrimitiveUnionNumber(lowerer, raw, expr.operand, loc);
+      if (unionNumber) return unionNumber;
+      operatorUnsupported(lowerer, expr, "+", [raw.type]);
     }
     case ts.SyntaxKind.ExclamationToken: {
       // `!x` is ToBoolean-then-negate: f64/string operands go through toBool.
diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts
index ac7728838..a5c09796c 100644
--- a/packages/compiler/src/frontend/lowering/lower-calls.ts
+++ b/packages/compiler/src/frontend/lowering/lower-calls.ts
@@ -3201,6 +3201,20 @@ function lowerStringPrototypeCall(
   );
 }
 
+/** ToNumber of a union of strings, numbers, booleans, null and undefined, as
+ * `Number(value)` converts it; null for other types. Unary `+` takes it too:
+ * the two conversions differ only for BigInt, which such unions don't hold. */
+export function lowerPrimitiveUnionNumber(
+  lowerer: Lowerer,
+  arg: IrExpr,
+  node: ts.Expression,
+  loc: SrcLoc,
+): IrExpr | null {
+  return (
+    lowerOptionalStringNumber(lowerer, arg, loc) ?? lowerScalarUnionNumber(lowerer, arg, node, loc)
+  );
+}
+
 function lowerScalarUnionNumber(
   lowerer: Lowerer,
   arg: IrExpr,
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6860-unary-plus-primitive-unions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6860-unary-plus-primitive-unions.ts.json
new file mode 100644
index 000000000..9847a1330
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6860-unary-plus-primitive-unions.ts.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6860-unary-plus-primitive-unions.ts"
+ ],
+ "diags": []
+}
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6861-unary-plus-optional-values.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6861-unary-plus-optional-values.js.json
new file mode 100644
index 000000000..7bf8c20a2
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6861-unary-plus-optional-values.js.json
@@ -0,0 +1,6 @@
+{
+ "order": [
+  "<repo>/tests/corpus/6861-unary-plus-optional-values.js"
+ ],
+ "diags": []
+}
diff --git a/tests/corpus/6860-unary-plus-primitive-unions.ts b/tests/corpus/6860-unary-plus-primitive-unions.ts
new file mode 100644
index 000000000..e112013d9
--- /dev/null
+++ b/tests/corpus/6860-unary-plus-primitive-unions.ts
@@ -0,0 +1,48 @@
+// Unary + on unions of strings, numbers and booleans converts as Number(value)
+// does: strings parse with StringToNumber (whitespace, hex, octal and binary
+// prefixes, Infinity), booleans become 1 and 0, and numbers keep their value.
+function show(label: string, value: number): void {
+  console.log(label, Object.is(value, -0) ? "-0" : String(value));
+}
+
+function plusTextOrNumber(value: string | number): number {
+  return +value;
+}
+
+function plusTextOrFlag(value: string | boolean): number {
+  return +value;
+}
+
+function plusNumberOrFlag(value: number | boolean): number {
+  return +value;
+}
+
+type Scalar = string | number | boolean;
+
+const texts = ["42", " 0x1F ", "", "  ", "1e3", "-0", "abc", "Infinity", "0b101", "0o17", "1_000", "\n7\t"];
+for (const text of texts) show(`text ${JSON.stringify(text)}`, plusTextOrNumber(text));
+for (const n of [9, -0, 0.5, Number.NaN, -Infinity]) show(`number ${String(n)}`, plusTextOrNumber(n));
+for (const value of [true, false, "3", "x"]) show(`text or flag ${String(value)}`, plusTextOrFlag(value));
+for (const value of [true, false, 2.5]) show(`number or flag ${String(value)}`, plusNumberOrFlag(value));
+
+const scalars: Scalar[] = ["7", 3.5, true, false, "", -0, " 12 "];
+let total = 0;
+for (const value of scalars) {
+  const n = +value;
+  total += n;
+  show(`scalar ${typeof value} ${JSON.stringify(value)}`, n);
+}
+show("total", total);
+
+// In expressions: sums, negation and comparisons.
+const width: string | number = texts.length > 3 ? "640" : 0;
+const ratio: string | number = texts.length > 3 ? 1.5 : "2";
+show("sum", +width + +ratio);
+show("negated", -+width);
+console.log("compare", +width > 600, +ratio === 1.5);
+
+type Level = "1" | "2" | 3;
+function plusLevel(level: Level): number {
+  return +level;
+}
+show("level", plusLevel("2") + plusLevel(3));
diff --git a/tests/corpus/6861-unary-plus-optional-values.js b/tests/corpus/6861-unary-plus-optional-values.js
new file mode 100644
index 000000000..6acf48e10
--- /dev/null
+++ b/tests/corpus/6861-unary-plus-optional-values.js
@@ -0,0 +1,49 @@
+// Unary + in JavaScript on values that may be undefined or null: command-line
+// argument slots, Map lookups, optional parameters and nullable values convert
+// as Number(value) does (undefined to NaN, null to 0).
+function show(label, value) {
+  console.log(label, Object.is(value, -0) ? "-0" : String(value));
+}
+
+// No arguments: the first argument slot is undefined.
+const n = +process.argv[2];
+show("argv[2]", n);
+show("argv[2] doubled", +process.argv[2] * 2);
+show("argv[2] or default", +process.argv[2] || 100);
+show("argv[0] is a path", +process.argv[0]);
+
+const settings = new Map([
+  ["width", "640"],
+  ["ratio", "1.5"],
+  ["blank", " "],
+]);
+show("map width", +settings.get("width"));
+show("map ratio", +settings.get("ratio"));
+show("map blank", +settings.get("blank"));
+show("map missing", +settings.get("height"));
+show("map sum", +settings.get("width") + +settings.get("ratio"));
+show("negated", -+settings.get("width"));
+
+function plusOptional(value) {
+  return +value;
+}
+for (const text of ["42", " 0x1F ", "", "1e3", "-0", "abc", undefined]) {
+  show(`optional ${String(text)}`, plusOptional(text));
+}
+
+function plusParameter(value = undefined) {
+  return +value;
+}
+show("parameter missing", plusParameter());
+show("parameter given", plusParameter("12.5"));
+
+const words = ["3", "x"];
+show("past the end", +words[5]);
+show("in range", +words[0]);
+
+const lookup = { a: "8" };
+show("missing key", +lookup.b);
+show("present key", +lookup.a);
+
+const maybeNull = words.length > 1 ? null : "1";
+show("null", +maybeNull);
diff --git a/tests/harness/corpus-costs/6860-unary-plus-primitive-unions.ts.json b/tests/harness/corpus-costs/6860-unary-plus-primitive-unions.ts.json
new file mode 100644
index 000000000..8211f0716
--- /dev/null
+++ b/tests/harness/corpus-costs/6860-unary-plus-primitive-unions.ts.json
@@ -0,0 +1 @@
+{ "plain": 2430, "san": 6860 }
diff --git a/tests/harness/corpus-costs/6861-unary-plus-optional-values.js.json b/tests/harness/corpus-costs/6861-unary-plus-optional-values.js.json
new file mode 100644
index 000000000..376953c70
--- /dev/null
+++ b/tests/harness/corpus-costs/6861-unary-plus-optional-values.js.json
@@ -0,0 +1 @@
+{ "plain": 2000, "san": 5370 }

From 71e118be7be32bd09c7d3a935155b3b8765e1086 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 21:42:23 -0500
Subject: [PATCH 65/67] Count loops bounded by a string's length in integers

A counted for loop needs a stable limit to run its counter in integer
storage. Array lengths qualified when the loop provably keeps them, but
a string's length did not, so `for (let i = 0; i < s.length; i++)`
kept a double counter and evaluated the length, through the UTF-16
mapping of a non-ASCII string, on every iteration. A string's length
cannot change, so it is now stable whenever the string's binding is
not rebound in the loop or boxed.
---
 .../compiler/src/ir/integer-loops.test.ts     | 39 +++++++++++++++++++
 packages/compiler/src/ir/integer-loops.ts     |  7 ++++
 2 files changed, 46 insertions(+)

diff --git a/packages/compiler/src/ir/integer-loops.test.ts b/packages/compiler/src/ir/integer-loops.test.ts
index 75968b262..aada3b053 100644
--- a/packages/compiler/src/ir/integer-loops.test.ts
+++ b/packages/compiler/src/ir/integer-loops.test.ts
@@ -209,6 +209,45 @@ test("a string read at the counter is an integer consumer", () => {
   expect(matchIntegerCountedForLoop(s, withText)).toBeNull();
 });
 
+test("a string length bounds a counted loop while its binding is unchanged", () => {
+  const withText = new Map(locals);
+  withText.set("s", { id: "s", name: "s", type: STRING, mutable: true });
+  const text = (): IrExpr => ({ kind: "varRef", localId: "s", type: STRING, loc });
+  const length: IrExpr = {
+    kind: "strIntrinsic",
+    method: "length",
+    receiver: text(),
+    args: [],
+    type: F64,
+    loc,
+  };
+  const s = counted(length);
+  s.body = [
+    {
+      kind: "exprStmt",
+      expr: {
+        kind: "strIntrinsic",
+        method: "charCodeAt",
+        receiver: text(),
+        args: [ref("i")],
+        type: F64,
+        loc,
+      },
+      loc,
+    },
+  ];
+  expect(matchIntegerCountedForLoop(s, withText)?.localId).toBe("i");
+  // Rebinding the string in the body changes the length the condition reads.
+  const rebinding = {
+    ...s,
+    body: [...s.body, { kind: "assign", localId: "s", value: text(), loc } as IrStmt],
+  };
+  expect(matchIntegerCountedForLoop(rebinding, withText)).toBeNull();
+  const boxed = new Map(withText);
+  boxed.set("s", { ...withText.get("s")!, boxed: true });
+  expect(matchIntegerCountedForLoop(s, boxed)).toBeNull();
+});
+
 test("a stable array length bounds a counted loop; a resizing body keeps it a condition", () => {
   const ARR = arrayOf(F64);
   const array = (localId: string): IrExpr => ({ kind: "varRef", localId, type: ARR, loc });
diff --git a/packages/compiler/src/ir/integer-loops.ts b/packages/compiler/src/ir/integer-loops.ts
index 3ba186376..9b4675685 100644
--- a/packages/compiler/src/ir/integer-loops.ts
+++ b/packages/compiler/src/ir/integer-loops.ts
@@ -83,6 +83,13 @@ function stableLoopValue(
         stableLoopValue(value.left, locals, body, invariant, counter, stableLength) &&
         stableLoopValue(value.right, locals, body, invariant, counter, stableLength)
       );
+    case "strIntrinsic":
+      // A string's length is fixed: stable while its binding is.
+      return (
+        value.method === "length" &&
+        value.receiver.kind === "varRef" &&
+        stableLoopValue(value.receiver, locals, body, invariant, counter)
+      );
     case "bytesIntrinsic":
     case "arrIntrinsic":
       return (

From ca446b2c30b3ecf5347d64e241a766af9989d52c Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 21:56:08 -0500
Subject: [PATCH 66/67] Read the tls.createServer SNICallback in source order

The runtime call reads the cert and key options before the SNICallback,
so a cert or key initializer after the callback that reassigned the
callback's binding changed the callback the server used, and the server
could serve the wrong certificate. When SNICallback comes before a cert
or key entry, the callback is now saved just before the next of them is
evaluated. With the callback read in order, a callback expression with
side effects lowers instead of being refused.
---
 .../src/frontend/lowering/lower-server.ts     | 27 +++++++++------
 tests/corpus/6933-tls-sni-callback.ts         | 34 ++++++++++++++++++-
 tests/diagnostics/tls-sni-callback-fences.ts  |  2 --
 .../tls-sni-callback-fences.ts.txt            | 17 +++-------
 4 files changed, 54 insertions(+), 26 deletions(-)

diff --git a/packages/compiler/src/frontend/lowering/lower-server.ts b/packages/compiler/src/frontend/lowering/lower-server.ts
index c27b2513e..058d7874a 100644
--- a/packages/compiler/src/frontend/lowering/lower-server.ts
+++ b/packages/compiler/src/frontend/lowering/lower-server.ts
@@ -4762,6 +4762,7 @@ function lowerTlsServerOptions(
   let cert: IrExpr | null = null;
   let key: IrExpr | null = null;
   let sni: IrExpr | undefined;
+  let pendingSni: IrStmt | null = null;
   for (const prop of node.properties.nodes) {
     let initializer: ts.Expression | null;
     if (
@@ -4780,20 +4781,22 @@ function lowerTlsServerOptions(
     }
     const k = (prop.name as ts.Identifier | ts.StringLiteral).text;
     if (k === "SNICallback" && allowSni) {
-      // The callback is a value read (a function or a binding), so it may
-      // be read after cert and key without changing what the program sees.
-      if (initializer !== null && !sideEffectFreeOptionValue(initializer)) {
-        lowerer.noLowering(
-          `a ${what} SNICallback expression with side effects`,
-          prop,
-          "pass a function or a variable that holds one",
-        );
-      }
       const value =
         initializer !== null
           ? lowerer.lowerExpr(initializer)
           : lowerer.lowerShorthandValue(prop as ts.ShorthandPropertyAssignment);
-      sni = checkSniCallbackValue(lowerer, value, prop, what);
+      const checked = checkSniCallbackValue(lowerer, value, prop, what);
+      if (cert !== null && key !== null) {
+        sni = checked;
+      } else {
+        // The runtime call reads cert and key first. A cert or key entry
+        // after the callback can change the binding the callback reads,
+        // so the callback is saved ahead of the next of them, in source
+        // order.
+        const saved = lowerer.declareHiddenLocal("%sniCallback", checked.type);
+        pendingSni = { kind: "varDecl", localId: saved.id, init: checked, loc: locOf(prop) };
+        sni = varRef(saved.id, checked.type, locOf(prop));
+      }
       continue;
     }
     if (k !== "cert" && k !== "key") {
@@ -4857,6 +4860,10 @@ function lowerTlsServerOptions(
         "cert/key are PEM strings or Buffers here",
       );
     }
+    if (pendingSni !== null) {
+      v = { kind: "seqExpr", stmts: [pendingSni], result: v, type: v.type, loc };
+      pendingSni = null;
+    }
     if (k === "cert") cert = v;
     else key = v;
   }
diff --git a/tests/corpus/6933-tls-sni-callback.ts b/tests/corpus/6933-tls-sni-callback.ts
index 7958882d5..8c9442806 100644
--- a/tests/corpus/6933-tls-sni-callback.ts
+++ b/tests/corpus/6933-tls-sni-callback.ts
@@ -33,6 +33,30 @@ const server = tls.createServer(
   },
 );
 
+// The callback is read where it appears, effects included: a later cert
+// initializer that reassigns its binding does not change the callback the
+// server uses.
+type Sni = (servername: string, cb: (err: Error | null, ctx?: tls.SecureContext) => void) => void;
+let chosen: Sni = (servername, cb) => {
+  console.log("first callback", servername);
+  cb(null, altContext);
+};
+const ordered = tls.createServer(
+  {
+    SNICallback: (console.log("read callback"), chosen),
+    cert: (console.log("read cert"),
+    (chosen = (servername, cb) => {
+      console.log("second callback", servername);
+      cb(null, undefined);
+    }),
+    cert),
+    key,
+  },
+  (socket) => {
+    socket.end("ordered");
+  },
+);
+
 function attempt(port: number, servername: string, next: () => void): void {
   let done = false;
   const finish = (line: string): void => {
@@ -58,7 +82,15 @@ server.listen(0, "127.0.0.1", () => {
   attempt(port, "localhost", () =>
     attempt(port, "alt.localhost", () =>
       attempt(port, "other.localhost", () =>
-        attempt(port, "fail.localhost", () => server.close(() => console.log("closed"))),
+        attempt(port, "fail.localhost", () =>
+          server.close(() => {
+            console.log("closed");
+            ordered.listen(0, "127.0.0.1", () => {
+              const orderedPort = (ordered.address() as net.AddressInfo).port;
+              attempt(orderedPort, "alt.localhost", () => ordered.close(() => console.log("ordered closed")));
+            });
+          }),
+        ),
       ),
     ),
   );
diff --git a/tests/diagnostics/tls-sni-callback-fences.ts b/tests/diagnostics/tls-sni-callback-fences.ts
index 0c745365c..20b6ce271 100644
--- a/tests/diagnostics/tls-sni-callback-fences.ts
+++ b/tests/diagnostics/tls-sni-callback-fences.ts
@@ -9,7 +9,5 @@ function makeSni(): (servername: string, cb: Answer) => void {
   return (_servername, cb) => cb(null, undefined);
 }
 
-// The callback expression has side effects.
-tls.createServer({ cert, key, SNICallback: makeSni() }, (socket) => socket.end());
 // SNICallback with options the runtime options walk reads.
 tls.createServer({ cert, key, ALPNProtocols: ["h2"], SNICallback: makeSni });
diff --git a/tests/harness/__snapshots__/tls-sni-callback-fences.ts.txt b/tests/harness/__snapshots__/tls-sni-callback-fences.ts.txt
index 920e65532..c45608bb9 100644
--- a/tests/harness/__snapshots__/tls-sni-callback-fences.ts.txt
+++ b/tests/harness/__snapshots__/tls-sni-callback-fences.ts.txt
@@ -1,17 +1,8 @@
-tls-sni-callback-fences.ts:13:31 - error SC2020: 'a tls.createServer SNICallback expression with side effects' is part of the standard library types but has no scriptc lowering yet
+tls-sni-callback-fences.ts:13:54 - error SC2020: 'tls.createServer with SNICallback and options the runtime walk reads' is part of the standard library types but has no scriptc lowering yet
 
-  12 | // The callback expression has side effects.
-  13 | tls.createServer({ cert, key, SNICallback: makeSni() }, (socket) => socket.end());
-     |                               ^~~~~~~~~~~~~~~~~~~~~~
-  14 | // SNICallback with options the runtime options walk reads.
-
-  hint: pass a function or a variable that holds one
-
-tls-sni-callback-fences.ts:15:54 - error SC2020: 'tls.createServer with SNICallback and options the runtime walk reads' is part of the standard library types but has no scriptc lowering yet
-
-  14 | // SNICallback with options the runtime options walk reads.
-  15 | tls.createServer({ cert, key, ALPNProtocols: ["h2"], SNICallback: makeSni });
+  12 | // SNICallback with options the runtime options walk reads.
+  13 | tls.createServer({ cert, key, ALPNProtocols: ["h2"], SNICallback: makeSni });
      |                                                      ^~~~~~~~~~~~~~~~~~~~
-  16 | 
+  14 | 
 
   hint: SNICallback lowers with cert and key; ALPNProtocols, minVersion, maxVersion and the validated options are not combined with it yet
\ No newline at end of file

From 71d5e92dc044b4d719d8ae0f76d11751619fb499 Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Wed, 21 Oct 2026 22:02:22 -0500
Subject: [PATCH 67/67] Address review feedback on properties untyped code adds
 to typed objects

---
 packages/runtime/src/scr_json.c               | 42 ++++++++++++-------
 .../corpus/6990-record-writes-from-js/main.ts |  6 +++
 2 files changed, 32 insertions(+), 16 deletions(-)

diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c
index bd9bc2cc2..54411bd54 100644
--- a/packages/runtime/src/scr_json.c
+++ b/packages/runtime/src/scr_json.c
@@ -2981,30 +2981,40 @@ static bool scr_jb_put_source_field(ScrJsonBuf *b, void *rec, const ScrRecordSou
  * a source, otherwise writes nothing and answers false. */
 static bool scr_dyn_key_is_index(const char *key, size_t len, double *out);
 
+typedef struct {
+  double index;
+  size_t entry;
+} ScrRecordSourceIntegerKey;
+
+static int scr_record_source_integer_cmp(const void *a, const void *b) {
+  double x = ((const ScrRecordSourceIntegerKey *)a)->index;
+  double y = ((const ScrRecordSourceIntegerKey *)b)->index;
+  return (x > y) - (x < y);
+}
+
 /* The entry indexes of `view` in JavaScript's own-key order: integer keys
  * ascending, then the other keys in insertion order. `out` holds len. */
 static void scr_record_source_key_order(const ScrDyn *view, size_t *out) {
-  size_t integers = 0;
-  for (size_t i = 0; i < view->v.obj.len; i++) {
-    double index;
+  size_t len = view->v.obj.len;
+  ScrRecordSourceIntegerKey small[64];
+  ScrRecordSourceIntegerKey *keys = len <= 64 ? small : malloc(len * sizeof *keys);
+  if (!keys) scr_json_oom();
+  size_t integers = 0, next = 0;
+  for (size_t i = 0; i < len; i++) {
     const ScrDynEntry *entry = &view->v.obj.entries[i];
-    if (!scr_dyn_key_is_index(entry->key, entry->key_len, &index)) continue;
-    size_t at = integers++;
-    for (; at > 0; at--) {
-      double before;
-      const ScrDynEntry *previous = &view->v.obj.entries[out[at - 1]];
-      scr_dyn_key_is_index(previous->key, previous->key_len, &before);
-      if (before < index) break;
-      out[at] = out[at - 1];
-    }
-    out[at] = i;
+    double index;
+    if (scr_dyn_key_is_index(entry->key, entry->key_len, &index))
+      keys[integers++] = (ScrRecordSourceIntegerKey){ index, i };
   }
-  size_t next = integers;
-  for (size_t i = 0; i < view->v.obj.len; i++) {
-    double index;
+  /* Integer keys are distinct, so the order is total. */
+  qsort(keys, integers, sizeof *keys, scr_record_source_integer_cmp);
+  for (size_t i = 0; i < integers; i++) out[next++] = keys[i].entry;
+  for (size_t i = 0; i < len; i++) {
     const ScrDynEntry *entry = &view->v.obj.entries[i];
+    double index;
     if (!scr_dyn_key_is_index(entry->key, entry->key_len, &index)) out[next++] = i;
   }
+  if (keys != small) free(keys);
 }
 
 bool scr_jb_try_record_source(ScrJsonBuf *b, void *rec,
diff --git a/tests/corpus/6990-record-writes-from-js/main.ts b/tests/corpus/6990-record-writes-from-js/main.ts
index 2b343efc5..2ca26b3e2 100644
--- a/tests/corpus/6990-record-writes-from-js/main.ts
+++ b/tests/corpus/6990-record-writes-from-js/main.ts
@@ -21,3 +21,9 @@ write(config, "debug", true);
 write(config, "tags", ["a", "b"]);
 console.log(JSON.stringify(config), keysOf(config));
 console.log(config);
+
+// Many integer keys added in descending order serialize in ascending order.
+const many = { name: "many" };
+for (let i = 3000; i > 0; i--) write(many, i, i);
+const text = JSON.stringify(many);
+console.log(text.length, text.slice(0, 40), text.slice(-30));