@geastack/compiler 1.0.15

package/dist/ir/certify/carrier-keys.js

@@ -0,0 +1,221 @@
+import { representationKey } from '../../representation/model.js';
+import { fieldPresenceOf, staticOwnFieldsOf } from '../../representation/record-fields.js';
+import { nativeEnumerationPlanOf } from '../native-enumeration.js';
+/**
+ * The pure `(kind, representation[, receiver][, deriver]) => string`
+ * refinements `preflight/runtime-helper-key.ts` used to compute a
+ * `protocol:*`/`allocation:regexp-object:*` carrier key from a SEMANTIC
+ * operand it first had to resolve through the plan. `ir/certify/runtime-helper.ts`
+ * needs the identical spellings for the LOWERED operand, which already
+ * carries its representation directly (`IrOperand.representation`) -- so the
+ * resolution half (operand -> representation, through the plan or the
+ * deriver) stays in `runtime-helper-key.ts`, and only the refinement half
+ * moves here, imported by both, so the two censuses cannot spell one carrier
+ * two different ways.
+ *
+ * Every function here takes `kind` as an explicit argument rather than
+ * deriving it from `representation.kind` internally, because the two are NOT
+ * always the same fact: a semantic operand whose own result exists but was
+ * never selected by the plan reports `kind === 'unselected'` while
+ * `representation` is `undefined` -- a real, distinct outcome from an
+ * operand that does not exist at all (`kind === 'absent'`), and both old
+ * skip-paths return `kind` verbatim in that case. Collapsing the two into
+ * one `representation?.kind ?? 'absent'` computation would silently turn
+ * "unselected" into "absent" and change what the old preflight walk
+ * certified. A lowered `IrOperand`'s representation is always resolved, so
+ * the IR side simply passes `representation.kind` for both arguments.
+ */
+/**
+ * `for`-`in`'s `get-iterator` step, refined the way a `native-record-ref`
+ * receiver (host-bound vs. compiler-owned) and a `dictionary`/`optional`
+ * receiver's own key domain must be to tell a claimed carrier from an
+ * identically-`.kind`ed one this backend cannot walk. See
+ * `preflight/runtime-helper-key.ts`'s own (much longer) doc for the full
+ * reasoning; this is that function's body, unchanged, parameterized by the
+ * representation directly instead of by a semantic operand.
+ */
+export const enumerateGetIteratorCarrierKeyOf = (kind, representation) => {
+    if (representation &&
+        (representation.kind === 'optional' || representation.kind === 'tagged-union') &&
+        nativeEnumerationPlanOf(representation))
+        return 'native-sum';
+    if (kind === 'dictionary')
+        return representation?.kind === 'dictionary' ? `dictionary(${representation.key})` : kind;
+    if (kind === 'optional') {
+        const payload = representation?.kind === 'optional' ? representation.payload : null;
+        if (!payload)
+            return kind;
+        return payload.kind === 'dictionary' ? `optional(dictionary(${payload.key}))` : `optional(${payload.kind})`;
+    }
+    if (kind !== 'native-record-ref')
+        return kind;
+    return representation?.kind === 'native-record-ref' && representation.native !== null ? 'native-record-ref(host-bound)' : kind;
+};
+/**
+ * Whether a "record"/"record-with-index" carrier declares its OWN
+ * `[Symbol.iterator]` (or `[Symbol.asyncIterator]`) field -- see
+ * `preflight/runtime-helper-key.ts`'s own doc for the full reasoning
+ * (unchanged here; only moved).
+ */
+export const recordHasIteratorMethodField = (deriver, representation) => {
+    const fields = representation.kind === 'record-with-index'
+        ? representation.fields
+        : representation.kind === 'record' || representation.kind === 'native-record-ref'
+            ? staticOwnFieldsOf(deriver, representation)
+            : null;
+    if (fields === null)
+        return false;
+    return fields.some((field) => {
+        if (!field.key.startsWith('sym('))
+            return false;
+        if (field.value.kind !== 'function-value-dispatch')
+            return false;
+        const abi = field.value.abi;
+        // A DECLARED receiver does not disqualify the member. ECMA-262 7.4.2
+        // `GetIterator` performs `Call(method, obj)` -- the receiver is part of
+        // the step, not an obstacle to it -- and `emitDynamicGetIterator` renders
+        // exactly that through `iteratorMethodCallText`, which supplies the
+        // receiver argument when and only when the ABI declares one. Refusing a
+        // receiver-carrying `[Symbol.iterator]` here made the DECLARATION's
+        // spelling decide whether the protocol was claimed at all: the identical
+        // member reached this predicate with a receiver when it was written as
+        // `type C = { [Symbol.iterator](): Cursor }` (an alias anchors the
+        // implicit receiver, `structural-receiver.ts`) and without one otherwise,
+        // so `typed-custom-iterator-close.ts` was refused by name for a shape the
+        // emitter can print. Parameters still disqualify: `GetIterator` passes
+        // none, so a member that requires one is not the protocol's method.
+        if (abi.parameters.length !== 0)
+            return false;
+        const nextResult = abi.result;
+        if (nextResult.kind === 'iterator')
+            return true;
+        const resultFields = nextResult.kind === 'record'
+            ? nextResult.fields
+            : nextResult.kind === 'native-record-ref'
+                ? staticOwnFieldsOf(deriver, nextResult)
+                : null;
+        const resultAccessors = nextResult.kind === 'record'
+            ? nextResult.accessors
+            : nextResult.kind === 'native-record-ref'
+                ? (() => {
+                    const resolved = deriver.layoutOf(nextResult.shapeId);
+                    return resolved.kind === 'record' ? resolved.accessors : null;
+                })()
+                : null;
+        if (resultFields === null && resultAccessors === null)
+            return false;
+        const member = (key) => resultFields?.find((entry) => entry.key === key);
+        if (member('value') !== undefined && member('done') !== undefined)
+            return true;
+        return (member('next')?.value.kind === 'function-value-dispatch' ||
+            resultAccessors?.some((accessor) => accessor.key === 'next' && accessor.getter !== null) === true);
+    });
+};
+/**
+ * Whether a `record` is a TUPLE's carrier whose elements a single native
+ * cursor can walk -- see `preflight/runtime-helper-key.ts`'s own doc.
+ */
+export const isUniformTupleRecord = (representation) => {
+    if (representation.kind !== 'record' || representation.fields.length === 0)
+        return false;
+    const first = representation.fields[0];
+    if (!first)
+        return false;
+    const elementKey = representationKey(first.value);
+    return representation.fields.every((field, position) => field.key === String(position) && field.required && representationKey(field.value) === elementKey);
+};
+/** The wrapped key an ABSENT iteration source reports, or `null` when `kind` is not `optional`. */
+const optionalIterationSourceKeyOf = (kind, representation) => {
+    if (kind !== 'optional')
+        return null;
+    if (representation?.kind !== 'optional')
+        return kind;
+    return `optional(${representation.payload.kind})`;
+};
+/**
+ * The `iterator`/`async-iterator` protocol's `get-method`/`get-iterator`
+ * carrier -- see `preflight/runtime-helper-key.ts`'s own doc for the full
+ * reasoning behind the `record(no-iterator-method)`/`record(tuple-values)`
+ * split.
+ */
+export const iteratorMethodCarrierKeyOf = (kind, representation, deriver) => {
+    const wrapped = optionalIterationSourceKeyOf(kind, representation);
+    if (wrapped !== null)
+        return wrapped;
+    if (kind !== 'record' && kind !== 'native-record-ref')
+        return kind;
+    if (!representation)
+        return `${kind}(no-iterator-method)`;
+    if (recordHasIteratorMethodField(deriver, representation))
+        return kind;
+    if (kind === 'native-record-ref')
+        return 'native-record-ref(no-iterator-method)';
+    return isUniformTupleRecord(representation) ? 'record(tuple-values)' : 'record(no-iterator-method)';
+};
+/** Whether a `record`/`class-ref` is a shape `emitSpreadCopy` can copy without calling user code -- see `runtime-helper-key.ts`'s doc. */
+const isCopyableSpreadRecord = (deriver, representation) => {
+    const fields = staticOwnFieldsOf(deriver, representation);
+    if (fields === null)
+        return false;
+    if (representation.kind === 'record' && representation.accessors.length > 0)
+        return false;
+    return fields.every((field) => !field.key.startsWith('sym(') && fieldPresenceOf(field) !== 'unprovable');
+};
+const isCopyableSpreadRecordInto = (deriver, representation, receiver) => {
+    if (!isCopyableSpreadRecord(deriver, representation) || receiver?.kind !== 'dictionary')
+        return false;
+    const fields = staticOwnFieldsOf(deriver, representation);
+    return fields !== null && (receiver.key === 'string' || fields.length === 0);
+};
+/** Whether every arm of a tagged-union is a shape `emitSpreadCopy` can copy into this receiver -- see `runtime-helper-key.ts`'s doc. */
+const isCopyableSpreadUnion = (deriver, representation, receiver) => representation.kind === 'tagged-union' &&
+    representation.arms.every((arm) => arm.value.kind === 'dictionary'
+        ? receiver?.kind === 'dictionary' && arm.value.key === receiver.key && (arm.value.key === 'string' || arm.value.key === 'symbol')
+        : isCopyableSpreadRecordInto(deriver, arm.value, receiver));
+/** The source carrier kinds `spreadSourceCarrierKeyOf` refines beyond their bare `.kind` -- see `runtime-helper-key.ts`'s doc. */
+const refinableSpreadSourceKinds = new Set(['tagged-union', 'optional', 'record', 'class-ref', 'native-record-ref']);
+/**
+ * `CopyDataProperties`'s source carrier, refined the way a `dictionary`'s key
+ * domain, a `tagged-union`'s per-arm copyability, and an `optional`'s present
+ * payload have to be -- see `preflight/runtime-helper-key.ts`'s own (longer)
+ * doc for the full reasoning; this is that function's body, parameterized by
+ * the two representations directly instead of by a semantic operand pair.
+ */
+export const spreadSourceCarrierKeyOf = (kind, representation, receiver, deriver) => {
+    if (!representation)
+        return kind;
+    const dictionaryKind = (candidate) => receiver?.kind === 'dictionary'
+        ? `dictionary(${candidate.key}->${receiver.key})`
+        : `dictionary(${candidate.key}->${receiver?.kind ?? 'absent'})`;
+    if (representation.kind === 'dynamic')
+        return `dynamic->${receiver?.kind ?? 'absent'}`;
+    if (representation.kind === 'dictionary')
+        return dictionaryKind(representation);
+    if (!refinableSpreadSourceKinds.has(kind))
+        return kind;
+    const copyableKind = (candidate) => isCopyableSpreadUnion(deriver, candidate, receiver)
+        ? 'tagged-union(record-or-dictionary)'
+        : candidate.kind === 'dictionary'
+            ? dictionaryKind(candidate)
+            : isCopyableSpreadRecordInto(deriver, candidate, receiver)
+                ? `${candidate.kind}(copyable)`
+                : null;
+    if (representation.kind === 'optional')
+        return `optional(${copyableKind(representation.payload) ?? representation.payload.kind})`;
+    return copyableKind(representation) ?? kind;
+};
+/**
+ * `u` selects the runtime's scalar-value matcher, while `v` stays unbuilt --
+ * see `preflight/runtime-helper-key.ts`'s own doc. Unlike that file's
+ * version, `flags` here is always a concrete string: by the time an
+ * `AllocateRegExpOperation` exists, lowering has already required its own
+ * `pattern-flags` operand to be a constant string (`lower-allocation.ts`'s
+ * `textOf`), so there is no `unselected-flags` state left to report.
+ */
+export const regexpFlagSupportKeyOf = (flags) => {
+    if (flags.includes('v'))
+        return 'unicode-sets-flags';
+    if (flags.includes('u') && flags.includes('i'))
+        return 'unicode-ignore-case-flags';
+    return flags.includes('u') ? 'unicode-flags' : 'supported-flags';
+};

