@scriptc/compiler 0.2.4 → 0.2.5

package/dist/frontend/lowering/lower-exprs.d.ts

@@ -74,45 +74,45 @@ export declare function lowerExpr(lowerer: Lowerer, expr: ts.Expression): IrExpr
  * type and the contextual/sibling rules below. */
 export declare function lowerTernary(lowerer: Lowerer, expr: ts.ConditionalExpression, expected?: IrType): IrExpr;
 /** Checker-driven union narrowing. tsc's control-flow analysis narrows a
-   * union-typed reference at use sites (`if (r.kind === "ok") { ...r... }`
-   * types `r` as the ok-arm inside the branch); the IR value is still the
-   * tagged union, so the read is bridged with a `unionNarrow` extracting
-   * the arm's payload. The extraction is tag-UNCHECKED at runtime —
-   * soundness rests entirely on tsc having proven the tag (the project's
-   * trust-the-checker thesis; see docs/ir.md). A checker type that maps to
-   * the same union (unnarrowed use), to a SUB-union (partial narrowing —
-   * unrepresentable without a re-tag), or to nothing (`never` in an
-   * exhaustive default) leaves the expression union-typed. */
+ * union-typed reference at use sites (`if (r.kind === "ok") { ...r... }`
+ * types `r` as the ok-arm inside the branch); the IR value is still the
+ * tagged union, so the read is bridged with a `unionNarrow` extracting
+ * the arm's payload. The extraction is tag-UNCHECKED at runtime —
+ * soundness rests entirely on tsc having proven the tag (the project's
+ * trust-the-checker thesis; see docs/ir.md). A checker type that maps to
+ * the same union (unnarrowed use), to a SUB-union (partial narrowing —
+ * unrepresentable without a re-tag), or to nothing (`never` in an
+ * exhaustive default) leaves the expression union-typed. */
 export declare function maybeNarrow(lowerer: Lowerer, expr: IrExpr, node: ts.Node): IrExpr;
 /** `v === undefined` / `v !== null` — the narrowing tests for unit-armed
-   * unions. A union operand compared with a unit literal lowers to a
-   * runtime TAG test (unionIsTag); afterwards tsc's control-flow narrowing
-   * types the branches and reads bridge through maybeNarrow as usual. When
-   * the checker already narrowed the non-literal side PAST the union
-   * (`w = 5; if (w !== null)`), the comparison is statically decided and
-   * folds to a bool literal — that drops only a side-effect-free read
-   * (flow narrowing applies to references, never to calls), and soundness
-   * is the same trust-the-checker bet unionNarrow already makes. Null when
-   * neither side is a unit literal (not a unit comparison). */
+ * unions. A union operand compared with a unit literal lowers to a
+ * runtime TAG test (unionIsTag); afterwards tsc's control-flow narrowing
+ * types the branches and reads bridge through maybeNarrow as usual. When
+ * the checker already narrowed the non-literal side PAST the union
+ * (`w = 5; if (w !== null)`), the comparison is statically decided and
+ * folds to a bool literal — that drops only a side-effect-free read
+ * (flow narrowing applies to references, never to calls), and soundness
+ * is the same trust-the-checker bet unionNarrow already makes. Null when
+ * neither side is a unit literal (not a unit comparison). */
 export declare function lowerUnitComparison(lowerer: Lowerer, left: IrExpr, right: IrExpr, negated: boolean, loc: SrcLoc): IrExpr | null;
 /** `a ?? b` — JS-exact nullish coalescing: ONLY null/undefined take the
-   * default (0, "", and false do not), and the right side evaluates lazily.
-   * On a unit-armed union left this is the `nullish` node (a runtime tag
-   * test against the unit arms, docs/ir.md); the two lowered shapes follow
-   * the checker's result type — pass-through (`(s: string | undefined) ??
-   * t` with t also `string | undefined`) and narrowed (`s ?? "d"` → plain
-   * string, the single non-unit arm). A left the checker types non-nullish
-   * never takes the right side, so the whole expression folds to the left
-   * value — dropping only the never-evaluated default, the same
-   * trust-the-checker bet as lowerUnitComparison's static fold. Sub-union
-   * results (several non-unit arms) and defaults that change the result
-   * type are fenced with narrow-first hints. */
+ * default (0, "", and false do not), and the right side evaluates lazily.
+ * On a unit-armed union left this is the `nullish` node (a runtime tag
+ * test against the unit arms, docs/ir.md); the two lowered shapes follow
+ * the checker's result type — pass-through (`(s: string | undefined) ??
+ * t` with t also `string | undefined`) and narrowed (`s ?? "d"` → plain
+ * string, the single non-unit arm). A left the checker types non-nullish
+ * never takes the right side, so the whole expression folds to the left
+ * value — dropping only the never-evaluated default, the same
+ * trust-the-checker bet as lowerUnitComparison's static fold. Sub-union
+ * results (several non-unit arms) and defaults that change the result
+ * type are fenced with narrow-first hints. */
 export declare function lowerNullishCoalesce(lowerer: Lowerer, expr: ts.BinaryExpression, loc: SrcLoc): IrExpr;
 /** A CONDITION-position expression: the result is consumed as a bool
-   * only, so `&&`/`||` descend recursively over ToBoolean'd operands —
-   * JS-exact (`ToBoolean(a && b)` ≡ `ToBoolean(a) && ToBoolean(b)`), still
-   * short-circuiting, and mixed operand kinds that have no VALUE
-   * representation (`u && flag` — a union and a bool) test fine here. */
+ * only, so `&&`/`||` descend recursively over ToBoolean'd operands —
+ * JS-exact (`ToBoolean(a && b)` ≡ `ToBoolean(a) && ToBoolean(b)`), still
+ * short-circuiting, and mixed operand kinds that have no VALUE
+ * representation (`u && flag` — a union and a bool) test fine here. */
 export declare function lowerCondition(lowerer: Lowerer, expr: ts.Expression): IrExpr;
 export declare function runtimeOptionalTrueIds(lowerer: Lowerer, node: ts.Expression): IrLocal[];
 /** Presence proved by one outcome of a boolean guard. Negation flips
@@ -122,36 +122,36 @@ export declare function runtimeOptionalTrueIds(lowerer: Lowerer, node: ts.Expres
 export declare function runtimeOptionalGuardIds(lowerer: Lowerer, node: ts.Expression, truthy: boolean | null): IrLocal[];
 export declare function withRuntimeOptionalNarrowed<T>(lowerer: Lowerer, locals: readonly IrLocal[], fn: () => T): T;
 /** JS ToBoolean: bool passes through; f64/string get a `toBool` wrapper
-   * (falsy: 0, -0, NaN, ""); unions get the same wrapper answered by a
-   * per-union interned helper (unit arms falsy; scalar/string arms by
-   * value; ref arms always truthy). Anything else (void) cannot be
-   * tested. */
+ * (falsy: 0, -0, NaN, ""); unions get the same wrapper answered by a
+ * per-union interned helper (unit arms falsy; scalar/string arms by
+ * value; ref arms always truthy). Anything else (void) cannot be
+ * tested. */
 export declare function ensureBool(lowerer: Lowerer, e: IrExpr, node: ts.Expression): IrExpr;
 /** Truthiness needs a ToBoolean per arm: dyn/caught arms have none (a
-   * dynamic ToBoolean over the checked-dynamic tree / the snapshot box) — fence those
-   * unions; every other arm kind is answerable (units false, scalars and
-   * strings by value, refs true, jsval by the engine). */
+ * dynamic ToBoolean over the checked-dynamic tree / the snapshot box) — fence those
+ * unions; every other arm kind is answerable (units false, scalars and
+ * strings by value, refs true, jsval by the engine). */
 export declare function requireTruthyUnion(lowerer: Lowerer, unionId: string, node: ts.Expression): void;
 /** Strict equality needs a per-arm comparison: units, scalars, strings,
-   * and ref kinds (pointer identity) all have one; dyn/caught arms have no
-   * static equality and jsval arms would need the engine's `===` — those
-   * unions keep the narrow-first fence. */
+ * and ref kinds (pointer identity) all have one; dyn/caught arms have no
+ * static equality and jsval arms would need the engine's `===` — those
+ * unions keep the narrow-first fence. */
 export declare function eqComparableUnion(lowerer: Lowerer, unionId: string): boolean;
 /** Property access on a string or array receiver: `.length` lowers to the
-   * matching intrinsic; a bare method reference (`const f = s.slice` — a
-   * function value) is rejected with a specific message. Returns null for
-   * other receivers (the generic property-access rejection applies). Both
-   * the receiver type AND the ambient-file provenance of the member are
-   * verified — the name alone proves nothing. */
+ * matching intrinsic; a bare method reference (`const f = s.slice` — a
+ * function value) is rejected with a specific message. Returns null for
+ * other receivers (the generic property-access rejection applies). Both
+ * the receiver type AND the ambient-file provenance of the member are
+ * verified — the name alone proves nothing. */
 export declare function lowerIntrinsicProperty(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
 /** `[a, b, c]`. The element type comes from the contextual type when tsc
-   * has one (`const a: number[] = []`, arguments, nested literals) and from
-   * the literal's own inferred type otherwise. A bare `[]` with no context
-   * is `never[]` — unmappable, rejected with the component fence (SC2009). `expected` overrides
-   * the contextual lookup where the caller knows the slot's array type and
-   * tsc's API doesn't surface it (ternary arms under an array context —
-   * tsc accepts the arm covariantly, but a tagged element representation
-   * must be BUILT as the slot's element type). */
+ * has one (`const a: number[] = []`, arguments, nested literals) and from
+ * the literal's own inferred type otherwise. A bare `[]` with no context
+ * is `never[]` — unmappable, rejected with the component fence (SC2009). `expected` overrides
+ * the contextual lookup where the caller knows the slot's array type and
+ * tsc's API doesn't surface it (ternary arms under an array context —
+ * tsc accepts the arm covariantly, but a tagged element representation
+ * must be BUILT as the slot's element type). */
 export declare function lowerArrayLiteral(lowerer: Lowerer, expr: ts.ArrayLiteralExpression, expected?: (IrType & {
     kind: "array";
 }) | (IrType & {
@@ -162,23 +162,23 @@ export declare function lowerArrayLiteral(lowerer: Lowerer, expr: ts.ArrayLitera
  * so compounds and binary arithmetic use this checked one-time extraction. */
 export declare function lowerOptionalNumber(lowerer: Lowerer, operand: IrExpr, loc: SrcLoc, narrowedNode?: ts.Expression): IrExpr;
 /** `a[i]` reads. Only f64 indices into array receivers are modeled; JS
-   * string-key element access (`a["length"]`) and string indexing (`s[0]`
-   * typechecks against the lib's index signature; use .charAt) stay out. */
+ * string-key element access (`a["length"]`) and string indexing (`s[0]`
+ * typechecks against the lib's index signature; use .charAt) stay out. */
 export declare function lowerElementAccess(lowerer: Lowerer, expr: ts.ElementAccessExpression): IrExpr;
 /** `r[k]` over a (non-tuple) record shape. A LITERAL key naming a declared
-   * field is the bracket spelling of field access (the ONLY spelling tsc
-   * permits for signature-declared fields under
-   * noPropertyAccessFromIndexSignature) — an ordinary recordGet. Everything
-   * else is a runtime-keyed read (recordKeyGet): declared fields answer
-   * first via an emitted string-switch, index-signature shapes fall through
-   * to the overflow map. The result type is the CHECKER's for the access —
-   * the index signature's value type (dyn for `unknown`), or its
-   * undefined-armed union under noUncheckedIndexedAccess. Every declared
-   * field must be able to SURFACE as that type (equal, an arm of it, or —
-   * for dyn results — JSON-safe for the dyn conversion); shapes mixing in
-   * fields outside that stay fenced. Declared-only shapes support reads
-   * whose key type proves membership (tsc's keyof check): all fields must
-   * share the result type, and a smuggled miss traps. */
+ * field is the bracket spelling of field access (the ONLY spelling tsc
+ * permits for signature-declared fields under
+ * noPropertyAccessFromIndexSignature) — an ordinary recordGet. Everything
+ * else is a runtime-keyed read (recordKeyGet): declared fields answer
+ * first via an emitted string-switch, index-signature shapes fall through
+ * to the overflow map. The result type is the CHECKER's for the access —
+ * the index signature's value type (dyn for `unknown`), or its
+ * undefined-armed union under noUncheckedIndexedAccess. Every declared
+ * field must be able to SURFACE as that type (equal, an arm of it, or —
+ * for dyn results — JSON-safe for the dyn conversion); shapes mixing in
+ * fields outside that stay fenced. Declared-only shapes support reads
+ * whose key type proves membership (tsc's keyof check): all fields must
+ * share the result type, and a smuggled miss traps. */
 export declare function lowerRecordKeyRead(lowerer: Lowerer, expr: ts.ElementAccessExpression, shapeId: string, shape: IrRecordShape, includeUndefined?: boolean): IrExpr;
 /** A keyed read used only to observe absence (`if (map[k])`, or the left
  * side of `||`/`??`). JavaScript answers undefined for missing record keys
@@ -203,24 +203,24 @@ export declare function lowerElementWrite(lowerer: Lowerer, expr: ts.BinaryExpre
 export declare function lowerEnvironmentKey(lowerer: Lowerer, node: ts.Expression): IrExpr;
 export declare function ensureString(lowerer: Lowerer, e: IrExpr, node: ts.Node): IrExpr;
 /** `new String(x)` (stdlib provenance, ≤1 argument) in a ToString
-   * position: the wrapper's only distinguishers are typeof and identity —
-   * neither is observable where the value immediately stringifies — so the
-   * span lowers as the argument's own ToString (`new String()` is "").
-   * Every other position keeps the wrapper-object constructor fence. */
+ * position: the wrapper's only distinguishers are typeof and identity —
+ * neither is observable where the value immediately stringifies — so the
+ * span lowers as the argument's own ToString (`new String()` is "").
+ * Every other position keeps the wrapper-object constructor fence. */
 export declare function stringWrapperToString(lowerer: Lowerer, node: ts.Expression): IrExpr | null;
 export declare function lowerTemplate(lowerer: Lowerer, expr: ts.TemplateExpression): IrExpr;
 /** `x as T`. Non-dyn inner values ordinarily erase; a record assertion
-   * changing monomorphic shape rebuilds through the established width-copy
-   * path so its represented value agrees with its asserted type.
-   * A dyn ('unknown') inner value makes this THE dynamic boundary:
-   * - `as unknown` (dyn → dyn) stays erasure;
-   * - dyn → a JSON-representable target type T compiles to `dynCheck`, a
-   *   runtime validation that builds the typed value or THROWS a catchable
-   *   TypeError-flavored error (JS `as` never checks — the headline
-   *   documented divergence: a lying cast throws instead of corrupting
-   *   memory);
-   * - dyn → anything else (closures, class instances, void) is rejected:
-   *   those types cannot be found inside a JSON dyn. */
+ * changing monomorphic shape rebuilds through the established width-copy
+ * path so its represented value agrees with its asserted type.
+ * A dyn ('unknown') inner value makes this THE dynamic boundary:
+ * - `as unknown` (dyn → dyn) stays erasure;
+ * - dyn → a JSON-representable target type T compiles to `dynCheck`, a
+ *   runtime validation that builds the typed value or THROWS a catchable
+ *   TypeError-flavored error (JS `as` never checks — the headline
+ *   documented divergence: a lying cast throws instead of corrupting
+ *   memory);
+ * - dyn → anything else (closures, class instances, void) is rejected:
+ *   those types cannot be found inside a JSON dyn. */
 /** `e as T` and the old-style assertion `<T>e` — one node shape (both
  * carry `.type` and `.expression`), one lowering. */
 export declare function lowerAsExpression(lowerer: Lowerer, expr: ts.AsExpression | ts.TypeAssertion): IrExpr;
@@ -235,85 +235,85 @@ export declare function lowerCompoundValueToTarget(lowerer: Lowerer, expr: ts.Bi
 export declare function lowerBinary(lowerer: Lowerer, expr: ts.BinaryExpression): IrExpr;
 export declare function lowerCaughtTypeofTest(lowerer: Lowerer, expr: ts.BinaryExpression, loc: SrcLoc): IrExpr | null;
 /** ALIASED-TYPEOF narrowing (npm-static JS): the narrows a condition
-   * PROVES about typeof-aliased operands when it evaluates to `polarity` —
-   * ms's `var type = typeof val; if (type === 'string' && val.length > 0)`
-   * shape, which tsc narrows only for CONST aliases. The walk follows the
-   * checker's own condition structure: parens, `!`, `&&` under true, `||`
-   * under false, and ===/!== leaves against string literals. A leaf
-   * qualifies when the alias is a never-reassigned var/let/const local
-   * initialized `typeof <param>`, the operand is a never-written
-   * identifier PARAMETER of a function containing the test (so `typeof
-   * val` is a post-entry constant and the alias can never be stale — the
-   * condition itself still lowers as the plain string comparison), the
-   * operand's type maps to a union whose arms all have static typeof
-   * answers, and EXACTLY ONE arm answers the literal. The result feeds
-   * lowerer.narrowingAliases: branch-scoped typeOf overrides, bridged by
-   * maybeNarrow's ordinary unionNarrow. */
+ * PROVES about typeof-aliased operands when it evaluates to `polarity` —
+ * ms's `var type = typeof val; if (type === 'string' && val.length > 0)`
+ * shape, which tsc narrows only for CONST aliases. The walk follows the
+ * checker's own condition structure: parens, `!`, `&&` under true, `||`
+ * under false, and ===/!== leaves against string literals. A leaf
+ * qualifies when the alias is a never-reassigned var/let/const local
+ * initialized `typeof <param>`, the operand is a never-written
+ * identifier PARAMETER of a function containing the test (so `typeof
+ * val` is a post-entry constant and the alias can never be stale — the
+ * condition itself still lowers as the plain string comparison), the
+ * operand's type maps to a union whose arms all have static typeof
+ * answers, and EXACTLY ONE arm answers the literal. The result feeds
+ * lowerer.narrowingAliases: branch-scoped typeOf overrides, bridged by
+ * maybeNarrow's ordinary unionNarrow. */
 export declare function aliasTypeofNarrows(lowerer: Lowerer, cond: ts.Expression, polarity: boolean): {
     sym: ts.Symbol;
     tsArm: ts.Type;
 }[];
 /** A read of a catch binding — the caught analog of maybeNarrow. Where
-   * tsc's control-flow narrowing has proven a supported test (`instanceof`
-   * over a hierarchy class, `typeof` over a primitive), the read bridges
-   * with a kind-unchecked `caughtNarrow` extraction (trust-the-checker,
-   * exactly like unionNarrow). Every OTHER read is the narrowness fence:
-   * the binding's payload is a typed exception snapshot, not a dyn, so
-   * un-narrowed uses have nothing sound to lower to. */
+ * tsc's control-flow narrowing has proven a supported test (`instanceof`
+ * over a hierarchy class, `typeof` over a primitive), the read bridges
+ * with a kind-unchecked `caughtNarrow` extraction (trust-the-checker,
+ * exactly like unionNarrow). Every OTHER read is the narrowness fence:
+ * the binding's payload is a typed exception snapshot, not a dyn, so
+ * un-narrowed uses have nothing sound to lower to. */
 export declare function caughtRead(lowerer: Lowerer, node: ts.Identifier, local: IrLocal, loc: SrcLoc): IrExpr;
 /** `String(e)` / `${e}` where e is a catch binding: JS's String() over
-   * the exception snapshot (scr_caught_to_string) — the one un-narrowed
-   * read with a sound rendering for every payload kind. Intercepts BEFORE
-   * lowerExpr like the other caught lowerings (caughtRead would fence).
-   * Null when the expression isn't a catch binding. */
+ * the exception snapshot (scr_caught_to_string) — the one un-narrowed
+ * read with a sound rendering for every payload kind. Intercepts BEFORE
+ * lowerExpr like the other caught lowerings (caughtRead would fence).
+ * Null when the expression isn't a catch binding. */
 export declare function caughtToString(lowerer: Lowerer, node: ts.Expression): IrExpr | null;
 /** The catch-binding local an expression names, or null. The dedicated
-   * lowerings (instanceof, typeof tests, rethrow) intercept on this BEFORE
-   * lowering the operand — a raw lowerExpr of the identifier would hit
-   * caughtRead's fence. */
+ * lowerings (instanceof, typeof tests, rethrow) intercept on this BEFORE
+ * lowering the operand — a raw lowerExpr of the identifier would hit
+ * caughtRead's fence. */
 export declare function caughtLocalOf(lowerer: Lowerer, node: ts.Expression): IrLocal | null;
 /** `x instanceof C` for a program-declared class C. When x's static
-   * class and C are both in extends-hierarchies the test is dynamic — the
-   * O(1) preorder-interval check against the vtable (`instanceOf` node).
-   * Everything else is decided by the static class graph alone and folds
-   * to the honest constant: `x instanceof C` is always true when x's
-   * static class IS C or descends from it, and always false when the
-   * classes are unrelated (a standalone class has no other relatives).
-   * Folding is limited to side-effect-free operands — dropping a computed
-   * operand would skip its effects, so those are rejected instead. */
+ * class and C are both in extends-hierarchies the test is dynamic — the
+ * O(1) preorder-interval check against the vtable (`instanceOf` node).
+ * Everything else is decided by the static class graph alone and folds
+ * to the honest constant: `x instanceof C` is always true when x's
+ * static class IS C or descends from it, and always false when the
+ * classes are unrelated (a standalone class has no other relatives).
+ * Folding is limited to side-effect-free operands — dropping a computed
+ * operand would skip its effects, so those are rejected instead. */
 export declare function lowerInstanceOf(lowerer: Lowerer, expr: ts.BinaryExpression, loc: SrcLoc): IrExpr;
 /** A regex literal `/ab+c/gi` → regexLit (fresh state per evaluation,
-   * shared bytecode per (pattern, flags) pair). The TS parser has already syntax-checked the literal;
-   * what remains here is the flag-alphabet fence (d and v are
-   * declared-valid TS flags outside this slice). Named capture groups
-   * `(?<name>...)` and `\k<name>` backreferences compile — libregexp
-   * executes them natively, replace templates resolve `$<name>` at
-   * runtime, and `.groups` reads desugar at their access sites
-   * (matchResultNamedGroupsOf). The engine validates the pattern itself
-   * lazily at first use (SEMANTICS.md documents the divergence from
-   * Node's parse-time SyntaxError). */
+ * shared bytecode per (pattern, flags) pair). The TS parser has already syntax-checked the literal;
+ * what remains here is the flag-alphabet fence (d and v are
+ * declared-valid TS flags outside this slice). Named capture groups
+ * `(?<name>...)` and `\k<name>` backreferences compile — libregexp
+ * executes them natively, replace templates resolve `$<name>` at
+ * runtime, and `.groups` reads desugar at their access sites
+ * (matchResultNamedGroupsOf). The engine validates the pattern itself
+ * lazily at first use (SEMANTICS.md documents the divergence from
+ * Node's parse-time SyntaxError). */
 export declare function lowerRegexLiteral(lowerer: Lowerer, expr: ts.RegularExpressionLiteral): IrExpr;
 /** The named-group table of the regex that PRODUCED a match-result
-   * expression — the `.groups` desugar's provenance question. Traces
-   * (through parens, `!`, and const bindings):
-   *   - `re.exec(s)` / `s.match(re)`   → re's static pattern
-   *   - a matchAll ROW: `rows[i]`, the for-of binding over a direct
-   *     `s.matchAll(re)` or a stored const drain → re's static pattern
-   * Answers null when the producing regex isn't statically known (the
-   * caller keeps its fence), or the groups list (possibly empty — a
-   * traced regex WITHOUT named groups is the Node-undefined case). */
+ * expression — the `.groups` desugar's provenance question. Traces
+ * (through parens, `!`, and const bindings):
+ *   - `re.exec(s)` / `s.match(re)`   → re's static pattern
+ *   - a matchAll ROW: `rows[i]`, the for-of binding over a direct
+ *     `s.matchAll(re)` or a stored const drain → re's static pattern
+ * Answers null when the producing regex isn't statically known (the
+ * caller keeps its fence), or the groups list (possibly empty — a
+ * traced regex WITHOUT named groups is the Node-undefined case). */
 export declare function matchResultNamedGroupsOf(lowerer: Lowerer, e: ts.Expression): {
     name: string;
     index: number;
 }[] | null;
 /** True when the IR type is the honest match slice — `string[]`, or a
-   * union of it with unit arms only (`string[] | null`). The groups
-   * projection's receiver gate, shared with the destructure interception. */
+ * union of it with unit arms only (`string[] | null`). The groups
+ * projection's receiver gate, shared with the destructure interception. */
 export declare function isMatchSliceType(lowerer: Lowerer, t: IrType): boolean;
 /** The groups-record projection holds string | undefined values, including
-   * an own overflow entry for every nonparticipating capture. One lifted helper per
-   * (index list, receiver representation) builds it; see
-   * lowerMatchGroupsRead for the semantics the body encodes. */
+ * an own overflow entry for every nonparticipating capture. One lifted helper per
+ * (index list, receiver representation) builds it; see
+ * lowerMatchGroupsRead for the semantics the body encodes. */
 export declare function lowerGroupsProjection(lowerer: Lowerer, recv: IrExpr, groups: {
     name: string;
     index: number;
@@ -322,79 +322,79 @@ export declare function lowerGroupsProjection(lowerer: Lowerer, recv: IrExpr, gr
  * an interned unbound callable; invocation supplies its receiver separately. */
 export declare function lowerFieldRead(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
 /** Shared-field read `r.f` on a UNION receiver: supported exactly when
-   * every arm is a record/class possessing the field with ONE shared IR
-   * type — the discriminant pattern (`r.kind`, primitive) and the
-   * shared-payload pattern (`spec.config` where every ServiceSpec arm
-   * carries the same record). Lowers to `unionDisc` (the backend switches
-   * on the runtime tag and reads the field from the concrete arm), which
-   * composes with existing strEq/bin/switch nodes, so `r.kind === "ok"`
-   * and `switch (r.kind)` work without dedicated test nodes. Anything else
-   * on a union receiver is rejected specifically (narrow first). */
+ * every arm is a record/class possessing the field with ONE shared IR
+ * type — the discriminant pattern (`r.kind`, primitive) and the
+ * shared-payload pattern (`spec.config` where every ServiceSpec arm
+ * carries the same record). Lowers to `unionDisc` (the backend switches
+ * on the runtime tag and reads the field from the concrete arm), which
+ * composes with existing strEq/bin/switch nodes, so `r.kind === "ok"`
+ * and `switch (r.kind)` work without dedicated test nodes. Anything else
+ * on a union receiver is rejected specifically (narrow first). */
 export declare function lowerUnionProperty(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
 /** Recognizes `obj.field` as an assignable field target: receiver is a
-   * known class instance OR a record, and the member is a field or (class
-   * receivers) a declared accessor property. Returns the pieces of a
-   * fieldSet/recordSet/accessor-call (minus value/kind) or null. */
+ * known class instance OR a record, and the member is a field or (class
+ * receivers) a declared accessor property. Returns the pieces of a
+ * fieldSet/recordSet/accessor-call (minus value/kind) or null. */
 export declare function fieldTarget(lowerer: Lowerer, access: ts.PropertyAccessExpression): FieldTarget | null;
 /** A STATICALLY-RESOLVABLE unique-symbol key: an identifier whose value
-   * resolves (imports included) to a module-level `const k = Symbol(...)`
-   * with no description or a literal one. tsc types such a const `unique
-   * symbol` — a compile-time identity — so a `this[k]` member is an
-   * ordinary hidden field of the static layout, named in Node's inspect
-   * spelling (`Symbol(limit)`). Everything else is null and keeps the
-   * symbol fences: `symbol`-typed parameters and locals (identity known
-   * only at runtime), `Symbol.for(...)` consts (two distinct consts can
-   * alias ONE runtime symbol through the global registry — tsc still
-   * types them as distinct unique symbols, so static slots would split
-   * what JS shares), and computed descriptions (the field name below
-   * must BE Node's, for inspect). */
+ * resolves (imports included) to a module-level `const k = Symbol(...)`
+ * with no description or a literal one. tsc types such a const `unique
+ * symbol` — a compile-time identity — so a `this[k]` member is an
+ * ordinary hidden field of the static layout, named in Node's inspect
+ * spelling (`Symbol(limit)`). Everything else is null and keeps the
+ * symbol fences: `symbol`-typed parameters and locals (identity known
+ * only at runtime), `Symbol.for(...)` consts (two distinct consts can
+ * alias ONE runtime symbol through the global registry — tsc still
+ * types them as distinct unique symbols, so static slots would split
+ * what JS shares), and computed descriptions (the field name below
+ * must BE Node's, for inspect). */
 export declare function uniqueSymbolKeyOf(lowerer: Lowerer, key: ts.Expression): {
     sym: ts.Symbol;
     fieldName: string;
 } | null;
 /** The declared symbol-keyed field (class name / layout field / type)
-   * `expr` resolves to, WITHOUT lowering the receiver — the routing test
-   * for the wiring sites (statement dispatch must not emit anything when
-   * it declines). Null off class receivers, for non-static keys, and for
-   * keys no class on the chain declares. */
+ * `expr` resolves to, WITHOUT lowering the receiver — the routing test
+ * for the wiring sites (statement dispatch must not emit anything when
+ * it declines). Null off class receivers, for non-static keys, and for
+ * keys no class on the chain declares. */
 export declare function symbolFieldInfo(lowerer: Lowerer, expr: ts.ElementAccessExpression): {
     className: string;
     field: string;
     fieldType: IrType;
 } | null;
 /** The read expression for a field target (fieldGet / recordGet /
-   * getter call). `blame` locates the rejection of a setter-only read —
-   * tsc-clean (the property types as the setter's param), but Node yields
-   * undefined, which these property types cannot represent. */
+ * getter call). `blame` locates the rejection of a setter-only read —
+ * tsc-clean (the property types as the setter's param), but Node yields
+ * undefined, which these property types cannot represent. */
 export declare function fieldGetExpr(lowerer: Lowerer, target: FieldTarget, loc: SrcLoc, blame: ts.Node): IrExpr;
 /** The write statement for a field target (fieldSet / recordSet / setter
-   * call). A write to a getter-only property never gets here in a clean
-   * program (tsc's TS2540 is the fence); the rejection is the backstop. */
+ * call). A write to a getter-only property never gets here in a clean
+ * program (tsc's TS2540 is the fence); the rejection is the backstop. */
 export declare function fieldSetStmt(lowerer: Lowerer, target: FieldTarget, value: IrExpr, loc: SrcLoc, blame: ts.Node): IrStmt;
 /** `Promise.reject(reason)` on THE Promise global: a pre-rejected
-   * promise. The reason is pinned to the Error hierarchy (the executor
-   * reject parameter's contract — rejection payloads share the
-   * thrown-Error representation, so catch-side instanceof and the
-   * uncaught printer keep working) and moves into the rejection slot
-   * exactly as an executor's reject() would store it; the result enters
-   * the unhandled ledger until something observes it, JS-exact. The
-   * checker types the call Promise<never>, so the CONTEXT names the
-   * result type (a declared return type, an annotated initializer, an
-   * argument slot); without one no representable type exists and the
-   * fence says so. Null for other members and non-Promise receivers. */
+ * promise. The reason is pinned to the Error hierarchy (the executor
+ * reject parameter's contract — rejection payloads share the
+ * thrown-Error representation, so catch-side instanceof and the
+ * uncaught printer keep working) and moves into the rejection slot
+ * exactly as an executor's reject() would store it; the result enters
+ * the unhandled ledger until something observes it, JS-exact. The
+ * checker types the call Promise<never>, so the CONTEXT names the
+ * result type (a declared return type, an annotated initializer, an
+ * argument slot); without one no representable type exists and the
+ * fence says so. Null for other members and non-Promise receivers. */
 export declare function lowerPromiseRejectCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** `Promise.all([...])` where the literal's every entry is the SAME
-   * promise type: the checker's tuple overload types the literal
-   * [Promise<T>, Promise<T>] — a tuple RECORD, which the array path
-   * rejects — but a homogeneous tuple of promises IS a Promise<T>[] in
-   * every observable way, so the entries build the array directly and
-   * the runtime's countdown combinator runs (the certs read-both-files
-   * shape). Result Promise<T[]>; void inners collapse to Promise<void>
-   * exactly like the array path. Null otherwise: heterogeneous literals
-   * and non-literal arguments keep the array path and its fences. */
+ * promise type: the checker's tuple overload types the literal
+ * [Promise<T>, Promise<T>] — a tuple RECORD, which the array path
+ * rejects — but a homogeneous tuple of promises IS a Promise<T>[] in
+ * every observable way, so the entries build the array directly and
+ * the runtime's countdown combinator runs (the certs read-both-files
+ * shape). Result Promise<T[]>; void inners collapse to Promise<void>
+ * exactly like the array path. Null otherwise: heterogeneous literals
+ * and non-literal arguments keep the array path and its fences. */
 export declare function lowerPromiseAllTupleCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** `obj.f op= e` (and `obj.f++` with rhs null ≡ 1) — the element spelling
-   * `obj[k] op= e` included when k is a declared symbol-keyed field.
-   * Save the receiver and old value before the RHS, then write through
-   * that same receiver even if the RHS replaces its original binding. */
+ * `obj[k] op= e` included when k is a declared symbol-keyed field.
+ * Save the receiver and old value before the RHS, then write through
+ * that same receiver even if the RHS replaces its original binding. */
 export declare function lowerFieldCompound(lowerer: Lowerer, access: ts.PropertyAccessExpression | ts.ElementAccessExpression, op: CompoundOp, rhsNode: ts.Expression | null, loc: SrcLoc): IrStmt;