@loopdive/js2 0.57.0

package/dist/runtime-containment.d.ts

@@ -0,0 +1,6 @@
+import { ImportIntent } from './index.js';
+/** Wrap an extern_class import function with DOM containment logic.
+ *  Restricts DOM access to the subtree rooted at `domRoot`. */
+export declare function wrapWithContainment(fn: Function, intent: ImportIntent & {
+    type: "extern_class";
+}, domRoot: Element | ShadowRoot): Function;

package/dist/runtime-eval.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Dynamic eval host shim (#1164).
+ *
+ * Polyfill of the long-term `func.new` Wasm JIT-interface proposal: when a
+ * compiled module calls `__extern_eval(src, isDirect)` at runtime, we
+ * re-enter the js2wasm pipeline, compile the eval string to a fresh Wasm
+ * module, instantiate it via `WebAssembly.compile` + `WebAssembly.instantiate`,
+ * and return the result.
+ *
+ * ## Why not `(0, eval)(src)`?
+ *
+ * The original #1006 implementation used the host JS `eval`.  Two problems:
+ *
+ *  1. **Capability leak.**  `(0, eval)(src)` runs in the JS global scope and
+ *     gets unrestricted access to `window`, `document`, `fetch`, `require`,
+ *     the `Function` constructor (allowing further dynamic codegen), and any
+ *     globally-assigned variables.  The Wasm sandbox vanishes the moment we
+ *     hit the host.
+ *  2. **CSP-blocked.**  `script-src` without `'unsafe-eval'` blocks the host
+ *     `eval` builtin.  Many production deployments cannot grant that
+ *     directive.  Wasm compilation needs only `'wasm-unsafe-eval'` — a
+ *     narrower, separately-grantable capability.
+ *
+ * ## Capability model
+ *
+ * The child Wasm module receives only the imports the host explicitly
+ * forwards in `selectiveImports`.  A host that wants maximum isolation
+ * passes `{}` — the child gets a pure Wasm sandbox with no JS surface at
+ * all.  A host that wants the same surface as the parent forwards the
+ * parent's `imports` object.
+ *
+ * **`__extern_eval` is itself a capability.**  Hosts that do not link this
+ * import cause the parent's eval calls to trap at instantiation, rather
+ * than escaping into JS.
+ *
+ * ## Synchronous semantics
+ *
+ * `eval` in JS is synchronous — the calling code expects a value back.
+ * `WebAssembly.compile` is async, but `WebAssembly.Module(bytes)` is sync.
+ * We use the sync path to keep `__extern_eval` synchronous from the Wasm
+ * caller's perspective.
+ *
+ * ## What this does NOT do
+ *
+ * - Direct-eval scope capture (caller variables visible inside the eval
+ *   string) — the child module is a fresh compilation unit; it has no
+ *   visibility into the parent's locals.  Tracked in #1073.
+ * - Standalone / WASI eval — see #1165 for the `func.new` native path.
+ * - Async eval — synchronous only; async strings (top-level `await`, etc.)
+ *   are a separate concern.
+ *
+ * ## Long-term path
+ *
+ * When the [Wasm JIT-interface proposal](https://github.com/WebAssembly/jit-interface)
+ * ships `func.new`, eval becomes a pure-Wasm operation:
+ *
+ *  1. Compile the eval string → bytes (using js2wasm compiled to Wasm)
+ *  2. Write bytes to linear memory
+ *  3. `func.new` → `funcref`
+ *  4. Call it
+ *
+ * This shim is a direct polyfill of that flow against the JS Wasm API.
+ */
+/**
+ * Options for {@link createEvalShim}.
+ */
+export interface EvalShimOptions {
+    /**
+     * Imports to forward to the child Wasm module.  Anything listed here
+     * overrides the auto-generated defaults.
+     *
+     * By default the shim builds a fully-functional import object for the
+     * child module from the child's own declared imports (via
+     * {@link buildImports}).  This gives the child access to the standard
+     * js2wasm runtime helpers (`__box_number`, `__get_undefined`, etc.) so
+     * that any expression form the compiler emits actually instantiates.
+     *
+     * To produce a *strict* sandbox with no JS surface beyond Wasm built-ins,
+     * pass `sandbox: true` (see below).  To merge custom imports on top of
+     * the defaults, pass `selectiveImports: { env: { customFn: ... } }`.
+     */
+    selectiveImports?: WebAssembly.Imports;
+    /**
+     * If `true`, do NOT auto-fill js2wasm runtime helpers — only the imports
+     * provided in `selectiveImports` (plus minimal `string_constants` /
+     * `wasm:js-string` shims) are available to the child.  Function imports
+     * the child declares but the host doesn't provide become trapping stubs
+     * that throw `ReferenceError` when called.
+     *
+     * Use this for capability-restricted execution: the child cannot box
+     * numbers, allocate JS strings outside the literal pool, throw exceptions
+     * with messages, etc.  Most non-trivial eval strings will fail to
+     * instantiate or throw at first runtime use of an unprovided helper.
+     *
+     * Default: `false` — auto-fill helpers for maximum compatibility.
+     */
+    sandbox?: boolean;
+    /**
+     * Optional identifier used as the "filename" for compiler diagnostics.
+     * Defaults to `__eval__.js`.
+     */
+    filename?: string;
+    /**
+     * If provided, called with the result of every successful compileSource
+     * invocation — useful for telemetry or caching.
+     */
+    onCompiled?: (info: {
+        src: string;
+        binarySize: number;
+        isDirect: boolean;
+    }) => void;
+}
+/**
+ * Build a `__extern_eval` host import for a JS-host runtime.
+ *
+ * Returns a function with the runtime signature
+ * `(src: any, isDirect: number) => any`.
+ *
+ * Per ECMA-262 §19.2.1 step 2: if the input is not a String, return it
+ * unchanged.
+ *
+ * @example
+ *   const evalImport = createEvalShim({ selectiveImports: {} });
+ *   const env = { ...otherImports, __extern_eval: evalImport };
+ */
+export declare function createEvalShim(options?: EvalShimOptions): (src: any, isDirect: number) => any;
+/**
+ * Default eval shim — pure Wasm sandbox, no JS surface forwarded to the
+ * child module.  Hosts that need a less restrictive policy should call
+ * {@link createEvalShim} directly with their chosen `selectiveImports`.
+ */
+export declare const defaultEvalShim: (src: any, isDirect: number) => any;

package/dist/runtime-instantiate.d.ts

@@ -0,0 +1,16 @@
+/** Instantiate a Wasm module, trying native wasm:js-string builtins first
+ *  (Chrome 130+, Firefox 135+), falling back to the JS polyfill.
+ *  Uses importedStringConstants to provide string literals as globals. */
+export declare function instantiateWasm(binary: ArrayBuffer | ArrayBufferView, env: Record<string, Function>, stringConstants?: Record<string, WebAssembly.Global>): Promise<{
+    instance: WebAssembly.Instance;
+    nativeBuiltins: boolean;
+}>;
+/** Instantiate a precompiled Wasm module from a Response/URL using streaming compilation
+ *  when available, falling back to byte instantiation if needed.
+ *  Shared runtime helpers stay outside the module-specific payload. */
+export declare function instantiateWasmStreaming(source: Response | Promise<Response> | RequestInfo | URL, env: Record<string, Function>, stringConstants?: Record<string, WebAssembly.Global>): Promise<{
+    instance: WebAssembly.Instance;
+    nativeBuiltins: boolean;
+}>;
+/** Compile TypeScript source and instantiate the Wasm module. */
+export declare function compileAndInstantiate(source: string, deps?: Record<string, any>): Promise<WebAssembly.Exports>;

package/dist/runtime.d.ts

@@ -0,0 +1,128 @@
+import { ImportDescriptor, ImportPolicy } from './index.js';
+/** wasm:js-string polyfill for engines without native support (https://developer.mozilla.org/de/docs/WebAssembly/Guides/JavaScript_builtins) */
+export declare const jsString: {
+    concat: (a: string, b: string) => string;
+    length: (s: string) => number;
+    equals: (a: string, b: string) => number;
+    substring: (s: string, start: number, end: number) => string;
+    charCodeAt: (s: string, i: number) => number;
+};
+/**
+ * Build string constants object for the "string_constants" import namespace.
+ * Each string pool entry becomes a WebAssembly.Global keyed by the literal text.
+ */
+export declare function buildStringConstants(stringPool?: string[]): Record<string, WebAssembly.Global>;
+/** Check a manifest against a policy blocklist before instantiation.
+ *  Returns an array of violated import keys (empty if all clear). */
+export declare function checkPolicy(manifest: ImportDescriptor[], policy: ImportPolicy): string[];
+/**
+ * Build a WASI polyfill for running WASI-compiled modules in JS environments.
+ * Routes fd_write(fd=1) to console.log, fd_write(fd=2) to console.error,
+ * and proc_exit to process.exit (Node) or throw (browser).
+ *
+ * Usage:
+ *   const wasi = buildWasiPolyfill();
+ *   const { instance } = await WebAssembly.instantiate(binary, {
+ *     wasi_snapshot_preview1: wasi,
+ *     env: wasi.envImports,
+ *   });
+ *   wasi.setMemory(instance.exports.memory as WebAssembly.Memory);
+ *   (instance.exports._start as Function)();
+ *
+ * #1482: The polyfill now exposes `envImports.__wasi_env_get_str` for the
+ * `process.env.X` fast path under `--target wasi`, plus `environ_sizes_get`
+ * and `environ_get` shims (memory-writing) for true WASI hosts. The defaults
+ * read from Node's `process.env`; pass `{ env: {...} }` to override.
+ */
+export declare function buildWasiPolyfill(options?: {
+    env?: Record<string, string | undefined>;
+}): {
+    fd_write: (fd: number, iovs: number, iovs_len: number, nwritten: number) => number;
+    fd_read: (fd: number, iovs: number, iovs_len: number, nread: number) => number;
+    proc_exit: (code: number) => void;
+    poll_oneoff: (in_ptr: number, out_ptr: number, nsubs: number, nevents_out: number) => number;
+    fd_fdstat_set_flags: (fd: number, flags: number) => number;
+    environ_sizes_get: (countPtr: number, bufSizePtr: number) => number;
+    environ_get: (envPtrsPtr: number, envBufPtr: number) => number;
+    clock_time_get: (clockid: number, precision: bigint, out_ptr: number) => number;
+    setMemory: (mem: WebAssembly.Memory) => void;
+    setStdin: (data: Uint8Array | string) => void;
+    envImports: Record<string, Function>;
+};
+/** Build the WebAssembly import object from a closed manifest */
+export declare function buildImports(manifest: ImportDescriptor[], deps?: Record<string, any>, stringPool?: string[], options?: {
+    domRoot?: Element | ShadowRoot;
+    globalSandbox?: Record<string, any>;
+}): {
+    env: Record<string, Function>;
+    "wasm:js-string": typeof jsString;
+    string_constants: Record<string, WebAssembly.Global>;
+    setExports?: (exports: Record<string, Function>) => void;
+};
+/**
+ * Wrap raw `instance.exports` so that any Wasm closure struct returned from
+ * a callable export becomes a JS-callable function (#1308).
+ *
+ * Without this wrapper, `exports.makeFn()` returns the raw Wasm closure
+ * struct — `typeof` reports `"object"`, the value is `[Object: null prototype] {}`,
+ * and direct invocation throws "is not a function". With the wrapper, the
+ * struct is replaced by a JS function that dispatches via the
+ * `__call_fn_N` exports the codegen emits (`__call_fn_0` for zero-arg
+ * closures, `__call_fn_1` for one-arg).
+ *
+ * Limitations / scope:
+ * - 0-arg closure returns: `wrapped()` works via `__call_fn_0`.
+ * - 1-arg closure returns: `wrapped(x)` works via `__call_fn_1`.
+ * - Variadic closures (`function(...args){...}`) are lifted as 0-arg
+ *   functions whose body reads `arguments`. Without a JS-side path to
+ *   populate `__extras_argv` + `__argc` before invoking, calling
+ *   `wrapped(2)` falls through to `__call_fn_0` and the closure body
+ *   sees an empty arguments object. Tracked as a follow-up.
+ * - Returned value from the wrapped closure that is itself a Wasm
+ *   struct is NOT recursively wrapped — only direct returns from
+ *   top-level exports. Recursive wrapping can be added if needed.
+ *
+ * Usage:
+ * ```ts
+ * const { instance } = await WebAssembly.instantiate(binary, imports);
+ * const exports = wrapExports(instance.exports);
+ * const negated = exports.negate(jsFn);  // typeof === "function"
+ * negated();                              // dispatches via __call_fn_0
+ * ```
+ */
+/**
+ * (#1700) TS-level classification of a single export param or result slot
+ * surfaced via `CompileResult.exportSignatures`. The Wasm signature alone
+ * is ambiguous for TypedArray vs `number[]` — both lower to
+ * `(ref null $Vec[f64])` — so the JS-host wrapper consults this metadata
+ * to (a) copy a JS `Uint8Array` into a fresh Wasm vec before the call and
+ * (b) wrap the returned plain `Array<number>` back into a `Uint8Array`.
+ */
+export interface WrapExportsSignature {
+    params: ("uint8array" | "typed-array" | "other")[];
+    result: "uint8array" | "typed-array" | "other";
+}
+export declare function wrapExports(rawExports: WebAssembly.Exports, options?: {
+    marshal?: "copy" | false;
+    /** Per-export TS-level type metadata from `CompileResult.exportSignatures`
+     *  (#1700). When provided, Uint8Array arguments are copied into a Wasm
+     *  vec before the call and Uint8Array-typed returns are wrapped on the
+     *  way out. Omitted ⇒ legacy behaviour (no per-call marshalling). */
+    signatures?: Record<string, WrapExportsSignature>;
+}): Record<string, any>;
+/** Instantiate a Wasm module, trying native wasm:js-string builtins first
+ *  (Chrome 130+, Firefox 135+), falling back to the JS polyfill.
+ *  Uses importedStringConstants to provide string literals as globals. */
+export declare function instantiateWasm(binary: ArrayBuffer | ArrayBufferView, env: Record<string, Function>, stringConstants?: Record<string, WebAssembly.Global>): Promise<{
+    instance: WebAssembly.Instance;
+    nativeBuiltins: boolean;
+}>;
+/** Instantiate a precompiled Wasm module from a Response/URL using streaming compilation
+ *  when available, falling back to byte instantiation if needed.
+ *  Shared runtime helpers stay outside the module-specific payload. */
+export declare function instantiateWasmStreaming(source: Response | Promise<Response> | RequestInfo | URL, env: Record<string, Function>, stringConstants?: Record<string, WebAssembly.Global>): Promise<{
+    instance: WebAssembly.Instance;
+    nativeBuiltins: boolean;
+}>;
+/** Compile TypeScript source and instantiate the Wasm module. */
+export declare function compileAndInstantiate(source: string, deps?: Record<string, any>): Promise<WebAssembly.Exports>;

package/dist/runtime.js

@@ -0,0 +1,12 @@
+import { b, j, k, l, m, o, p, q, w } from "./runtime-C-4q_KwU.js";
+export {
+  b as buildImports,
+  j as buildStringConstants,
+  k as buildWasiPolyfill,
+  l as checkPolicy,
+  m as compileAndInstantiate,
+  o as instantiateWasm,
+  p as instantiateWasmStreaming,
+  q as jsString,
+  w as wrapExports
+};

package/dist/shape-inference.d.ts

@@ -0,0 +1,20 @@
+import { ts } from './ts-api.js';
+export interface InferredShape {
+    /** Named fields set on the variable (e.g. "length") with inferred types */
+    fields: Map<string, {
+        type: "number" | "string" | "boolean" | "unknown";
+    }>;
+    /** Whether numeric indexing is used (obj[0] = x) */
+    hasNumericIndexing: boolean;
+    /** Type of values stored at numeric indices */
+    numericValueType: "number" | "string" | "unknown";
+    /** Whether the variable is used in Array.prototype.X.call(obj, ...) */
+    usedInCallApply: boolean;
+    /** Highest literal numeric index seen */
+    maxNumericIndex: number;
+}
+/**
+ * Collect shape information for module-level variables by walking the AST.
+ * Returns a map from variable name to inferred shape.
+ */
+export declare function collectShapes(checker: ts.TypeChecker, sourceFile: ts.SourceFile): Map<string, InferredShape>;

package/dist/treeshake.d.ts

@@ -0,0 +1,17 @@
+import { ts } from './ts-api.js';
+/**
+ * Perform tree-shaking: given entry exports and a set of source files,
+ * determine which top-level declarations are reachable.
+ *
+ * The algorithm is conservative — if in doubt, a declaration is kept.
+ *
+ * @param entryExports - Names of exports from the entry file to keep
+ * @param sourceFiles - All source files in the compilation
+ * @param checker - TypeScript type checker for resolving references
+ * @returns Set of reachable top-level declaration nodes
+ */
+export declare function treeshake(entryExports: string[], sourceFiles: ts.SourceFile[], checker: ts.TypeChecker): Set<ts.Node>;
+/**
+ * Get the set of exported names from an entry source file.
+ */
+export declare function getEntryExportNames(entryFile: ts.SourceFile): string[];

package/dist/ts-api.d.ts

@@ -0,0 +1,30 @@
+import { default as ts } from 'typescript';
+export { ts };
+export declare const isTs7: boolean;
+/**
+ * Active runtime TypeScript backend. Same shape as `import * as ts from
+ * "typescript"` but possibly swapped to `@typescript/native-preview` under
+ * `--ts7`. Use this when you need behaviour that should follow the flag (e.g.
+ * `tsRuntime.createProgram(...)` at the compile entry point).
+ *
+ * Most call sites should keep using the static `import * as ts from
+ * "./ts-api.js"` form — that always points at typescript@5 and is safe for
+ * type-level access. Only swap to `tsRuntime` for code paths we explicitly
+ * want the flag to control.
+ */
+export declare const tsRuntime: typeof import("typescript");
+/**
+ * Backend-agnostic `forEachChild` helper (#1290).
+ *
+ * `typescript@5` exposes `forEachChild` as a static function: `ts.forEachChild(node, cb)`.
+ * `@typescript/native-preview` exposes it as an instance method on every AST node:
+ * `node.forEachChild(cb)`. The two forms accept the same signature.
+ *
+ * This helper dispatches automatically: if `node` carries an instance method
+ * (TS7 native-preview), call it; otherwise fall back to the static TS5 form.
+ *
+ * All src tree modules should import this helper instead of calling
+ * `ts.forEachChild` directly so that codegen can iterate over either backend's
+ * AST without per-call-site changes.
+ */
+export declare function forEachChild<T>(node: ts.Node, cbNode: (node: ts.Node) => T | undefined, cbNodeArray?: (nodes: ts.NodeArray<ts.Node>) => T | undefined): T | undefined;

package/dist/wit-generator.d.ts

@@ -0,0 +1,18 @@
+import { TypedAST } from './checker/index.js';
+import { Import, TypeDef } from './ir/types.js';
+export interface WitGeneratorOptions {
+    /** Package name for the WIT world (default: derived from the source filename) */
+    packageName?: string;
+    /** World name (default: "module") */
+    worldName?: string;
+    /** Compiled module imports to include in the world import surface. */
+    imports?: readonly Import[];
+    /** Compiled module type table used to render import function signatures. */
+    types?: readonly TypeDef[];
+}
+/**
+ * Generate a WIT interface definition from a TypedAST.
+ * Extracts all exported functions and referenced interfaces/type aliases,
+ * then maps them to WIT types.
+ */
+export declare function generateWit(ast: TypedAST, options?: WitGeneratorOptions): string;

package/package.json

@@ -0,0 +1,187 @@
+{
+  "name": "@loopdive/js2",
+  "version": "0.57.0",
+  "description": "Direct AOT compilation from JavaScript and TypeScript to WebAssembly GC",
+  "keywords": [
+    "webassembly",
+    "wasm",
+    "wasm-gc",
+    "compiler",
+    "typescript",
+    "aot",
+    "ahead-of-time",
+    "javascript"
+  ],
+  "homepage": "https://js2.loopdive.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/loopdive/js2.git"
+  },
+  "bugs": {
+    "url": "https://github.com/loopdive/js2/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "author": "Thomas Tränkler <git@thomas.traenkler.com>",
+  "license": "Apache-2.0 WITH LLVM-exception",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "js2": "./dist/cli.js",
+    "js2wasm": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.js"
+    },
+    "./optimize": {
+      "types": "./dist/optimize.d.ts",
+      "import": "./dist/optimize.js"
+    },
+    "./cli": "./dist/cli.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "peerDependencies": {
+    "binaryen": "^125.0.0",
+    "bun": ">=1.3.14",
+    "deno": ">=2.8.1"
+  },
+  "peerDependenciesMeta": {
+    "binaryen": {
+      "optional": true
+    },
+    "bun": {
+      "optional": true
+    },
+    "deno": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "typescript": "^5.7"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1",
+    "@bytecodealliance/componentize-js": "^0.20.0",
+    "@types/lodash": "^4.17.24",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^22",
+    "@typescript/native-preview": "^7.0.0-dev.20260502.1",
+    "axios": "^1.16.1",
+    "binaryen": "^125.0.0",
+    "bun": "1.3.14",
+    "deno": "2.8.1",
+    "esbuild": "^0.25.12",
+    "eslint": "^10.0.3",
+    "hono": "^4.12.16",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.4.0",
+    "lodash": "^4.18.1",
+    "lodash-es": "^4.18.1",
+    "marked": "^18.0.2",
+    "monaco-editor": "^0.55.1",
+    "prettier": "^3.8.1",
+    "react": "^19.2.6",
+    "shiki": "^4.0.2",
+    "ts-morph": "^27.0.2",
+    "vite": "^6",
+    "vite-plugin-dts": "^4",
+    "vitest": "^3",
+    "wabt": "^1.0.39"
+  },
+  "lint-staged": {
+    "*.{ts,js,mjs}": [
+      "prettier --write",
+      "biome lint --diagnostic-level=error --no-errors-on-unmatched"
+    ],
+    "*.json": "prettier --write"
+  },
+  "scripts": {
+    "release": "node scripts/release.mjs",
+    "new:issue-id": "node scripts/next-issue-id.mjs",
+    "worktree:provision": "bash scripts/provision-worktree-deps.sh",
+    "build": "vite build --config vite.config.lib.ts",
+    "build:playground": "vite build --config website/playground/vite.config.ts",
+    "dev": "pnpm run build:compiler-bundle && (pnpm run dashboard:watch &) && vite serve --config website/playground/vite.config.ts",
+    "test": "node node_modules/vitest/dist/cli.js run",
+    "test:watch": "node node_modules/vitest/dist/cli.js",
+    "test:ir:alloc": "IR_VERIFY_ALLOC=1 node node_modules/vitest/dist/cli.js run tests/ir/alloc-registry.test.ts tests/ir/alloc-provenance.test.ts",
+    "test:equivalence:gate": "node scripts/equivalence-gate.mjs",
+    "test:262": "bash scripts/run-test262-vitest.sh",
+    "test:262:validate-baseline": "npx tsx scripts/validate-test262-baseline.ts",
+    "baseline:fetch": "node scripts/fetch-baseline-jsonl.mjs",
+    "check:ir-fallbacks": "npx tsx scripts/check-ir-fallbacks.ts",
+    "gen:ir-adoption": "node scripts/gen-ir-adoption.mjs",
+    "check:ir-adoption": "node scripts/gen-ir-adoption.mjs --check",
+    "check:stack-balance": "npx tsx scripts/check-stack-balance.ts",
+    "census:async": "node scripts/async-call-census.mjs",
+    "check:codegen-fallbacks": "npx tsx scripts/check-codegen-fallbacks.ts",
+    "check:any-box-sites": "node scripts/check-any-box-sites.mjs",
+    "check:speculative-rollback": "node scripts/check-speculative-rollback-sites.mjs",
+    "check:coercion-sites": "node scripts/check-coercion-sites.mjs",
+    "check:test262-hard-errors": "node scripts/check-test262-hard-errors.mjs",
+    "check:issue-spec-coverage": "node scripts/check-issue-spec-coverage.mjs",
+    "check:issues": "node scripts/update-issues.mjs --check",
+    "test:diff": "npx tsx scripts/diff-test.ts",
+    "test:diff:triage": "npx tsx scripts/diff-triage.ts",
+    "test:diff:gate": "npx tsx scripts/diff-test-gate.ts",
+    "dogfood:acorn": "npx tsx tests/dogfood/acorn-harness.mjs",
+    "refresh:benchmarks": "npx tsx --experimental-wasm-stringref --experimental-wasm-custom-descriptors benchmarks/run.ts && pnpm run build:compiler-bundle && node --experimental-wasm-stringref --experimental-wasm-custom-descriptors scripts/generate-playground-benchmark-sidebar.mjs && node --experimental-wasm-stringref --experimental-wasm-custom-descriptors scripts/generate-playground-benchmark-sidebar-no-jit.mjs && pnpm run generate:size-benchmarks && node scripts/generate-browser-runtime-benchmarks.mjs",
+    "refresh:benchmarks:no-jit": "pnpm run build:compiler-bundle && node --experimental-wasm-stringref --experimental-wasm-custom-descriptors scripts/generate-playground-benchmark-sidebar-no-jit.mjs",
+    "refresh:benchmarks:wasmtime": "pnpm run build:compiler-bundle && node --experimental-wasm-stringref --experimental-wasm-custom-descriptors scripts/generate-wasmtime-hot-runtime.mjs",
+    "build:compiler-bundle": "esbuild scripts/compiler-bundle-entry.ts --bundle --platform=node --format=esm --outfile=scripts/compiler-bundle.mjs --external:typescript --external:binaryen --external:@typescript/native-preview --external:@typescript/native-preview/*",
+    "build:standalone-cli": "node scripts/build-standalone-cli.mjs",
+    "format": "prettier --write 'src/**/*.ts' 'tests/**/*.ts' 'scripts/**/*.ts'",
+    "format:check": "prettier --check 'src/**/*.ts' 'tests/**/*.ts' 'scripts/**/*.ts'",
+    "lint": "biome lint src tests scripts --diagnostic-level=error",
+    "typecheck": "tsc --noEmit",
+    "generate:editions": "npx tsx scripts/generate-editions.ts",
+    "generate:feature-badges": "node scripts/derive-feature-badges.mjs",
+    "generate:feature-badges:check": "node scripts/derive-feature-badges.mjs --check",
+    "generate:feature-examples": "npx tsx scripts/generate-feature-examples.ts",
+    "generate:size-benchmarks": "npx tsx --experimental-wasm-stringref --experimental-wasm-custom-descriptors scripts/generate-size-benchmarks.ts",
+    "generate:browser-runtime-benchmarks": "node scripts/generate-browser-runtime-benchmarks.mjs",
+    "build:planning-artifacts": "node scripts/build-planning-artifacts.mjs",
+    "dashboard": "node website/dashboard/build-data.js",
+    "dashboard:watch": "node --watch --watch-path plan/issues --watch-path plan/issues/sprints --watch-path plan/issues/done --watch-path plan/issues/ready --watch-path plan/issues/blocked website/dashboard/build-data.js",
+    "report": "npx tsx scripts/serve-report.ts",
+    "sync:conformance": "node scripts/sync-conformance-numbers.mjs",
+    "sync:conformance:check": "node scripts/sync-conformance-numbers.mjs --check",
+    "build:pages": "node scripts/run-pages-build.mjs",
+    "deploy:registry-home": "mkdir -p .registry-home && cp website/index.html .registry-home/index.html && node ../file-registry-cli/dist/bin/main.js commit .registry-home -r users/tt/projects/ts2wasm && node ../file-registry-cli/dist/bin/main.js push .registry-home -r users/tt/projects/ts2wasm --public",
+    "upload": "pnpm run build:playground && node ../file-registry-cli/dist/bin/main.js commit && node ../file-registry-cli/dist/bin/main.js push",
+    "reconcile:tasks": "node scripts/reconcile-tasklist.mjs",
+    "issues:pr-status": "node scripts/poll-merged-pr-issues.mjs --once --sync-artifacts",
+    "issues:pr-status:watch": "node scripts/poll-merged-pr-issues.mjs --sync-artifacts",
+    "symphony": "node scripts/symphony.mjs",
+    "symphony:once": "node scripts/symphony.mjs --once",
+    "symphony:dry-run": "node scripts/symphony.mjs --once --dry-run",
+    "symphony:status": "node scripts/symphony.mjs --status",
+    "symphony:control": "node scripts/symphony.mjs --control",
+    "dispatch:queue": "node scripts/dispatch-channel.mjs queue",
+    "dispatch:request-claude": "node scripts/dispatch-channel.mjs request-claude",
+    "dispatch:inbox": "node scripts/dispatch-channel.mjs inbox",
+    "claude:symphony-channel": "node scripts/claude-symphony-channel.mjs",
+    "check:issue-ids": "node scripts/check-issue-ids.mjs",
+    "check:issue-ids:staged": "node scripts/check-issue-ids.mjs --staged",
+    "check:issue-ids:against-main": "node scripts/check-issue-ids.mjs --against-main",
+    "new:issue-id:allocate": "node scripts/claim-issue.mjs --allocate"
+  }
+}