@geastack/compiler 1.0.15

package/dist/projection/synthesized-abi.d.ts

@@ -0,0 +1,61 @@
+import type { DeclarationId, FunctionId } from '../identity/ids.js';
+import type { CallableAbi } from '../representation/model.js';
+/**
+ * The identity of one extra calling convention over `declaration`.
+ *
+ * `identity/ids.ts` mints every real `FunctionId` from a declaration alone
+ * (`functionId`), because an ordinary function has exactly one: the
+ * convention its own parameter list states. An extra convention is not that
+ * function -- calling it with the ordinary convention's frame would read
+ * arguments nobody pushed -- so it needs its own identity, and this compiler
+ * has no declaration to mint one from: nothing in the checked program is the
+ * extra convention. What it does have is the declaration the convention is
+ * *about*, which is real and already sealed, plus whatever the caller uses to
+ * tell two extra conventions on one declaration apart. Keying on both is what
+ * makes the result stable (the same inputs always mint the same identity),
+ * reproducible (any later reader with the same two facts can recompute it
+ * independently), and collision-free with the declaration's own convention:
+ * `functionId(declaration)` alone is never a valid identity here, because
+ * `synthesizedFunctionId` always appends a field after it, and an ordinary
+ * `FunctionId` never has one.
+ *
+ * Built from a file path, a source position, or generated text, this would
+ * silently change identity every time the program was reformatted or a
+ * function moved in the file -- the exact failure this compiler's identity
+ * scheme (`identity/ids.ts`'s own module comment) exists to rule out
+ * everywhere else. `declaration` and `discriminator` are the only two inputs
+ * to guarantee that outcome cannot happen here either.
+ */
+export declare const synthesizedFunctionId: (declaration: DeclarationId, discriminator: string) => FunctionId;
+/** One caller-supplied statement: "this declaration also has this convention, distinguished by this discriminator". */
+export interface SynthesizedAbiRequest {
+    readonly declaration: DeclarationId;
+    /** Distinguishes two extra conventions the caller wants on the same declaration; opaque to this file. */
+    readonly discriminator: string;
+    readonly abi: CallableAbi;
+}
+/** Two requests named the same declaration and discriminator but disagreed about the convention. */
+export interface SynthesizedAbiConflict {
+    readonly declaration: DeclarationId;
+    readonly discriminator: string;
+    readonly reason: string;
+}
+export interface SynthesizedAbiProjection {
+    readonly abis: ReadonlyMap<FunctionId, CallableAbi>;
+    readonly conflicts: readonly SynthesizedAbiConflict[];
+}
+/**
+ * Keys every request by its identity and publishes the map.
+ *
+ * A repeated `(declaration, discriminator)` pair is not an error by itself --
+ * two callers, or one caller building its request list twice, may legitimately
+ * agree -- so it is accepted silently when the two `CallableAbi`s are the same
+ * convention (`abiKey` equal). Two *different* conventions asking to be the
+ * same identity is the one case this must not let through in silence: the
+ * `FunctionId` the map ends up publishing for that identity would depend on
+ * request order, which is exactly the "one operation, one authoritative
+ * result" invariant every other publication step in this compiler enforces,
+ * so a conflict is reported here rather than resolved by whichever request
+ * happened to run last.
+ */
+export declare const projectSynthesizedAbis: (requests: readonly SynthesizedAbiRequest[]) => SynthesizedAbiProjection;

package/dist/projection/synthesized-abi.js

