@loopdive/js2 0.57.0

package/dist/codegen/regex/casefold.d.ts

@@ -0,0 +1,41 @@
+/**
+ * #2720 — non-Unicode (legacy) case folding for the standalone regex engine.
+ *
+ * The pure-WasmGC matcher works on UTF-16 code units. Under the `i` flag WITHOUT
+ * `u`/`v`, §22.2.2.9.3 Canonicalize folds each code unit through the Unicode
+ * default UPPERCASE mapping — not ASCII-only — so `/Ä/i` matches `ä`, `/Σ/i`
+ * matches `σ`/`ς`, Cyrillic case pairs match, etc. (`u`/`v` mode uses simple
+ * case folding and is already handled at parse time by the host-oracle in
+ * `unicode.ts`; this module is the NON-unicode arm only.)
+ *
+ * Following the same "host as spec oracle" pattern as #1911/#1912, the
+ * canonicalization equivalence classes are computed ONCE AT COMPILE TIME from
+ * the host's `String.prototype.toUpperCase` (whose Unicode tables the spec
+ * Canonicalize is defined against) and the fold is desugared into plain unit
+ * CLASS ranges. The emitted module stays pure Wasm with zero runtime tables.
+ *
+ * Legacy Canonicalize(ch), ch a UTF-16 code unit (§22.2.2.9.3, IgnoreCase,
+ * non-Unicode):
+ *   1. let u = the uppercase mapping of the single-code-unit string of `ch`.
+ *   2. if u is not a single code unit, return ch.   (e.g. ß → "SS")
+ *   3. let cu = u's single code unit.
+ *   4. if ch ≥ 128 and cu < 128, return ch.         (ASCII-guard: ſ→S, K→K stay)
+ *   5. return cu.
+ * Two code units are `i`-equivalent iff they Canonicalize to the same value.
+ */
+/** Sorted, de-duplicated code-unit list → coalesced inclusive ranges. */
+export declare function unitsToRanges(units: number[]): Array<[number, number]>;
+/**
+ * The legacy-canonicalization equivalence class of a single code unit (always
+ * includes `code` itself). Size 1 ⇒ no case partners (emit a plain CHAR);
+ * size > 1 ⇒ desugar to a CLASS over the returned units.
+ */
+export declare function foldCharUnitsLegacy(code: number): number[];
+/**
+ * Expand a class's inclusive ranges with every legacy-canonicalization case
+ * partner of any member, then coalesce. For each cased unit that falls inside
+ * the input ranges, its whole equivalence set is added (so `[À-Ý]/i` also
+ * matches `à-ý`, `[Σ]/i` also matches `σ`/`ς`, …). Folding happens BEFORE the
+ * CLASS op applies negation, so `[^a]/i` correctly excludes both `a` and `A`.
+ */
+export declare function foldClassRangesLegacy(ranges: Array<[number, number]>): Array<[number, number]>;

package/dist/codegen/regex/compile.d.ts

