@scriptc/compiler 0.0.0 → 0.0.2

package/dist/frontend/lowering/lower-expando.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lower-expando.js","sourceRoot":"","sources":["../../../src/frontend/lowering/lower-expando.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,524 @@
+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 { 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;
+ * fieldType is the property's one type). */
+export type FieldTarget = {
+    container: "class";
+    obj: IrExpr;
+    className: string;
+    field: string;
+    fieldType: IrType;
+} | {
+    container: "record";
+    obj: IrExpr;
+    shapeId: string;
+    field: string;
+    fieldType: IrType;
+} | {
+    container: "recordOvf";
+    obj: IrExpr;
+    shapeId: string;
+    field: string;
+    fieldType: IrType;
+} | {
+    container: "accessor";
+    obj: IrExpr;
+    className: string;
+    field: string;
+    fieldType: IrType;
+} | {
+    container: "recordAccessor";
+    obj: IrExpr;
+    shapeId: string;
+    field: string;
+    fieldType: IrType;
+    getType?: IrType & {
+        kind: "func";
+    };
+    setType?: IrType & {
+        kind: "func";
+    };
+};
+/** A template piece's RAW text (String.raw's contract: escapes stay
+ * characters). 7's client AST ships no rawText at runtime (the typing
+ * declares it; the serialized node data omits it), so the raw span comes
+ * off the SOURCE: between the piece's delimiters — backticks for the
+ * 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): 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;
+/** 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(L: 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(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;
+/** 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
+   * the two-unit-arm `== null` composition, the union `typeof` forms, and
+   * the union-switch desugar, whose operands ride several tests. */
+/** A static expression whose evaluation is unobservable — safe to DROP
+ * (typeof's constant fold: JS evaluates the operand, but when nothing in
+ * it can throw, call, write, or allocate observably, folding it away
+ * changes nothing). Strictly wider than pureReemittable: numeric
+ * arithmetic (f64 ops never throw — division by zero is Infinity),
+ * string concatenation, logical/ternary composition, and unit/literal
+ * leaves compose; anything with a call, an island op, an index read (can
+ * trap), or an unknown kind answers false. */
+export declare function droppableStatic(e: IrExpr): boolean;
+export declare function pureReemittable(e: IrExpr): 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
+   * 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(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;
+/** 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
+ * __filename; ESM files stay out (Node never defines require there —
+ * the ambient symbol would not resolve anyway). Shared by the property
+ * 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;
+/** 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;
+/** 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;
+/** 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;
+/** Truthiness needs a ToBoolean per arm: dyn/caught arms have none (a
+   * dynamic ToBoolean over the DOM / 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;
+/** 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;
+/** 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;
+/** `[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 SC2001. `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(L: Lowerer, expr: ts.ArrayLiteralExpression, expected?: IrType & {
+    kind: "array";
+}): IrExpr;
+export declare function foldedStringKeyOf(L: Lowerer, expr: ts.Expression): string | null;
+export declare function lowerObjectLiteral(L: 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) & {
+    name: ts.Identifier | ts.StringLiteral;
+};
+/** Parses the conditional-spread idiom `...(c ? { k: v, ... } : {})`
+   * (either orientation). Returns the condition, the non-empty arm's
+   * properties, and which arm carries them; "unsupported" for conditional
+   * sources OUTSIDE the idiom (both arms non-empty, computed/method
+   * members); null when the spread source isn't a conditional at all.
+   * Callers slice their own honest subset (the static record path takes
+   * exactly one property; the island literal takes any number; spawn's
+   * options walk takes a `detached` boolean literal). */
+export declare function conditionalSpreadOf(expr: ts.Expression): {
+    cond: ts.Expression;
+    props: CondSpreadProp[];
+    whenTrue: boolean;
+} | "unsupported" | null;
+/** 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;
+/** 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;
+/** `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;
+/** `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 DOM 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(L: Lowerer, expr: ts.ElementAccessExpression, shapeId: string, shape: IrRecordShape): IrExpr;
+/** 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;
+/** `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.
+   * 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 DOM. */
+/** `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;
+/** 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
+   * L.narrowingAliases: branch-scoped typeOf overrides, bridged by
+   * maybeNarrow's ordinary unionNarrow. */
+export declare function aliasTypeofNarrows(L: 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 DOM 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;
+/** 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 DOM, so
+   * un-narrowed uses have nothing sound to lower to. */
+export declare function caughtRead(L: 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;
+/** 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;
+/** `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(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;
+/** 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 are the slice fences: the flag alphabet (d and v are
+   * declared-valid TS flags outside this slice) and named capture groups
+   * (their results are unreachable without exec/match). 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;
+/** Field read `obj.f` on class-instance and record receivers, through the
+   * shared FieldTarget union (fieldGet / recordGet). Bound method references
+   * 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;
+/** 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(L: 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;
+/** 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). */
+export declare function uniqueSymbolKeyOf(L: 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. */
+export declare function symbolFieldInfo(L: 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;
+/** 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;
+/** `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. */
+export declare function lowerPromiseRejectCall(L: 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. */
+export declare function lowerPromiseAllTupleCall(L: 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;