@scriptc/compiler 0.2.4 → 0.2.5

package/dist/frontend/lowering/lowerer.d.ts

@@ -1,25 +1,28 @@
+import type { FieldLift } from "./coercions/structural-plans.js";
+import { CoercionState } from "./coercions/state.js";
 import { RuntimeOptionalLocals } from "./runtime-optional-locals.js";
 import type { WidthLift } from "./width-lift.js";
-export type { WidthLift } from "./width-lift.js";
 import { type FnCtx } from "./function-context.js";
-export { newFnCtx, type FnCtx } from "./function-context.js";
 import type { FrontendServices } from "../services.js";
 import { DeferredModuleInitializers } from "./deferred-module-initializers.js";
 import type { ClassSymbolKey } from "./symbol-fields.js";
 import type { HttpClientFnBinding } from "./lower-server.js";
+export type { WidthLift } from "./width-lift.js";
+export { newFnCtx, type FnCtx } from "./function-context.js";
 import * as ts from "../ts7/adapter.js";
 import { type UnionLiteral } from "../union-discriminants.js";
 import type { ScrDiagnostic } from "../../diagnostics/diagnostic.js";
 import { UNSUPPORTED } from "../../diagnostics/diagnostic.js";
 import type { IrClassDef, IrExpr, IrFfiImport, IrFunction, IrGlobal, IrLocal, IrModule, IrParam, IrRecordShape, IrStmt, IrType, IrUnionDef, SrcLoc } from "../../ir/ir.js";
-import { type DynamicImportResolution, type NpmBuiltinUse, type NpmLazyTrap } from "../npm.js";
+import type { DynamicImportResolution, NpmBuiltinUse, NpmLazyTrap } from "../npm.js";
 import { type StartupCrash } from "../program.js";
 import { ShapeRegistry, type TypeMapperCtx, UnionRegistry } from "../type-mapper.js";
 import { type CompoundOp, type IslandFnEntry, type BuiltinModuleFn } from "./surfaces.js";
 import { type FileParts } from "./lower-modules.js";
 import { type ClassInfo, type ClassIteratorInfo, type GenericClassInfo, findStaticOn } from "./lower-classes.js";
 import { type MixinFnShape } from "./lower-mixins.js";
-import { type ParamShape, type FnSig, type GenericFnInfo, type GenericInstance } from "./lower-calls.js";
+import { type ParamShape, type FnSig } from "./call-signatures.js";
+import { type GenericFnInfo, type GenericInstance } from "./generic-functions.js";
 import { type ComputedEventPattern, type EmitSpecCtx, type EmitSpecRequest, type EventSig } from "./lower-event-emitter.js";
 import { type FieldTarget } from "./lower-exprs.js";
 import type { ExpandoMembers } from "./lower-expando.js";