@@ -0,0 +1,94 @@
+import { functionId } from '../identity/ids.js';
+import { abiKey } from '../representation/model.js';
+/**
+ * Publishing an extra calling convention for a declaration that already has
+ * one.
+ *
+ * An ordinary function's calling convention is derived, not stated: the plan
+ * selects a carrier for its `function-object` allocation, and `projectAbis`
+ * (`projection/abi.ts`) reads that carrier back as the one true ABI for the
+ * one identity `functionId` mints from its declaration. That is correct for
+ * every convention the program itself wrote, and it is exactly why it cannot
+ * be the whole answer: nothing in a checked program is obligated to write
+ * every convention a caller of this compiler might need. Something composing
+ * this compiler into a larger tool may know -- from information this compiler
+ * has no way to see, because it is not TypeScript -- that a given declaration
+ * is also reachable through one or more *additional* conventions the checked
+ * source never spells out. This compiler cannot derive such a convention
+ * (there is nothing in the program to derive it from), cannot name why it
+ * exists (that reason lives entirely outside a checked program), and must not
+ * guess at one either -- so it does neither. It only does the one part that
+ * is genuinely generic: given a convention already built by the caller, key
+ * it so it is addressable, stable across runs, and never confusable with the
+ * declaration's own ordinary convention or with a different caller's.
+ *
+ * That is the whole of this file. It has no notion of what an extra
+ * convention is *for*, does not decide which declarations get one, and does
+ * not build one from a declaration's shape -- all three are the caller's
+ * business, supplied as data (a `DeclarationId`, a `discriminator`, and an
+ * already-built `CallableAbi`) rather than inferred here. Nothing here is
+ * called during an ordinary compilation; it exists to be called by whichever
+ * later caller has that information, unconditionally on it, if any ever does.
+ */
+/** Escapes this identity's own field separator, exactly as `identity/ids.ts`'s own (unexported) `encode` does. */
+const encode = (part) => part.replace(/[|]/g, '%7C');
+/**
+ * The identity of one extra calling convention over `declaration`.
+ *
+ * `identity/ids.ts` mints every real `FunctionId` from a declaration alone
+ * (`functionId`), because an ordinary function has exactly one: the
+ * convention its own parameter list states. An extra convention is not that
+ * function -- calling it with the ordinary convention's frame would read
+ * arguments nobody pushed -- so it needs its own identity, and this compiler
+ * has no declaration to mint one from: nothing in the checked program is the
+ * extra convention. What it does have is the declaration the convention is
+ * *about*, which is real and already sealed, plus whatever the caller uses to
+ * tell two extra conventions on one declaration apart. Keying on both is what
+ * makes the result stable (the same inputs always mint the same identity),
+ * reproducible (any later reader with the same two facts can recompute it
+ * independently), and collision-free with the declaration's own convention:
+ * `functionId(declaration)` alone is never a valid identity here, because
+ * `synthesizedFunctionId` always appends a field after it, and an ordinary
+ * `FunctionId` never has one.
+ *
+ * Built from a file path, a source position, or generated text, this would
+ * silently change identity every time the program was reformatted or a
+ * function moved in the file -- the exact failure this compiler's identity
+ * scheme (`identity/ids.ts`'s own module comment) exists to rule out
+ * everywhere else. `declaration` and `discriminator` are the only two inputs
+ * to guarantee that outcome cannot happen here either.
+ */
+export const synthesizedFunctionId = (declaration, discriminator) => `${functionId(declaration)}|${encode(discriminator)}`;
+/**
+ * Keys every request by its identity and publishes the map.
+ *
+ * A repeated `(declaration, discriminator)` pair is not an error by itself --
+ * two callers, or one caller building its request list twice, may legitimately
+ * agree -- so it is accepted silently when the two `CallableAbi`s are the same
+ * convention (`abiKey` equal). Two *different* conventions asking to be the
+ * same identity is the one case this must not let through in silence: the
+ * `FunctionId` the map ends up publishing for that identity would depend on
+ * request order, which is exactly the "one operation, one authoritative
+ * result" invariant every other publication step in this compiler enforces,
+ * so a conflict is reported here rather than resolved by whichever request
+ * happened to run last.
+ */
+export const projectSynthesizedAbis = (requests) => {
+    const abis = new Map();
+    const conflicts = [];
+    for (const request of requests) {
+        const id = synthesizedFunctionId(request.declaration, request.discriminator);
+        const existing = abis.get(id);
+        if (existing && abiKey(existing) !== abiKey(request.abi)) {
+            conflicts.push({
+                declaration: request.declaration,
+                discriminator: request.discriminator,
+                reason: `two requests name declaration ${request.declaration} under discriminator "${request.discriminator}" with different ` +
+                    `calling conventions: "${abiKey(existing)}" and "${abiKey(request.abi)}"`
+            });
+            continue;
+        }
+        abis.set(id, request.abi);
+    }
+    return { abis, conflicts: Object.freeze(conflicts) };
+};

package/dist/representation/array-index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Whether a key's known constant text spells a canonical array index --
+ * ECMA-262 6.1.7's own definition, the same one `gea::ArrayObject::isIndex`
+ * applies at runtime for a key that is not a compile-time constant.
+ *
+ * `keyOf` (semantics/normalize/producers/properties.ts) records a numeric
+ * *and* a string literal key identically -- `ToPropertyKey` turns `0` into the
+ * String `"0"`, so `a[0]` and `a["0"]` reach here as the same constant text --
+ * which means a constant key on an Array is never provably "not an index" by
+ * its syntax alone; the value has to be parsed the same way a computed key's
+ * runtime value would be, so a literal and a computed key never disagree on
+ * whether the same value is an index.
+ */
+export declare const canonicalIndexLiteral: (text: string) => string | null;

