@scriptc/compiler 0.0.35 → 0.1.1

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

@@ -1,6 +1,6 @@
 import * as ts from "../ts7/adapter.js";
 import type { Lowerer } from "./lowerer.js";
-import { IrExpr, IrLocal, IrRecordShape, IrStmt, IrType, SrcLoc } from "../../ir/nodes.js";
+import { IrExpr, IrLocal, IrRecordShape, IrStmt, IrType, SrcLoc } from "../../ir/ir.js";
 import { CompoundOp } from "./surfaces.js";
 /** An assignable `obj.field` target — a class field, a record field, or a
  * class ACCESSOR property (reads become getter calls, writes setter calls;
@@ -52,15 +52,8 @@ export declare function templateRawTextOf(node: ts.NoSubstitutionTemplateLiteral
 /** True when a property access names an ABSTRACT property declaration
  * (`abstract p: number` — a PropertyDeclaration, not an accessor): the
  * named-fence test for reads/writes through abstract-typed receivers. */
-export declare function abstractPropertyDeclOf(L: Lowerer, expr: ts.PropertyAccessExpression): boolean;
-export declare function lowerExpr(L: Lowerer, expr: ts.Expression): IrExpr;
-/** `c ? a : b` — see the inline comments. `expected` plays the contextual
-   * array type's role when the caller knows the slot's array type and tsc's
-   * API doesn't surface it (a ternary as a SPREAD source — lowerArrayLiteral
-   * threads the literal's own type in). */
-export declare function lowerTernary(L: Lowerer, expr: ts.ConditionalExpression, expected?: IrType & {
-    kind: "array";
-}): IrExpr;
+export declare function abstractPropertyDeclOf(lowerer: Lowerer, expr: ts.PropertyAccessExpression): boolean;
+export declare function lowerExpr(lowerer: Lowerer, expr: ts.Expression): 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
@@ -71,7 +64,7 @@ export declare function lowerTernary(L: Lowerer, expr: ts.ConditionalExpression,
    * 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(L: Lowerer, expr: IrExpr, node: ts.Node): IrExpr;
+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
@@ -82,20 +75,7 @@ export declare function maybeNarrow(L: Lowerer, expr: IrExpr, node: ts.Node): Ir
    * (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(L: Lowerer, left: IrExpr, right: IrExpr, negated: boolean, loc: SrcLoc): IrExpr | null;
-/** `x == null` / `x != null` — JS's idiomatic null-OR-undefined test, the
-   * ONE loose comparison with static semantics: `== null` matches exactly
-   * null and undefined (0, "", and false do not). Requires a syntactic
-   * null LITERAL on either side; the other operand's unit arms become a
-   * runtime tag test — one `unionIsTag` when the union has a single unit
-   * arm, a short-circuit pair over both tags otherwise (that shape re-emits
-   * the operand, so only side-effect-free reads compose; anything else
-   * keeps the fence). A unit-literal operand folds (null and undefined are
-   * mutually loose-equal), and a non-nullable operand folds statically —
-   * the same trust-the-checker bet as lowerUnitComparison. Null (fence)
-   * when this isn't a null-literal comparison or the operand has no
-   * lowering here (dyn/jsval/void). */
-export declare function lowerLooseNullCompare(L: Lowerer, expr: ts.BinaryExpression, loc: SrcLoc): IrExpr | null;
+export declare function lowerUnitComparison(lowerer: Lowerer, left: IrExpr, right: IrExpr, negated: boolean, loc: SrcLoc): IrExpr | null;
 /** Safe to EMIT twice: plain reads with no side effects — local/global
    * reads and record/class field reads over such (accessor properties
    * lower to getter CALLS, so they never appear as field reads). Used by
@@ -123,35 +103,7 @@ export declare function pureReemittable(e: IrExpr): boolean;
    * 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(L: Lowerer, expr: ts.BinaryExpression, loc: SrcLoc): IrExpr;
-/** One optional-chain STEP: `a?.b`, `a?.m(...)`, `a?.[i]` (the token on
-   * the member access) and `f?.()` (the token on the call). The receiver
-   * lowers once; when it is a unit-armed union with ONE non-unit arm, the
-   * member/call lowers exactly as its non-optional spelling would — the
-   * receiver node reads back as the chain's bound narrowed value
-   * (chainRecv) and types as its non-nullish type — and the whole thing
-   * becomes an optChain node: tag test, undefined on the unit path (JS:
-   * null receivers still yield undefined), the body lazily otherwise,
-   * argument side effects included. A receiver the checker types
-   * never-nullish makes `?.` behave exactly like `.` — the guard folds
-   * away and the plain lowering is the value (trust-the-checker, like
-   * ??'s fold). Multi-step TAILS (`a?.b.c`, `x?.trim().toLowerCase()`)
-   * short-circuit whole: the guarded member step is the chain's dot and
-   * every later step lowers inside the guard, checker-narrowed non-nullish
-   * (see chainTailDot); sub-union receivers are fenced with rewrite
-   * hints. */
-/** The unhandled `?.`-carrying MEMBER step in this node's receiver
- * spine, when the node is the TAIL of an optional chain whose token sits
- * deeper — `x?.trim().toLowerCase()` reads nothing past the guard when x
- * is nullish, so the whole tail must lower inside it. Walks
- * property/element accesses and call steps only (parens and `!` break
- * the chain per the grammar: `(a?.b).c` throws on undefined in JS);
- * the node's OWN token — and a call's immediate callee token — are the
- * plain entries' cases, not tails, and handled markers make the chain
- * lowering's re-dispatch walk past its own step. `f?.()` steps stay out
- * (a call carrying the token has no member step to re-enter — the
- * split-it fence keeps them). */
-export declare function chainTailDot(L: Lowerer, expr: ts.Expression): ts.PropertyAccessExpression | ts.ElementAccessExpression | null;
+export declare function lowerNullishCoalesce(lowerer: Lowerer, expr: ts.BinaryExpression, loc: SrcLoc): IrExpr;
 /** True when `expr` is `require.main.filename` (either dot optional) on
  * the AMBIENT CommonJS require — the entry-module identity read. The
  * value is the ENTRY file's path, a compile-time constant like
@@ -160,57 +112,44 @@ export declare function chainTailDot(L: Lowerer, expr: ts.Expression): ts.Proper
  * lowering (the fold) and lowerStringMethodCall's receiver gate (the
  * checker types the chain `string | undefined`, but the folded receiver
  * IS a string). */
-export declare function isRequireMainFilename(L: Lowerer, expr: ts.Expression): boolean;
-/** True when `expr` is the tail of an optional chain the STATIC chain
- * machinery should short-circuit whole: an unhandled deeper `?.` whose
- * guarded receiver lowers as a unit-armed union. Dyn ('unknown') and
- * island ('any') receivers answer their tails through their own
- * undefined-propagating reads and stay out; never-nullish receivers fold
- * at the token's own entry. */
-export declare function chainTailClaimed(L: Lowerer, expr: ts.Expression): boolean;
-/** True when an EARLIER step of this access chain carries `?.` — JS
- * short-circuits the whole tail (`a?.b.c` reads nothing when a is
- * nullish), so a dyn tail read must answer undefined instead of
- * throwing. Walks the receiver spine only; the argument of the access
- * itself is not part of the guard. */
-export declare function chainGuardedByQuestionDot(expr: ts.Expression): boolean;
-export declare function lowerOptionalChain(L: Lowerer, expr: ts.CallExpression | ts.PropertyAccessExpression | ts.ElementAccessExpression): IrExpr;
+export declare function isRequireMainFilename(lowerer: Lowerer, expr: ts.Expression): boolean;
+export declare function lowerOptionalChain(lowerer: Lowerer, expr: ts.CallExpression | ts.PropertyAccessExpression | ts.ElementAccessExpression): IrExpr;
 /** The optChain node around a lowered chain body: void bodies keep the
    * statement form (`cb?.();` — the checker's `void | undefined` result IS
    * void here); value bodies wrap into the checker's undefined-armed
    * result union. */
-export declare function finishOptionalChain(L: Lowerer, expr: ts.Expression, id: string, receiver: IrExpr, body: IrExpr, loc: SrcLoc): IrExpr;
+export declare function finishOptionalChain(lowerer: Lowerer, expr: ts.Expression, id: string, receiver: IrExpr, body: IrExpr, 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. */
-export declare function lowerCondition(L: Lowerer, expr: ts.Expression): IrExpr;
-export declare function runtimeOptionalTrueIds(L: Lowerer, node: ts.Expression): IrLocal[];
-export declare function withRuntimeOptionalNarrowed<T>(L: Lowerer, locals: readonly IrLocal[], fn: () => T): T;
+export declare function lowerCondition(lowerer: Lowerer, expr: ts.Expression): IrExpr;
+export declare function runtimeOptionalTrueIds(lowerer: Lowerer, node: ts.Expression): 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. */
-export declare function ensureBool(L: Lowerer, e: IrExpr, node: ts.Expression): IrExpr;
+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). */
-export declare function requireTruthyUnion(L: Lowerer, unionId: string, node: ts.Expression): void;
+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. */
-export declare function eqComparableUnion(L: Lowerer, unionId: string): boolean;
+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. */
-export declare function lowerIntrinsicProperty(L: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
+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
@@ -219,12 +158,12 @@ export declare function lowerIntrinsicProperty(L: Lowerer, expr: ts.PropertyAcce
    * 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(L: Lowerer, expr: ts.ArrayLiteralExpression, expected?: (IrType & {
+export declare function lowerArrayLiteral(lowerer: Lowerer, expr: ts.ArrayLiteralExpression, expected?: (IrType & {
     kind: "array";
 }) | (IrType & {
     kind: "record";
 })): IrExpr;
-export declare function foldedStringKeyOf(L: Lowerer, expr: ts.Expression): string | null;
+export declare function foldedStringKeyOf(lowerer: Lowerer, expr: ts.Expression): string | null;
 /** The runtime-keyed JS object literal (a computed key that doesn't fold):
    * builds a dyn object member-by-member. Keys evaluate before their values,
    * properties in source order — JS's object-literal evaluation exactly.
@@ -236,8 +175,12 @@ export declare function foldedStringKeyOf(L: Lowerer, expr: ts.Expression): stri
    * (dynFrom's domain, functions box); a value with no dyn representation
    * fences per property. Spreads copy through dyn.assign in source order;
    * accessors stay fenced. */
-export declare function lowerDynObjectLiteral(L: Lowerer, expr: ts.ObjectLiteralExpression, boxValue?: (node: ts.Expression, value: IrExpr) => IrExpr): IrExpr;
-export declare function lowerObjectLiteral(L: Lowerer, expr: ts.ObjectLiteralExpression): IrExpr;
+export declare function lowerDynObjectLiteral(lowerer: Lowerer, expr: ts.ObjectLiteralExpression, boxValue?: (node: ts.Expression, value: IrExpr) => IrExpr): IrExpr;
+/** Convert an undefined-armed numeric value at an arithmetic use. Ordinary
+ * reads preserve their tagged value; JavaScript's ToNumber(undefined) is NaN,
+ * 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;
+export declare function lowerObjectLiteral(lowerer: Lowerer, expr: ts.ObjectLiteralExpression): IrExpr;
 /** A conditional spread's carrier property: `name: value` or shorthand,
    * with an identifier/string-literal name. */
 export type CondSpreadProp = (ts.PropertyAssignment | ts.ShorthandPropertyAssignment) & {
@@ -259,23 +202,16 @@ export declare function conditionalSpreadOf(expr: ts.Expression): {
 /** The value of a shorthand property (`{ x }`): the binding `x` refers to.
    * The property name's own symbol is the PROPERTY, so resolution goes
    * through getShorthandAssignmentValueSymbol. */
-export declare function lowerShorthandValue(L: Lowerer, prop: ts.ShorthandPropertyAssignment): IrExpr;
+export declare function lowerShorthandValue(lowerer: Lowerer, prop: ts.ShorthandPropertyAssignment): IrExpr;
 /** Rejects any `this` inside an object-literal method body — including in
    * nested arrows, which inherit the method's `this` (nested function
    * expressions reset it, but their bare `this` is already a tsc error
    * under noImplicitThis, so over-rejecting them here changes nothing). */
-export declare function rejectThisInObjectMethod(L: Lowerer, node: ts.Node): void;
-/** The accessor twin of rejectThisInObjectMethod: a get/set accessor body
-   * referencing `this` (`get x() { return this._x }`). The accessor lowers
-   * as a closure stored IN the record — passing the record as a receiver
-   * would capture the value under construction (an RC cycle), and the
-   * generic lexical-this walk would silently bind an ENCLOSING method's
-   * `this`; the fence names the fix (capture a binding instead). */
-export declare function rejectThisInObjectAccessor(L: Lowerer, node: ts.Node): void;
+export declare function rejectThisInObjectMethod(lowerer: Lowerer, node: ts.Node): void;
 /** `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. */
-export declare function lowerElementAccess(L: Lowerer, expr: ts.ElementAccessExpression): IrExpr;
+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
@@ -290,7 +226,7 @@ export declare function lowerElementAccess(L: Lowerer, expr: ts.ElementAccessExp
    * 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(L: Lowerer, expr: ts.ElementAccessExpression, shapeId: string, shape: IrRecordShape, includeUndefined?: boolean): IrExpr;
+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
  * and array indices even when noUncheckedIndexedAccess is disabled. Keep
@@ -298,29 +234,15 @@ export declare function lowerRecordKeyRead(L: Lowerer, expr: ts.ElementAccessExp
  * consumed it; ordinary unchecked reads retain the typed trap. Assertions
  * around the read are erased here because this context handles the missing
  * arm instead of consuming it as the asserted type. */
-export declare function lowerAbsenceProbe(L: Lowerer, node: ts.Expression): IrExpr | null;
-/** The compile-time string spelling of a record key literal: a string
- * literal's text, or a NON-NEGATIVE numeric literal's canonical JS
- * spelling (`1` → "1", `1e21` → "1e+21" — String(Number(text)), which is
- * exactly the key JS derives; negative/computed keys stay runtime
- * expressions and canonicalize through ensureString instead). Null for
- * everything else. */
-export declare function recordKeyLiteralText(node: ts.Expression): string | null;
-/** The compile-time key an IDENTIFIER's TYPE proves: a key variable whose
- * (narrowed) type is one string/number literal — `const k: "a" = …; o[k]`,
- * and the generic-body form where k's type is a keyof-constrained
- * parameter bound to a literal (`pick(o, "a")`'s instance reads `o[k]`
- * with K = "a", resolved through typeParamTsBindings). Identifier reads
- * are pure, so the static field read may skip evaluating the key exactly
- * like a syntactic literal. Null anywhere the type keeps more than one
- * key. */
-export declare function recordKeyTypeLiteralText(L: Lowerer, node: ts.Expression): string | null;
+export declare function lowerAbsenceProbe(lowerer: Lowerer, node: ts.Expression): IrExpr | null;
 /** `a[i] = v` in statement position → arraySet (element writes, like local
    * assignment, produce no value in our subset). */
-export declare function lowerElementWrite(L: Lowerer, expr: ts.BinaryExpression): IrStmt;
-export declare function ensureString(L: Lowerer, e: IrExpr, node: ts.Node): IrExpr;
-export declare function lowerTemplate(L: Lowerer, expr: ts.TemplateExpression): IrExpr;
-/** `x as T`. Non-dyn inner values keep today's pure-erasure semantics.
+export declare function lowerElementWrite(lowerer: Lowerer, expr: ts.BinaryExpression): IrStmt;
+export declare function ensureString(lowerer: Lowerer, e: IrExpr, node: ts.Node): IrExpr;
+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
@@ -332,17 +254,10 @@ export declare function lowerTemplate(L: Lowerer, expr: ts.TemplateExpression):
    *   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(L: Lowerer, expr: ts.AsExpression | ts.TypeAssertion): IrExpr;
-export declare function lowerPrefixUnary(L: Lowerer, expr: ts.PrefixUnaryExpression): IrExpr;
-/** `x++`/`x--`/`++x`/`--x` in EXPRESSION position — the incDec node:
-   * read, write ±1, yield old (postfix) or new (prefix) value. Receivers
-   * are f64 LOCALS or module globals (captured/boxed included — the
-   * backend reads/writes through the box); record fields and array
-   * elements keep the fence in value position (statement-position `obj.f++`
-   * still desugars through the compound-field path). */
-export declare function lowerIncDec(L: Lowerer, expr: ts.PrefixUnaryExpression | ts.PostfixUnaryExpression, prefix: boolean): IrExpr;
-export declare function lowerBinary(L: Lowerer, expr: ts.BinaryExpression): IrExpr;
-export declare function lowerCaughtTypeofTest(L: Lowerer, expr: ts.BinaryExpression, loc: SrcLoc): IrExpr | null;
+export declare function lowerAsExpression(lowerer: Lowerer, expr: ts.AsExpression | ts.TypeAssertion): IrExpr;
+export declare function lowerPrefixUnary(lowerer: Lowerer, expr: ts.PrefixUnaryExpression): IrExpr;
+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)`
@@ -356,67 +271,19 @@ export declare function lowerCaughtTypeofTest(L: Lowerer, expr: ts.BinaryExpress
    * 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
-   * L.narrowingAliases: branch-scoped typeOf overrides, bridged by
+   * lowerer.narrowingAliases: branch-scoped typeOf overrides, bridged by
    * maybeNarrow's ordinary unionNarrow. */
-export declare function aliasTypeofNarrows(L: Lowerer, cond: ts.Expression, polarity: boolean): {
+export declare function aliasTypeofNarrows(lowerer: Lowerer, cond: ts.Expression, polarity: boolean): {
     sym: ts.Symbol;
     tsArm: ts.Type;
 }[];
-/** `typeof v === "lit"` / `typeof v !== "lit"` where v is UNION-typed: the
-   * arms whose static typeof answer equals the literal form a tag set, and
-   * the test is a runtime tag test — one `unionIsTag` for a single matching
-   * arm (the operand embeds once, so even effectful operands compose), a
-   * short-circuit chain for several (pure reads only — the operand rides
-   * every test, exactly the `== null` composition rule). When every arm
-   * answers the same way the comparison is statically decided and folds to
-   * a bool literal — dropping only a side-effect-free read, the same
-   * trust-the-checker bet as lowerUnitComparison. tsc's control-flow
-   * narrowing then types the branches, and reads bridge through
-   * maybeNarrow's unionNarrow as usual. Null when neither side is a typeof
-   * over a union-typed operand or the literal side isn't a literal (the
-   * bare-typeof value form then composes with strEq for pure operands). */
-export declare function lowerUnionTypeofTest(L: Lowerer, expr: ts.BinaryExpression, loc: SrcLoc): IrExpr | null;
-/** `typeof v === "lit"` / `typeof v !== "lit"` where v is `unknown`-typed
-   * (dyn): the runtime kind test over the dyn node's tag. Only the kinds a
-   * later read can bridge narrow ("string"/"number"/"boolean") plus
-   * "undefined" (no payload to read); "object"/"function" tests keep the
-   * fence — an object-narrowed `unknown` read has no lowering anyway (a
-   * checked cast `v as T` is the supported extraction). Null when neither
-   * side is a typeof over a dyn-typed operand (not this pattern). */
-export declare function lowerDynTypeofTest(L: Lowerer, expr: ts.BinaryExpression, loc: SrcLoc): IrExpr | null;
-/** `exports.<name>` in a JS module whose `module.exports =` REPLACED the
-   * export object, with no `exports.<name> =` attachment anywhere in the
-   * file: the read observes the ORIGINAL (empty-here) exports object, so
-   * the honest value is undefined (Node's object identity exactly; tsc's
-   * CJS model types the read off the replacement — identity-blind). Null
-   * everywhere else: no replacement, a real attachment of this name, a
-   * shadowing binding named `exports`, or write position. */
-export declare function lowerReplacedExportsRead(L: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
-/** A read that resolves to a CJS export-table ACCESSOR property
-   * (`module.exports = { get path() {...}, set path(v) {...} }`): the
-   * getter lifts as a module-level function (module globals need no
-   * captures) — interned per declaration so every read site calls ONE
-   * function — and the read IS the call, Node's per-read evaluation
-   * exactly. Null when the identifier doesn't resolve to such a property
-   * (or it has no getter: a setter-only read answers undefined in Node —
-   * rare enough to keep fenced). */
-export declare function cjsExportAccessorRead(L: Lowerer, ident: ts.Identifier): IrExpr | null;
-/** `this.<name>` INSIDE a CJS export-table accessor (test/common's
-   * `get localhostIPv4() { if (this.inFreeBSDJail) ... }`): Node binds the
-   * getter's receiver to module.exports, so the read is the SIBLING table
-   * property — a sibling GETTER's lifted call (per-read evaluation, like
-   * any accessor read). Only arrows inherit the binding (a nested function
-   * expression's `this` is its own). Null everywhere else — non-getter
-   * siblings and absent names keep their per-site fences (none of the
-   * probed suite shapes read them). */
-export declare function lowerCjsExportTableThisMember(L: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
 /** Lowers an expression, converting a fence (PoisonError) into a null
    * DECLINE — the probing dispatch for shapes where only the lowered
    * value's type can say whether a lowering applies. unsupported() pushes
    * its diagnostic BEFORE throwing, so the probe runs behind a diagnostic
    * sink: a declined probe's diagnostics vanish (the sibling lowerings
    * own the site), a successful probe's flush through afterwards. */
-export declare function probeLower(L: Lowerer, node: ts.Expression): IrExpr | null;
+export declare function probeLower(lowerer: Lowerer, node: ts.Expression): IrExpr | null;
 /** 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
@@ -424,18 +291,18 @@ export declare function probeLower(L: Lowerer, node: ts.Expression): IrExpr | nu
    * 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(L: Lowerer, node: ts.Identifier, local: IrLocal, loc: SrcLoc): IrExpr;
+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. */
-export declare function caughtToString(L: Lowerer, node: ts.Expression): IrExpr | null;
+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. */
-export declare function caughtLocalOf(L: Lowerer, node: ts.Expression): IrLocal | null;
+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).
@@ -445,22 +312,7 @@ export declare function caughtLocalOf(L: Lowerer, node: ts.Expression): IrLocal
    * 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(L: Lowerer, expr: ts.BinaryExpression, loc: SrcLoc): IrExpr;
-/** `"key" in v` — the key-presence test. Three lowered receivers:
-   * process.env (getenv(3) presence — Node-exact, an empty value still
-   * counts as present), and monomorphic record shapes, where the answer is
-   * type-directed: a declared non-optional field is a compile-time `true`,
-   * a missing field (no index signature) a compile-time `false` — both
-   * folds limited to side-effect-free receivers, the lowerInstanceOf rule —
-   * and an OPTIONAL field (undefined-armed union) is a runtime tag test on
-   * the slot: present iff the arm is not undefined. That last case is the
-   * representation's honest answer — a field explicitly assigned
-   * `undefined` reads as absent (`"a" in {a: undefined}` is true in JS,
-   * false here; SEMANTICS.md 55). Union receivers (the `in`-narrowing
-   * idiom over multiple shapes), index-signature keys, class instances,
-   * and dyn/unknown stay fenced. Keys are literal strings — a computed key
-   * over a shape would need the runtime key table. */
-export declare function lowerInExpression(L: Lowerer, expr: ts.BinaryExpression, loc: SrcLoc): IrExpr;
+export declare function lowerInstanceOf(lowerer: Lowerer, expr: ts.BinaryExpression, loc: SrcLoc): IrExpr;
 /** A regex literal `/ab+c/gi` → regexLit (interned per (pattern, flags)
    * by the backend). The TS parser has already syntax-checked the literal;
    * what remains here is the flag-alphabet fence (d and v are
@@ -471,27 +323,7 @@ export declare function lowerInExpression(L: Lowerer, expr: ts.BinaryExpression,
    * (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(L: Lowerer, expr: ts.RegularExpressionLiteral): IrExpr;
-/** The pattern's named capture groups, in source order: each `(?<name>`
-   * with its 1-based capture index (numbered and named groups share the
-   * numbering — the index IS the match slice's element position). Null
-   * when the scan can't answer confidently (an unterminated construct, a
-   * `\u`-escaped group name) — callers fence rather than guess. Duplicate
-   * names (ES2025 — valid across alternatives) appear once per
-   * declaration; consumers pick the participating occurrence. The scan
-   * only needs to track escapes, character classes, and `(` kinds; tsc
-   * has already syntax-checked the literal, so a malformed pattern here
-   * answers null and the engine's lazy compile reports it. */
-export declare function namedCaptureGroupsOfPattern(pattern: string): {
-    name: string;
-    index: number;
-}[] | null;
-/** The statically-known regex PATTERN behind an expression: a regex
-   * literal, a const local initialized with one (the crypto.js
-   * `const regexp = /(?<m>\d+)/` shape), or `new RegExp("...")` over a
-   * string literal (the cooked text IS the pattern). Null when the regex
-   * only exists at runtime — .groups consumers fence there. */
-export declare function staticRegexPatternOf(L: Lowerer, e: ts.Expression): string | null;
+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):
@@ -501,37 +333,14 @@ export declare function staticRegexPatternOf(L: Lowerer, e: ts.Expression): stri
    * 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(L: Lowerer, e: ts.Expression): {
+export declare function matchResultNamedGroupsOf(lowerer: Lowerer, e: ts.Expression): {
     name: string;
     index: number;
 }[] | null;
-/** `m.groups` on a match result whose producing regex is statically
-   * known: the honest slice already HOLDS every named group's value at
-   * its capture index, so the groups object is a compile-time record
-   * projection — `{ year: m[1], month: m[2] }` — built by one interned
-   * helper per (shape, index list, receiver type). Node's exact shape
-   * decisions:
-   *   - no named groups → `undefined` (the identifier-receiver shapes —
-   *     a call receiver would lose its own null trap, so those keep the
-   *     member fence);
-   *   - a nullable receiver (the JS `s.match(re).groups` idiom) throws
-   *     Node's exact TypeError on the unit arms;
-   *   - every declared name is a key (nonparticipating groups hold "" —
-   *     divergence 51's rule, exactly the slice elements they project);
-   *   - ES2025 duplicate names (distinct alternatives) project the first
-   *     participating occurrence: at most one participates, and a
-   *     participating-empty "" falls through to slots that are "" anyway;
-   *   - key order is group declaration order (declaredOrder), Node's own.
-   * The record has no prototype — Node's groups object is null-prototype,
-   * observable only through util.inspect's "[Object: null prototype]"
-   * prefix (the Object.groupBy stance, ledgered). Null when the receiver
-   * isn't a match slice or the regex isn't traceable — the caller's
-   * member fence (with the groups hint) names the gap. */
-export declare function lowerMatchGroupsRead(L: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | 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. */
-export declare function isMatchSliceType(L: Lowerer, t: IrType): boolean;
+export declare function isMatchSliceType(lowerer: Lowerer, t: IrType): boolean;
 /** The groups-record projection call: the result is the CHECKER'S OWN
    * shape — `{ [key: string]: string }`, the hybrid index-signature
    * record with no declared fields — holding one OVERFLOW entry per
@@ -540,7 +349,7 @@ export declare function isMatchSliceType(L: Lowerer, t: IrType): boolean;
    * wrap) meets exactly the type tsc reported. One lifted helper per
    * (index list, receiver representation) builds it; see
    * lowerMatchGroupsRead for the semantics the body encodes. */
-export declare function lowerGroupsProjection(L: Lowerer, recv: IrExpr, groups: {
+export declare function lowerGroupsProjection(lowerer: Lowerer, recv: IrExpr, groups: {
     name: string;
     index: number;
 }[], loc: SrcLoc): IrExpr;
@@ -549,7 +358,7 @@ export declare function lowerGroupsProjection(L: Lowerer, recv: IrExpr, groups:
    * on classes are rejected specifically; func-typed record fields are
    * ordinary closure values, so bare references to them work (unlike class
    * methods, which have no bound-value form). */
-export declare function lowerFieldRead(L: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
+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
@@ -559,12 +368,12 @@ export declare function lowerFieldRead(L: Lowerer, expr: ts.PropertyAccessExpres
    * 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(L: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
+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. */
-export declare function fieldTarget(L: Lowerer, access: ts.PropertyAccessExpression): FieldTarget | 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
@@ -577,7 +386,7 @@ export declare function fieldTarget(L: Lowerer, access: ts.PropertyAccessExpress
    * 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(L: Lowerer, key: ts.Expression): {
+export declare function uniqueSymbolKeyOf(lowerer: Lowerer, key: ts.Expression): {
     sym: ts.Symbol;
     fieldName: string;
 } | null;
@@ -586,23 +395,20 @@ export declare function uniqueSymbolKeyOf(L: Lowerer, key: ts.Expression): {
    * 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(L: Lowerer, expr: ts.ElementAccessExpression): {
+export declare function symbolFieldInfo(lowerer: Lowerer, expr: ts.ElementAccessExpression): {
     className: string;
     field: string;
     fieldType: IrType;
 } | null;
-/** `obj[k]` as an assignable field target — the symbol-keyed twin of
-   * fieldTarget's class branch (the receiver lowers here, exactly once). */
-export declare function symbolFieldTarget(L: Lowerer, expr: ts.ElementAccessExpression): FieldTarget | 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. */
-export declare function fieldGetExpr(L: Lowerer, target: FieldTarget, loc: SrcLoc, blame: ts.Node): IrExpr;
+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. */
-export declare function fieldSetStmt(L: Lowerer, target: FieldTarget, value: IrExpr, loc: SrcLoc, blame: ts.Node): IrStmt;
+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
@@ -614,7 +420,7 @@ export declare function fieldSetStmt(L: Lowerer, target: FieldTarget, value: IrE
    * 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(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+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
@@ -624,19 +430,9 @@ export declare function lowerPromiseRejectCall(L: Lowerer, call: ts.CallExpressi
    * 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(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+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.
    * Restricted to side-effect-free receivers (identifier or `this`)
    * because the desugar evaluates the receiver twice. */
-export declare function lowerFieldCompound(L: Lowerer, access: ts.PropertyAccessExpression | ts.ElementAccessExpression, op: CompoundOp, rhsNode: ts.Expression | null, loc: SrcLoc): IrStmt;
-/** The primitive-constructor closure (`String`/`Number`/`Boolean` as a
- * VALUE): interns one synthesized module function per constructor —
- * `%builtin.String` et al. — and returns the zero-capture closure over it.
- * The body IS the string-coercion the type mapping promised
- * (`(value: string) => primitive`): String is identity, Number the ECMA
- * StringToNumber (num.fromString — the same runtime call the direct
- * `Number(s)` lowering emits), Boolean the emptiness test. Interning makes
- * every reference the SAME immortal closure, so `opt.type === String`
- * compares like JS function identity. */
-export declare function primitiveCtorClosure(L: Lowerer, name: "String" | "Number" | "Boolean", loc: SrcLoc): IrExpr;
+export declare function lowerFieldCompound(lowerer: Lowerer, access: ts.PropertyAccessExpression | ts.ElementAccessExpression, op: CompoundOp, rhsNode: ts.Expression | null, loc: SrcLoc): IrStmt;