package/dist/ir/certify/function-source.d.ts

@@ -0,0 +1,4 @@
+import type { SemanticGraph } from '../../semantics/model/graph.js';
+import type { SemanticOperation } from '../../semantics/model/operations.js';
+/** Only direct calls are implemented: an extracted builtin must not bind itself to the original function. */
+export declare const isDirectFunctionSourceRead: (graph: SemanticGraph, operation: SemanticOperation) => boolean;

package/dist/ir/certify/function-source.js

@@ -0,0 +1,28 @@
+import { operandOf } from '../../semantics/model/operands.js';
+/** Only direct calls are implemented: an extracted builtin must not bind itself to the original function. */
+export const isDirectFunctionSourceRead = (graph, operation) => {
+    if (operation.family !== 'property' || operation.internalMethod !== 'get' || operation.keyIsComputed)
+        return false;
+    const key = operandOf(operation, 'key');
+    const receiver = operandOf(operation, 'receiver');
+    if (key?.source.kind !== 'constant' || key.source.text !== 'toString' || receiver?.source.kind !== 'result')
+        return false;
+    const result = operation.results.find((candidate) => candidate.role === 'value');
+    if (!result)
+        return false;
+    let calls = 0;
+    for (const edge of graph.edges) {
+        if (edge.kind !== 'value' || edge.result !== result.id)
+            continue;
+        const user = graph.operations.get(edge.to);
+        if (edge.role !== 'callee' || user?.family !== 'invocation' || user.internalMethod !== 'call' || user.optionalChain)
+            return false;
+        const supplied = operandOf(user, 'receiver');
+        if (supplied?.source.kind !== 'result' || supplied.source.result !== receiver.source.result)
+            return false;
+        if (user.operands.some((operand) => operand.role === 'spread-argument'))
+            return false;
+        calls++;
+    }
+    return calls > 0;
+};