package/dist/representation/array-index.js

@@ -0,0 +1,17 @@
+/**
+ * Whether a key's known constant text spells a canonical array index --
+ * ECMA-262 6.1.7's own definition, the same one `gea::ArrayObject::isIndex`
+ * applies at runtime for a key that is not a compile-time constant.
+ *
+ * `keyOf` (semantics/normalize/producers/properties.ts) records a numeric
+ * *and* a string literal key identically -- `ToPropertyKey` turns `0` into the
+ * String `"0"`, so `a[0]` and `a["0"]` reach here as the same constant text --
+ * which means a constant key on an Array is never provably "not an index" by
+ * its syntax alone; the value has to be parsed the same way a computed key's
+ * runtime value would be, so a literal and a computed key never disagree on
+ * whether the same value is an index.
+ */
+export const canonicalIndexLiteral = (text) => {
+    const value = Number(text);
+    return Number.isInteger(value) && value >= 0 && value < 4294967295 && String(value) === text ? text : null;
+};

package/dist/representation/callable-object.d.ts

@@ -0,0 +1,3 @@
+import type { Representation } from './model.js';
+/** These carriers preserve a Function object's shared property-table identity. */
+export declare const isNativeCallableCarrier: (kind: Representation["kind"]) => boolean;

package/dist/representation/callable-object.js

@@ -0,0 +1,6 @@
+/** These carriers preserve a Function object's shared property-table identity. */
+export const isNativeCallableCarrier = (kind) => kind === 'function' ||
+    kind === 'function-family' ||
+    kind === 'function-value-family' ||
+    kind === 'function-value-dispatch' ||
+    kind === 'function-and-constructor';

package/dist/representation/collections.d.ts

@@ -0,0 +1,84 @@
+import type { StructuralTypeId } from '../identity/ids.js';
+import type { StructuralShape } from '../semantics/model/structural-types.js';
+import type { Representation } from './model.js';
+import type { KeyedCollectionFamily, OwnershipPolicy } from './policies.js';
+/**
+ * The carrier for the language's four keyed collections.
+ *
+ * Its own module rather than a case inside `derive.ts` for the architecture
+ * gate's 800-line ceiling, and it stays one function: `derive.ts`'s
+ * `'declared'` case hands it the already-resolved family plus the two things
+ * it cannot compute for itself -- the deriver's stored-position carrier (which
+ * is recursive, and belongs to the deriver's own memo/cycle bookkeeping) and
+ * the ownership policy.
+ */
+/**
+ * Whether a carrier is physically a POINTER, so two values of it can be
+ * compared by reference identity.
+ *
+ * The question a weak collection asks of its key, and the only honest way to
+ * ask it here: `targets/cpp/types.ts`'s `cppOwnershipWrap` spells exactly
+ * these kinds as `std::shared_ptr<...>` when their own ownership is
+ * `shared-refcount`, and spells them as a bare value otherwise -- so the
+ * ownership is as load-bearing as the kind. A `record` held `owned` is a
+ * struct by value, and two copies of it are two objects with two addresses;
+ * using one as a weak key would look up a different entry every time.
+ * A tagged union qualifies only when every arm qualifies: its discriminant
+ * selects one arm's pointer without changing that object's identity.
+ *
+ * Stated here rather than in `model.ts` beside `alwaysTruthyKinds` because it
+ * is a fact about one BACKEND's spelling, and a target that carried these
+ * kinds differently would need a different answer. It is enforced at
+ * derivation rather than at emission for the ordinary fail-closed reason: a
+ * `WeakMap<number, T>` has no correct lowering at all, so it must never reach
+ * a certificate.
+ */
+export declare const hasReferenceIdentity: (representation: Representation) => boolean;
+/**
+ * `Map<K, V>` / `Set<T>` / `WeakMap<K, V>` / `WeakSet<T>` over the concrete
+ * key and value carriers, or a NAMED refusal.
+ *
+ * This is the port of v1's `typedJsCollectionCarrierRule`
+ * (`compiler/packages/geatsc/src/targets/cpp/driver/type-carriers/typed-js-collections.ts`),
+ * and it keeps that rule's three real decisions:
+ *
+ * - all-or-nothing over the type arguments, exactly like `records.ts` /
+ *   `unions.ts` / `arrays.ts` there and `deriveTuple` here: one argument
+ *   that proves no carrier refuses the whole collection rather than
+ *   half-sealing it;
+ * - the key is the strict position. It participates in the collection's own
+ *   SameValueZero comparison, so a key with no proven equality has no
+ *   proven lookup;
+ * - a Set/WeakSet's element is a key, not a payload, and is held to the
+ *   same standard.
+ *
+ * A `dynamic` key or value RESOLVES here, and that is deliberate. `dynamic`
+ * is not a box over a static type -- `deriveStored` reaches it only for a
+ * position the program itself declared `any`/`unknown` and never narrowed,
+ * which is a genuine dynamic boundary and gets the real dynamic carrier. The
+ * one thing that must never happen is the reverse: a key or value the program
+ * DID give a type to must stay that type, and it does, because nothing here
+ * widens. Refusing the declared-`any` case instead was measurably wrong --
+ * `unresolved` is lattice bottom ("normalization could not name the shape"),
+ * so stating it for a shape that is perfectly well named made every consumer
+ * downstream fail closed on a carrier that had an answer; it accounted for
+ * 107 of 133 unmet obligations in the reactive runtime on its own. The C++
+ * side of admitting it is three explicit specializations in
+ * `runtime/gea_runtime.h` -- `sameValueZero<Value>`, `canonicalKey<Value>`
+ * and `weakKeySame<Value>` -- so a dynamic key is compared by the SAME
+ * ECMA-262 rules a static one is, not by a looser stand-in.
+ *
+ * The type-argument COUNT is checked against the family rather than assumed:
+ * a `Map` reached in its open generic form (the library's own declaration,
+ * which has type PARAMETERS and no arguments) has nothing concrete to
+ * specialize over, and mistaking that for a zero-argument instantiation is
+ * how a carrier for "some Map" would get minted. Same guard as v1's
+ * `checkerArguments.length !== TYPE_ARGUMENT_COUNT[family]`.
+ */
+export declare const deriveKeyedCollection: (family: KeyedCollectionFamily, shape: Extract<StructuralShape, {
+    kind: "declared";
+}>, 
+/** The interned identity of `shape`, which the ownership policy is keyed by. */
+id: StructuralTypeId, 
+/** The deriver's own stored-position carrier for one type id -- see `derive.ts`'s `deriveStored`. */
+deriveStored: (id: StructuralTypeId) => Representation, ownership: OwnershipPolicy) => Representation;

