@scriptc/compiler 0.3.6 → 0.4.1

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

@@ -2,6 +2,13 @@ import * as ts from "../ts7/adapter.js";
 import type { Lowerer } from "./lowerer.js";
 import { type IrExpr, type IrLocal, type IrRecordShape, type IrStmt, type IrType, type SrcLoc } from "../../ir/ir.js";
 import { type CompoundOp } from "./surfaces.js";
+export { DEFERRED_READ_MESSAGE, abstractPropertyDeclOf, builtinFunctionValue, builtinGlobalValue, fieldGetExpr, fieldTarget, isMatchSliceType, lowerFieldRead, lowerGroupsProjection, lowerIntrinsicProperty, lowerUnionProperty, matchResultNamedGroupsOf, primitiveConstructorOr, } from "./expressions/property-access.js";
+export { lowerAsExpression, lowerTernary, maybeNarrow, runtimeOptionalGuardIds, runtimeOptionalTrueIds, v8CalleeText, withRuntimeOptionalNarrowed, } from "./expressions/narrowing.js";
+export { ensureString, lowerBinary, lowerCompoundValueToTarget, lowerElementCompound, lowerNativeFunctionAssignment, lowerStrictEquality, lowerUnitComparison, } from "./expressions/binary.js";
+export { jsHoldsDynObject, lowerArrayLiteral } from "./expressions/array-literals.js";
+export { lowerElementAccess, lowerElementWrite, lowerEnvironmentKey, lowerRecordKeyRead, } from "./expressions/element-access.js";
+export { fieldSetStmt, lowerIncDec, lowerIncDecTarget, lowerPrefixUnary, } from "./expressions/updates.js";
+export { lowerInstanceOf } from "./expressions/relational.js";
 /** An assignable `obj.field` target — a class field, a record field, or a
  * class ACCESSOR property (reads become getter calls, writes setter calls;
  * fieldType is the property's one type). */