@@ -0,0 +1,51 @@
+import { CompiledRegex } from './bytecode.js';
+import { ParsedRegex, ReNode } from './parse.js';
+/**
+ * Conservative nullability test (#1959): can `node` match the empty string?
+ * Used to decide whether a star/plus loop needs the empty-iteration PROGRESS
+ * guard. Over-approximating (returning true when unsure) only adds a cheap
+ * guard; under-approximating would risk the silent-no-match bug, so unknown
+ * shapes default to nullable. Zero-width assertions (`^`, `$`, `\b`,
+ * lookaround) are nullable; consuming atoms (char/class/any) are not.
+ */
+export declare function canMatchEmpty(node: ReNode): boolean;
+/**
+ * Capture-group index span of a subtree (#1960): `[min, max]` of every group's
+ * `capIndex` reachable inside `node`, or null when it contains no captures.
+ * Used to emit a `CLEAR` at each quantifier-iteration head so stale captures
+ * from an earlier iteration don't leak (§22.2.2.3.1 RepeatMatcher). Lookaround
+ * bodies are NOT descended into — their captures live in separate sub-programs
+ * governed by the lookaround's own atomic attempt, not the outer loop.
+ */
+export declare function captureSpan(node: ReNode): [number, number] | null;
+/** Thrown when `{n,m}` expansion would blow past the size cap. */
+export declare class RepeatTooLargeError extends Error {
+    constructor(detail: string);
+}
+/** ASCII-only case fold (uppercase → lowercase). Phase 2a `i` is ASCII; full
+ *  Unicode case folding is deferred (documented in the issue + test file). */
+export declare function asciiFold(code: number): number;
+/**
+ * For the `i` flag (ASCII), augment class ranges with their case counterparts
+ * so a CLASS op stays a plain range-membership test (no per-op fold). For each
+ * range overlapping `A-Z` we add the matching lowercase span and vice versa.
+ * Letters only; non-letters are unaffected (ASCII case folding).
+ */
+export declare function foldClassRangesAscii(ranges: Array<[number, number]>): Array<[number, number]>;
+/**
+ * Structurally reverse an AST for lookbehind compilation (#1911): concat order
+ * flips recursively so the body matches right-to-left when the VM runs with
+ * direction -1. Alternative ORDER is preserved (only each option's contents
+ * reverse). Lookaround nodes are leaves — their bodies are separate
+ * sub-programs compiled in their own direction.
+ */
+export declare function reverseNode(node: ReNode): ReNode;
+/**
+ * Compile a parsed pattern + flag bits into a runnable program. Wraps the body
+ * in SAVE 0 … SAVE 1 (whole match) and a trailing MATCH, then appends the
+ * queued lookaround sub-programs.
+ */
+export declare function compileParsed(parsed: ParsedRegex, flags: number): CompiledRegex;
+/** Convenience: parse + compile in one step. Throws RegexUnsupportedError /
+ *  RepeatTooLargeError for out-of-subset patterns. */
+export declare function compilePattern(pattern: string, flags: number): CompiledRegex;

package/dist/codegen/regex/parse.d.ts

@@ -0,0 +1,76 @@
+export type ReNode = {
+    kind: "char";
+    code: number;
+} | {
+    kind: "any";
+} | {
+    kind: "class";
+    ranges: Array<[number, number]>;
+    negated: boolean;
+} | {
+    kind: "bol";
+} | {
+    kind: "eol";
+} | {
+    kind: "wordBoundary";
+    negated: boolean;
+} | {
+    kind: "backref";
+    index: number;
+} | {
+    kind: "lookaround";
+    node: ReNode;
+    negated: boolean;
+    behind: boolean;
+} | {
+    kind: "modGroup";
+    add: number;
+    remove: number;
+    node: ReNode;
+} | {
+    kind: "udot";
+} | {
+    kind: "concat";
+    parts: ReNode[];
+} | {
+    kind: "alt";
+    options: ReNode[];
+} | {
+    kind: "star";
+    node: ReNode;
+    greedy: boolean;
+} | {
+    kind: "plus";
+    node: ReNode;
+    greedy: boolean;
+} | {
+    kind: "opt";
+    node: ReNode;
+    greedy: boolean;
+} | {
+    kind: "repeat";
+    node: ReNode;
+    min: number;
+    max: number;
+    greedy: boolean;
+} | {
+    kind: "group";
+    node: ReNode;
+    capIndex: number;
+    name: string | null;
+};
+export interface ParsedRegex {
+    root: ReNode;
+    /** Number of capturing groups (group 0 / whole match NOT included). */
+    numCaptures: number;
+    /** Capture name → 1-based group index for named groups. */
+    groupNames: Map<string, number>;
+}
+/**
+ * Complement a range list over the full UTF-16 code-unit space [0, 0xFFFF].
+ * Used to lower negated shorthands *inside* a class (`[\D]`) to plain ranges,
+ * since a class is the union of its members and per-member negation cannot be
+ * expressed in the run-length class table. #1912.
+ */
+export declare function complementRanges(ranges: Array<[number, number]>): Array<[number, number]>;
+export declare function parsePattern(pattern: string, flags?: number): ParsedRegex;

package/dist/codegen/regex/unicode.d.ts

