@geastack/compiler 1.0.15

package/dist/representation/model.js

@@ -0,0 +1,1019 @@
+import { createHash } from 'node:crypto';
+/**
+ * Physical carriers.
+ *
+ * A representation answers "which physical thing holds this value", and it is
+ * selected from an already-published semantic result. It is never a second
+ * interpretation of the source: if choosing a carrier requires re-reading the
+ * program, the semantic layer did not publish enough.
+ *
+ * `array-object` and `dense-buffer` are deliberately different kinds. A
+ * JavaScript-observable Array is an exotic object with hole semantics, an
+ * array-index key domain, and `length` define/delete/truncation rules; a dense
+ * buffer is a compiler-private storage block with none of that. Letting one
+ * kind mean both is what allows a single Array to be a tagged array object in
+ * one endpoint and a bare vector in another.
+ */
+/** The only reasons a value may be carried dynamically. */
+export const dynamicReasons = [
+    /** Explicit compiler option permits C++ dynamic dispatch without a static specialization. */
+    'opt-in-fallback',
+    /** `ToString` of a value whose type the program never narrows. */
+    'tostring-of-unknown',
+    /** A thrown value, which JavaScript does not type. */
+    'thrown-error-carrier',
+    /** `JSON.parse` with no asserted result type. */
+    'unasserted-json-parse',
+    /** The program itself declared `any`/`unknown` and never narrowed it. */
+    'declared-any-never-narrowed',
+    /** A host-authenticated CommonJS module record is deliberately an `any` boundary. */
+    'commonjs-module-boundary',
+    // The bare `Function` interface (`lib.es5.d.ts`), which states a value is
+    // callable and states nothing else: no parameter list, no arity, no result.
+    // That is `unknown` for callables, and it is a genuinely dynamic boundary
+    // rather than a lowering this compiler has not written yet -- a physical
+    // frame cannot be chosen from a signature the program never gave. The
+    // checker already reaches this same conclusion on the CALLEE side, where it
+    // declines to check a call whose callee is `Function` and answers `any`
+    // (see `resolvedCalleeSignatureType`, semantics/normalize/producers/
+    // shared.ts); this is the same answer for a `Function`-typed VALUE, so the
+    // two are one authority instead of two.
+    //
+    // Reached by more than an explicit `value: Function` annotation:
+    // `typeof x === 'function'` narrows an `unknown` TO `Function`, and
+    // `lib.es5.d.ts` types `Object.prototype.constructor` as `Function`. Before
+    // this reason existed all three derived to `native-handle(Function@1)` --
+    // a host protocol no target can ever register, since there is no C++ type
+    // for "some callable" -- so the program refused with an obligation nothing
+    // could satisfy instead of boxing the one thing that genuinely is dynamic.
+    'untyped-callable',
+    // A read of `call`/`apply`/`bind` off a Function object the program itself
+    // installed an own property of that name onto. `lib.es5.d.ts` types such a
+    // read as `Function.prototype`'s method, which is not what the program will
+    // find there: the own property shadows it, and what the own-property table
+    // holds is whatever was written, under no declared convention. The renderer
+    // already agrees -- `ir/certify/property-access-keys.ts` gives exactly this
+    // read the `(prototype-dynamic)` recipe, which emits `callableDynamicGet`
+    // and yields a `gea::Value` -- so before this reason existed the carrier and
+    // the code emitted for it disagreed about the same read.
+    'shadowed-callable-builtin'
+];
+/**
+ * A whole numeric property table stores text keys after ToPropertyKey, unlike
+ * a numeric sidecar selected from a record's disjoint index signatures. Keep
+ * the numeric fast path, but carry other non-Symbol primitives through the
+ * table's text protocol. In particular absence names "undefined"/"null";
+ * recovering a number would either refuse it or alias a different property.
+ */
+export const dictionaryKeyDomainOf = (declared, key) => {
+    if (declared !== 'number' || (key.kind === 'scalar' && key.domain === 'number'))
+        return declared;
+    const primitiveText = (value) => {
+        if (value.kind === 'scalar' || value.kind === 'string' || value.kind === 'null' || value.kind === 'undefined' || value.kind === 'void')
+            return true;
+        if (value.kind === 'optional')
+            return primitiveText(value.payload);
+        return value.kind === 'tagged-union' && value.arms.length > 0 && value.arms.every((arm) => primitiveText(arm.value));
+    };
+    return primitiveText(key) ? 'string' : declared;
+};
+/** Exact ECMAScript Number::toString spelling accepted by a number index signature. */
+export const isCanonicalNumberPropertyKeyText = (text) => {
+    const numeric = Number(text);
+    return Number.isNaN(numeric) ? text === 'NaN' : String(numeric) === text;
+};
+/** Select the disjoint sidecar addressed by a statically carried property key. */
+export const recordIndexForKeyCarrier = (indexes, key, constantText) => {
+    if (key.kind === 'symbol')
+        return indexes.find((index) => index.key === 'symbol') ?? null;
+    if (key.kind === 'scalar' && key.domain === 'number')
+        return indexes.find((index) => index.key === 'string') ?? indexes.find((index) => index.key === 'number') ?? null;
+    if (key.kind === 'string') {
+        const stringIndex = indexes.find((index) => index.key === 'string');
+        if (stringIndex)
+            return stringIndex;
+        // A number index is a set of PROPERTY KEYS, not a set of finite doubles.
+        // Number::toString is the canonicalizer: in particular NaN and both
+        // infinities are valid keys, while -0 aliases "0" and "01" is not the
+        // canonical spelling of 1.
+        const canonical = constantText !== undefined && isCanonicalNumberPropertyKeyText(constantText);
+        return canonical ? (indexes.find((index) => index.key === 'number') ?? null) : null;
+    }
+    if (key.kind === 'tagged-union' &&
+        key.arms.every((arm) => arm.value.kind === 'string' || (arm.value.kind === 'scalar' && arm.value.domain === 'number')))
+        return indexes.find((index) => index.key === 'string') ?? null;
+    return null;
+};
+/**
+ * `passingOf`'s answer for `value` under `ownership` (the ABI's own override
+ * for this position, or `null` to ask the carrier's own tier -- mirroring
+ * `cppTypeOf`'s optional second argument).
+ *
+ * `string` and `callable-identity` carry no `ownership` field at all -- a
+ * `std::string` always owns its buffer and `gea::Ref<gea::FunctionObjectIdentity>`
+ * is `cppTypeOf`'s one hardcoded reference spelling -- so both are named
+ * directly rather than falling out of the ownership-tier check below. Every
+ * other reference-shaped carrier (`class-ref`, `record`, `record-with-index`,
+ * `native-record-ref`, `array-object`, `typed-array`, `array-buffer`,
+ * `shared-array-buffer`, `data-view`, `keyed-collection`, `dictionary`) is
+ * spelled `gea::Ref<...>` by `cppTypeOf`'s `cppOwnershipWrap` exactly when its
+ * effective ownership is `shared-refcount`, which is what `'ownership' in
+ * value` plus the tier check reproduces without spelling anything.
+ *
+ * The one exception this function and `targets/cpp/types.ts`'s
+ * `cppAbiParameterType` still apply identically: an ArrayBuffer-family view
+ * keeps ITS OWN shared-refcount tier even when a function-value signature
+ * stamps the parameter `owned` after publication settled on the standard
+ * buffer carrier as shared, because the bytes still have observable reference
+ * identity a by-value copy would silently break.
+ */
+export const passingOf = (value, ownership = null) => {
+    const aliasing = value.kind === 'array-buffer' || value.kind === 'shared-array-buffer' || value.kind === 'data-view' || value.kind === 'typed-array';
+    const effective = aliasing && value.ownership === 'shared-refcount' && ownership === 'owned'
+        ? value.ownership
+        : (ownership ?? ('ownership' in value ? value.ownership : null));
+    return value.kind === 'string' || value.kind === 'callable-identity' || effective === 'shared-refcount' ? 'const-ref' : 'by-value';
+};
+/**
+ * The fixpoint identity a carrier participates in, or `null` for an ordinary
+ * acyclic container. Kept in the model so derivation, verification, and the
+ * C++ spelling read the same fact instead of each inferring recursion from a
+ * traversal of their own.
+ */
+export const recursiveCarrierOf = (representation) => {
+    switch (representation.kind) {
+        case 'array-object':
+        case 'keyed-collection':
+        case 'dictionary':
+        case 'function-value-dispatch':
+            return representation.recursive ?? null;
+        case 'native-record-ref':
+            return representation.recursive ?? null;
+        default:
+            return null;
+    }
+};
+/**
+ * A stable key for a representation.
+ *
+ * Two carriers are the same carrier exactly when their keys match. This is used
+ * to detect the case the architecture forbids outright: one value published
+ * with two different carriers in two endpoints.
+ */
+/**
+ * Keys already built, by the carrier object that produced them.
+ *
+ * A carrier is immutable -- every field of every variant is `readonly`, and
+ * nothing in this compiler writes one after it is constructed -- so a key is a
+ * function of the object's identity and may be remembered by it. That is worth
+ * remembering because the key is recursive and inlines its whole subject: the
+ * deepest one a measured application produced was 26,467 characters, a
+ * `record-with-index` carrying an entire host object's shape, and it was rebuilt
+ * from nothing on every call. The same measurement found 112,276 selected
+ * results resolving to 2,660 distinct carrier objects, so all but ~2% of the
+ * calls ask for a key that already exists.
+ *
+ * A `WeakMap` rather than a `Map` because the carriers outlive nothing: they
+ * belong to the plan, and a strong table here would keep every carrier of every
+ * compilation alive for the life of the process.
+ */
+const keysByRepresentation = new WeakMap();
+const abiKeys = new WeakMap();
+/**
+ * How a nested carrier contributes to its parent's key.
+ *
+ * ⛔ This used to be the child's WHOLE key, spliced in as text -- which makes a
+ * key a tree serialization of a graph, and that is not merely wasteful, it does
+ * not terminate at any useful size. mongodb's `Filter` carrier has three fields
+ * that each contain the next level, so every level TRIPLED its parent's key:
+ * measured at 1,191 characters at the innermost level, 11 MB eight levels up,
+ * 299 MB three levels above that, and then `Array.join` threw
+ * `RangeError: Invalid string length` -- V8 caps a string at 536,870,888
+ * characters and the full key would have been ~17 GB. The compile died with a
+ * stack trace naming a template literal, in a compiler whose whole discipline
+ * is to refuse with a reason.
+ *
+ * `structural-self-reference.ts` closes that particular cycle, so no carrier
+ * SHOULD be that deep any more. This is the other half, and it is the half that
+ * holds for every future target and every future program: a key is now bounded
+ * by the carrier's OWN field count, never by the size of the graph beneath it.
+ * Any two distinct sub-carriers still give distinct parent keys -- the digest is
+ * over the child's own full key, so a difference anywhere below propagates up
+ * through every enclosing digest, exactly as a Merkle chain does.
+ *
+ * The digest is prefixed with what it stands for (`record#type|1041@a3f9...`)
+ * rather than left opaque. A key is read by people: it names the missing
+ * primitive in every unmet-obligation row the compass prints, and an obligation
+ * that says only `k9f2c...` would trade one unreadable report (8 KB of inlined
+ * header fields on ONE line, which is what this produced for hono's `Context`)
+ * for another.
+ */
+// `GEA_FULL_KEYS` prints every nested key in full: a digest names WHICH union a
+// refusal is about, never what its arms are, and finding the arm a merge could
+// not reach needs the arms. Read once at load, so the keys are the same
+// everywhere in one run.
+const nestedKeyLimit = process.env['GEA_FULL_KEYS'] ? Number.POSITIVE_INFINITY : 80;
+// Memoized beside `keysByRepresentation`, and for the same reason: the digest
+// is a pure function of the carrier, and a parent key asks for it once per
+// field on every rebuild of a parent that is not itself remembered yet. On
+// TypeScript's own compiler the digest, not the walk, was half the cost of
+// keying a union's arms.
+const nestedKeys = new WeakMap();
+const nestedKey = (representation) => {
+    const remembered = nestedKeys.get(representation);
+    if (remembered !== undefined)
+        return remembered;
+    const own = representationKey(representation);
+    const built = own.length <= nestedKeyLimit ? own : digestedKey(representation, own);
+    nestedKeys.set(representation, built);
+    return built;
+};
+const digestedKey = (representation, own) => {
+    const shaped = 'shapeId' in representation ? representation.shapeId : undefined;
+    const label = shaped === undefined ? representation.kind : `${representation.kind}#${shaped}`;
+    return `${label}@${createHash('sha256').update(own).digest('hex').slice(0, 16)}`;
+};
+/**
+ * The extension half of an `array-object` key: empty for a plain array, so
+ * every key written before extensions existed is unchanged, and the field
+ * list -- name, requiredness, carrier -- for an extended one. Exported so the
+ * emitter names the generated struct by the same identity the carrier has.
+ */
+export const arrayExtensionKey = (extension) => extension === null
+    ? ''
+    : `,{${extension.map((field) => `${field.key}${field.required ? '' : '?'}:${representationKey(field.value)}`).join(',')}}`;
+export const representationKey = (representation) => {
+    const remembered = keysByRepresentation.get(representation);
+    if (remembered !== undefined)
+        return remembered;
+    const built = buildRepresentationKey(representation);
+    keysByRepresentation.set(representation, built);
+    return built;
+};
+const buildRepresentationKey = (representation) => {
+    const recursive = recursiveCarrierOf(representation);
+    // A recursive carrier is a graph node, not a tree. Its structural identity
+    // is the full key: descending into its children would serialize the cycle
+    // forever, while replacing it with a digest would hide the declaration/type
+    // identity which proves the two paths carry the same native object.
+    if (recursive) {
+        switch (representation.kind) {
+            case 'array-object':
+            case 'keyed-collection':
+            case 'dictionary':
+                return `recursive(${recursive.type},${recursive.container},${representation.ownership})`;
+            case 'native-record-ref':
+                return `recursive(${recursive.type},${recursive.container},${representation.ownership})`;
+            // A callable wrapper is one by-value struct, so its ownership is fixed
+            // rather than carried. It is still spelled, because the back edge and
+            // the definition must key IDENTICALLY -- that identity is what proves a
+            // parameter bound from the reference and an ABI spelled from the
+            // definition name the same physical object.
+            case 'function-value-dispatch':
+                return `recursive(${recursive.type},${recursive.container},owned)`;
+            default:
+                throw new Error(`recursive marker appeared on non-container ${representation.kind}`);
+        }
+    }
+    switch (representation.kind) {
+        case 'unresolved':
+            return `unresolved(${representation.reason})`;
+        case 'void':
+        case 'string':
+        case 'symbol':
+        case 'null':
+        case 'undefined':
+            return representation.kind;
+        case 'scalar':
+            return `scalar(${representation.domain})`;
+        case 'class-ref':
+            return `class-ref(${representation.declaration},${representation.ownership})`;
+        case 'native-handle':
+            // `call`/`construct` are folded into the key -- omitting them would let
+            // two handles of the same protocol that disagree on invocability
+            // collide under one key, which is exactly the "one value, two carriers"
+            // case `representationKey` exists to catch.
+            return (`native-handle(${representation.protocol}@${representation.version}` +
+                `;call=${representation.call ? abiKey(representation.call) : '-'}` +
+                `;construct=${representation.construct ? abiKey(representation.construct) : '-'})`);
+        case 'record':
+            return `record(${representation.shapeId},${representation.ownership},${representation.fields
+                .map((field) => `${field.key}${field.required ? '' : '?'}:${nestedKey(field.value)}`)
+                .join(',')};${representation.accessors.map((accessor) => `${accessor.key}=${accessor.getter ?? '-'}/${accessor.setter ?? '-'}`).join(',')})`;
+        case 'record-with-index':
+            return `record-with-index(${representation.shapeId},${representation.ownership},${representation.fields
+                .map((field) => `${field.key}${field.required ? '' : '?'}:${nestedKey(field.value)}`)
+                .join(',')};${representation.indexes.map((index) => `index[${index.key}]=${nestedKey(index.value)}`).join(';')})`;
+        case 'proxy-object':
+            return `proxy-object(${nestedKey(representation.target)},${nestedKey(representation.handler)})`;
+        case 'native-record-ref':
+            return `native-record-ref(${representation.shapeId},${representation.ownership},${representation.native ?? ''})`;
+        case 'borrowed-ref':
+            return `borrowed-ref(${nestedKey(representation.referent)})`;
+        case 'array-object':
+            return `array-object(${nestedKey(representation.element)},${representation.ownership}${arrayExtensionKey(representation.extension)})`;
+        case 'dense-buffer':
+            return `dense-buffer(${nestedKey(representation.element)})`;
+        case 'typed-array':
+            return `typed-array(${representation.element},${representation.buffer},${representation.ownership})`;
+        case 'array-buffer':
+            return `array-buffer(${representation.ownership})`;
+        case 'shared-array-buffer':
+            return `shared-array-buffer(${representation.ownership})`;
+        case 'data-view':
+            return `data-view(${representation.ownership})`;
+        case 'native-sequence':
+            return `native-sequence(${nestedKey(representation.element)})`;
+        case 'iterator':
+            return `iterator(${nestedKey(representation.element)})`;
+        case 'promise':
+            return `promise(${nestedKey(representation.value)})`;
+        case 'keyed-collection':
+            return (`keyed-collection(${representation.family},${nestedKey(representation.key)},` +
+                `${representation.value ? nestedKey(representation.value) : '-'},${representation.ownership})`);
+        case 'dictionary':
+            return `dictionary(${representation.key},${nestedKey(representation.value)},${representation.ownership})`;
+        case 'function':
+            return `function(${representation.functionId},${abiKey(representation.abi)})`;
+        case 'function-family':
+            return `function-family(${[...representation.members].sort().join('+')},${abiKey(representation.abi)})`;
+        case 'constructor-family':
+            return `constructor-family(${[...representation.members].sort().join('+')},${abiKey(representation.abi)})`;
+        case 'constructor-value-dispatch':
+            return `constructor-value-dispatch(${abiKey(representation.abi)})`;
+        case 'function-and-constructor':
+            return `function-and-constructor(${abiKey(representation.call)},${abiKey(representation.construct)})`;
+        case 'function-value-family':
+            return `function-value-family(${[...representation.members].sort().join('+')},${abiKey(representation.abi)},${representation.optional})`;
+        case 'function-value-dispatch':
+            return `function-value-dispatch(${abiKey(representation.abi)})`;
+        case 'callable-identity':
+            return 'callable-identity';
+        case 'generic-function-set':
+            return `generic-function-set(${representation.members.join('+')})`;
+        case 'optional':
+            return `optional(${nestedKey(representation.payload)},${representation.absence})`;
+        case 'tagged-union':
+            return `tagged-union(${representation.arms
+                .map((arm) => {
+                const discriminator = arm.runtimeDiscriminator.kind === 'callable-membership'
+                    ? `callable(${[...arm.runtimeDiscriminator.members].sort().join('+')})`
+                    : arm.runtimeDiscriminator.kind;
+                return `${arm.tag}:${discriminator}:${nestedKey(arm.value)}`;
+            })
+                .join('|')})`;
+        case 'dynamic':
+            return `dynamic(${representation.reason})`;
+    }
+};
+/** A stable key for a calling convention. */
+export const abiKey = (abi) => {
+    const remembered = abiKeys.get(abi);
+    if (remembered !== undefined)
+        return remembered;
+    const built = buildAbiKey(abi);
+    abiKeys.set(abi, built);
+    return built;
+};
+const buildAbiKey = (abi) => `(${abi.parameters.map((parameter) => `${nestedKey(parameter.value)}/${parameter.ownership}`).join(',')}` +
+    `${abi.restFrom === null ? '' : `|rest@${abi.restFrom}`})` +
+    `->${nestedKey(abi.result)}` +
+    `@${abi.receiver ? nestedKey(abi.receiver) : '-'}`;
+/**
+ * Whether a carrier boxes a value that has a static type.
+ *
+ * Used by the no-boxing gate. `dynamic` is legitimate only for the four
+ * declared reasons; every other appearance is a defect to fix at the producer.
+ */
+export const isBoxed = (representation) => representation.kind === 'dynamic';
+/**
+ * Every carrier kind ECMAScript's `ToBoolean` can never answer `false` for.
+ *
+ * Each of these is, in every shape this compiler ever selects for it, a JS
+ * Object or a callable -- and an Object is truthy regardless of its contents,
+ * empty array, empty record and zero-argument callable included. `native-
+ * handle` is deliberately absent even though it is also object-shaped: a host
+ * handle self-encodes its own absence as an invalid state
+ * (`representation/optional.ts`'s collapse of `T | null` onto one), which
+ * *is* a falsy state this fact must not claim away. `tagged-union` is absent
+ * from the set itself and handled by recursion in `isDeadMergeContribution`
+ * below, because whether one can be falsy depends on its arms, not its kind.
+ */
+const alwaysTruthyKinds = new Set([
+    'record',
+    'record-with-index',
+    'native-record-ref',
+    'array-object',
+    'dictionary',
+    'typed-array',
+    'promise',
+    // A Map/Set/WeakMap/WeakSet is an ordinary Object for ToBoolean: `new Map()`
+    // is truthy with zero entries, exactly as `[]` is.
+    'keyed-collection',
+    'proxy-object',
+    'function',
+    'function-family',
+    'function-value-family',
+    'function-value-dispatch',
+    // A function object is truthy whatever its convention -- and the identity
+    // carrier is the SAME object, reached through the handle every callable
+    // already owns. Its absence lives in the `optional` wrapper around it, as it
+    // does for every other callable kind here.
+    'callable-identity',
+    'generic-function-set',
+    'constructor-family',
+    'constructor-value-dispatch',
+    'function-and-constructor'
+]);
+/**
+ * Whether a carrier has no absent state at all -- so `a ?? b` over it never
+ * evaluates `b`.
+ *
+ * Read straight off `alwaysTruthyKinds` because that set is already exactly
+ * this fact plus more: every kind in it is an Object or a callable whose
+ * absence, where it has one, lives in an `optional` WRAPPER rather than in the
+ * carrier itself. The three carriers that self-encode absence are outside the
+ * set for reasons its own comment states -- `native-handle` and a
+ * shared-refcount `class-ref`, the two `representation/optional.ts` collapses
+ * `T | null` onto -- and so are `optional`, `dynamic` and every sum, each of
+ * which plainly has one.
+ *
+ * `constructor-family` is the measured case: node-server's `export const
+ * CloseEvent: typeof globalThis.CloseEvent = globalThis.CloseEvent ?? class
+ * extends Event {...}`. The plan gives the global read a bare constructor
+ * family, which is the census's own statement that the value is there -- a host
+ * that says otherwise says so through `semantics/normalize/absent-globals.ts`,
+ * which turns the read's type into `undefined` and takes the carrier out of
+ * this set. So the fallback class never runs, and asking for a conversion
+ * between two unrelated program classes is asking for a value that arm never
+ * produces.
+ */
+export const carriesNoAbsence = (representation) => alwaysTruthyKinds.has(representation.kind);
+/**
+ * Whether `representation` -- unwrapped once if it is an `optional` -- can
+ * only ever be absent, never a live, present-but-falsy value.
+ *
+ * This is the fact that licenses treating one arm of a merge as dead code
+ * rather than a missing conversion: `a && a.b` keeps `a` on the branch where
+ * `a` tested falsy, and an Object is never falsy, so when `a`'s own payload
+ * is one, the present case cannot be the reason that branch runs -- only
+ * `a`'s own absence can, and the checker's own type for the whole `&&`
+ * already reflects that by excluding the payload from the join. A bare
+ * (non-optional) representation with an always-truthy kind answers `true`
+ * too: it has no absence at all, so if it reaches here as the falsy side of
+ * an `&&`, the branch is not merely narrowed, it is wholly unreachable.
+ *
+ * One fact with one asker: `ir/lower-narrow.ts`'s `mergeIncoming` (what a
+ * dead arm lowers to). Preflight's `buildMergeNarrowingObligations` asked it
+ * too until Phase 1.6 deleted that second decision tree; the obligation ids
+ * quoted below are its historical spelling of the same pairs.
+ */
+/**
+ * Whether a merge's own carrier has an absent state a dead `&&` arm can be
+ * materialized into.
+ *
+ * The companion fact to `isDeadMergeContribution`: that one says the kept arm
+ * contributes nothing but absence, this one says the merge has somewhere to
+ * put it. Both authorities need both halves, and both used to spell this one
+ * as `kind === 'optional'`.
+ *
+ * That spelling was too narrow by exactly one carrier, and it is the carrier
+ * this file's own `alwaysTruthyKinds` comment already names: `optional.ts`
+ * COLLAPSES `T | null` onto a bare `native-handle`, because a host handle
+ * self-encodes absence as an invalid state. So a merge whose checker type is
+ * `WSInst | null` has carrier `native-handle`, not `optional` -- and the
+ * `kind === 'optional'` test then refused a program the collapse itself
+ * created.
+ *
+ * Measured on `examples/dialer`: `if (e.candidate && this.ws)`, with
+ * `ws: WebSocketInstance | null`, raised
+ * `merge-narrowing:optional(native-record-ref(...),null)->native-handle(...)`,
+ * an obligation no conversion could ever satisfy, on a program with zero
+ * violations. The C++ side already had the spelling all along --
+ * `types.ts`'s `carriesAbsence` answers `true` for `native-handle`, so the
+ * constant renders as an empty handle (`gea::host::WebSocket{}`), which is
+ * exactly what `emit-narrowing.ts`'s `emptyHandleText` writes for the same
+ * carrier on the store path.
+ */
+/**
+ * Whether a carrier has an `undefined` state at all -- the question a
+ * definedness test asks, asked of the carrier rather than of a value.
+ *
+ * `targets/cpp/emit-presence.ts`'s `definedTestText` is the same rule as a
+ * spelling, and delegates here rather than restating it: a carrier this answers
+ * `false` for renders the test as the constant `true`, which is honest -- such a
+ * value genuinely cannot be `undefined` -- and is exactly why a lowering that
+ * MERGES over a definedness guard has to ask this first. A merge over a
+ * constant-true test is not a merge; its absent arm is dead, and building one
+ * anyway hands the emitter a branch whose other side can never run.
+ *
+ * A host handle's own absence stands for `null`, never for `undefined` (see
+ * `optionalOf`), so it is defined whatever it holds -- as is every carrier that
+ * is simply a value that exists.
+ */
+export const carriesUndefined = (representation) => {
+    if (representation.kind === 'undefined' || representation.kind === 'void')
+        return true;
+    if (representation.kind === 'borrowed-ref')
+        return carriesUndefined(representation.referent);
+    if (representation.kind === 'optional')
+        return representation.absence === 'undefined';
+    if (representation.kind === 'tagged-union')
+        return representation.arms.some((arm) => carriesUndefined(arm.value));
+    return representation.kind === 'dynamic';
+};
+/**
+ * Whether `ir/lower-destructuring.ts`'s array-pattern fast path already reads
+ * this carrier positionally, in place: a plain array, a positional tuple
+ * record (`ir/lower-allocation.ts`'s `lowerTupleLiteral` names the same shape
+ * "record" -- there is deliberately no separate tuple carrier), or a tagged
+ * union every arm of which is itself one of these two --
+ * `preflight/tuple-destructuring.ts`'s uniform tuple-union.
+ */
+export const isArrayPatternCapable = (representation) => {
+    if (representation.kind === 'array-object')
+        return true;
+    if (representation.kind === 'record')
+        return representation.fields.every((field, index) => field.key === String(index));
+    if (representation.kind === 'tagged-union')
+        return representation.arms.every((arm) => isArrayPatternCapable(arm.value));
+    return false;
+};
+/**
+ * The one arm of a tagged union a nested array-pattern position can read
+ * positionally, when every OTHER arm cannot -- `number | number[]`, the
+ * per-position element of a plain (non-tuple) array whose own element is
+ * itself a union: exactly one arm (the array) supports positional reads, and
+ * the other (the number) is exactly the value ECMA-262 7.4.2 `GetIterator`
+ * throws a `TypeError` over. `null` for a union with zero such arms, or with
+ * MORE than one -- two capable arms (`number[] | string[]`) is a genuine
+ * ambiguity this compiler does not resolve, and refusing it is the
+ * fail-closed answer, not a guess.
+ */
+export const soleArrayPatternCapableArm = (representation) => {
+    if (representation.kind !== 'tagged-union')
+        return null;
+    let sole = null;
+    for (const [index, arm] of representation.arms.entries()) {
+        if (!isArrayPatternCapable(arm.value))
+            continue;
+        if (sole)
+            return null;
+        sole = { index, arm: arm.value };
+    }
+    return sole;
+};
+/**
+ * The payload under a field value's own `undefined`-optional carrier, or
+ * `null` for every other field.
+ *
+ * Property presence no longer comes from this wrapper. Generated structs keep
+ * an independent bit for every `!required` field, because a present property
+ * whose value is `undefined` and a missing property are observably different.
+ * This helper remains the value-carrier decomposition used where code needs
+ * the payload of `T | undefined` itself.
+ */
+export const absentFieldPayload = (field) => !field.required && field.value.kind === 'optional' && field.value.absence === 'undefined' ? field.value.payload : null;
+export const carriesMergeAbsence = (representation) => representation.kind === 'optional' ||
+    representation.kind === 'native-handle' ||
+    (representation.kind === 'class-ref' && representation.ownership === 'shared-refcount');
+/**
+ * Whether a tagged union tags absence in an arm of its own.
+ *
+ * The one fact an arm cannot see about itself, and the fact that decides
+ * whether the arm beside it is the absence-collapsed form of its carrier --
+ * see `isDeadMergeArm`.
+ */
+const unionTagsAbsence = (union) => union.arms.some((arm) => arm.value.kind === 'null' || arm.value.kind === 'undefined' || arm.value.kind === 'void');
+/**
+ * `isDeadMergeContribution` over a carrier that may sit INSIDE another one,
+ * carrying the single fact only that enclosing carrier knows: whether absence
+ * is tagged in a place of its own out there.
+ *
+ * `class-ref(shared-refcount)` and `native-handle` are deliberately outside
+ * `alwaysTruthyKinds` because `representation/optional.ts` COLLAPSES `T | null`
+ * onto them, so a BARE one is genuinely nullable and that null is a falsy state
+ * nothing may claim away. `absenceTaggedOutside` is precisely the proof that
+ * the collapse did not happen here, and it arrives two ways:
+ *
+ * - a union carrying its own `null`/`undefined` arm. Arms are disjoint, so a
+ *   `present:` arm sitting beside a `null:` arm carries a type null was already
+ *   removed from. Without this, three's `this.environment &&
+ *   this.environment.isTexture` over a `Texture | null` field raised
+ *   `merge-narrowing:tagged-union(undefined|null|present:class-ref(...,shared-
+ *   refcount))->tagged-union(undefined|null|present:scalar(boolean))` -- an
+ *   obligation no conversion could satisfy, because all three arms read live
+ *   and `partialDeadMergeArms` therefore reported no split to rebuild from.
+ * - an `optional` WRAPPER around one of them. `optionalOf` collapses these two
+ *   payloads for `absence === 'null'` and only then, so a surviving wrapper can
+ *   only be tagged `'undefined'` -- and `union.ts` reaches that wrapper solely
+ *   when the source union had exactly ONE absent member. Both facts together
+ *   say `null` was never in the type, so the pointer inside is object-shaped
+ *   and therefore always truthy. Without this, mongodb's `this.session &&
+ *   this.session.inTransaction()` -- `session: ClientSession | undefined`, the
+ *   guard-and-call idiom -- raised `merge-narrowing:optional(class-ref(...,
+ *   shared-refcount),undefined)->optional(scalar(boolean),undefined)`, 39 rows
+ *   over three classes, for a merge whose kept arm can only ever be absent.
+ */
+const isDeadMergePayload = (representation, absenceTaggedOutside) => {
+    if (representation.kind === 'optional')
+        return isDeadMergePayload(representation.payload, true);
+    if (representation.kind === 'tagged-union') {
+        const tagsAbsence = unionTagsAbsence(representation);
+        return representation.arms.every((arm) => isDeadMergePayload(arm.value, tagsAbsence || absenceTaggedOutside));
+    }
+    if (absenceTaggedOutside && (representation.kind === 'class-ref' || representation.kind === 'native-handle'))
+        return true;
+    // A class instance is object-shaped and so always truthy -- unless it is the
+    // one shape that self-encodes absence, exactly as `native-handle` does. A
+    // REFCOUNTED instance is a `gea::Ref<T>` that `optional.ts` collapses
+    // `T | null` onto, so a null one is a falsy state this must not claim away.
+    if (representation.kind === 'class-ref')
+        return representation.ownership !== 'shared-refcount';
+    return alwaysTruthyKinds.has(representation.kind);
+};
+export const isDeadMergeContribution = (representation) => isDeadMergePayload(representation, false);
+/**
+ * The `||` mirror of `isDeadMergeContribution`: a kept operand with NO truthy
+ * state. `a || b` publishes `a` only when `ToBoolean(a)` is true, and a carrier
+ * that is only ever `null`/`undefined` (propertyHelper's `verifyProp || name`,
+ * where every caller passes `null` or nothing) has no such state, so the
+ * kept branch never runs and the merge only ever publishes the evaluated
+ * side. Nothing is converted because nothing arrives. Asked by
+ * `ir/lower-narrow.ts`'s `mergeIncoming`. Deliberately not extended to an
+ * `optional` or a union: those carry a payload that CAN be truthy.
+ */
+export const contributesNoTruthiness = (representation) => representation.kind === 'null' || representation.kind === 'undefined' || representation.kind === 'void';
+/**
+ * Whether every falsy state this carrier has is an ABSENCE -- the WHOLE-operand
+ * question, as against `isDeadMergeContribution`'s per-arm one.
+ *
+ * The two differ over exactly the carriers `optional.ts` COLLAPSES `T | null`
+ * onto: a bare `class-ref(shared-refcount)` (a `gea::Ref<T>`) and a bare
+ * `native-handle`. `isDeadMergeContribution` must refuse those, and its own
+ * comment says why -- a null `Ref` is a falsy state, and an ARM proven dead is
+ * DROPPED from `partialDeadMergeArms`'s rebuild, so a null flowing through a
+ * dropped arm would fall out of the chain into a neighbour's value.
+ *
+ * Asked of a whole `&&` operand into a merge that carries an absence, nothing
+ * is dropped and the answer changes. ECMAScript's `ToBoolean` is `true` for
+ * every object, so the only value such a carrier can hold on the branch where
+ * it tested falsy is its own null -- and the merge's own absence is where that
+ * null belongs. `crash.ts`'s `this.engine && this.endBuffer` (`AudioEngine |
+ * null` guarding a `BufferLike | null`) is the shape: the kept operand
+ * contributes nothing the merge does not already have a state for, yet
+ * `merge-narrowing:class-ref(...)->optional(native-record-ref(...),null)`
+ * asked for a conversion no registry could hold.
+ *
+ * Strictly wider than `isDeadMergeContribution` -- `absenceTaggedOutside` only
+ * ever ENABLES the return above -- so every merge the narrower fact licensed
+ * is licensed identically here. `ir/lower-narrow.ts`'s `mergeIncoming` asks
+ * this one and does not re-derive it.
+ */
+export const contributesOnlyAbsence = (representation) => isDeadMergePayload(representation, true);
+/**
+ * The per-arm decomposition of `isDeadMergeContribution`, asked only when the
+ * WHOLE answer is neither wholly `true` nor wholly `false`.
+ *
+ * `isDeadMergeContribution` covers two ends: every arm dead (the kept operand
+ * contributes nothing but its own absence -- `mergeIncoming`'s existing
+ * bypass) and every arm live (an ordinary conversion, already the general
+ * conversion graph's job). This is the middle: SOME arms dead, at least one
+ * live -- `results[name]` typed `T[] | string`, where `T[]` can never be the
+ * reason a `&&` fell through but `string` can (an empty one).
+ *
+ * Returns `null` for anything that is not that middle case: not a tagged
+ * union at all (once unwrapped of one optional layer, matching
+ * `isDeadMergeContribution`'s own unwrap), wholly dead, or wholly live. Each
+ * `null` is a real "does not apply", not a missing answer -- the caller falls
+ * through to whichever of the two existing paths does apply.
+ *
+ * One fact, asked from both authorities that must never disagree about it,
+ * exactly as `isDeadMergeContribution` and `carriesMergeAbsence` already are:
+ * `ir/lower-narrow.ts`'s `mergeIncoming`, which both decides to rebuild via
+ * the live-arm proof instead of a general conversion and checks that the
+ * rebuild is buildable at all -- every live arm must actually have somewhere
+ * to convert to, and the source's own absence, if it has one, needs
+ * `carriesMergeAbsence(merged)` to hold it -- blocking the body otherwise.
+ */
+/**
+ * Whether `representation` is boolean-shaped: itself `scalar(boolean)`, or an
+ * `optional` whose payload is.
+ *
+ * The signal `ir/lower-narrow.ts`'s `mergeIncoming` checks
+ * before licensing `ToBoolean` (`targets/cpp/emit-presence.ts`'s
+ * `booleanTestText`) as a live arm's conversion into a `&&` merge's own
+ * carrier, rather than requiring a structural, value-preserving one.
+ *
+ * Sound only here, at a `&&` merge whose own published type already
+ * collapsed to boolean-or-absent: ECMA-262's own definition of `&&` decides
+ * which operand to keep by `ToBoolean`, so when the checker's inferred type
+ * for the WHOLE expression is `boolean | undefined` rather than the kept
+ * operand's own type, it has already proven the kept contribution is
+ * meaningful only as its truthiness -- an object-shaped arm has no boolean
+ * value of its own, but it does have a `ToBoolean` answer, and that answer is
+ * exactly what the checker's type says this merge publishes. This is why
+ * `partialDeadMergeArms`'s live/dead split still matters here rather than
+ * making this a blanket "any carrier converts to boolean" capability: the
+ * SAME renderer applies `ToBoolean` only to arms this merge's own narrowing
+ * already proved live, one call site's condition and nowhere else -- not a
+ * new entry in the general conversion registry, which would let it fire for
+ * any unrelated occurrence of the same representation pair.
+ */
+/**
+ * Whether a `&&` merge publishes its kept operand's TRUTHINESS rather than
+ * its value.
+ *
+ * The same proof `isBooleanShapedMergeTarget` states for one live arm of a
+ * partially-dead tagged union, asked of the kept operand as a WHOLE -- and
+ * for the same reason. ECMA-262 decides which operand `&&` keeps by
+ * `ToBoolean` in the first place, so when the checker's type for the whole
+ * expression is a plain `boolean` while the kept operand's own carrier is
+ * not, it has already proven the kept contribution meaningful only as its
+ * truthiness. `object && object.isObject3D` over three's `Object3D` is the
+ * shape: the merge publishes `boolean`, the kept side is a
+ * `class-ref(shared-refcount)` -- nullable, because `optional.ts` collapses
+ * `T | null` onto it -- and its `ToBoolean` (`emit-presence.ts`'s
+ * `booleanTestText`, total over every carrier) IS the value this branch
+ * yields.
+ *
+ * Deliberately EXACT, not `isBooleanShapedMergeTarget`'s optional-tolerant
+ * test: `optional(scalar(boolean))` would need the boolean wrapped back into
+ * an optional, a second step `ir/lower-narrow.ts` has no conversion use to
+ * name here. A merge that publishes `boolean | undefined` keeps raising its
+ * obligation, correctly, rather than being half-answered.
+ *
+ * Asked by `ir/lower-narrow.ts`'s `mergeIncoming`, the one authority on what
+ * a merge arm builds.
+ */
+export const mergesAsTruthiness = (merged) => merged.kind === 'scalar' && merged.domain === 'boolean';
+export const isBooleanShapedMergeTarget = (representation) => {
+    const payload = representation.kind === 'optional' ? representation.payload : representation;
+    return payload.kind === 'scalar' && payload.domain === 'boolean';
+};
+export const partialDeadMergeArms = (representation) => {
+    const candidate = representation.kind === 'optional' ? representation.payload : representation;
+    const keptIsOptional = representation.kind === 'optional';
+    if (candidate.kind !== 'tagged-union')
+        return null;
+    const tagsAbsence = unionTagsAbsence(candidate);
+    const liveIndices = candidate.arms
+        .map((arm, index) => (isDeadMergePayload(arm.value, tagsAbsence || keptIsOptional) ? -1 : index))
+        .filter((index) => index >= 0);
+    if (liveIndices.length === 0 || liveIndices.length === candidate.arms.length)
+        return null;
+    return { payload: candidate, liveIndices, keptIsOptional };
+};
+/**
+ * The ownership class a carrier crosses a body boundary under, or `null` when
+ * it states none a copy can be proven safe under.
+ *
+ * One function, because everything that spells a `capture:` capability keys
+ * the manifest's `captureOwnershipSupport` by this string: `ir/certify.ts`
+ * demands it, `targets/cpp/captures.ts` admits it, and
+ * `emit-binding-reference.ts` names it in the refusal when admission says no.
+ *
+ * It used to be two. This one answered `'value'` by `default` and the one in
+ * `ir/captures.ts` answered `null` for `unresolved`, `proxy-object`,
+ * `borrowed-ref`, `dense-buffer`, `native-sequence`, `iterator` and `promise`
+ * -- so certification published `capture:value` for carriers whose admission
+ * then refused them by name, the same certify/print disagreement 2.3 fixed
+ * four of. The fail-CLOSED answer is the correct one and is what survives: a
+ * carrier that names no copy-safe ownership must refuse where the certificate
+ * is minted, not where the text is spelled. The hole was invisible only
+ * because `AllocateCallableOperation.captures` is still unfilled, so
+ * `ir/certify.ts`'s own demand list is empty today.
+ */
+export const ownershipOf = (representation) => {
+    switch (representation.kind) {
+        case 'void':
+        case 'scalar':
+        case 'string':
+        // `gea::Symbol` is an interned id and nothing aliases one, exactly as for
+        // `string` above.
+        case 'symbol':
+        case 'null':
+        case 'undefined':
+        case 'function':
+        case 'function-family':
+        case 'function-value-family':
+        case 'function-value-dispatch':
+        case 'generic-function-set':
+        case 'constructor-family':
+        case 'constructor-value-dispatch':
+        case 'function-and-constructor':
+            // Nothing else aliases a plain value. A callable carrier's own
+            // `environment` pointer is a deliberate, permanent leak (see
+            // `emitAllocateCallable`), so copying the `{invoke, environment}` pair
+            // into another environment is exactly as safe as the original copy.
+            return 'value';
+        case 'native-handle':
+            // A host handle is copied by value and the HOST owns what it names:
+            // every carrier a host states for one is a value type -- an id, a small
+            // struct, or a standard container -- and none owns the object on the
+            // other side of the boundary. A copy in an environment stays good for
+            // exactly as long as the host keeps the thing it names.
+            return 'value';
+        case 'class-ref':
+        case 'record':
+        case 'record-with-index':
+        case 'native-record-ref':
+        case 'array-object':
+        case 'dictionary':
+        case 'typed-array':
+        case 'array-buffer':
+        case 'shared-array-buffer':
+        case 'data-view':
+        case 'keyed-collection':
+            return representation.ownership;
+        case 'optional':
+            // `gea::Optional<T>` copies its payload by the same rule `T` copies by;
+            // an optional local is not a different capture question from a required
+            // one, only a wrapped one.
+            return ownershipOf(representation.payload);
+        case 'dynamic':
+            // The box copies by value and the copy is independent: `gea::Value`'s
+            // payload is a `std::shared_ptr<void>`, so a copy is a refcount bump
+            // over an immutable-by-construction cell.
+            return 'value';
+        case 'tagged-union': {
+            // A sum is copy-safe only when every arm is: the live arm is a runtime
+            // fact. Ask each arm's ownership rule instead of maintaining a second
+            // table that could disagree with those same carriers outside a union.
+            let weakest = 'value';
+            for (const arm of representation.arms) {
+                const ownership = ownershipOf(arm.value);
+                if (ownership === null)
+                    return null;
+                if (ownership !== 'value')
+                    weakest = ownership;
+            }
+            return weakest;
+        }
+        default:
+            // `unresolved`, `proxy-object`, `borrowed-ref`, `dense-buffer`,
+            // `native-sequence`, `iterator`, `promise`: none states a copy-safe
+            // ownership, either because the carrier has no ownership field to read
+            // (a proxy's two-part identity) or because it is explicitly borrowed
+            // from somewhere else. Refusing them is the fail-closed answer, not a
+            // gap to route around with a box.
+            return null;
+    }
+};
+/**
+ * The `capture:` capability discriminator for a carrier -- what both the
+ * demand and the refusal spell.
+ *
+ * A carrier with no copy-safe ownership still has to name SOMETHING, because
+ * a demand keyed on a name the manifest cannot publish is precisely how the
+ * refusal stays typed and attributable: `capture:unsupported-proxy-object`
+ * says which carrier could not be transported, where a bare `capture:null`
+ * would say only that one could not. `null` for the representation itself is
+ * a placement that never stated one, which is a different unknown and spells
+ * differently.
+ */
+export const captureCapabilityOf = (representation) => representation === null ? 'unstated' : (ownershipOf(representation) ?? `unsupported-${representation.kind}`);
+/**
+ * Every carrier reachable inside a representation, including the root.
+ *
+ * One walk, shared: `verify.ts`'s guards ask "is anything in here unresolved /
+ * boxed / a dense buffer", and a probe in the emitter asks "is anything in here
+ * unresolved" before it asks for a physical C++ type. Two copies of this switch
+ * would answer those questions over different carrier sets, which is precisely
+ * how a fail-closed guard silently stops covering a kind.
+ *
+ * ⛔ `record-with-index` was missing from this switch and fell through to
+ * `default`, so nothing inside one was ever visited: mongodb's `Filter` -- a
+ * record-with-index whose fields are the whole query -- was invisible to every
+ * guard built on this walk.
+ */
+export function* walkRepresentation(representation, visited = new Set()) {
+    // With `visited`, a carrier OBJECT is yielded once across every walk that
+    // shares the set. The derive memo hands every reader of one structural
+    // type the same object, so a record's field carriers, a union's arms and
+    // the selections that embed them are one DAG, not a forest of trees --
+    // and a per-node question asked of that DAG is answered once per node.
+    if (visited.has(representation))
+        return;
+    visited.add(representation);
+    yield representation;
+    const walk = (inner) => walkRepresentation(inner, visited);
+    switch (representation.kind) {
+        case 'record':
+            for (const field of representation.fields)
+                yield* walk(field.value);
+            return;
+        case 'record-with-index':
+            for (const field of representation.fields)
+                yield* walk(field.value);
+            for (const index of representation.indexes)
+                yield* walk(index.value);
+            return;
+        case 'proxy-object':
+            yield* walk(representation.target);
+            yield* walk(representation.handler);
+            return;
+        case 'borrowed-ref':
+            yield* walk(representation.referent);
+            return;
+        case 'array-object':
+            yield* walk(representation.element);
+            for (const field of representation.extension ?? [])
+                yield* walk(field.value);
+            return;
+        case 'dense-buffer':
+        case 'native-sequence':
+            yield* walk(representation.element);
+            return;
+        case 'iterator':
+            yield* walk(representation.element);
+            yield* walk(representation.resume);
+            yield* walk(representation.completion);
+            return;
+        case 'promise':
+            yield* walk(representation.value);
+            return;
+        case 'keyed-collection':
+            yield* walk(representation.key);
+            if (representation.value)
+                yield* walk(representation.value);
+            return;
+        case 'dictionary':
+            yield* walk(representation.value);
+            return;
+        case 'optional':
+            yield* walk(representation.payload);
+            return;
+        case 'tagged-union':
+            for (const arm of representation.arms)
+                yield* walk(arm.value);
+            return;
+        case 'function':
+        case 'function-family':
+        case 'constructor-family':
+        case 'constructor-value-dispatch':
+        case 'function-value-family':
+        case 'function-value-dispatch':
+            for (const parameter of representation.abi.parameters)
+                yield* walk(parameter.value);
+            yield* walk(representation.abi.result);
+            if (representation.abi.receiver)
+                yield* walk(representation.abi.receiver);
+            return;
+        case 'function-and-constructor':
+            for (const abi of [representation.call, representation.construct]) {
+                for (const parameter of abi.parameters)
+                    yield* walk(parameter.value);
+                yield* walk(abi.result);
+                if (abi.receiver)
+                    yield* walk(abi.receiver);
+            }
+            return;
+        case 'unresolved':
+        case 'void':
+        case 'scalar':
+        case 'string':
+        case 'symbol':
+        case 'null':
+        case 'undefined':
+        case 'class-ref':
+        case 'native-handle':
+        case 'native-record-ref':
+        case 'typed-array':
+        case 'array-buffer':
+        case 'shared-array-buffer':
+        case 'data-view':
+        case 'dynamic':
+        case 'generic-function-set':
+        case 'callable-identity':
+            return;
+        default: {
+            const unhandled = representation;
+            throw new Error(`unhandled representation in traversal: ${String(unhandled)}`);
+        }
+    }
+}
+/**
+ * Whether a carrier holds lattice bottom anywhere inside it.
+ *
+ * `unresolved` has no physical type, and `targets/cpp/types.ts`'s `cppTypeOf`
+ * throws on one rather than inventing a slot -- correctly, since a carrier that
+ * was never selected must not materialize as a default-constructed value. That
+ * makes it a hazard for the emitter's *probes*: a function asking "could this
+ * record be recast to an array?" is asking a question with a legitimate `false`
+ * answer, and it must not blow up the compile to find out. Asking this first is
+ * how such a probe stays a probe.
+ */
+export const containsUnresolved = (representation) => {
+    for (const found of walkRepresentation(representation))
+        if (found.kind === 'unresolved')
+            return true;
+    return false;
+};
+/**
+ * The carrier every `throw` converts its value into: ECMAScript does not
+ * type a thrown value, so this is the one genuinely dynamic boundary the
+ * language itself states. The catch side reads it back without conversion
+ * (`ir/lower-exceptions.ts`).
+ */
+export const thrownValueCarrier = { kind: 'dynamic', reason: 'thrown-error-carrier' };