package/dist/representation/collections.js

@@ -0,0 +1,139 @@
+import { representationKey } from './model.js';
+import { unresolved } from './primitives.js';
+/**
+ * The carrier for the language's four keyed collections.
+ *
+ * Its own module rather than a case inside `derive.ts` for the architecture
+ * gate's 800-line ceiling, and it stays one function: `derive.ts`'s
+ * `'declared'` case hands it the already-resolved family plus the two things
+ * it cannot compute for itself -- the deriver's stored-position carrier (which
+ * is recursive, and belongs to the deriver's own memo/cycle bookkeeping) and
+ * the ownership policy.
+ */
+/**
+ * Whether a carrier is physically a POINTER, so two values of it can be
+ * compared by reference identity.
+ *
+ * The question a weak collection asks of its key, and the only honest way to
+ * ask it here: `targets/cpp/types.ts`'s `cppOwnershipWrap` spells exactly
+ * these kinds as `std::shared_ptr<...>` when their own ownership is
+ * `shared-refcount`, and spells them as a bare value otherwise -- so the
+ * ownership is as load-bearing as the kind. A `record` held `owned` is a
+ * struct by value, and two copies of it are two objects with two addresses;
+ * using one as a weak key would look up a different entry every time.
+ * A tagged union qualifies only when every arm qualifies: its discriminant
+ * selects one arm's pointer without changing that object's identity.
+ *
+ * Stated here rather than in `model.ts` beside `alwaysTruthyKinds` because it
+ * is a fact about one BACKEND's spelling, and a target that carried these
+ * kinds differently would need a different answer. It is enforced at
+ * derivation rather than at emission for the ordinary fail-closed reason: a
+ * `WeakMap<number, T>` has no correct lowering at all, so it must never reach
+ * a certificate.
+ */
+export const hasReferenceIdentity = (representation) => {
+    if (representation.kind === 'tagged-union')
+        return representation.arms.every((arm) => hasReferenceIdentity(arm.value));
+    switch (representation.kind) {
+        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 === 'shared-refcount';
+        // A `dynamic` key is admitted, and `gea::Value::identity()` is why: it is
+        // the address of the held payload, which for an object-tagged box is
+        // exactly the reference identity ECMA-262 asks for, shared by every box
+        // of that same object. `weakKeySame<Value>` in `runtime/gea_runtime.h`
+        // reads it. The divergence, stated rather than hidden: a box holding a
+        // PRIMITIVE has a per-box address, so `weakMap.has(1)` answers `false`
+        // where ECMA-262 24.3.3.3 throws a TypeError -- a wrong answer only for a
+        // program that is already illegal, and the alternative was to refuse
+        // `WeakMap<object, T>` outright, since `object` carries dynamically.
+        case 'dynamic':
+            return true;
+        default:
+            return false;
+    }
+};
+/**
+ * `Map<K, V>` / `Set<T>` / `WeakMap<K, V>` / `WeakSet<T>` over the concrete
+ * key and value carriers, or a NAMED refusal.
+ *
+ * This is the port of v1's `typedJsCollectionCarrierRule`
+ * (`compiler/packages/geatsc/src/targets/cpp/driver/type-carriers/typed-js-collections.ts`),
+ * and it keeps that rule's three real decisions:
+ *
+ * - all-or-nothing over the type arguments, exactly like `records.ts` /
+ *   `unions.ts` / `arrays.ts` there and `deriveTuple` here: one argument
+ *   that proves no carrier refuses the whole collection rather than
+ *   half-sealing it;
+ * - the key is the strict position. It participates in the collection's own
+ *   SameValueZero comparison, so a key with no proven equality has no
+ *   proven lookup;
+ * - a Set/WeakSet's element is a key, not a payload, and is held to the
+ *   same standard.
+ *
+ * A `dynamic` key or value RESOLVES here, and that is deliberate. `dynamic`
+ * is not a box over a static type -- `deriveStored` reaches it only for a
+ * position the program itself declared `any`/`unknown` and never narrowed,
+ * which is a genuine dynamic boundary and gets the real dynamic carrier. The
+ * one thing that must never happen is the reverse: a key or value the program
+ * DID give a type to must stay that type, and it does, because nothing here
+ * widens. Refusing the declared-`any` case instead was measurably wrong --
+ * `unresolved` is lattice bottom ("normalization could not name the shape"),
+ * so stating it for a shape that is perfectly well named made every consumer
+ * downstream fail closed on a carrier that had an answer; it accounted for
+ * 107 of 133 unmet obligations in the reactive runtime on its own. The C++
+ * side of admitting it is three explicit specializations in
+ * `runtime/gea_runtime.h` -- `sameValueZero<Value>`, `canonicalKey<Value>`
+ * and `weakKeySame<Value>` -- so a dynamic key is compared by the SAME
+ * ECMA-262 rules a static one is, not by a looser stand-in.
+ *
+ * The type-argument COUNT is checked against the family rather than assumed:
+ * a `Map` reached in its open generic form (the library's own declaration,
+ * which has type PARAMETERS and no arguments) has nothing concrete to
+ * specialize over, and mistaking that for a zero-argument instantiation is
+ * how a carrier for "some Map" would get minted. Same guard as v1's
+ * `checkerArguments.length !== TYPE_ARGUMENT_COUNT[family]`.
+ */
+export const deriveKeyedCollection = (family, shape, 
+/** The interned identity of `shape`, which the ownership policy is keyed by. */
+id, 
+/** The deriver's own stored-position carrier for one type id -- see `derive.ts`'s `deriveStored`. */
+deriveStored, ownership) => {
+    const pair = family === 'map' || family === 'weak-map';
+    const expected = pair ? 2 : 1;
+    if (shape.typeArguments.length !== expected) {
+        return unresolved(`${family} reached representation with ${shape.typeArguments.length} type argument(s) and needs exactly ${expected}`);
+    }
+    // `deriveStored`, not `derive`: both positions are STORED inside the
+    // collection, so they take the same storage promotion every record field
+    // and array element takes. v1 spelled this as its own
+    // `typedJsCollectionMapValueCarrier`/`typedJsCollectionSetElementCarrier`
+    // promotion for the identical reason (a record or callable held in a
+    // collection has exactly one legal physical storage form).
+    const key = deriveStored(shape.typeArguments[0]);
+    const value = pair ? deriveStored(shape.typeArguments[1]) : null;
+    if (key.kind === 'unresolved')
+        return unresolved(`a ${family} key carries no representation: ${key.reason}`);
+    if (value?.kind === 'unresolved')
+        return unresolved(`a ${family} value carries no representation: ${value.reason}`);
+    // A weak collection's key must be a REFERENCE. ECMA-262 24.3/24.4 admit
+    // only objects (and, since ES2023, unregistered symbols) as weak keys, and
+    // this runtime's weak families compare keys by pointer identity -- so a
+    // key carried by value (a `double`, a `std::string`) has no pointer to
+    // compare and would silently become an ordinary equality map wearing the
+    // weak name. See `gea::WeakMap` in `runtime/gea_runtime.h`.
+    if ((family === 'weak-map' || family === 'weak-set') && !hasReferenceIdentity(key)) {
+        return unresolved(`a ${family} key carried as "${representationKey(key)}" has no reference identity; ECMA-262 24.3/24.4 admit only ` +
+            'objects as weak keys, and this runtime compares a weak key by pointer');
+    }
+    return { kind: 'keyed-collection', family, key, value, ownership: ownership.forShape(shape, id) };
+};