@@ -278,21 +281,6 @@ export declare function uncheckedOverloadHandleCall(lowerer: Lowerer, expr: ts.E
  * `never` at the ROOT stays out (`for (const v of [])`'s loop var — the
  * dead read the f64 mapping is FOR). */
 export declare function neverTaintedJsType(lowerer: Lowerer, node: ts.Node, t: ts.Type): boolean;
-/** The dyn undefined value — what an uninitialized checked-dynamic
- * binding holds (JS: declared bindings read `undefined` before any
- * assignment). A NULL dyn slot is a trap, never a value, so every dyn
- * binding that is READABLE before its first assignment must start here:
- * `let x;` declarations, hoisted `var`s (function and module scope,
- * forward captures included), and the implicit-return completion
- * (lower-calls' own copy of this pattern predates the helper). */
-export declare function dynUndefinedExpr(loc: SrcLoc): IrExpr;
-/** An always-throwing Node-parity error expression (the error.nodeThrow
- * libCall — the lowered form of arms Node rejects unconditionally:
- * ERR_INVALID_THIS receivers, ERR_MISSING_ARGS arity ladders, the
- * symbol-to-string TypeError). kind 0 Error / 1 TypeError / 2 RangeError;
- * an empty code means no code slot. `type` is the replaced expression's
- * own (never materialized — the global.undefRead pattern). */
-export declare function nodeThrowExpr(kind: 0 | 1 | 2 | 5, code: string, message: string, type: IrType, loc: SrcLoc): IrExpr;
 /** The post-validation fence STRING a validation-ladder Chk libCall
  * throws after its Node-order checks pass: the same SC2020 text the
  * per-statement runtime fence would have thrown (message + "[code at
@@ -429,8 +417,8 @@ export declare class Lowerer {
      * the body needs — indexed accesses (`T[K]` needs K's literal key) and
      * keyed record reads (`o[k]` where k's type is a literal-bound K). */
     typeParamTsBindings: Map<ts.Symbol, ts.Type> | null;
-    /** Non-null while an IMPLICIT-ANY instance body lowers (npm-static JS —
-     * lower-calls' implicit-monomorphization section): bound param symbol →
+    /** Non-null while an IMPLICIT-ANY instance body lowers (npm-static JS;
+     * see generic-functions.ts): bound param symbol →
      * the call site's checker type, consulted by typeOf for identifier
      * references the checker still types `any`. The implicit twin of
      * typeParamBindings — the checker has no `T` to substitute, so the
@@ -569,31 +557,17 @@ export declare class Lowerer {
     readonly emitSpecDone: Set<string>;
     readonly emitSpecQueue: EmitSpecRequest[];
     emitSpecCtx: EmitSpecCtx | null;
-    /** Width-coercion helpers (%rec.width.N / %arr.width.N), interned per
-     * (from, to) shape pair — see widthCoerce. */
-    readonly widthHelpers: Map<string, string>;
-    /** (fromShape, toShape) pairs whose width plan is being computed — the
-     * cycle guard for RECURSIVE shapes (a self-referential record narrowing
-     * into a self-referential subset). Re-entering an in-progress pair
-     * answers "assume coercible" (the greatest fixed point: every OTHER
-     * constraint of the cycle is still checked by the outer call, and the
-     * built helper terminates because recordWidthHelper interns its name
-     * before building the body, so the recursive reference resolves to the
-     * helper itself). */
-    private readonly widthPlanning;
+    readonly coercions: CoercionState;
+    /** Generated value helpers, keyed by operation and type. Callers own
+     * their key prefixes; this includes more than structural conversions. */
+    readonly valueHelpers: Map<string, string>;
     /** Interned node:assert helpers (deep-equality comparisons keyed by
      * typeKey, throws wrappers keyed by callback type + expected class) —
-     * the widthHelpers pattern with its own namespace. */
+     * the valueHelpers pattern with its own namespace. */
     readonly assertHelpers: Map<string, string>;
     /** util.inspect's per-type traversal helpers (%util.insp.N), interned
      * by typeKey — the assertHelpers pattern with its own namespace. */
     readonly inspectHelpers: Map<string, string>;
-    /** Union re-tag helpers (%union.retag.N), interned per (from, to)
-     * unionId pair — see unionRetagHelper. */
-    readonly retagHelpers: Map<string, string>;
-    /** Copy-only routes depend on the two union contracts and discriminator
-     * layouts, without recursive width assumptions or evolving class members. */
-    private readonly copyRetagHelpers;
     private readonly unionLiteralOwners;
     private readonly strippedUndefinedArms;
     private readonly addedUndefinedArms;
@@ -626,18 +600,10 @@ export declare class Lowerer {
             kind: "func";
         };
     }>;
-    readonly narrowHelpers: Map<string, string>;
-    /** Exact members of narrowHelpers produced by narrowedArmHelper. This
-     * lets property consumers recognize an earlier checked extraction by
-     * provenance instead of relying on its generated-name prefix. */
-    private readonly checkedNarrowHelpers;
     /** Interned `%iter.drain.<n>` helpers (classIteratorDrainCall): one per
      * receiver class — the eager drain of a class iterable's protocol into
      * a fresh element array, behind array/call spreads. */
     readonly iterDrainHelpers: Map<string, string>;
-    /** Island-lift builder helpers (%jsin.rec.N / %jsin.arr.N /
-     * %jsin.elems.N), interned per source type — see jsvalLiftExpr. */
-    readonly jsinHelpers: Map<string, string>;
     /** Synthetic Map.forEach loop functions, interned per key/value type +
      * callback arity: key → fn name (see lowerMapForEachCall). */
     readonly mapHofHelpers: Map<string, string>;