package/dist/ir/certify/has-property-key.d.ts

@@ -0,0 +1,88 @@
+import type { Representation } from '../../representation/model.js';
+import type { RepresentationDeriver } from '../../representation/derive.js';
+/**
+ * The obligation key for `k in o`, ECMA-262 13.10.1's `[[HasProperty]]`.
+ *
+ * `in` is unlike the other computation forms in that neither operand alone
+ * decides whether a backend can answer it. `'value' in descriptor` over a
+ * closed struct is settled before the program runs; `k in descriptor` over the
+ * same struct is not settled at all, because a C++ struct has no runtime key
+ * table to consult; and `k in table` over a dictionary is a real lookup that
+ * needs no static key. So the key names BOTH halves -- what the key operand is,
+ * and what the receiver carries -- rather than the operator, which is always
+ * the word `in` and therefore says nothing (the same reasoning
+ * `runtime-helper-key.ts` already applies to `typeof`, whose old flat
+ * `computation:in:in` spelling this replaces).
+ *
+ * Two narrowings matter and are folded into the receiver half here, following
+ * `preflight/property-access.ts`'s own `native-record-ref(no-index-sidecar)`
+ * precedent -- resolve the named shape through the one deriver this compilation
+ * built, then state what was found:
+ *
+ * - `record(own-field)` -- the static key names a REQUIRED field of the
+ *   receiver's own layout. A required field is present on every instance of
+ *   that layout, so `in` is the constant `true`.
+ * - `record(optional-field)` -- the static key names a field whose carrier
+ *   states its own presence, so `in` is that flag. This proves the key IS
+ *   there when the flag is set, which needs no prototype reasoning at all: a
+ *   prototype can only ever add keys, never remove one.
+ * - `record(sidecar)` -- an otherwise-unknown static key on a compiler-owned
+ *   shared object. Its generated field dispatcher and identity-keyed expando
+ *   table together answer the runtime own-property question; known prototype
+ *   members are handled separately.
+ * - `record(unproven)` -- everything else, and ABSENCE ALWAYS. `in` walks the
+ *   prototype chain, so a key no layout names is not thereby missing:
+ *   `'toString' in o` is `true` for every ordinary object, and a `class-ref`'s
+ *   prototype carries the class's own methods. Even a plain struct is not
+ *   enough, because getting a value into one can SLICE a class instance down
+ *   to the declared fields -- see `staticKeyPresenceOf`'s own note and
+ *   `test/fixtures/in-operator-class-through-interface.ts`, which is what a version
+ *   of this that DID answer absence compiled to a wrong answer. Presence is
+ *   proven; absence is not.
+ */
+/**
+ * A resolved record layout answers only for a required own field. A
+ * `record-with-index`'s open half is deliberately not claimed here either: its
+ * dictionary sidecar really could answer. This field-only helper still leaves
+ * the receiver unproven; `hasPropertyHelperKey` upgrades a compiler-owned
+ * shared carrier to the exact runtime sidecar answer after prototype members
+ * have been settled.
+ */
+export declare const recordAnswerFor: (layout: Representation, key: string | null) => string;
+/**
+ * The named-shape resolution `receiverLayoutOf` already applies to the
+ * top-level receiver, applied again to a NESTED representation -- an
+ * `optional`'s payload, in practice, since that is the one place a name gets
+ * discovered a second layer in.
+ */
+export declare const resolvedLayoutOf: (representation: Representation, deriver: RepresentationDeriver) => {
+    readonly layout: Representation;
+};
+/** A compiler-owned object carrier whose shared identity can key the native dynamic-property sidecar. */
+export declare const generatedSharedObjectCarrier: (representation: Representation) => boolean;
+/**
+ * A compiler-emitted record has an identity-keyed expando table even when the
+ * key is only known at runtime.  Classes deliberately stay out of this
+ * predicate: an arbitrary string can name an inherited program method, and
+ * that prototype question is not recoverable from the record sidecar.
+ */
+export declare const generatedSharedRecordCarrier: (representation: Representation) => boolean;
+/** Any compiler-owned ordinary object carrier, including by-value records with no expando identity. */
+export declare const generatedObjectCarrier: (representation: Representation) => boolean;
+/**
+ * The `computation:in:*` answer suffix for one resolved layout, factored out
+ * so `optional` can ask it of its own payload without a second copy of the
+ * record/dictionary rules.
+ *
+ * `k in maybeNull` is answerable, and exactly as far as the payload's own
+ * layout is: 13.10.1 throws a TypeError before `[[HasProperty]]` runs when
+ * the receiver is absent (the language's own answer, rendered by
+ * `emit-in.ts`), and when it is present the question is the identical one
+ * this function already asks of any other receiver -- so a receiver the
+ * checker left nullable is not a fourth case, it is the same three cases one
+ * presence test away. Missing this left the fallback below leak the bare
+ * word "optional" as the whole claim, which is never installed anywhere:
+ * every `in` over a nullable receiver refused, even ones whose payload is a
+ * required own field.
+ */
+export declare const layoutAnswerSuffix: (layout: Representation, key: string | null, deriver: RepresentationDeriver) => string;