@@ -0,0 +1,42 @@
+import { ReNode } from './parse.js';
+/** Inclusive code-point ranges, sorted and coalesced. */
+export type CpRanges = Array<[number, number]>;
+/**
+ * Enumerate the exact code-point membership of a class-like atom under the
+ * given flag string (must include `u` or `v`; may include `i`). `source` is
+ * the literal pattern text of the atom: `[...]` (negation included), a
+ * `\p{…}`/`\P{…}` escape, or a single (escaped) character.
+ *
+ * Throws `RegexUnsupportedError` when the host rejects the source (the
+ * caller's host-oracle pass should have caught genuinely invalid patterns
+ * already) or when the atom can match strings (`\q{…}`).
+ */
+export declare function enumerateClassRanges(source: string, flagStr: string): CpRanges;
+/**
+ * Parse the body of a v-mode `\q{…}` string disjunction (§22.2.1
+ * ClassStringDisjunction) into its `|`-separated operands, each resolved to its
+ * sequence of code points. `qBody` is the text BETWEEN the braces (the caller
+ * has already stripped `\q{` and the closing `}`).
+ *
+ * Each operand is a `ClassString` = a list of `ClassSetCharacter`s. Inside the
+ * disjunction the only structural metacharacters are `|` (operand separator)
+ * and `\` (escape); every other source character — including `.`, `*`, `(`,
+ * `[`, `{` — is a LITERAL code point. The empty operand (`\q{}` or an empty arm
+ * of `\q{|a}`) yields a zero-length code-point array (matches the empty
+ * string).
+ *
+ * Returns one `number[]` (code points) per operand. Throws
+ * `RegexUnsupportedError` on a malformed escape so the caller's refusal stays
+ * loud rather than emitting a wrong node.
+ */
+export declare function parseStringDisjunction(qBody: string): number[][];
+/**
+ * Desugar a code-point range set into the unit-level AST (see module doc).
+ * The result consumes exactly one CODE POINT (1 or 2 units) per match, so
+ * quantifiers wrapped around it iterate by code point as `u` requires.
+ */
+export declare function cpRangesToNode(ranges: CpRanges): ReNode;
+/** Code-point ranges for `.` in u/v mode (static — no host needed). */
+export declare function dotCpRanges(dotAll: boolean): CpRanges;
+/** Escape a code point as a class-safe `\u{…}` source fragment. */
+export declare function codePointSource(cp: number): string;

package/dist/codegen/regex/vm.d.ts

@@ -0,0 +1,24 @@
+/** Matches the Wasm VM's step cap. Tunable; documented in the issue. */
+export declare const REGEX_STEP_CAP = 1000000;
+export interface VmMatch {
+    /** Capture slots: `[g0start,g0end,g1start,g1end,…]`; -1 = unset. */
+    caps: Int32Array;
+}
+/**
+ * Run `prog` against `input` starting at `startIdx`. Returns the filled
+ * capture array on a match (anchored at `startIdx`), or null on no match /
+ * step-cap exceeded. This is a single anchored attempt — callers (test/exec/
+ * match) drive the start position scan.
+ *
+ * #1911: `entryPc` selects the (sub-)program to run, `dir` the scan direction
+ * (-1 for lookbehind bodies), and `capsIn` seeds the capture state for
+ * recursive lookaround attempts (copy-on-write — the caller's array is never
+ * mutated; adopt the RETURNED array to observe sub-captures).
+ */
+export declare function runAt(prog: number[], classTable: number[], nGroups: number, input: string, startIdx: number, entryPc?: number, dir?: number, capsIn?: Int32Array, nScratch?: number): Int32Array | null;
+/**
+ * Full search: scan start positions `startIdx..len` (sticky callers pass a
+ * pre-clamped range via a single `runAt`). Returns the first match's caps or
+ * null.
+ */
+export declare function search(prog: number[], classTable: number[], nGroups: number, input: string, startIdx: number, sticky: boolean, nScratch?: number): Int32Array | null;

package/dist/codegen/regexp-standalone.d.ts