@@ -38,6 +45,15 @@ export type FieldTarget = {
     shapeId: string;
     field: string;
     fieldType: IrType;
+} | {
+    container: "recordKeyed";
+    obj: IrExpr;
+    shapeId: string;
+    field: string;
+    keys: readonly string[] | null;
+    key: IrExpr | null;
+    fieldType: IrType;
+    missNaN?: true;
 } | {
     container: "accessor";
     obj: IrExpr;
@@ -64,37 +80,35 @@ export type FieldTarget = {
  * no-substitution form, `\`...${` / `}...${` / `}...\`` for head/middle/
  * tail. 5.9.3's rawText, when a build ever supplies it, wins unchanged. */
 export declare function templateRawTextOf(node: ts.NoSubstitutionTemplateLiteral | ts.TemplateHead | ts.TemplateMiddle | ts.TemplateTail): string;
-/** True when a property access names an ABSTRACT property declaration
- * (`abstract p: number` — a PropertyDeclaration, not an accessor).
- * These uses need concrete property dispatch because the base has no slot. */
-export declare function abstractPropertyDeclOf(lowerer: Lowerer, expr: ts.PropertyAccessExpression): boolean;
 export declare function lowerExpr(lowerer: Lowerer, expr: ts.Expression): IrExpr;
-/** `c ? a : b`. An explicit destination constructs each branch at that
- * layout before joining it. Without one, retain the expression's inferred
- * 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. */
-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). */
-export declare function lowerUnitComparison(lowerer: Lowerer, left: IrExpr, right: IrExpr, negated: boolean, loc: SrcLoc): IrExpr | null;
+type RuntimeOptionalUse = {
+    kind: "property";
+    access: ts.PropertyAccessExpression;
+    optional: boolean;
+    complex: boolean;
+    comma: boolean;
+} | {
+    kind: "element";
+    access: ts.ElementAccessExpression;
+    optional: boolean;
+    complex: boolean;
+    comma: boolean;
+} | {
+    kind: "call";
+    access: ts.CallExpression;
+    optional: boolean;
+    complex: boolean;
+    comma: boolean;
+};
+export declare function runtimeOptionalUseOf(expr: ts.Expression): RuntimeOptionalUse | null;
+export declare function runtimeOptionalElementKey(expr: ts.Expression): string | null;
+/** Whether `xs[i]!` lands where an absent element's undefined is
+ * representable: array storage (a literal element, a push/unshift
+ * argument, an element assignment — arrays record the undefined state),
+ * an equality operand, or a slot whose contextual type admits undefined.
+ * TypeScript's `!` has no runtime effect, so such reads stay optional. */
+export declare function assertedElementKeepsUndefined(lowerer: Lowerer, node: ts.NonNullExpression): boolean;
+export declare function runtimeOptionalAssertionErases(lowerer: Lowerer, expr: ts.Expression, inner: IrExpr, use: RuntimeOptionalUse | null): boolean;
 /** `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
@@ -108,22 +122,24 @@ export declare function lowerUnitComparison(lowerer: Lowerer, left: IrExpr, righ
  * 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;
-/** The TypeError of a deferred-init field read that finds the field
- * unassigned where its declared type cannot hold undefined. */
-export declare const DEFERRED_READ_MESSAGE = "undefined is not representable in the target union (a value narrowed or asserted past it still held it)";
+/** The undefined-armed slot behind a checked deferred-init field read, or
+ * the value itself (Lowerer.deferredFieldSlot). */
+export declare function deferredSlotOr(lowerer: Lowerer, value: IrExpr): IrExpr;
+/** Test the original storage before projecting its present value. Both
+ * branches are lazy, and an effectful receiver is evaluated exactly once.
+ * Keeping the original tags matters when the checker has removed an arm
+ * or the default changes the union's layout. */
+export declare function nullishBranches(lowerer: Lowerer, left: IrExpr, leftType: IrType & {
+    kind: "union";
+}, arms: readonly IrType[], type: IrType, loc: SrcLoc, absent: () => IrExpr, present: (stable: IrExpr) => IrExpr): 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(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
- * the outcome; all operands of a true AND or false OR have that outcome.
- * Assignments invalidate a syntactic proof even when checker types hide
- * the undefined produced by an out-of-bounds read. */
-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;
+export declare function lowerPromiseThenPresence(lowerer: Lowerer, access: ts.PropertyAccessExpression, result: IrExpr): IrExpr | null;
+export declare function runtimeOptionalLocalOf(lowerer: Lowerer, node: ts.Expression): IrLocal | null;
 /** 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
@@ -132,26 +148,6 @@ export declare function withRuntimeOptionalNarrowed<T>(lowerer: Lowerer, locals:
 export declare function ensureBool(lowerer: Lowerer, e: IrExpr, node: ts.Expression): IrExpr;
 export declare function requireTruthyUnion(lowerer: Lowerer, unionId: string, node: ts.Expression): void;
 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(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). */
-export declare function lowerArrayLiteral(lowerer: Lowerer, expr: ts.ArrayLiteralExpression, expected?: (IrType & {
-    kind: "array";
-}) | (IrType & {
-    kind: "record";
-})): 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. */
@@ -162,25 +158,6 @@ export declare function lowerOptionalNumber(lowerer: Lowerer, operand: IrExpr, l
  * out-of-range read, a local or field holding one, or a hole — converts to
  * NaN instead of trusting the checker's number type. */
 export declare function lowerToNumberArgument(lowerer: Lowerer, node: 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. */
-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. */
-export declare function lowerRecordKeyRead(lowerer: Lowerer, expr: ts.ElementAccessExpression, shapeId: string, shape: IrRecordShape, includeUndefined?: boolean): IrExpr;
 /** The stored value of an identifier whose storage holds an undefined arm
  * that the checker's type at this use has dropped. An assignment from an
  * unchecked indexed read narrows the declared type even though the value
@@ -195,28 +172,36 @@ export declare function lowerPresenceOperand(lowerer: Lowerer, node: ts.Expressi
  * side of `||`/`??`). JavaScript answers undefined for missing record keys
  * and array indices even when noUncheckedIndexedAccess is disabled. Keep
  * that value in an explicit union until the surrounding guard/default has
- * consumed it; ordinary unchecked reads retain the typed trap. Assertions
+ * consumed it, including class-field and declared-only reads that otherwise
+ * keep their typed storage. 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(lowerer: Lowerer, node: ts.Expression): IrExpr | null;
-/** `a[i] op= rhs` over native arrays and byte views. A compound assignment
- * evaluates the receiver and index, reads the old element, evaluates rhs,
- * then writes. Capture each stage so a call in the index or rhs cannot
- * change the target or the value used by the operator. The expression yields
- * the computed value before a typed array or Buffer coerces it for storage. */
-export declare function lowerElementCompound(lowerer: Lowerer, expr: ts.BinaryExpression, op: CompoundOp): IrExpr;
+/** Can every value a dynamic key can reach (declared fields + the
+ * overflow) surface as the read's result type? dyn results need
+ * dyn-convertible fields (JSON-safe, with the undefined arm allowed at
+ * the top — an optional field's undefined becomes the undefined dyn
+ * value, exactly what the missing-key path produces); typed results need
+ * each field to be the type itself or one of its arms, and the overflow
+ * value to be the type or wrappable into it. */
+export declare function recordKeyResultOk(lowerer: Lowerer, shape: IrRecordShape, type: IrType): boolean;
+export declare function exactUnionWidening(lowerer: Lowerer, from: IrType, to: IrType): boolean;
 /** `a[i] op= rhs` in statement position: a string array append becomes the
  * canonical `a[i] = a[i] + rhs` store (receiver and index saved first),
  * which the backend appends in place; other forms keep the value path. */
 export declare function lowerElementCompoundStatement(lowerer: Lowerer, expr: ts.BinaryExpression, op: CompoundOp): IrStmt;
-/** JavaScript callable members live on the closure, so aliases and chained
- * writes share the same storage as Object.defineProperties. */
-export declare function lowerNativeFunctionAssignment(lowerer: Lowerer, expr: ts.BinaryExpression): IrExpr | null;
-export declare function lowerElementWrite(lowerer: Lowerer, expr: ts.BinaryExpression): IrStmt;
-/** Environment property names use ToPrimitive with the string hint, so
- * checked objects must execute their own conversion hooks. */
-export declare function lowerEnvironmentKey(lowerer: Lowerer, node: ts.Expression): IrExpr;
-export declare function ensureString(lowerer: Lowerer, e: IrExpr, node: ts.Node): IrExpr;
+/** Checked member assignment evaluates the reference before its RHS and
+ * yields the original assigned value, including in a chained assignment. */
+export declare function lowerDynMemberAssignment(lowerer: Lowerer, expr: ts.BinaryExpression, recv: IrExpr): IrExpr;
+/** `typeof` of a Node 24 Web-platform constructor global or one of its
+ * static methods: "function", decided by name. The read has no effects.
+ * Static methods answer by name because after a `typeof
+ * globalThis.AbortSignal === "function" &&` guard the checker narrows a
+ * fallback-typed receiver to never, hiding the member's declaration. */
+export declare function constructorGlobalTypeof(lowerer: Lowerer, tested: ts.Expression): string | null;
+/** An operand of `+` with a string: ToString of ToPrimitive with the
+ * default hint, which tries a class instance's valueOf before toString. */
+export declare function concatOperand(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
@@ -224,38 +209,34 @@ export declare function ensureString(lowerer: Lowerer, e: IrExpr, node: ts.Node)
  * 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. */
-/** `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;
-export declare function lowerPrefixUnary(lowerer: Lowerer, expr: ts.PrefixUnaryExpression): IrExpr;
-/** Member updates evaluate the reference once, convert its old value with
- * ToNumeric, store the new value, then yield the old or new numeric value. */
-export declare function lowerIncDec(lowerer: Lowerer, expr: ts.PrefixUnaryExpression | ts.PostfixUnaryExpression, prefix: boolean): IrExpr;
-/** Numeric updates read the represented slot once and write the computed
- * value back in that same representation. In particular, an unchecked
- * indexed initializer can leave undefined in an otherwise numeric binding. */
-export declare function lowerIncDecTarget(lowerer: Lowerer, expr: ts.PrefixUnaryExpression | ts.PostfixUnaryExpression, target: {
-    id: string;
-    type: IrType;
-}, prefix: boolean): IrExpr;
-export declare function lowerCompoundValueToTarget(lowerer: Lowerer, expr: ts.BinaryExpression, compound: CompoundOp, target: {
-    id: string;
-    type: IrType;
-}): IrExpr;
-export declare function lowerBinary(lowerer: Lowerer, expr: ts.BinaryExpression): IrExpr;
+/** `old op= rhs` over two bigints: the binary operator's libCall. Null
+ * for other operand types (and `>>>`, which BigInt does not have). */
+export declare function bigintCompoundValue(op: CompoundOp, left: IrExpr, right: IrExpr, loc: SrcLoc): IrExpr | null;
+/** The runtime operator of a compound assignment over two checked-dynamic
+ * operands (Node's ToPrimitive/ToNumeric order lives in the runtime). */
+export declare function dynCompoundValue(op: CompoundOp, left: IrExpr, right: IrExpr, loc: SrcLoc): IrExpr;
+/** SC1043 for a compound assignment whose operand types have no lowering,
+ * naming the operator and both types rather than the comparison wording. */
+export declare function compoundUnsupported(lowerer: Lowerer, node: ts.Node, op: CompoundOp, target: IrType, value: IrType): never;
+/** SC1043 for an arithmetic, unary or update operator whose operand types
+ * have no lowering (comparisons keep the registry wording). */
+export declare function operatorUnsupported(lowerer: Lowerer, node: ts.Node, op: string, operands: readonly IrType[]): never;
+/** `typeof e === "lit"` / `typeof e !== "lit"` where e is a catch
+ * binding: the runtime kind test over the snapshot's tag. Only the
+ * primitive literals narrow ("string"/"number"/"boolean" — exactly what
+ * the exception cell can distinguish); "object"/"function"/"undefined"
+ * cannot be answered from the payload kinds (a thrown array and a thrown
+ * record are both refs) and get the instanceof hint. Null when neither
+ * side is a typeof over a catch binding (not this pattern). */
+/** The %Error-rooted object type inside a checker type, or null: the
+ * direct mapping when it IS one, else the first mappable %Error-rooted
+ * constituent of an intersection (`Error & Record<"code", unknown>` —
+ * what `err instanceof Error && "code" in err` narrows a catch binding
+ * to; the refinement parts are type-level decoration, the VALUE is the
+ * error object). */
+export declare function errorRootedObjectOf(lowerer: Lowerer, t: ts.Type): IrType | null;
 export declare function lowerCaughtTypeofTest(lowerer: Lowerer, expr: ts.BinaryExpression, loc: SrcLoc): IrExpr | null;
+export declare function typeofAnswer(arm: IrType): string | 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)`
@@ -275,11 +256,27 @@ export declare function aliasTypeofNarrows(lowerer: Lowerer, cond: ts.Expression
     sym: ts.Symbol;
     tsArm: ts.Type;
 }[];
+/** Visit both operand orders while keeping the sequence an array of pairs. */
+export declare function operandPairs(expr: ts.BinaryExpression): [ts.Expression, ts.Expression][];
+/** The module global holding the value an accessor export had when an
+ * ES-module importer first linked its CommonJS module. */
+export declare function cjsAccessorSnapshotOf(lowerer: Lowerer, getter: ts.GetAccessorDeclaration): {
+    id: string;
+    type: IrType;
+} | null;
+/** Node's ES-module loader reads every lexer-visible export of a CommonJS
+ * module once, when an importer first links it, and the import bindings
+ * keep those values. For the accessors a bundler rewrite introduced, the
+ * importer's link point runs each getter once, in the lexer's order, and
+ * stores the values its bindings read. Empty when the module has none. */
+export declare function cjsAccessorSnapshotStores(lowerer: Lowerer, dep: ts.SourceFile, loc: SrcLoc): IrStmt[];
+/** The interned lifted-getter call both accessor-read paths share. */
+export declare function cjsAccessorCall(lowerer: Lowerer, getter: ts.GetAccessorDeclaration, loc: SrcLoc): 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
- * with a kind-unchecked `caughtNarrow` extraction (trust-the-checker,
- * exactly like unionNarrow). Every OTHER read is the narrowness fence:
+ * with a `caughtNarrow` extraction whose kind backends verify at run time,
+ * 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;
@@ -294,20 +291,10 @@ export declare function caughtToString(lowerer: Lowerer, node: ts.Expression): I
  * 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. */
-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
+ * what remains here is the flag-alphabet fence (d is a
+ * declared-valid TS flag 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
@@ -315,49 +302,60 @@ export declare function lowerInstanceOf(lowerer: Lowerer, expr: ts.BinaryExpress
  * 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). */
-export declare function matchResultNamedGroupsOf(lowerer: Lowerer, e: ts.Expression): {
+/** 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;
-/** 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(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. */
-export declare function lowerGroupsProjection(lowerer: Lowerer, recv: IrExpr, groups: {
+/** 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(lowerer: Lowerer, e: ts.Expression): string | null;
+/** The initializer behind a CONST identifier binding (a plain
+ * VariableDeclaration under a const list) — the one-hop provenance step
+ * the regex traces walk. Null for let/var (reassignable), params,
+ * destructured bindings, and unresolvable names. */
+export declare function constInitializerOf(lowerer: Lowerer, ident: ts.Identifier): ts.Expression | null;
+/** The regex behind `param` when it is the first parameter of an inline
+ * callback whose rows come from a matchAll drain. */
+export declare function matchAllCallbackRegexOf(lowerer: Lowerer, param: ts.ParameterDeclaration): ts.Expression | null;
+/** The named groups of the rows `param` receives when it is the first
+ * parameter of an inline matchAll callback (matchAllCallbackRegexOf). */
+export declare function matchCallbackParamGroupsOf(lowerer: Lowerer, param: ts.ParameterDeclaration): {
     name: string;
     index: number;
-}[], loc: SrcLoc): IrExpr;
-/** Field reads use the shared FieldTarget union. Native method reads select
- * 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). */
-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(lowerer: Lowerer, access: ts.PropertyAccessExpression): FieldTarget | null;
+}[] | null;
+/** The regex argument of a (possibly const-stored) `s.matchAll(re)`. */
+export declare function matchAllRegexOf(lowerer: Lowerer, e: ts.Expression): ts.Expression | null;
+/** A number-keyed read in JavaScript on an array that may be undefined or
+ * null outside an optional chain (`m[1]` on a `RegExpExecArray | null`
+ * that an earlier statement ruled non-null without narrowing it): the
+ * array arm is an ordinary JavaScript element read, so a hole, a present
+ * undefined (a regex group that did not participate) or an invalid index
+ * answers undefined, as lowerSafeIndexRead does for a plain array. The
+ * unit arms keep the keyed read's answer. The receiver and key evaluate
+ * once, in source order. Null when the union is not exactly one array arm
+ * beside unit arms; optional-chain tails and TypeScript keep the keyed
+ * read. */
+export declare function lowerOptionalArrayIndexRead(lowerer: Lowerer, expr: ts.ElementAccessExpression, value: IrExpr, key: IrExpr): IrExpr | null;
+/** A structural assertion can leave the value in its original class
+ * representation, including an unchecked array read's undefined arm. Only
+ * a single nominal payload has an unambiguous property layout. Validate
+ * that payload before dispatching a field or accessor; an absent receiver
+ * must never reach the backend as an object pointer. */
+export declare function hasClassPayload(lowerer: Lowerer, type: IrType): boolean;
+export declare function representedClassFieldTarget(lowerer: Lowerer, receiverNode: ts.Expression, fieldName: string, value: IrExpr): 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
@@ -384,15 +382,9 @@ export declare function symbolFieldInfo(lowerer: Lowerer, expr: ts.ElementAccess
     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. */
-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(lowerer: Lowerer, target: FieldTarget, value: IrExpr, loc: SrcLoc, blame: ts.Node): IrStmt;
+/** `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(lowerer: Lowerer, expr: ts.ElementAccessExpression): FieldTarget | null;
 /** `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
@@ -420,3 +412,13 @@ export declare function lowerPromiseAllTupleCall(lowerer: Lowerer, call: ts.Call
  * 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;
+/** The primitive-constructor closure (`String`/`Number`/`Boolean` as a
+ * VALUE): interns one synthesized module function per constructor/ABI and
+ * returns the zero-capture closure over it. Typed sources use the mapped
+ * `(value: string) => primitive` signature; a recognized JavaScript
+ * concise-arrow selector (`() => String`, the picocolors fallback) takes
+ * dyn so its ordinary coercion signature survives inference residue. The
+ * dyn bodies run exact ToString/ToNumber/ToBoolean, including object hooks.
+ * Interning makes every reference under one ABI the SAME immortal closure,
+ * so `opt.type === String` compares like JS function identity. */
+export declare function primitiveCtorClosure(lowerer: Lowerer, name: "String" | "Number" | "Boolean" | "BigInt", loc: SrcLoc, dynamicInput: boolean): IrExpr;