package/dist/ir/certify/has-property-key.js

@@ -0,0 +1,116 @@
+import { staticKeyPresenceOf } from '../../representation/record-fields.js';
+/**
+ * The obligation key for `k in o`, ECMA-262 13.10.1's `[[HasProperty]]`.
+ *
+ * `in` is unlike the other computation forms in that neither operand alone
+ * decides whether a backend can answer it. `'value' in descriptor` over a
+ * closed struct is settled before the program runs; `k in descriptor` over the
+ * same struct is not settled at all, because a C++ struct has no runtime key
+ * table to consult; and `k in table` over a dictionary is a real lookup that
+ * needs no static key. So the key names BOTH halves -- what the key operand is,
+ * and what the receiver carries -- rather than the operator, which is always
+ * the word `in` and therefore says nothing (the same reasoning
+ * `runtime-helper-key.ts` already applies to `typeof`, whose old flat
+ * `computation:in:in` spelling this replaces).
+ *
+ * Two narrowings matter and are folded into the receiver half here, following
+ * `preflight/property-access.ts`'s own `native-record-ref(no-index-sidecar)`
+ * precedent -- resolve the named shape through the one deriver this compilation
+ * built, then state what was found:
+ *
+ * - `record(own-field)` -- the static key names a REQUIRED field of the
+ *   receiver's own layout. A required field is present on every instance of
+ *   that layout, so `in` is the constant `true`.
+ * - `record(optional-field)` -- the static key names a field whose carrier
+ *   states its own presence, so `in` is that flag. This proves the key IS
+ *   there when the flag is set, which needs no prototype reasoning at all: a
+ *   prototype can only ever add keys, never remove one.
+ * - `record(sidecar)` -- an otherwise-unknown static key on a compiler-owned
+ *   shared object. Its generated field dispatcher and identity-keyed expando
+ *   table together answer the runtime own-property question; known prototype
+ *   members are handled separately.
+ * - `record(unproven)` -- everything else, and ABSENCE ALWAYS. `in` walks the
+ *   prototype chain, so a key no layout names is not thereby missing:
+ *   `'toString' in o` is `true` for every ordinary object, and a `class-ref`'s
+ *   prototype carries the class's own methods. Even a plain struct is not
+ *   enough, because getting a value into one can SLICE a class instance down
+ *   to the declared fields -- see `staticKeyPresenceOf`'s own note and
+ *   `test/fixtures/in-operator-class-through-interface.ts`, which is what a version
+ *   of this that DID answer absence compiled to a wrong answer. Presence is
+ *   proven; absence is not.
+ */
+/**
+ * A resolved record layout answers only for a required own field. A
+ * `record-with-index`'s open half is deliberately not claimed here either: its
+ * dictionary sidecar really could answer. This field-only helper still leaves
+ * the receiver unproven; `hasPropertyHelperKey` upgrades a compiler-owned
+ * shared carrier to the exact runtime sidecar answer after prototype members
+ * have been settled.
+ */
+export const recordAnswerFor = (layout, key) => {
+    const fields = layout.kind === 'record' || layout.kind === 'record-with-index' ? layout.fields : null;
+    const presence = staticKeyPresenceOf(fields, key);
+    if (presence === 'present')
+        return 'record(own-field)';
+    return presence === 'flagged' ? 'record(optional-field)' : 'record(unproven)';
+};
+/**
+ * The named-shape resolution `receiverLayoutOf` already applies to the
+ * top-level receiver, applied again to a NESTED representation -- an
+ * `optional`'s payload, in practice, since that is the one place a name gets
+ * discovered a second layer in.
+ */
+export const resolvedLayoutOf = (representation, deriver) => {
+    if (representation.kind !== 'native-record-ref' && representation.kind !== 'class-ref')
+        return { layout: representation };
+    return { layout: deriver.layoutOf(representation.shapeId) };
+};
+/** A compiler-owned object carrier whose shared identity can key the native dynamic-property sidecar. */
+export const generatedSharedObjectCarrier = (representation) => {
+    if (representation.kind === 'record' || representation.kind === 'record-with-index' || representation.kind === 'class-ref') {
+        return representation.ownership === 'shared-refcount';
+    }
+    return representation.kind === 'native-record-ref' && representation.native === null && representation.ownership === 'shared-refcount';
+};
+/**
+ * A compiler-emitted record has an identity-keyed expando table even when the
+ * key is only known at runtime.  Classes deliberately stay out of this
+ * predicate: an arbitrary string can name an inherited program method, and
+ * that prototype question is not recoverable from the record sidecar.
+ */
+export const generatedSharedRecordCarrier = (representation) => (representation.kind === 'record' || representation.kind === 'record-with-index') && representation.ownership === 'shared-refcount';
+/** Any compiler-owned ordinary object carrier, including by-value records with no expando identity. */
+export const generatedObjectCarrier = (representation) => representation.kind === 'record' ||
+    representation.kind === 'record-with-index' ||
+    representation.kind === 'class-ref' ||
+    (representation.kind === 'native-record-ref' && representation.native === null);
+/**
+ * The `computation:in:*` answer suffix for one resolved layout, factored out
+ * so `optional` can ask it of its own payload without a second copy of the
+ * record/dictionary rules.
+ *
+ * `k in maybeNull` is answerable, and exactly as far as the payload's own
+ * layout is: 13.10.1 throws a TypeError before `[[HasProperty]]` runs when
+ * the receiver is absent (the language's own answer, rendered by
+ * `emit-in.ts`), and when it is present the question is the identical one
+ * this function already asks of any other receiver -- so a receiver the
+ * checker left nullable is not a fourth case, it is the same three cases one
+ * presence test away. Missing this left the fallback below leak the bare
+ * word "optional" as the whole claim, which is never installed anywhere:
+ * every `in` over a nullable receiver refused, even ones whose payload is a
+ * required own field.
+ */
+export const layoutAnswerSuffix = (layout, key, deriver) => {
+    if (layout.kind === 'record' || layout.kind === 'record-with-index')
+        return recordAnswerFor(layout, key);
+    // A dictionary's KEY DOMAIN is part of the receiver half: `gea::Dictionary`
+    // is keyed by `std::string` and `gea::NumericDictionary` by `double`, two
+    // genuinely different containers (`types.ts`'s own note), so one claim
+    // covering both would certify a string key against a numeric table.
+    if (layout.kind === 'dictionary')
+        return `dictionary(${layout.key})`;
+    if (layout.kind === 'optional') {
+        return `optional(${layoutAnswerSuffix(resolvedLayoutOf(layout.payload, deriver).layout, key, deriver)})`;
+    }
+    return layout.kind;
+};