@@ -0,0 +1,350 @@
+import { ts } from '../ts-api.js';
+import { ValType } from '../ir/types.js';
+import { CodegenContext, FunctionContext } from './context/types.js';
+import { InnerResult } from './shared.js';
+export declare const STANDALONE_REGEXP_ABI_VERSION = 1;
+export declare const STANDALONE_REGEXP_ENGINE_KIND: "quickjs-libregexp";
+export declare const STANDALONE_REGEXP_SUBSET_ENGINE_KIND: "native-literal-substring";
+export type StandaloneRegExpEngineKind = typeof STANDALONE_REGEXP_ENGINE_KIND | typeof STANDALONE_REGEXP_SUBSET_ENGINE_KIND;
+export interface StandaloneRegExpAbiFunction {
+    /**
+     * Function name expected in the generated module. These are in-module
+     * symbols, not `env` JS-host imports.
+     */
+    name: string;
+    params: readonly ValType[];
+    results: readonly ValType[];
+}
+export interface StandaloneRegExpEngineConfig {
+    kind: StandaloneRegExpEngineKind;
+    abiVersion: typeof STANDALONE_REGEXP_ABI_VERSION;
+    functions: typeof STANDALONE_REGEXP_ABI;
+}
+export interface StandaloneRegExpEngineState {
+    standaloneRegExpEngine?: StandaloneRegExpEngineConfig | null;
+}
+/**
+ * Minimal ABI boundary for the first native engine slice. Lowering code should
+ * only query this contract after #1474's refusal gate is opened.
+ */
+export declare const STANDALONE_REGEXP_ABI: {
+    readonly compile: {
+        readonly name: "__re_compile";
+        readonly params: readonly [{
+            readonly kind: "i32";
+        }, {
+            readonly kind: "i32";
+        }, {
+            readonly kind: "i32";
+        }];
+        readonly results: readonly [{
+            readonly kind: "i32";
+        }];
+    };
+    readonly exec: {
+        readonly name: "__re_exec";
+        readonly params: readonly [{
+            readonly kind: "i32";
+        }, {
+            readonly kind: "i32";
+        }, {
+            readonly kind: "i32";
+        }, {
+            readonly kind: "i32";
+        }];
+        readonly results: readonly [{
+            readonly kind: "i32";
+        }];
+    };
+    readonly free: {
+        readonly name: "__re_free";
+        readonly params: readonly [{
+            readonly kind: "i32";
+        }];
+        readonly results: readonly [];
+    };
+    readonly groupStart: {
+        readonly name: "__re_group_start";
+        readonly params: readonly [{
+            readonly kind: "i32";
+        }, {
+            readonly kind: "i32";
+        }];
+        readonly results: readonly [{
+            readonly kind: "i32";
+        }];
+    };
+    readonly groupEnd: {
+        readonly name: "__re_group_end";
+        readonly params: readonly [{
+            readonly kind: "i32";
+        }, {
+            readonly kind: "i32";
+        }];
+        readonly results: readonly [{
+            readonly kind: "i32";
+        }];
+    };
+};
+export declare function quickJsLibRegexpEngineConfig(): StandaloneRegExpEngineConfig;
+export declare function nativeLiteralRegExpEngineConfig(): StandaloneRegExpEngineConfig;
+export declare function getStandaloneRegExpEngine(state: StandaloneRegExpEngineState): StandaloneRegExpEngineConfig | null;
+export declare function hasStandaloneRegExpEngine(state: StandaloneRegExpEngineState): boolean;
+export declare function isGlobalRegExpIdentifier(ctx: CodegenContext, ident: ts.Identifier): boolean;
+export declare function isGlobalRegExpType(type: ts.Type): boolean;
+/**
+ * EscapeRegExpPattern (ECMA-262 §22.2.6.13.1), computed at compile time —
+ * standalone patterns are always static. The escaped form must let
+ * `"/" + escaped + "/" + flags` reparse as an equivalent
+ * RegularExpressionLiteral:
+ * - empty pattern → `"(?:)"` (a bare `//` would lex as a comment);
+ * - unescaped `/` outside a class → `\/` (escaped or in-class occurrences
+ *   already reparse);
+ * - LineTerminators → their escape sequences (they can enter via
+ *   `new RegExp("\n")` and would terminate the literal otherwise).
+ */
+export declare function escapeRegExpPattern(pattern: string): string;
+export declare function compileStandaloneRegExpLiteral(ctx: CodegenContext, fctx: FunctionContext, pattern: string, flags: string, node: ts.Node): ValType | null;
+export declare function compileStandaloneRegExpConstructor(ctx: CodegenContext, fctx: FunctionContext, args: readonly ts.Expression[], node: ts.Node): ValType | null;
+/**
+ * (#2175 S1) Brand-recovery prologue for a *dynamic* (externref) RegExp `this`.
+ *
+ * The reflective forms — `RegExp.prototype.test.call(re, s)`,
+ * `re[Symbol.match](s)`, the `flags`-getter via a property descriptor — receive
+ * the receiver as an opaque externref through a closure call, so there is no
+ * receiver *expression* to brand-narrow at a syntactic site. This helper does
+ * the identical externref→`$NativeRegExp` narrowing that the static fast path's
+ * `loadStandaloneRegExpStruct` performs on an expression (the
+ * `any.convert_extern` + `ref.test` + `ref.cast` body), but driven from a local
+ * holding the externref `this`. On a non-RegExp `this` it throws a **catchable
+ * `TypeError`** (§22.2.6.4.1 RegExpHasFlag step 2) via the shared exception-tag
+ * path — never a raw `ref.cast` trap (mirrors #2100 M2).
+ *
+ * Leaves nothing on the stack; returns the local holding the cast struct and the
+ * struct type index for the caller's field reads / engine calls. Returns `null`
+ * only if the standalone RegExp struct can't be registered (defensive — it
+ * always can under standalone).
+ */
+export declare function recoverRegExpStructFromExternref(ctx: CodegenContext, fctx: FunctionContext, thisExternLocal: number): {
+    regexpLocal: number;
+    structTypeIdx: number;
+} | null;
+export declare function tryCompileStandaloneRegExpTest(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression, propAccess: ts.PropertyAccessExpression): InnerResult | undefined;
+/**
+ * `RegExp.prototype.exec(str)` in standalone mode (#1539 Phase 2b).
+ *
+ * This slice materializes the capture array for backend-created static RegExp
+ * values with non-global/non-sticky flags. `g`/`y` require observable
+ * `lastIndex` mutation and stay refused until the dedicated lastIndex slice.
+ */
+export declare function tryCompileStandaloneRegExpExec(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression, propAccess: ts.PropertyAccessExpression): InnerResult | undefined;
+/**
+ * `String.prototype.search(regexp)` in standalone mode (#1539 Phase 2b).
+ *
+ * Per ECMA-262 §22.1.3.13 + §22.2.6.13 (`RegExp.prototype[@@search]`): search
+ * sets `lastIndex` to 0, runs `RegExpExec`, then restores `lastIndex`, returning
+ * the match's `.index` or `-1` on no match. It is unaffected by the `g` flag and
+ * never advances. Here the subject (string) is the receiver and the RegExp is
+ * the argument: `"abc".search(/b/)`. The argument must be a backend-created
+ * static RegExp; a string argument (which the spec coerces to `new RegExp(arg)`)
+ * stays a narrowed refusal in standalone for this slice.
+ *
+ * Returns f64 (the index, or -1). `caps[0]` holds the whole-match start.
+ * Never returns `VOID_RESULT`, so the type stays `ValType | null | undefined`
+ * to match the `compileNativeStringMethodCall` caller contract.
+ */
+export declare function tryCompileStandaloneStringSearch(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression, propAccess: ts.PropertyAccessExpression): ValType | null | undefined;
+/**
+ * `String.prototype.match(regexp)` in standalone mode (#1539 Phase 2b).
+ *
+ * Non-global static RegExp arguments share the same result shape as `.exec`.
+ * Global `match` returns an all-matches array and sticky/global lastIndex
+ * details are intentionally left to the next capture-array slice.
+ */
+export declare function tryCompileStandaloneStringMatch(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression, propAccess: ts.PropertyAccessExpression): ValType | null | undefined;
+/**
+ * `String.prototype.matchAll(/re/g)` in standalone mode (#2161).
+ *
+ * §22.1.3.13 / §22.2.6.9: returns a RegExpStringIterator yielding the **full
+ * match array** (with capture groups, `.index`, `.input`) for every match. The
+ * native engine already builds per-match arrays via `__regex_capture_array`
+ * (used by `exec` / non-global `match`); `__regex_match_all_arrays` drives the
+ * eager AdvanceStringIndex loop collecting those capture-arrays into a vec. The
+ * vec is iterable by the native-vec for-of / spread consumers (#2169), so
+ * `for (const m of s.matchAll(re))` and `[...s.matchAll(re)]` both work without
+ * a JS host.
+ *
+ * Narrowed slice: requires a static global (`g`) RegExp value. matchAll on a
+ * non-global regex is a runtime TypeError (§22.1.3.13 step 4.a) — left to the
+ * host/refusal path rather than mis-modelled. String-arg coercion
+ * (`s.matchAll("x")` → `new RegExp("x","g")`) and dynamic flags fall through.
+ */
+export declare function tryCompileStandaloneStringMatchAll(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression, propAccess: ts.PropertyAccessExpression): ValType | null | undefined;
+/**
+ * `String.prototype.replace(re, "str")` / `String.prototype.replaceAll(re,
+ * "str")` in standalone mode (#1539 Phase 2c) — **literal replacement string
+ * only**.
+ *
+ * Per ECMA-262 §22.1.3.19 / §22.2.6.11 (`RegExp.prototype[@@replace]`): walk
+ * the subject, replacing each match (all matches when the regex has the `g`
+ * flag or the method is `replaceAll`; otherwise just the first) with the
+ * replacement string, returning the rebuilt string. The result is a
+ * `$NativeString` — no array boundary, no host import.
+ *
+ * Refused (left to the narrowed gate): `$n`/`$&`/`$\``/`$'`/`$<name>`
+ * substitution patterns and function replacers (Phase 2c follow-up — they need
+ * capture-group materialization / closure dispatch), and `replaceAll` with a
+ * non-global regex (which is a runtime `TypeError` per spec; let the host path
+ * handle that diagnostic rather than mis-modelling it here).
+ */
+export declare function tryCompileStandaloneStringReplace(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression, propAccess: ts.PropertyAccessExpression): ValType | null | undefined;
+/**
+ * `String.prototype.split(re)` in standalone mode (#1539 Phase 2c) —
+ * non-capturing, non-nullable static RegExp separator only.
+ *
+ * Capturing-group split has extra result interleaving semantics, and nullable
+ * separators need the full SplitMatch/AdvanceStringIndex edge-case handling.
+ * Both stay narrowed refusals until the capture-array/string-method follow-up.
+ */
+export declare function tryCompileStandaloneStringSplit(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression, propAccess: ts.PropertyAccessExpression): ValType | null | undefined;
+/**
+ * `re[Symbol.match](str)` / `re[Symbol.matchAll](str)` / `re[Symbol.search](str)`
+ * — the explicit well-known-symbol protocol forms (§22.2.6) — in standalone
+ * mode (#2161).
+ *
+ * These are the operand-swapped duals of `String.prototype.match/matchAll/
+ * search`: the RegExp is the **receiver** and the string is the **argument**.
+ * The native engine is operand-order agnostic (the lower-level emitters take an
+ * explicit regex expression + subject expression), so each method reuses the
+ * exact same core that backs the corresponding String.prototype method — there
+ * is no separate engine path and no host import.
+ *
+ * Gating mirrors the String.prototype path: the receiver must be a static /
+ * backend-created RegExp value (so the pattern + flags are known at compile
+ * time) and the (first) argument must be string-like. Dynamic-flag receivers
+ * and string-coercion arguments return `undefined`, so the caller falls through
+ * to the existing `__regex_symbol_call` host import (JS-host mode) or the
+ * standalone refusal.
+ *
+ * `@@replace` / `@@split` carry a second operand (replacement / limit). They
+ * reuse the same operand-explicit cores as `String.prototype.replace`/`split`
+ * with the operands swapped (regex = receiver, subject = arg[0]).
+ *
+ * `methodName` is the `@@<id>` sentinel the element-access dispatcher resolved
+ * for the computed Symbol key (e.g. `"@@match"`).
+ */
+export declare function tryCompileStandaloneRegExpSymbolCall(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression, regexExpr: ts.Expression, methodName: string): ValType | null | undefined;
+/**
+ * The property names the standalone backend answers natively on RegExp
+ * receivers. The import scan in index.ts consults this set so it never
+ * registers an `env.RegExp_get_*` host import for these reads under
+ * `--target standalone` (the acceptance criterion of #1914: no `env.RegExp_*`
+ * leaks). Keep in sync with {@link tryCompileStandaloneRegExpPropertyRead}.
+ */
+export declare const STANDALONE_REGEXP_REFLECTION_PROPS: ReadonlySet<string>;
+/**
+ * Property READS on standalone RegExp receivers (#1914).
+ *
+ * - `.source` → struct field 4 (stored pre-escaped per §22.2.6.13.1).
+ * - `.flags` → `__regex_flags_str(flags)` building the d-g-i-m-s-u-v-y string
+ *   from the bitfield (§22.2.6.4).
+ * - flag booleans (`.global`, `.ignoreCase`, …) → `(flags & bit) != 0`
+ *   (§22.2.6.5–.12 RegExpHasFlag).
+ * - `.lastIndex` → struct field 5 (f64).
+ *
+ * Returns `undefined` when the receiver/property is not a standalone RegExp
+ * reflection read (caller falls through), `null` after reporting a narrowed
+ * refusal, or the result ValType.
+ */
+export declare function tryCompileStandaloneRegExpPropertyRead(ctx: CodegenContext, fctx: FunctionContext, expr: ts.PropertyAccessExpression): ValType | null | undefined;
+/**
+ * Shared core for §22.2.6.14 `RegExp.prototype.toString()` rendering of a
+ * static / backend-created RegExp *receiver expression* — `"/" + source + "/" +
+ * flags` — emitting a native string with ZERO host imports.
+ *
+ * The spec result is `"/" + R.[[OriginalSource]] + "/" + R.[[OriginalFlags]]`,
+ * both of which the native backend already produces (the struct's `source`
+ * field is stored in the spec-escaped §22.2.6.13.1 form, and `__regex_flags_str`
+ * builds the d-g-i-m-s-u-v-y flag string). In standalone / nativeStrings mode
+ * there is no JS host, so the generic ref→string coercion path leaked
+ * `env::Object_toString` (or null-deref'd). This composes the two native field
+ * reads with `__str_concat`.
+ *
+ * Used by the `re.toString()` method dispatch (`tryCompileStandaloneRegExpToString`)
+ * AND by the value→string coercion paths (`String(re)`, `` `${re}` ``) which
+ * would otherwise null-deref or yield `"[object Object]"` (#2161).
+ *
+ * Returns the emitted native-string `ValType`, `null` after a reported refusal
+ * (e.g. a non-backend RegExp), or `undefined` when the expression is not a
+ * static / backend-created RegExp the caller should keep falling through for.
+ */
+export declare function emitStandaloneRegExpToStringFromExpr(ctx: CodegenContext, fctx: FunctionContext, regexpExpr: ts.Expression): ValType | null | undefined;
+export declare function tryCompileStandaloneRegExpToString(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression, propAccess: ts.PropertyAccessExpression): ValType | null | undefined;
+/**
+ * (#2175 S1) Shared RegExp reflection field-read sequence, factored out of
+ * `tryCompileStandaloneRegExpPropertyRead` so the native-method-getter closures
+ * (#2175) emit the *identical* getter body off a recovered struct local. The
+ * caller has already pushed nothing on the stack; this helper pushes the
+ * `local.get regexpLocal` itself and the field read, returning the getter's
+ * result ValType. Static path callers route through here byte-for-byte.
+ */
+export declare function emitRegExpReflectionFieldRead(ctx: CodegenContext, fctx: FunctionContext, propName: string, regexpLocal: number, structTypeIdx: number): ValType;
+/**
+ * (#2175 S1) RegExp `.test` driven by a recovered struct local + a subject
+ * string local, for the native-method-closure body where there is no receiver
+ * *expression* (the reflective `RegExp.prototype.test.call(re, s)` /
+ * `re[Symbol.match]`-adjacent forms). Self-contained — does NOT route through
+ * `emitRegexSearchCall` (which is expression-driven) so the static fast path
+ * stays byte-identical. Returns the i32 match flag (1/0) on the stack.
+ *
+ * `subjStrLocal` holds a flattened native-string struct ref (the closure body
+ * flattens its externref arg before calling). The search starts at index 0 and
+ * honours stickiness like the non-g/y `.test` static path; lastIndex mutation
+ * for g/y reflective receivers is deferred (the dynamic receiver makes the
+ * static flag analysis unavailable — a conservative, spec-observable subset).
+ */
+export declare function emitRegExpTestFromLocals(ctx: CodegenContext, fctx: FunctionContext, regexpLocal: number, structTypeIdx: number, subjStrLocal: number): void;
+/** (#2175 S1) The standalone-RegExp struct type index, for the proto populator. */
+export declare function getStandaloneRegExpStructTypeIdx(ctx: CodegenContext): number;
+/**
+ * (#2175 S1) Register the RegExp builtin-prototype glue with the shared
+ * `native-proto` core. Idempotent — safe to call from every reflective entry.
+ * Returns the RegExp brand, or `undefined` if the brand band isn't available
+ * (defensive — it always is).
+ */
+export declare function ensureRegExpNativeProtoGlue(ctx: CodegenContext): number | undefined;
+/**
+ * `re.lastIndex = value` on a standalone RegExp receiver (#1914).
+ *
+ * [[LastIndex]] is a plain writable data property (§22.2.7.1); the struct
+ * stores it as f64. The spec defers coercion to exec's ToLength, so only
+ * numeric writes are accepted here — non-numeric RHS values are a narrowed
+ * refusal rather than a silently mis-modelled store. Leaves the RHS f64 on
+ * the stack (assignment-expression value).
+ */
+export declare function tryCompileStandaloneRegExpLastIndexWrite(ctx: CodegenContext, fctx: FunctionContext, target: ts.PropertyAccessExpression, value: ts.Expression): ValType | null | undefined;
+/**
+ * `.index` / `.input` reads on standalone exec/match results (#1914).
+ *
+ * The receiver's static TS type (`RegExpExecArray` / `RegExpMatchArray`) is
+ * the routing signal; the runtime value is the `$__regexp_match_vec` subtype
+ * every standalone exec/match constructs (`__regex_capture_array`). Receivers
+ * statically typed as the base nstr vec are `ref.cast` down — construction
+ * provenance guarantees the cast succeeds; a null result traps, matching the
+ * TypeError a member read on `null` must produce.
+ */
+export declare function tryCompileStandaloneRegExpMatchResultRead(ctx: CodegenContext, fctx: FunctionContext, expr: ts.PropertyAccessExpression): ValType | null | undefined;
+/**
+ * Module-global type inference for `var m = re.exec(s)` under standalone
+ * (#1914). Without this the global widens to externref and indexed reads
+ * route through the native `__extern_get_idx`, which only recognises the
+ * open-object `$ObjVec` — a typed match-vec read back from externref returns
+ * null and the comparison traps in `__str_flatten` (the
+ * `null_deref __str_flatten` test262 bucket).
+ *
+ * Returns `ref_null $__regexp_match_vec` only when the initializer is a
+ * backend exec/match call AND every other write to the var in the file is
+ * also one (or null/undefined) — any foreign write keeps the externref
+ * widening so the precise global type can never reject a store.
+ */
+export declare function inferStandaloneRegExpMatchGlobalType(ctx: CodegenContext, decl: ts.VariableDeclaration): ValType | null;