@@ -1324,118 +1290,19 @@ export declare class Lowerer {
      * else (including a DIFFERENT union) is left for requireExactShape, which
      * rejects union mismatches with SC2003. */
     coerceToExpected(expr: IrExpr, expected: IrType): IrExpr;
-    /** Copy-based structural WIDTH coercion — a `Full` record flowing into a
-     * narrower `{ id }` slot, or `Full[]` into `{ id }[]` (the Pick-typed
-     * display-table pattern): TS's width subtyping is free on erased types,
-     * but monomorphic structs must RESHAPE, so the value is rebuilt with the
-     * subset of fields copied — per element, via an interned helper, for
-     * arrays. A deliberate divergence from JS's aliasing (SEMANTICS.md 35,
-     * next to the marshal-copy stance): mutations through the narrowed value
-     * don't reach the original and vice versa. Exactly two flows coerce —
-     * record→record and record-array→record-array, each target field copied
-     * from a same-named source field whose type matches exactly or LIFTS
-     * into the target field's union (see recordWidthHelper); anything
-     * deeper keeps the exactness fences. Null when the pair isn't
-     * width-coercible. */
     widthCoerce(expr: IrExpr, expected: IrType): IrExpr | null;
-    /** One step of the recursive width-lift relation: how a `src`-typed
-     * value enters a `dst`-typed slot under the copy-reshape family. The
-     * pure planning side — nothing interns here, so whole plans validate
-     * before any helper exists. The cases, in order:
-     *   copy      — exact same type (typeEquals), the field/element moves as is
-     *   retag     — union into union, every arm mapped (unionRetagMappable —
-     *               identity arms and compatible payload conversions; a shared
-     *               discriminant may select different record destinations)
-     *   wrap      — a non-unit arm value into a union that contains it
-     *   discriminantWrap — identical recursive layouts distinguished by
-     *               their literal field value rather than their storage id
-     *   liftWrap  — a record/array value into a union with NO identical arm
-     *               but exactly ONE arm it width-lifts into (the findRoute
-     *               rule applied at every level; several candidates are
-     *               ambiguous and decline)
-     *   width     — record into a strict-subset record (recordWidthPlan,
-     *               recursively — NESTED width)
-     *   arr       — array into array whose element pair lifts (per-element
-     *               copy loop, arrayWidthHelper)
-     *   dynIn     — a typed value into an 'unknown' (dyn) slot — the same
-     *               static→dyn deep copy coerceToExpected applies top-level
-     *   upcast    — a derived class instance into a base-typed slot (the
-     *               prefix-layout pointer reinterpret, no copy)
-     *   funcAdapt — a function into a slot whose signature differs only by
-     *               CLEAN mechanical conversions (cleanFuncAdaptable); the
-     *               stranded (trap-only) dispositions stay out of the plan
-     * Null when the pair isn't in the relation — callers keep their fences. */
     widthLiftPlan(src: IrType, dst: IrType): WidthLift | null;
-    /** True for the unit-only element types (`(null | undefined)[]`, the
-     * `readonly []` mapping): a union whose every arm is a unit. */
     unitOnlyElem(t: IrType): boolean;
-    /** The build side of widthLiftPlan: the IrExpr converting `value` into
-     * `dst` under a plan the caller validated. Interns whatever helpers the
-     * lift needs (planned first, so the interns cannot fail — a failure here
-     * is a lowerer bug, not a user diagnostic). */
     applyWidthLift(lift: WidthLift, value: IrExpr, dst: IrType, loc: SrcLoc): IrExpr;
-    /** Dispatch a structural copy from its runtime union tag. Each record
-     * payload has its own field offsets and optional-field completions;
-     * interpreting all arms as the destination layout would corrupt memory.
-     * Intern before descending so recursive record unions can reuse it. */
     unionRecordWidthHelper(fromId: string, target: IrType & {
         kind: "record";
     }, loc: SrcLoc): string;
-    /** Interned `%rec.width.<n>(r)` — builds the target shape from a source
-     * record by copying fields: every target field must exist on the source
-     * with the EXACT same type, or with a type that LIFTS under
-     * widthLiftPlan — an arm value wraps (`text: string` into
-     * `text?: string`), a whole union re-tags (unionRetagMappable), a field
-     * whose own record/array type needs narrowing reshapes RECURSIVELY
-     * (nested width — the copy stance applies per level), and a MISSING
-     * optional-flavored field completes to its undefined arm (the
-     * literal-completion rule). TUPLES width-coerce too, arity-exact (TS
-     * permits no other tuple width): per-position lifts, never completion.
-     * Index-signature SOURCES narrow here like any wider record — declared
-     * fields copy, the overflow drops with the width (missing target
-     * fields decline: the overflow could hold them). Index-signature
-     * TARGETS keep the overflow CAPTURE helper (widthCoerce's other arm).
-     * Null when the shapes don't relate that way. */
-    /** The pure planning half of recordWidthHelper — every target field's
-     * lift, or null when the pair isn't width-coercible. Callers that must
-     * validate a WHOLE plan before interning anything (the retag helper's
-     * per-arm width lifts) probe with this. */
-    recordWidthPlan(fromId: string, toId: string): Map<string, {
-        src: IrType;
-        lift: WidthLift;
-    } | {
-        absent: true;
-        utag: number;
-    } | {
-        absentDyn: true;
-    }> | null;
-    /** Post-hoc classifier for SC2002's record→record residue: WHY the
-     * width family (recordWidthPlan and the overflow capture — widthCoerce's
-     * two record arms) declined this pair — the FIRST blocking rule, named.
-     * Pure description on the failure path (the site already carries the
-     * rejection): mirrors the planners' gates, never changes what coerces,
-     * and answers null when no pointed story applies (the generic message
-     * stands). */
+    recordWidthPlan(fromId: string, toId: string): Map<string, FieldLift> | null;
     describeRecordWidthBlocker(fromId: string, toId: string): string | null;
     recordWidthHelper(fromId: string, toId: string, loc: SrcLoc): string | null;
-    /** Interned `%arr.width.<n>(a)` — the per-element copy loop over
-     * widthLiftPlan's element lift: out = []; n = a.length; for (...)
-     * out.push(lift(a[i])); return out. Record elements reshape
-     * (recordWidthHelper), union elements wrap or re-tag (`number[]` into
-     * `(number | undefined)[]`), nested arrays recurse. Null when the
-     * element pair isn't width-liftable. */
-    /** Interned `%tup.arr.<n>(t)` — rebuilds a TUPLE as an ARRAY: positions
-     * read in order, each lifted into the element type under widthLiftPlan.
-     * Null unless the source shape really is a tuple whose every position
-     * lifts (records with named fields never relate to arrays). */
     tupleArrayWidthHelper(fromId: string, toT: IrType & {
         kind: "array";
     }, loc: SrcLoc): string | null;
-    /** Interned `%arr.empty.<n>(a)` — the EMPTY-array lift's build side: a
-     * unit-only-element array reshapes into any data-element array by
-     * answering a FRESH empty array, after a runtime non-empty trap (a
-     * genuinely inhabited `(null | undefined)[]` cannot reshape — the
-     * catchable-TypeError stance every checked extraction takes). */
     emptyArrayLiftHelper(fromT: IrType & {
         kind: "array";
     }, toT: IrType & {
@@ -1446,39 +1313,8 @@ export declare class Lowerer {
     }, toT: IrType & {
         kind: "array";
     }, loc: SrcLoc): string | null;
-    /** The planning half of objRecordWidthHelper — how a CLASS INSTANCE
-     * projects into a record shape (tsc's structural view of classes makes
-     * `new Point(0,0)` flow into `{x: number; y: number}` slots). Every
-     * target field must be a plain instance FIELD on the class (inherited
-     * included) whose type lifts, or a missing optional-flavored field
-     * completing to its undefined arm — but never a field the class
-     * satisfies through a METHOD or accessor (bound method references have
-     * no lowering; the plan declines instead of projecting a lie). Builtin
-     * runtime layouts (the Error/EventEmitter/stream chains) decline: their
-     * fields aren't plain emitted storage. */
-    objToRecordPlan(className: string, toId: string): Map<string, {
-        src: IrType;
-        lift: WidthLift;
-    } | {
-        absent: true;
-        utag: number;
-    }> | null;
-    /** Interned `%obj.width.<n>(o)` — builds a record from a class
-     * instance's fields under objToRecordPlan: the width-copy stance
-     * (divergence 305 — a fresh record, mutations don't alias, extra class
-     * members drop). */
+    objToRecordPlan(className: string, toId: string): Map<string, FieldLift> | null;
     objRecordWidthHelper(className: string, toId: string, loc: SrcLoc): string | null;
-    /** The planning half of recordClassWidthHelper — how a RECORD enters a
-     * class-instance slot. Construction IS the projection, so the class
-     * must be a pure parameter-property data class: its own trivial
-     * constructor (every parameter a parameter property, empty body), no
-     * other fields, no methods/accessors anywhere in the chain (a
-     * fabricated instance must carry no behavior the record lacks), no
-     * decoration, no base beyond a generic FAMILY ancestor (fieldless and
-     * methodless by construction). Each constructor parameter takes the
-     * same-named source field under widthLiftPlan, or — omittable params —
-     * the absent undefined arm. One entry per constructor parameter, in
-     * parameter order. */
     recordToClassPlan(fromId: string, className: string): ({
         field: string;
         src: IrType;
@@ -1486,84 +1322,24 @@ export declare class Lowerer {
     } | {
         absent: true;
     })[] | null;
-    /** Interned `%cls.width.<n>(r)` — `new C(r.p1, ..., r.pn)` under
-     * recordToClassPlan: the record's fields become the trivial
-     * constructor's arguments (divergence 305's copy stance — a fresh
-     * instance, mutations don't alias, and `instanceof C` answers true
-     * where Node's plain object answers false). */
     recordClassWidthHelper(fromId: string, className: string, loc: SrcLoc): string | null;
-    /** A CLASS VALUE's statics projected into a record shape (`var f:
-     * ShapeFactory = Shape`): the record literal capturing static FIELDS as
-     * copies of their globals and static METHODS as the zero-capture
-     * closures `const f = C.m` builds (params all required — value-form
-     * completion rules stay out of coercions). Inherited statics resolve
-     * like JS's class-object prototype walk. Divergence 305's copy stance:
-     * later writes to a writable static field don't flow into the record
-     * (Node aliases the one class object). Null when any target field has
-     * no projectable static. */
     classStaticsProjection(className: string, toId: string, loc: SrcLoc): IrExpr | null;
-    /** Interned `%fn.width.<n>(f)` — the function-RETURN width adapter: a
-     * zero-param `() => Wide[]` value flowing into a `() => Narrow[]` slot
-     * (the createProxyServer getRoutes shape) wraps in a fresh closure that
-     * calls the original and maps the result through the per-element record
-     * width copy (%arr.width). The adapter is a factory lifted function
-     * whose param the returned closure captures; each invocation of the
-     * adapted value builds a FRESH array of narrowed records (the width
-     * machinery's copy stance — callers see the values, not the identity).
-     * Null when the return shapes aren't width-coercible; bounded to
-     * zero-param signatures (the one observed site — widening needs a
-     * param-forwarding story nothing drives yet). */
     funcReturnWidthAdapter(fromT: IrType & {
         kind: "func";
     }, toT: IrType & {
         kind: "func";
     }, loc: SrcLoc): string | null;
-    /** Whether a `src`-typed VALUE converts into a `dst` slot through the
-     * coercions coerceToExpected applies mechanically — the PURE probe
-     * behind funcCoerceAdapter (nothing interns): exact types, arm wraps
-     * into unions, whole-union re-tags (unionRetagMappable), checked
-     * single-arm narrows, void into an undefined-armed union, and the dyn
-     * boundary in both directions (dynFrom / dynCheck's JSON-safe domain).
-     * Deliberately EXCLUDES the trap-only stranded conversions — an adapter
-     * that could only ever throw is a fence, not a bridge. */
     coercibleValue(src: IrType, dst: IrType): boolean;
-    /** True when a `src` function value enters a `dst` slot through
-     * funcCoerceAdapter with NO stranded (trap-only) piece: no rest packs,
-     * no surplus source params, every slot parameter converts into the
-     * wrapped function's own type, and the result converts back (a void
-     * slot drops it; a void result answers the exact JS undefined for
-     * dyn/jsval slots). The width family's func gate — widthLiftPlan
-     * bridges only signatures whose every call succeeds by construction. */
     cleanFuncAdaptable(src: IrType & {
         kind: "func";
     }, dst: IrType & {
         kind: "func";
     }): boolean;
-    /** Interned `%fn.adapt.<n>(f)` — the GENERAL function-value adapter: a
-     * `fromT` function value flowing into a `toT` slot whose pieces differ
-     * only by coercibleValue conversions. The slot's callers pass toT's
-     * parameters: the wrapper takes them, converts the first
-     * fromT.params.length into the wrapped function's own types (surplus
-     * slot parameters are DROPPED — JS's extra-argument rule), calls it,
-     * and converts the result back (a void slot drops the result; a void
-     * result wraps as the slot union's undefined arm). Rest signatures on
-     * either side decline (the pack shapes don't line up mechanically).
-     * Null when any piece is outside coercibleValue — the exactness fences
-     * stay. */
     funcCoerceAdapter(fromT: IrType & {
         kind: "func";
     }, toT: IrType & {
         kind: "func";
     }, loc: SrcLoc): string | null;
-    /** The spawnSync-runner VALUE adapter's plan — a function returning the
-     * opaque spawnRes flowing into a slot whose signature returns the
-     * STRUCTURAL result record tsc accepted (`defaultRunner` into a
-     * `CommandRunner` param: `{ status: number | null; stdout?: string;
-     * stderr?: string; error?: Error }`). Parameters must agree pairwise;
-     * each target field must be one of the spawnRes reads (status, stdout,
-     * stderr, error) at its exact lowered type — string fields optionally
-     * undefined-armed. Null when the pair isn't this shape. Pure: callers
-     * probe before interning. */
     spawnResFnAdapterPlan(fromT: IrType & {
         kind: "func";
     }, toT: IrType & {
@@ -1572,54 +1348,14 @@ export declare class Lowerer {
         field: string;
         build: (r: IrExpr, loc: SrcLoc) => IrExpr;
     }[] | null;
-    /** Interned `%fnval.spawnres.<n>(f)` — the runner-value adapter: a
-     * fresh closure of the TARGET signature forwarding its arguments to the
-     * captured function and converting the opaque spawnRes result into the
-     * target's structural record (one eager read per declared field —
-     * spawnResFnAdapterPlan's set). Divergence caveat: stdout/stderr read
-     * as the captured text ("" when nothing was captured, e.g. stdio
-     * "inherit") where Node stores null. */
     spawnResFnAdapter(fromT: IrType & {
         kind: "func";
     }, toT: IrType & {
         kind: "func";
     }, loc: SrcLoc): string | null;
-    /** Validate the complete union conversion before interning helpers.
-     * Recursive width plans close through the same in-progress pair guard;
-     * no optimistic result is memoized after that planning stack unwinds. */
     unionRetagMappable(fromId: string, toId: string): boolean;
-    /** A checker-NARROWED union flowing into a different union: `typeof r
-     * === "string" || Buffer.isBuffer(r)` proves the record arm of r away,
-     * then `{ data: r }` needs `Buffer | string | Rec` in a `Buffer | string`
-     * slot. Control-flow narrowing to a sub-union erases at lowering, so the
-     * IR value still carries the wide union — but the SITE's checker type
-     * names exactly the arms still possible, and every one of those must
-     * exist in both unions. The stranded arms compile to trap cases exactly
-     * like stranded units (divergence 38's trust-the-checker stance): sound
-     * narrowing never reaches them, a lying cast throws a catchable
-     * TypeError instead of smuggling an unrepresentable arm. Null when the
-     * site type isn't a genuine sub-union of the source (the SC2003 fence
-     * stays). */
     narrowedRetagHelper(node: ts.Node, fromId: string, toId: string, loc: SrcLoc): string | null;
-    /** The stranded-UNIT trap for PLAIN (non-union) slots: a null/undefined
-     * value flowing into a non-nullable typed slot the checker approved —
-     * `null!` and `null as any as T` casts, and the non-strict world's
-     * legal `let s: string = null`. The compiled representation has no null
-     * to carry, so the FLOW throws the catchable stranded TypeError
-     * (divergence 38's stance: Node lets the impossible value ride until it
-     * is used; the trap surfaces at the assignment instead). Unit sources
-     * only — they are pure, so the nullary helper evaluates nothing. */
     strandedUnitTrap(expr: IrExpr, expected: IrType, loc: SrcLoc): IrExpr | null;
-    /** The STRANDED-SOURCE trap: a checker-approved value flowing into a
-     * union that cannot represent it (armTag < 0, no class widening, no
-     * width lift). Only shapes that PROVE a lying assertion trap: unit
-     * sources (null/undefined literals smuggled through `null!` / `as any`
-     * casts), and record/array sources with ZERO same-family width-lift
-     * candidates among the arms — an AMBIGUOUS lift (several candidates)
-     * stays a compile fence, because honest code lands there. The interned
-     * helper evaluates the operand (JS evaluates it too) and throws the
-     * stranded-arm TypeError verbatim. Null when the shape doesn't prove
-     * the lie. */
     strandedCoercionTrap(expr: IrExpr, expected: IrType & {
         kind: "union";
     }, loc: SrcLoc): IrExpr | null;
@@ -1627,65 +1363,13 @@ export declare class Lowerer {
         kind: "record";
     }, toId: string, loc: SrcLoc): string | null;
     unionRetagHelper(fromId: string, toId: string, loc: SrcLoc, trappable?: ReadonlySet<number>): string | null;
-    /** Interned `%union.narrow.<n>(u)` — the CHECKED single-arm extraction
-     * behind `x!` on union values: the asserted arm's payload comes out
-     * (+1 for ref arms, like any unionNarrow), and every OTHER arm throws
-     * the catchable TypeError — divergence 38's lying-assertion stance (an
-     * unchecked unionNarrow would misread the payload where JS lets the
-     * impossible value flow on). Null when the target isn't a non-unit arm
-     * of the union — those uses keep their erasure/fences. */
     narrowedArmHelper(fromId: string, target: IrType, loc: SrcLoc): string | null;
-    /** The DEFERRED-INIT field read (`stream!: T` assigned past the
-     * constructor's top level — the slot is `T | undefined`): interned
-     * `%deferred.read.<n>(u)` extracting the declared type. SCALAR arms
-     * whose JS-undefined behavior a unit default reproduces read that
-     * default — bool false (conditions are exact: undefined and false are
-     * both falsy; only printing/strict-equality could tell) and f64 NaN
-     * (arithmetic and conditions exact) — while string and REF arms keep
-     * the checked-extraction TRAP: JS itself TypeErrors the first member
-     * use of such an undefined, so the catchable TypeError at the read is
-     * the same failure, named earlier (SEMANTICS.md). */
     deferredReadHelper(fromId: string, target: IrType, loc: SrcLoc): string | null;
-    /** True when a static value can become ONE island value: jsval itself,
-     * anything boundary-safe (the deep JSON marshal), a record whose fields
-     * all can (built as an island OBJECT literal, field by field), or an
-     * array of such (built as an island ARRAY, element by element). The
-     * lift beyond boundarySafe exists for jsval-BEARING composites —
-     * `{ role: string; content: any[] }[]` flowing into an `any[]` slot —
-     * which have no JSON serialization (a handle isn't JSON) but an honest
-     * per-field construction. Recursion terminates: recursive shapes are
-     * rejected at mapping time. */
     jsvalLiftable(t: IrType, visiting?: Set<string>): boolean;
-    /** A jsval-typed expression carrying `e`'s value into the island —
-     * jsvalLiftable's constructive side. Primitives and JSON-safe composites
-     * keep the jsMarshal deep copy; jsval-bearing records and arrays go
-     * through interned per-type builder helpers (%jsin.*), so the operand is
-     * always evaluated exactly once (as the helper's argument). */
     jsvalLiftExpr(e: IrExpr, loc: SrcLoc): IrExpr;
-    /** Interned `%jsin.union.<n>(u)` — the runtime tag switch marshaling a
-     * union value INTO the island: unit arms become the engine's own
-     * undefined/null (JS-exact — `{ instructions: undefined }` crossing in
-     * has the property present and undefined, exactly what the source
-     * spells), every other arm narrows and lifts as itself (strings by
-     * value, JSON-safe composites as deep copies, typed arrays as engine
-     * typed-array copies, URLs as engine URL instances). Caller must have
-     * checked jsvalLiftable. */
     unionToJsvalHelper(unionId: string, loc: SrcLoc): string;
-    /** Interned `%jsin.rec.<n>(r)` — builds an island OBJECT from a
-     * jsval-bearing record: marshaled key strings, each field lifted through
-     * jsvalLiftExpr (jsval fields pass as handles, JSON-safe fields deep-copy,
-     * nested composites recurse through their own helpers). Caller must have
-     * checked jsvalLiftable. */
     recordToJsvalHelper(shapeId: string, loc: SrcLoc): string;
-    /** Interned `%jsin.arr.<n>(a)` — builds ONE island ARRAY from a native
-     * array whose elements lift: out = []; for (...) out[i] = lift(a[i]);
-     * return out. The index marshals by value like any number. Caller must
-     * have checked jsvalLiftable of the element. */
     arrayToJsvalHelper(elem: IrType, loc: SrcLoc): string;
-    /** Interned `%jsin.elems.<n>(a)` — a NATIVE array of island handles from
-     * a native array whose elements lift: the `any[]`-slot coercion (each
-     * element becomes one island value; the array stays static). Null when
-     * the element doesn't lift. */
     arrayToJsvalArrayHelper(fromElem: IrType, loc: SrcLoc): string | null;
     jsvalIn(e: IrExpr, node: ts.Node): IrExpr;
     /** THE coercion path for values flowing into a typed slot: union arms
@@ -2101,16 +1785,10 @@ export declare class Lowerer {
     lowerMapForEachCall(call: ts.CallExpression, receiver: IrExpr, mapT: IrType & {
         kind: "map";
     }): IrExpr;
-    buildMapForEachFn(name: string, mapT: IrType & {
-        kind: "map";
-    }, arity: number, fnRet: IrType, loc: SrcLoc): IrFunction;
     lowerSetMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
     lowerSetForEachCall(call: ts.CallExpression, receiver: IrExpr, setT: IrType & {
         kind: "set";
     }): IrExpr;
-    buildSetForEachFn(name: string, setT: IrType & {
-        kind: "set";
-    }, arity: number, fnRet: IrType, loc: SrcLoc): IrFunction;
     lowerRegexLiteral(expr: ts.RegularExpressionLiteral): IrExpr;
     lowerRegexMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
     lowerStringMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
@@ -2211,12 +1889,10 @@ export declare class Lowerer {
         module: string;
         member: string;
     }, loc: SrcLoc): IrExpr | null;
-    lowerChildArgsArg(node: ts.Expression | undefined, loc: SrcLoc): IrExpr;
     lowerSpawnSyncCall(expr: ts.CallExpression, loc: SrcLoc): IrExpr;
     lowerSpawnCall(expr: ts.CallExpression, loc: SrcLoc): IrExpr;
     lowerExecFileCall(expr: ts.CallExpression, loc: SrcLoc): IrExpr;
     lowerExecSyncCall(expr: ts.CallExpression, shell: boolean, loc: SrcLoc): IrExpr;
-    recordToEnvPairs(node: ts.Expression): IrExpr;
     envToPairsHelper(shapeId: string, loc: SrcLoc): string | null;
     lowerJsonMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
     fencedBuiltinImportOf(ident: ts.Identifier): string | null;
@@ -2258,12 +1934,11 @@ export declare class Lowerer {
     lowerErrorCodeProperty(expr: ts.PropertyAccessExpression): IrExpr | null;
     lowerStringDecoderMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
     lowerReadlineMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-    lowerDcChannelMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-    lowerAlsMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-    lowerDcChannelProperty(access: ts.PropertyAccessExpression): IrExpr | null;
-    lowerDcTracingChannelMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-    lowerDcTracingChannelProperty(access: ts.PropertyAccessExpression): IrExpr | null;
-    strdecHelper(op: "write" | "end" | "endChunk" | "endString" | "writeString", shapeId: string, loc: SrcLoc): string;
+    lowerDiagnosticsChannelMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerAsyncLocalStorageMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerDiagnosticsChannelProperty(access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerTracingChannelMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+    lowerTracingChannelProperty(access: ts.PropertyAccessExpression): IrExpr | null;
     lowerProcessProperty(expr: ts.PropertyAccessExpression): IrExpr | null;
     lowerFsConstantsProperty(expr: ts.PropertyAccessExpression): IrExpr | null;
     lowerBuiltinConstantsProperty(expr: ts.PropertyAccessExpression): IrExpr | null;
@@ -2282,11 +1957,6 @@ export declare class Lowerer {
     lowerTimeoutMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
     registerPromisifiedBuiltinDecl(nameNode: ts.Node, init: ts.Expression | undefined): boolean;
     lowerExecFileAsyncCall(expr: ts.CallExpression, loc: SrcLoc): IrExpr;
-    execFileAsyncHelper(loc: SrcLoc): {
-        name: string;
-        shapeId: string;
-    };
-    envSnapshotHelper(shapeId: string, loc: SrcLoc): string | null;
     lowerNumberStaticCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
     lowerDateCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
     lowerTextCodecCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;