@scriptc/compiler 0.2.3 → 0.2.5

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

@@ -1,382 +0,0 @@
-import * as ts from "../ts7/adapter.js";
-import type { Lowerer } from "./lowerer.js";
-import { type IrExpr, type IrFunction, type IrRecordShape, type IrStmt, type IrType, type SrcLoc } from "../../ir/ir.js";
-/** Object() and new Object() preserve known object inputs. Primitive
- * boxing and unproven checked-dynamic values retain their refusal. */
-export declare function lowerObjectConstructor(lowerer: Lowerer, args: readonly ts.Expression[], loc: SrcLoc): IrExpr | null;
-/** Ambient array method calls. `push`/`unshift`/`pop`/`reverse`/
- * `indexOf`/`includes`/`join`
-   * lower to arrIntrinsic; the HOF family — `map`/`filter`/`forEach`/
-   * `find`/`some`/`every`/`flatMap`/`reduce`/`reduceRight` — desugars to a
-   * direct call of a synthetic loop function (see lowerArrayHofCall and
-   * friends). Null when this isn't an ambient array method call. tsc has
-   * already checked arity and argument types against ambient/scriptc.d.ts. */
-export declare function lowerArrayMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** Tuple methods keep the original receiver alive through argument evaluation.
- * Callback methods read each position only when it is visited, so writes to
- * later positions through a captured alias are visible. A tuple cannot be
- * passed as the callback's array parameter without changing its identity;
- * that parameter retains an explicit representation boundary. */
-export declare function lowerTupleReadMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, tupleReceiver?: IrExpr): IrExpr | null;
-/** An ordinary indexed read: values retain their element type, while
- * holes, missing properties, and present undefined yield undefined. */
-export declare function lowerSafeIndexRead(lowerer: Lowerer, arr: IrExpr, index: IrExpr, loc: SrcLoc): IrExpr | null;
-/** Fuse only our own f64-array read helper with immediate ToNumber.
- * Reuse its arguments verbatim so the receiver and index still evaluate
- * exactly once, in order, before the read. Do not specialize user calls,
- * union-element arrays, or optional values stored in locals. */
-export declare function tryLowerNumericIndexRead(lowerer: Lowerer, operand: IrExpr, loc: SrcLoc): IrExpr | null;
-/** Backward-compatible name for the npm-static probe path. */
-export declare const lowerNpmStaticSafeIndexRead: typeof lowerSafeIndexRead;
-/** The Array constructor's element and count forms, shared by calls and new. */
-export declare function lowerArrayConstructor(lowerer: Lowerer, expr: ts.CallExpression | ts.NewExpression, args: readonly ts.Expression[]): IrExpr;
-/** `Array.of` creates an array of its arguments, including a lone number. */
-export declare function lowerArrayOfCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** Mapper-less checked Array.from: acquire once, then step through emitted
- * property and call dispatch so native class iterators retain their methods. */
-export declare function lowerCheckedArrayFrom(lowerer: Lowerer, source: IrExpr, loc: SrcLoc, mapper?: IrExpr, receiver?: IrExpr, numeric?: boolean, iterable?: IrExpr): Extract<IrExpr, {
-    kind: "seqExpr";
-}>;
-export declare function lowerArrayFromValue(lowerer: Lowerer, loc: SrcLoc): IrExpr;
-/** `Array.from({ length: n }, mapfn)` — the counted-generation idiom — on
-   * THE stdlib Array global. The source must be an OBJECT LITERAL whose
-   * single property is `length` (the shape the idiom always spells; the
-   * ArrayLike record never exists as a value). Desugars to an interned
-   * synthetic loop calling the mapper with (undefined, i) exactly like JS —
-   * the first argument is the dyn undefined singleton, matching the
-   * checker's own `unknown` for it — and pushing each result. The loop
-   * bound is `i <= n - 1`, which IS ToLength for the finite lengths that
-   * terminate (fractional lengths truncate, negative/NaN produce an empty
-   * array — Node-exact). Array inputs copy through the iterator's indexed
-   * values, including holes as present undefined, and may map each value.
-   * Map and Set inputs consume live values or entries and may map them.
-   * Strings iterate by code point and may map.
-   * Other iterable shapes keep the fence. Null when the callee isn't an
-   * Array-static access. */
-export declare function lowerArrayFromCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** `Array.from(s)` / `[...s]` on a STRING: the code-point split into a
-   * fresh string[], through one interned helper per module. */
-export declare function strCharsCall(lowerer: Lowerer, src: IrExpr, loc: SrcLoc): IrExpr;
-/** Ambient Map method calls. `get`/`set`/`has`/`delete`/`clear` lower to
-   * mapIntrinsic; `forEach` desugars to a direct call of a synthetic loop
-   * function over the iteration primitives (lowerMapForEachCall). Null when
-   * this isn't an ambient Map method call. tsc has already checked arity
-   * and argument types against ambient/scriptc.d.ts. */
-export declare function lowerMapMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** An immediate Map spread observes the same entry order as entries().
- * Each pair is new; its key and value retain their original identities. */
-export declare function mapEntriesArray(lowerer: Lowerer, receiver: IrExpr): IrExpr;
-/** Snapshot a collection for immediate iteration. Array reads and callback
- * parameters may retain an undefined arm even when the checker spells a
- * bare collection. Observe that arm before touching native storage. */
-export declare function lowerCollectionSpread(lowerer: Lowerer, source: IrExpr, node: ts.Expression): IrExpr | null;
-/** `m.forEach(fn)` desugars to a direct call of a synthetic module
-   * function — one per key/value type + callback arity, interned — whose
-   * body is an index loop over the map's ITERATION PRIMITIVES: read
-   * iterCount fresh every pass (entries appended by the callback are
-   * visited), skip tombstones with iterLive (deleted entries are skipped),
-   * and bracket the loop with iterEnter/iterExit inside try/finally so the
-   * runtime never compacts indices out from under it — even when the
-   * callback throws. That is JS's live-iteration contract, Node-verified
-   * (SEMANTICS.md). The callback receives (value, key) like JS; declaring
-   * fewer parameters — (value) or () — is ordinary TS and supported. */
-export declare function lowerMapForEachCall(lowerer: Lowerer, call: ts.CallExpression, receiver: IrExpr, mapT: IrType & {
-    kind: "map";
-}, bindUntyped?: boolean): IrExpr;
-/** The loop body of the Map.forEach desugar, from existing IR nodes:
-   *
-   *   m.iterEnter();
-   *   try {
-   *     for (i = 0; i < m.iterCount; i++) {
-   *       if (m.iterLive(i)) { v = m.iterValue(i); k = m.iterKey(i); f(v, k); }
-   *     }
-   *   } finally { m.iterExit(); }
-   *
-   * The finally keeps the runtime's iteration depth exact when the callback
-   * throws (unwinding runs the finally with the exception pending and
-   * propagation resumes — the emitter's standard contract). */
-export declare function buildMapForEachFn(lowerer: Lowerer, name: string, mapT: IrType & {
-    kind: "map";
-}, arity: number, fnRet: IrType, loc: SrcLoc): IrFunction;
-/** Ambient Set method calls — Map's lowering with the value slot gone.
-   * `add`/`has`/`delete`/`clear` lower to setIntrinsic; `forEach` desugars
-   * like Map's over the shared iteration primitives. Null when this isn't
-   * an ambient Set method call. */
-export declare function lowerSetMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** `s.forEach(fn)` — Map's desugar shape over the set primitives. JS
-   * passes (value, value, set): the second parameter IS the element again,
-   * so both one- and two-parameter callbacks receive elem-typed arguments
-   * (iterKey read once, passed twice). Same live-iteration bracketing. */
-export declare function lowerSetForEachCall(lowerer: Lowerer, call: ts.CallExpression, receiver: IrExpr, setT: IrType & {
-    kind: "set";
-}): IrExpr;
-/** The loop body of the Set.forEach desugar — buildMapForEachFn with
-   * iterKey as the (single) element read:
-   *
-   *   s.iterEnter();
-   *   try {
-   *     for (i = 0; i < s.iterCount; i++) {
-   *       if (s.iterLive(i)) { v = s.iterKey(i); f(v, v); }
-   *     }
-   *   } finally { s.iterExit(); }
-   */
-export declare function buildSetForEachFn(lowerer: Lowerer, name: string, setT: IrType & {
-    kind: "set";
-}, arity: number, fnRet: IrType, loc: SrcLoc): IrFunction;
-/** Object.groupBy / Map.groupBy (ES2024): group an ARRAY's elements by a
-   * per-element key. Both lower to one interned helper loop per callback
-   * type — the callback runs synchronously per element (index included in
-   * the two-parameter form), the first occurrence of a key creates its
-   * group in encounter order, and later hits push onto the same array
-   * (JS's exact accumulation — the stored arrays are the live groups).
-   * Map.groupBy keeps typed keys under SameValueZero; Object.groupBy
-   * requires a STRING-KEYED result (Partial<Record<string, T[]>> — a
-   * literal-union key type makes a fixed-field record, which has no
-   * grouping representation) and stringifies number keys like JS property
-   * keys. Node's result carries a null prototype — records here have no
-   * prototype at all, so the difference is unobservable except through
-   * util.inspect's "[Object: null prototype]" prefix (ledgered). Other
-   * iterables fence (spread into an array first); Null when the callee
-   * isn't the stdlib Object/Map groupBy. */
-export declare function lowerGroupByStaticCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** The lowered iterator-helper chains: `arr.values()` (the array
-   * iterator) through any run of map/filter/take/drop/flatMap into a
-   * consuming terminal (toArray/forEach/reduce/some/every/find), FUSED
-   * into one per-element loop — which IS the helpers' lazy pull order:
-   * each source element flows through every stage before the next is
-   * touched, take closes the pipeline without pulling upstream again
-   * (budget checked before delivery), and short-circuit terminals stop
-   * the walk at their hit. Stage callbacks take (value) or (value,
-   * counter) — counters count each stage's own input stream, per spec.
-   * take/drop budgets validate eagerly AT THE CALL (Node's RangeError,
-   * raw value in the message) through an interned checker call inserted
-   * at the argument's evaluation position. The source array is iterated
-   * LIVE by index against a re-read length, exactly the array iterator's
-   * contract. Everything else — iterator objects stored in bindings,
-   * generator/Set/Map receivers, Iterator.from — keeps the lib fences.
-   * Null when the callee isn't a terminal over such a chain. */
-export declare function lowerIteratorHelperCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** `for (const [k, v] of m)` / `for (const e of m)` — for-of over a Map,
-   * desugared IN PLACE (the body is user code, so no helper function) over
-   * the same iteration primitives as the forEach desugar, with the same
-   * Node-exact live-iteration contract: iterCount re-read every pass
-   * (entries appended by the body are visited), tombstones skipped
-   * (deleted entries are not). Shape:
-   *
-   *   %m = <iterable>; %m.iterEnter();
-   *   try {
-   *     for (%i = 0; %i < %m.iterCount; %i++) {
-   *       if (%m.iterLive(%i)) { <bindings>; <body> }
-   *     }
-   *   } catch (%c) { %m.iterExit(); rethrow %c; }
-   *   %m.iterExit();
-   *
-   * catch-and-rethrow instead of a finally because break/continue/return
-   * may not cross a finally (the emitter's documented contract) and a
-   * for-of body legitimately contains all three: break/continue bind to
-   * the desugared loop INSIDE the plain try (jumps out of plain try need
-   * nothing), and every `return` in the body gets an iterExit inserted
-   * before it (exitBeforeReturns) so the depth count stays exact on that
-   * path too. A `[k, v]` head of plain identifiers binds straight from
-   * iterKey/iterValue — the tuple record never materializes; an identifier
-   * head binds the checker's own [K, V] tuple built per iteration. */
-/** The iterator-method projections a for-of can ride directly:
- * `for (const k of m.keys())`, `.values()`, `.entries()` — the SAME
- * live-iteration walk as `for..of m` (JS's container iterators are live
- * views, not snapshots), just yielding the key, the value, or the pair. */
-export type ForOfIterProjection = "keys" | "values" | "entries";
-/** for-of over a URLSearchParams (and its keys()/values()/entries()
-   * projections consumed directly by the head): the LIVE index walk —
-   * sp.size re-reads every pass, so entries appended mid-walk are visited
-   * and deletes shift, the spec's index-based iterator exactly. No
-   * enter/exit bracketing: the pair list compacts immediately (no
-   * tombstones), so there is no iteration depth to keep exact. */
-export declare function lowerForOfSearchParams(lowerer: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr, proj?: ForOfIterProjection): IrStmt;
-/** for-of over an ARRAY/typed-array keys()/entries() projection consumed directly
-   * by the head (`for (const [index, line] of lines.entries())` — the
-   * dominant formatter idiom): the LIVE index walk — the length re-reads
-   * every pass, exactly the array iterator's contract (elements appended
-   * mid-walk are visited; a shrink ends the loop early) — yielding the
-   * index (`keys`, a number) or the [index, element] pair (`entries`).
-   * `values` never lands here: lowerForOf's receiver unwrap owns it. A
-   * `[i, v]` head of plain identifiers binds straight from the reads (the
-   * tuple never materializes); identifier heads and the remaining
-   * patterns bind through the checker's own element type — the interned
-   * [number, T] tuple record. Stored iterator OBJECTS keep their fence
-   * (only the direct for-of position unwraps). */
-export declare function lowerForOfArrayIter(lowerer: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr, proj: "keys" | "entries"): IrStmt;
-export declare function lowerForOfMap(lowerer: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr, mapT: IrType & {
-    kind: "map";
-}, proj?: ForOfIterProjection): IrStmt;
-/** `for (const v of s)` — for-of over a Set: the Map desugar with iterKey
-   * as the (single) element read; same live-iteration contract. */
-export declare function lowerForOfSet(lowerer: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr, setT: IrType & {
-    kind: "set";
-}, proj?: ForOfIterProjection): IrStmt;
-/** Consume a Set seed immediately, including optional inherited sets used
- * by compiler tables. Nullish seeds construct empty sets; a lazy fallback
- * consumes its evaluated branch even when it reassigns the source binding. */
-export declare function lowerSetSeedNew(lowerer: Lowerer, node: ts.Expression, setT: IrType & {
-    kind: "set";
-}): IrExpr | null;
-/** Consume supported Map seeds: matching Maps and tuple arrays, plus
- * nullish values that construct an empty Map. Conditional/nullish seeds
- * select one lazy branch without representing a first-class iterable.
- * Copy loops preserve entry order and stored reference identities. */
-export declare function lowerMapSeedNew(lowerer: Lowerer, argNode: ts.Expression, mapT: IrType & {
-    kind: "map";
-}): IrExpr | null;
-export declare function mapFromSeedValue(lowerer: Lowerer, seed: IrExpr, mapT: IrType & {
-    kind: "map";
-}): IrExpr | null;
-/** `Object.keys/values/entries` over an INDEX-SIGNATURE (overflow-carrying)
-   * record shape: declared fields answer first from the compile-time field
-   * list (declaration order, undefined-valued fields skipped — exactly the
-   * fixed-shape lowering and SEMANTICS.md 37), then the overflow map's live
-   * keys in JS OWN-KEY order (canonical array indices ascending, then
-   * insertion order — recordOvfKeys). For a PURE index-signature shape
-   * (Record<string, T> — no declared fields, the typical CLI config patterns) the
-   * result order is Node-exact; hybrids inherit the documented
-   * declared-then-overflow divergence. Values surface as the checker's
-   * result element type: identity, an arm-into-union wrap, or (dyn
-   * results) the dyn conversion — recordKeyGet's own surfacing rules for
-   * the overflow, mirrored statically for declared fields. */
-export declare function lowerObjectIterOverIndexShape(lowerer: Lowerer, call: ts.CallExpression, member: "keys" | "values" | "entries", argIr: IrType & {
-    kind: "record";
-}, shape: IrRecordShape): IrExpr;
-/** The construction core, receiver/result pre-resolved — `node` anchors
- * the fences. for-in reuses the "keys" arm directly (it iterates exactly
- * the keys Object.keys answers; same intern key, one helper). */
-export declare function objectIterOverIndexShape(lowerer: Lowerer, node: ts.Node, member: "keys" | "values" | "entries", argIr: IrType & {
-    kind: "record";
-}, shape: IrRecordShape, receiver: IrExpr, resultT: IrType & {
-    kind: "array";
-}, loc: SrcLoc): IrExpr;
-/** `Object.fromEntries(pairs)` over a `[string, V][]` VALUE into the
-   * checker's own index-signature result shape (`{ [k: string]: V }` —
-   * always declared-field-free from the lib signature): an interned helper
-   * loops the pairs and keyed-writes each into a fresh record's overflow —
-   * later duplicates overwrite in place (first insertion position wins for
-   * ORDER, last value wins — exactly JS). Values flow into the signature's
-   * value slot (dyn slots convert JSON-safe values, identity otherwise).
-   * The `as ModelPricing` reshape AFTER it is the width-coercion capture
-   * (lowerRecordOvfCaptureHelper). Null when the argument or result shape
-   * is outside this (Maps, richer iterables → the SC2020 fence). */
-export declare function lowerObjectFromEntriesCall(lowerer: Lowerer, call: ts.CallExpression, callee: ts.Expression): IrExpr | null;
-/** Interned `%rec.capture.<n>(s)` — the INDEX-SIGNATURE reshape behind
-   * `Object.fromEntries(entries) as ModelPricing` (hybrid→hybrid width
-   * coercion) and `const r: Record<string, number> = { a: 1, b: 2 }`
-   * (a DECLARED-fields shape narrowing into a pure overflow shape — the
-   * record becomes width-free key/value storage), both called from
-   * widthCoerce after recordWidthHelper declines: builds the target shape
-   * fresh — declared fields default to their undefined arms — then
-   * keyed-writes every source key into it, declared fields first in the
-   * source's DECLARATION order (skipping ones holding the undefined arm,
-   * the unset convention — insertion order is what Object.keys/JSON
-   * answer, stance 37), then the source overflow in JS own-key order. A
-   * key colliding with a target DECLARED field validates through the
-   * keyed write's dynCheck (a mismatch throws the catchable TypeError —
-   * divergence 34), which is exactly what makes the `as` honest. The
-   * result is a COPY (divergence 36's stance). Null when the pair is
-   * outside the supported matrix: the target needs an index signature,
-   * every source value (declared fields, and the overflow slot when the
-   * source carries one) must enter the target's value slot (identity, a
-   * width lift — arm wrap/re-tag/nested reshape, or JSON-safe into a dyn
-   * slot), and every target field must either be initialized directly by
-   * a same-named source declared field (the rule that admits REQUIRED
-   * declared members) or be optional-flavored (the fresh record's
-   * default) and writable at runtime. */
-export declare function lowerRecordOvfCaptureHelper(lowerer: Lowerer, fromId: string, toId: string, loc: SrcLoc): string | null;
-/** `Object.assign(target, ...sources)` into an INDEX-SIGNATURE record:
-   * the capture helper's keyed-write walk aimed at the EXISTING target —
-   * each source's declared fields write in declaration order (unset
-   * optionals skip, stance 37), then its overflow in JS own-key order,
-   * and the result IS the target (identity, like JS — later reads through
-   * the target see every merged key). One interned `%obj.assign.<n>(t, s)`
-   * per (target shape, source shape) pair; multiple sources chain. Null
-   * when outside the matrix: the target needs an index signature, every
-   * source value must enter its value slot (identity, a width lift, or
-   * the dyn conversion), and tsc's `T & U` result type must collapse back
-   * to the target's own record shape (the self-shaped merges init-config
-   * patterns spell). */
-export declare function lowerObjectAssignIndexShape(lowerer: Lowerer, call: ts.CallExpression): IrExpr | null;
-/** One contributor of a pure-index-record MERGE literal: a full spread of
- * an index-signature record, or one explicit key. */
-export type IndexMergeContributor = {
-    kind: "spread";
-    shapeId: string;
-    value: IrExpr;
-} | {
-    kind: "field";
-    name: string;
-    value: IrExpr;
-}
-/** A RUNTIME-keyed property (`{ ...m, ["a" + "b"]: v }`, `{ [K]: v }`
- * over a runtime string K): the key is its own helper argument, passed
- * immediately BEFORE its value (JS's per-property key-then-value order
- * rides the call's argument evaluation), already stringified by the
- * caller (ToPropertyKey). */
- | {
-    kind: "keyedField";
-    key: IrExpr;
-    value: IrExpr;
-}
-/** `...(cond ? { k: v } : {})` at its literal position: the key writes
- * ONLY when the value isn't the undefined arm (overflow entries model
- * presence — an absent key stays absent, exactly JS's empty-arm spread).
- * The caller builds `value` as `cond ? v : <interned undefined arm of
- * the target's value slot>` — cond evaluates once, `v` lazily — so the
- * target's index-value type must carry an undefined arm. The explicit
- * `{ k: undefined }` true-arm collapses to absence, divergence 56's
- * documented stance. */
- | {
-    kind: "condField";
-    name: string;
-    value: IrExpr;
-};
-/** The interned merge helper behind `{ ...a, ...b, K: v }` literals whose
-   * TARGET shape is a PURE index-signature record (no declared fields) —
-   * the spawn-env pattern (`{ ...process.env, ...extraEnv }`). Contributors
-   * apply in literal order with keyed writes, so JS's last-write-wins holds
-   * for colliding runtime keys. Spread sources must be index-signature
-   * records whose value slot IS the target's or LIFTS into it (a
-   * `Record<string, string>` spreads into a `string | undefined` target by
-   * wrapping each copied value); their declared fields copy first (skipping
-   * undefined-armed absents — the unset convention), then their overflow in
-   * JS own-key order. Explicit values arrive pre-coerced to the target's
-   * value slot. Null when a spread source is outside that matrix (the
-   * caller keeps its fence). */
-export declare function lowerIndexMergeHelper(lowerer: Lowerer, toId: string, contributors: IndexMergeContributor[], loc: SrcLoc): string | null;
-/** The interned helper flattening an env-shaped record into the
-   * [k0, v0, k1, v1, ...] string[] cp.execSync consumes — declared string
-   * fields first (undefined-armed absents skipped, the Node-drops-undefined
-   * rule), then index-signature overflow in JS own-key order. Every value
-   * source must be a string or a `string | undefined` union whose value arm
-   * is a string. Null when the shape carries a non-string field/value slot
-   * (the caller fences). */
-export declare function lowerEnvToPairsHelper(lowerer: Lowerer, shapeId: string, loc: SrcLoc): string | null;
-/** The validated-STRING extraction of a dyn method receiver — the receiver
- * expression the string/regex method lowerings consume. */
-export declare function dynStringReceiver(lowerer: Lowerer, recv: IrExpr, access: ts.PropertyAccessExpression): IrExpr;
-/** `d.filter(pred)` on a dyn receiver: the receiver must BE a dyn array
- * (else the Node-shaped TypeError above); the predicate runs per element
- * over the dyn value, and each SURVIVOR is validated-extracted into the
- * result's element type T — the type the checker already committed the
- * call to (the contextual `RouteMapping[]`/`string[]` slot). Extraction is
- * the checked-cast machinery: a survivor that doesn't fit T throws the
- * catchable TypeError instead of misreading (a LYING predicate is the only
- * way there). The result is a fresh STATIC array of extracted copies —
- * the dyn boundary's marshal-copy stance (SEMANTICS.md). Null when the
- * call shape isn't claimable (the method-call fence stays). */
-export declare function lowerDynArrayFilterCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, recv: IrExpr): IrExpr | null;
-/** `.flatMap(f)` on a dyn ('unknown'/`any[]`-narrowed) receiver where the
-   * callback returns a STATIC array (`parsed.flatMap((v) => typeof v ===
-   * "string" ? parseTldList(v) : [])` — the tlds-file shape): the checked-dynamic tree
-   * array walks element-by-element, the callback sees each element as the
-   * dyn value `unknown` code sees, and its typed results concatenate —
-   * depth-1 flatten by construction, no validation needed on the results
-   * (they are already typed; only the RECEIVER is dynamic). Non-array
-   * receivers throw the Node-shaped TypeError. Callbacks returning
-   * NON-array values (JS would keep them as single elements) or dynamic
-   * results keep the fence — nothing drives them yet. */
-export declare function lowerDynArrayFlatMapCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, recv: IrExpr): IrExpr | null;