package/dist/codegen/registry/error-types.d.ts

@@ -0,0 +1,38 @@
+import { CodegenContext } from '../context/types.js';
+/**
+ * The 8 built-in JS Error constructors that Phase 1 supports as Wasm-native
+ * struct construction in WASI mode. Order matches the order in which test262
+ * tests typically reference them.
+ */
+declare const WASI_ERROR_NAMES: readonly ["Error", "TypeError", "RangeError", "SyntaxError", "URIError", "EvalError", "ReferenceError", "AggregateError"];
+export type WasiErrorName = (typeof WASI_ERROR_NAMES)[number];
+/** Returns true if `name` is one of the 8 Error constructors handled by Phase 1. */
+export declare function isWasiErrorName(name: string): name is WasiErrorName;
+/**
+ * Get or register the `$Error_struct` WasmGC type. Idempotent — returns the
+ * cached type index on subsequent calls.
+ */
+export declare function getOrRegisterErrorStructType(ctx: CodegenContext): number;
+/**
+ * Emit an internal Wasm function `__new_<errorName>` that constructs a new
+ * `$Error_struct` and returns it as externref. The function takes `argCount`
+ * externref params (the constructor arguments seen at call sites — typically
+ * 0 or 1 for `new Error(msg)`).
+ *
+ * Idempotent — does nothing if `__new_<errorName>` is already registered
+ * (whether as a host import or a previously-emitted internal function).
+ *
+ * #1536 Phase 2 — the `$name` field is now materialized with the error
+ * class's name string ("Error" / "TypeError" / …) instead of the Phase-1
+ * `ref.null extern` placeholder, so `err.name` reads the correct value in
+ * standalone mode (the property-access fast path in `property-access.ts`
+ * already does `struct.get $Error_struct[2]` for `.name` under
+ * `ctx.wasi || ctx.standalone`). The constant is materialized via the
+ * shared `stringConstantExternrefInstrs` dual-mode helper: nativeStrings
+ * mode builds the FlatString struct inline + `extern.convert_any`;
+ * host-strings mode emits a `global.get` of the interned string constant.
+ * The string is registered via `addStringConstantGlobal` first so the
+ * helper finds it in `ctx.stringGlobalMap`.
+ */
+export declare function emitWasiErrorConstructor(ctx: CodegenContext, errorName: WasiErrorName, argCount: number): void;
+export {};