package/dist/ir/certify/instanceof-key.d.ts

@@ -0,0 +1,24 @@
+import type { Representation } from '../../representation/model.js';
+/**
+ * The carrier vocabulary of the `v instanceof C` key (ECMA-262 13.10.2), whose
+ * IR-side spelling is `ir/certify/property-access.ts`'s `instanceofRuntimeHelperKey`.
+ *
+ * Keyed by BOTH operands, for the same reason `typeof` is keyed by its
+ * operand and `in` by both of its own (`has-property-key.ts`): the operator is always the word `instanceof`, so
+ * spelling it says nothing, while what decides whether a backend can answer is
+ * what the two sides carry. A boxed value against a host `Error` constructor
+ * is a real runtime question this backend answers; the same value against a
+ * program's own class is a prototype walk nothing here has written. One flat
+ * `computation:instanceof:instanceof` key claimed both at once, which is
+ * exactly the over-claim a manifest row must not make -- the program certifies
+ * and is then refused at emission.
+ *
+ * The right half names the host PROTOCOL rather than its carrier kind.
+ * `native-handle` alone would merge `Error` with `Math` and with every other
+ * bound protocol into one claim, and the protocol is what decides the answer:
+ * `gea::host::instanceOfError` (gea_runtime.h) is written for the seven error
+ * constructors and for nothing else.
+ */
+/** A carrier that cannot possibly hold an ECMAScript object. */
+export declare const definitelyPrimitive: (representation: Representation) => boolean;
+export declare const mapTestable: (representation: Representation) => boolean;