package/dist/representation/derive.d.ts

@@ -0,0 +1,159 @@
+import type { FunctionId, StructuralTypeId } from '../identity/ids.js';
+import { type SelectedSignature } from '../semantics/model/selected-signature.js';
+import type { SignatureShape, StructuralType } from '../semantics/model/structural-types.js';
+import type { CallableAbi, Representation } from './model.js';
+import type { DateDeclarationPolicy, HostBindingPolicy, HostNamespaceRootPolicy, KeyedCollectionPolicy, OwnershipPolicy, PromiseDeclarationPolicy, GeneratorDeclarationPolicy, RegExpDeclarationPolicy, StandardBufferPolicy, StringObjectDeclarationPolicy, ErrorDeclarationPolicy, FunctionDeclarationPolicy, ClassHeritagePolicy, ClassCopyPolicy, InterfaceImplementorPolicy, TypedArrayElementPolicy, ValueRecordPolicy } from './policies.js';
+import { defaultClassCopyPolicy, defaultDateDeclarationPolicy, defaultHostBindingPolicy, defaultHostNamespaceRootPolicy, defaultKeyedCollectionPolicy, defaultOwnershipPolicy, defaultPromiseDeclarationPolicy, defaultGeneratorDeclarationPolicy, defaultRegExpDeclarationPolicy, defaultStandardBufferPolicy, defaultStringObjectDeclarationPolicy, defaultErrorDeclarationPolicy, defaultFunctionDeclarationPolicy, defaultClassHeritagePolicy, defaultInterfaceImplementorPolicy, defaultTypedArrayElementPolicy, defaultValueRecordPolicy } from './policies.js';
+export type { DateDeclarationPolicy, HostBindingPolicy, HostNamespaceRootPolicy, HostProtocolBinding, KeyedCollectionFamily, KeyedCollectionPolicy, OwnershipPolicy, PromiseDeclarationPolicy, GeneratorDeclarationPolicy, RegExpDeclarationBinding, RegExpDeclarationKind, RegExpDeclarationPolicy, StandardBufferKind, StandardBufferPolicy, StringObjectDeclarationPolicy, ErrorDeclarationPolicy, FunctionDeclarationPolicy, ClassHeritagePolicy, ClassCopyPolicy, InterfaceImplementorPolicy, TypedArrayElementPolicy, ValueRecordPolicy } from './policies.js';
+export { defaultClassCopyPolicy, defaultDateDeclarationPolicy, defaultHostBindingPolicy, defaultHostNamespaceRootPolicy, defaultKeyedCollectionPolicy, defaultOwnershipPolicy, defaultPromiseDeclarationPolicy, defaultGeneratorDeclarationPolicy, defaultRegExpDeclarationPolicy, defaultStandardBufferPolicy, defaultStringObjectDeclarationPolicy, defaultErrorDeclarationPolicy, defaultFunctionDeclarationPolicy, defaultClassHeritagePolicy, defaultInterfaceImplementorPolicy, defaultTypedArrayElementPolicy, defaultValueRecordPolicy };
+/**
+ * Selecting a physical carrier for a canonical structural shape.
+ *
+ * This is the only place a shape becomes a carrier, and it reads nothing but the
+ * sealed structural table. It never consults the AST, a name, or a print form:
+ * if a carrier cannot be selected from the shape alone, the shape did not carry
+ * enough and the answer is `unresolved` with a reason, never a guess.
+ * `unresolved` here is not failure -- it is the fail-closed answer that stops a
+ * half-known value from reaching materialization. The opt-in fallback also
+ * admits runtime-erased type expressions and proxy-connected types, selected
+ * before publication. Missing structure remains unresolved in both modes.
+ */
+export interface RepresentationDeriver {
+    readonly dynamicFallback?: boolean;
+    readonly derive: (type: StructuralTypeId) => Representation;
+    /**
+     * The LAYOUT a shape id names, for a lookup that holds a `native-record-ref`
+     * (or a `class-ref`, or a tuple's shape) and needs its fields -- as opposed
+     * to `derive`, which is the carrier a VALUE of that type occupies. For every
+     * shape but one the two are the same answer. The exception is an anonymous
+     * record that contains itself (`nameSelfReferencedRecord`): `derive` spells
+     * it by name at every value position so its key does not depend on walk
+     * order, and this is where its record definition is still served from.
+     * Every "what fields does this shape have" question must ask here, never
+     * `derive`, or it reads the name back and finds no fields.
+     */
+    readonly layoutOf: (type: StructuralTypeId) => Representation;
+    /** The ABI of one signature shape, or `null` when its arity is not physical. */
+    readonly abiOf: (signature: SignatureShape) => CallableAbi | null;
+    /**
+     * The carrier a *stored* position holds -- see `primitives.ts`'s
+     * `storedCarrier`. Exposed alongside `derive` because a stored position is
+     * not only something this deriver builds internally (a record field, an
+     * array element, a parameter's ABI slot): any external caller asking "what
+     * does this cell physically hold" -- a binding's own storage, not a
+     * transient expression result -- needs the identical `void`-is-`undefined`
+     * correction `abiOf` already applies to every parameter slot, and had no
+     * way to ask for it before this was added.
+     */
+    readonly deriveStored: (type: StructuralTypeId) => Representation;
+    /**
+     * Whether a structural type's own shape is the primitive `never` --
+     * distinct from asking whether its *carrier* is `{kind:'void'}`, which
+     * `never` and a genuine completed-void evaluation share on purpose
+     * (`primitives.ts`'s own comment: "physically both occupy no storage").
+     * That equivalence is correct for storage and wrong for reachability: a
+     * position whose structural type is `never` is provably never reached, so
+     * an operation performed on it (a property read, an `instanceof` test, a
+     * conversion) is dead code, while an operation on a genuine `void` result
+     * is not. Consumers that need to tell "unreachable" from "a completed
+     * evaluation with no result" must ask this, not compare carrier kinds.
+     */
+    readonly isNeverType: (type: StructuralTypeId) => boolean;
+    /**
+     * Whether a shape is a CLOSED TUPLE -- the one record layout whose values
+     * are Array exotic objects in the language.
+     *
+     * "There is deliberately no tuple carrier: a closed tuple is a record whose
+     * keys are its indices", which is the right physical answer and loses the
+     * one non-physical fact 23.1.2.2 asks for. `Array.isArray` is decided from
+     * the carrier's kind alone (`isArrayConstantOf`), and `record` is in that
+     * table's `false` set because an object literal is not an Array -- so a
+     * tuple, whose record is indistinguishable from one, was answered `false`
+     * for a value the language says `true` for. hono's trie router is the
+     * measured case: `Pattern = readonly [string, string, RegExp | true] | '*'`
+     * and `Array.isArray(pattern) ? pattern[0] : p` folded to the string arm at
+     * compile time, so no parameterized route would ever have been registered.
+     *
+     * Asked of the SHAPE rather than carried on the carrier on purpose: the
+     * record's layout is genuinely the same either way, and a flag on the
+     * representation would make two physically identical carriers compare
+     * unequal everywhere conversions and the certificate key them.
+     */
+    readonly isTupleShape: (type: StructuralTypeId) => boolean;
+    /**
+     * The calling convention of one checker-authenticated source function that
+     * semantic publication registered for dynamic Function-object storage.
+     * StructuralTypeId is intentionally not accepted: unrelated functions can
+     * share one signature shape and may never borrow each other's ABI.
+     */
+    readonly nativeCallableConventions: (functionId: FunctionId) => {
+        call: CallableAbi;
+        construct: CallableAbi | null;
+    } | null;
+    /**
+     * Whether a carrier is the standard `Date`. The C++ spelling a Date is
+     * carried in is a fact this layer only carries (`DateDeclarationPolicy`),
+     * so the one place that can say "this `native-record-ref` is a Date" is
+     * the deriver that stamped the spelling on. The slot census asks, because
+     * ECMA-262 ToPrimitive of a Date prefers `valueOf` where every other object
+     * this compiler carries has only `toString` to fall through to -- a
+     * mixed-carrier `+`/`<` over a Date is not the ToString answer.
+     */
+    readonly isDateCarrier?: (representation: Representation) => boolean;
+}
+/**
+ * The `SignatureShape` a checker-resolved invocation actually calls.
+ *
+ * A callee's own declared type is an overload *set*, and `sharedAbiOf` below
+ * correctly refuses to join it into one convention when the overloads are not
+ * physically identical -- that is not a gap, it is the honest fact that one
+ * value's general-purpose carrier has no single calling convention to state.
+ * A call site is a different question: the checker already resolved it to
+ * exactly one signature (`InvocationOperation.selectedSignature`,
+ * `semantics/model/selected-signature.ts`), with no sibling overload left to
+ * disagree with it, and `SelectedSignature` already carries every field
+ * `abiOf` needs to answer that question -- it is a `SignatureShape` under
+ * `returnType` instead of `result`. Naming that correspondence here, instead
+ * of leaving it as an unstated coincidence two field lists happen to share, is
+ * what makes it the one thing an invocation lowering has to reach for instead
+ * of a joined lowest-common-denominator carrier it was never going to get.
+ */
+export declare const signatureShapeOfSelectedSignature: (signature: SelectedSignature) => SignatureShape;
+/**
+ * The frame one `new` of a host constructor fills, read off the overload the
+ * checker selected at that site -- the construct-side use of
+ * `signatureShapeOfSelectedSignature` above.
+ *
+ * `hostInvocationAbiOf` answers for the constructor VALUE, and for
+ * `MapConstructor` (`new ()` beside `new <K, V>(entries?)`),
+ * `WeakMapConstructor` (generic, plus an `Iterable` overload) and every
+ * typed-array constructor (`length` / `ArrayLike<number>` / `buffer,
+ * byteOffset?, length?`) it correctly answers "no single convention". Yet
+ * every three.js renderer module builds its cache as `new WeakMap()` or
+ * `new Map()` (`WebGLProperties`, `WebGLRenderStates`, `WebGLShaderCache`,
+ * `WebGLGeometries`, ...), and each of those SITES resolved to exactly one
+ * overload. Without a frame to test, the reflection census read each of them
+ * as an unknown construction and published the new collection's key and
+ * value carriers -- every field of every render-state record they hold.
+ *
+ * Only the formals the site FILLS are laid out. A formal the site omits is
+ * optional by the checker's own resolution (`minimumArity`), the host
+ * construction reads its absence itself (`emitKeyedCollectionConstruct`'s
+ * zero-argument `gea::makeRef<T>()`), and no value is transported into it --
+ * so it states nothing about the frame and, for a generic overload, never has
+ * to be instantiated. A FILLED formal of a generic overload whose type
+ * arguments the checker inferred is refused: `instantiatedParameterTypes`
+ * withholds those on purpose, and reconstructing them here would be the
+ * rediscovery that authority exists to prevent. A rest formal has no fixed
+ * position to lay out and is refused with it.
+ *
+ * The result is the carrier the construction itself holds, not the
+ * signature's return type: the checker defaults `new WeakMap()` to
+ * `WeakMap<WeakKey, any>` while the collection census bound the key and value
+ * the program actually stores (`collection-construct-type-inference`), and the
+ * host renderer mints the held carrier directly. That is how a generic
+ * overload's K/V are instantiated here -- from the construction's own result,
+ * never from argument syntax.
+ */
+export declare const selectedHostConstructFrameOf: (deriver: Pick<RepresentationDeriver, "abiOf">, signature: SelectedSignature, received: number, result: Representation) => CallableAbi | null;
+export declare const createRepresentationDeriver: (types: ReadonlyMap<StructuralTypeId, StructuralType>, ownership?: OwnershipPolicy, binding?: HostBindingPolicy, elements?: TypedArrayElementPolicy, promise?: PromiseDeclarationPolicy, collections?: KeyedCollectionPolicy, buffers?: StandardBufferPolicy, namespaceRoots?: HostNamespaceRootPolicy, date?: DateDeclarationPolicy, generator?: GeneratorDeclarationPolicy, regexp?: RegExpDeclarationPolicy, stringObject?: StringObjectDeclarationPolicy, functionType?: FunctionDeclarationPolicy, heritage?: ClassHeritagePolicy, valueRecords?: ValueRecordPolicy, implementors?: InterfaceImplementorPolicy, errors?: ErrorDeclarationPolicy, dynamicFallback?: boolean, dynamicFallbackTypes?: ReadonlySet<StructuralTypeId>, dynamicCallableShapes?: ReadonlyMap<FunctionId, StructuralTypeId>, dynamicWrittenTypes?: ReadonlySet<StructuralTypeId>, classCopies?: ClassCopyPolicy) => RepresentationDeriver;