package/dist/ir/certify/instanceof-key.js

@@ -0,0 +1,35 @@
+/**
+ * The carrier vocabulary of the `v instanceof C` key (ECMA-262 13.10.2), whose
+ * IR-side spelling is `ir/certify/property-access.ts`'s `instanceofRuntimeHelperKey`.
+ *
+ * Keyed by BOTH operands, for the same reason `typeof` is keyed by its
+ * operand and `in` by both of its own (`has-property-key.ts`): the operator is always the word `instanceof`, so
+ * spelling it says nothing, while what decides whether a backend can answer is
+ * what the two sides carry. A boxed value against a host `Error` constructor
+ * is a real runtime question this backend answers; the same value against a
+ * program's own class is a prototype walk nothing here has written. One flat
+ * `computation:instanceof:instanceof` key claimed both at once, which is
+ * exactly the over-claim a manifest row must not make -- the program certifies
+ * and is then refused at emission.
+ *
+ * The right half names the host PROTOCOL rather than its carrier kind.
+ * `native-handle` alone would merge `Error` with `Math` and with every other
+ * bound protocol into one claim, and the protocol is what decides the answer:
+ * `gea::host::instanceOfError` (gea_runtime.h) is written for the seven error
+ * constructors and for nothing else.
+ */
+/** A carrier that cannot possibly hold an ECMAScript object. */
+export const definitelyPrimitive = (representation) => representation.kind === 'scalar' ||
+    representation.kind === 'string' ||
+    representation.kind === 'symbol' ||
+    representation.kind === 'null' ||
+    representation.kind === 'undefined';
+export const mapTestable = (representation) => {
+    if (representation.kind === 'unresolved' || representation.kind === 'borrowed-ref')
+        return false;
+    if (representation.kind === 'optional')
+        return mapTestable(representation.payload);
+    if (representation.kind === 'tagged-union')
+        return representation.arms.every((arm) => mapTestable(arm.value));
+    return true;
+};