@geastack/compiler 1.0.15

package/dist/semantics/model/selected-signature.d.ts

@@ -0,0 +1,261 @@
+import ts from 'typescript';
+import type { DeclarationId, StructuralTypeId } from '../../identity/ids.js';
+import type { SignatureParameter } from './structural-types.js';
+/**
+ * The signature TypeScript selected for an invocation.
+ *
+ * This is checker resolution, not runtime target proof. It says which
+ * declaration the checker picked; it does not claim that declaration is the
+ * complete set of functions that can run. That claim is a separate attachment
+ * so that a monkey-patched, shadowed, or reassigned callee cannot inherit the
+ * checker's confidence.
+ */
+/**
+ * Where a generic instantiation came from.
+ *
+ * The public checker API exposes the type arguments a call site wrote, but not
+ * the mapper it inferred. `inferred` therefore records that substitutions exist
+ * and are unavailable. A consumer that needs instantiated parameter types must
+ * fail closed on it -- re-deriving substitutions from argument expressions,
+ * callee spelling, or declaration display names is exactly the rediscovery this
+ * layer exists to prevent.
+ */
+export type TypeArgumentProvenance = {
+    readonly kind: 'none';
+} | {
+    readonly kind: 'explicit';
+    readonly arguments: readonly ExplicitTypeArgument[];
+} | {
+    readonly kind: 'inferred';
+    readonly reason: 'checker-mapper-not-public';
+};
+/** One written type argument, paired with the parameter it instantiates. */
+export interface ExplicitTypeArgument {
+    readonly parameter: DeclarationId;
+    readonly argument: StructuralTypeId;
+}
+/** Whether the selected declaration is real source or an ambient declaration. */
+export type SignatureProvenance = 'source' | 'ambient';
+export interface SelectedSignature {
+    /** The declaration the checker selected. Identity, never a display name. */
+    readonly declaration: DeclarationId;
+    readonly provenance: SignatureProvenance;
+    /**
+     * Runtime parameter shape. An explicit `this` parameter is authenticated
+     * separately and excluded here, because it is a type-system device rather
+     * than an argument the call site passes.
+     */
+    readonly parameters: readonly SignatureParameter[];
+    readonly minimumArity: number;
+    readonly thisParameter: StructuralTypeId | null;
+    readonly typeArguments: TypeArgumentProvenance;
+    /** The instantiated structural return type of the selected signature. */
+    readonly returnType: StructuralTypeId;
+}
+/**
+ * Why an invocation's result type may differ from its selected signature's
+ * return type.
+ *
+ * Every reason is listed here. Anything else disagreeing is a defect, and
+ * the check below is what turns that defect into a failure instead of letting a
+ * consumer silently pick whichever type it prefers.
+ */
+export type InvocationResultDivergence = 
+/** `a?.b()` adds the short-circuit `undefined` path to the call result. */
+{
+    readonly kind: 'optional-call-short-circuit';
+}
+/** `super()` evaluates to `void`, not to the base constructor's instance type. */
+ | {
+    readonly kind: 'super-constructor-initialization';
+}
+/**
+ * `JSON.parse(text) as T`: the call's own declared return type is `any`
+ * (`lib.es5.d.ts`), and the caller's own assertion is what names the real,
+ * physical type this backend renders `JSON.parse` as returning
+ * (`targets/cpp/emit-json.ts`'s `jsonCallText` — this compiler controls and
+ * renders `JSON.parse`'s own implementation, which is what makes
+ * substituting the caller's asserted type safe here and nowhere else; see
+ * `producers/invocations.ts`'s `jsonParseResultOverride`).
+ */
+ | {
+    readonly kind: 'json-parse-type-assertion';
+}
+/**
+ * `new Array(n)`: the constructor's own declared return type is `any[]`
+ * (`lib.es5.d.ts`'s `ArrayConstructor` has no generic parameter for a
+ * contextual type to narrow), and the enclosing `as T[]` assertion or the
+ * variable/field declaration this construction directly initializes is
+ * what names the real, physical element type this backend allocates
+ * (`targets/cpp/emit-callable.ts`'s `emitArrayConstruct` -- this compiler
+ * controls and renders `new Array(n)`'s own implementation, which is what
+ * makes substituting the declared element type safe here and nowhere else;
+ * see `producers/invocations.ts`'s `arrayConstructResultOverride`).
+ */
+ | {
+    readonly kind: 'array-construct-type-annotation';
+}
+/**
+ * `new RangeError(m) as RangeError & { code: string }`: the constructor's
+ * own declared return type is the plain error interface, and the enclosing
+ * assertion is what names the record this backend actually mints.
+ * `gea::host::<Ctor>::create<ErrorRecord>` is a TEMPLATE over the struct
+ * (`targets/cpp/runtime/gea_runtime.h`) -- this compiler controls and
+ * renders the construction, so it can allocate the asserted shape directly
+ * and the extra fields are value-initialized exactly as an omitted property
+ * would be. Without it the construction mints one struct and the binding
+ * holding it declares another, and no conversion between two unrelated C++
+ * structs exists: certified, emitted, and rejected by clang. See
+ * `producers/invocations.ts`'s `errorConstructResultOverride`.
+ */
+ | {
+    readonly kind: 'error-construct-type-assertion';
+}
+/**
+ * `new Map()`/`new Set()`/`new WeakMap()`/`new WeakSet()`: the ambient
+ * constructor's own declared signature has nothing to infer K/(V) from --
+ * no type arguments, no constructor argument -- so the checker defaults
+ * both to `unknown`, and the selected signature's return type is that
+ * defaulted, uninformative shape. `collection-bindings.ts`'s whole-program
+ * census (`typeArgumentsAt`/`typeArgumentsForOwner`/`typeArgumentsForRead`)
+ * answers the SAME question `array-construct-type-annotation` answers for
+ * `new Array(n)` one collection family over: what does the program's own
+ * later use of this cell actually store. `structural.ts`'s `typeAt` already
+ * substitutes that census's answer for this call's own published result
+ * (`inferredCollectionTypeArgumentsAt`, `structural-array-element.ts`) --
+ * this divergence exists so that substitution does not also have to agree
+ * with the SEPARATE, checker-only computation `buildSelectedSignature`
+ * derives from the resolved signature object. See
+ * `producers/invocations.ts`'s `collectionConstructResultOverride`.
+ */
+ | {
+    readonly kind: 'collection-construct-type-inference';
+}
+/**
+ * `Object.create(null)`: `lib.es5.d.ts` declares the return type `any`, and
+ * the enclosing `as T` assertion or the annotation of the variable/field
+ * this call directly initializes is what names the object carrier this
+ * backend actually mints. 20.1.2.2's OrdinaryObjectCreate with a null
+ * prototype and no own properties is physically an empty
+ * `gea::Dictionary<V>` or a value-initialized record struct, and
+ * `targets/cpp/host/emit-host-object.ts`'s `createText` -- this compiler's
+ * own rendering of the call -- mints exactly that. Without it the call
+ * boxes a `DynamicObject` that the annotated store then unboxes into a
+ * different C++ payload type, which aborts at runtime rather than failing
+ * to compile. See `producers/invocations.ts`'s `objectCreateResultOverride`.
+ */
+ | {
+    readonly kind: 'object-create-type-annotation';
+}
+/**
+ * `Object.assign(target, source)` returns the target object itself. The
+ * ambient generic signature reports `T & U`, which describes the extra
+ * properties visible through TypeScript but is not a second allocation and
+ * must not become a second physical carrier. The native renderer mutates the
+ * target (using its identity-keyed expando table for source keys the target
+ * does not declare) and returns that same target handle. See
+ * `producers/invocations.ts`'s `objectAssignTargetOverride`.
+ */
+ | {
+    readonly kind: 'object-assign-target-identity';
+}
+/**
+ * `collection.get( k )` on a `Map`/`WeakMap` that same census bound: the
+ * sibling of the construct divergence above, at the OTHER end of the same
+ * storage. Fixing the receiver's type does not fix this call, because a
+ * prototype call's result comes from the callee's SIGNATURE, which the
+ * checker instantiates from the receiver EXPRESSION's type rather than from
+ * whatever this compiler selected for it -- so `buildSelectedSignature`
+ * derives `any` from the resolved signature while `structural.ts`'s `typeAt`
+ * publishes the census's `V | undefined`
+ * (`collectionMemberResultTypeAt`, `structural-array-element.ts`). The two
+ * are not in conflict; the signature is simply the half the checker could
+ * not instantiate. See `producers/invocations.ts`'s
+ * `collectionMemberResultOverride`.
+ */
+ | {
+    readonly kind: 'collection-member-type-inference';
+}
+/**
+ * A call that RETURNS an object bag: three's `WebGLProperties.get`, whose
+ * body is `let map = properties.get( object ); if ( map === undefined ) {
+ * map = {}; ... } return map`. Nothing in the source states that return
+ * type, so `buildSelectedSignature` derives `any` from the resolved
+ * signature, while `object-bag-bindings.ts`'s whole-program census bound the
+ * 47 members the renderer then reads off it and `structural.ts`'s `typeAt`
+ * publishes them (`bagShapeTypeAt` via `callResultShapeAt`).
+ *
+ * The bag census REFUSES to answer at a call unless a caller takes on this
+ * declaration -- see `callResultShapeAt`'s own header for the measurement
+ * that made that rule (withheld 8 -> 20 when only one authority moved). See
+ * `producers/invocations.ts`'s `bagResultOverride`.
+ */
+ | {
+    readonly kind: 'bag-return-inference';
+}
+/**
+ * `const K = Symbol.for('k')`: TypeScript's own rule, not this compiler's.
+ * `checkCallExpression` replaces a `Symbol()`/`Symbol.for()` call's result
+ * with a FRESH `unique symbol` type when the call is the initializer of a
+ * `const` declaration or a `readonly static` property, while the selected
+ * signature still returns plain `symbol`. Both are the same physical thing
+ * -- `representation/derive.ts` maps `unique-symbol` and `symbol` to the one
+ * `{ kind: 'symbol' }` carrier -- so nothing downstream has to choose; this
+ * arm exists to say the disagreement is the language's, so a disagreement
+ * that is NOT can still fail closed.
+ */
+ | {
+    readonly kind: 'unique-symbol-fresh-type';
+}
+/**
+ * `Array.of.call(Pack, ...)` / `Array.prototype.map.call(arrayLike, fn)`:
+ * `Function.prototype.call`/`.apply`'s own ambient signature
+ * (`call<T, A extends any[], R>(this: (this: T, ...args: A) => R, thisArg:
+ * T, ...args: A): R`) ties its return type to ONE inferred parameter `R`,
+ * which loses precision the moment the receiver's own call is itself
+ * generic or overloaded (`Array.prototype.map<U>(...): U[]` has its own
+ * free `U` nothing in `.call`'s three type parameters resolves through).
+ * `normalize/structural-callable.ts`'s `createStructuralCallResultResolver`
+ * reads the receiver's OWN authenticated call signature(s) directly instead
+ * -- the same "receiver has a call signature" test
+ * `flow/callable-reach.ts`'s `unwrapExplicitThisCall` makes of the identical
+ * shape -- and `structural.ts`'s `callResultAt` already wires that answer
+ * into `context.types.typeAt(node)`, which is what an invocation's
+ * published result falls back to. This licenses the resulting disagreement
+ * against the checker's own overload-resolved `signature.getReturnType()`;
+ * see `producers/invocations.ts`'s `isExplicitThisCallWithAuthenticatedReceiver`.
+ */
+ | {
+    readonly kind: 'explicit-this-call-return';
+} | {
+    readonly kind: 'none';
+};
+/**
+ * Fail closed when the invocation result and the selected return type disagree
+ * for a reason the language does not license.
+ *
+ * A divergence that is real must be declared, not inferred downstream. If this
+ * throws, the producer published two answers for one operation.
+ */
+export declare const validateInvocationResult: (signature: SelectedSignature, invocationResult: StructuralTypeId, divergence: InvocationResultDivergence) => void;
+/**
+ * Instantiated parameter types, or `null` when the checker withheld the mapper.
+ *
+ * Returning `null` is the fail-closed answer. A caller must handle it by
+ * reporting a missing capability, never by reconstructing substitutions.
+ */
+export declare const instantiatedParameterTypes: (signature: SelectedSignature) => readonly StructuralTypeId[] | null;
+/**
+ * Whether the checker's own `unique symbol` rule is what made this call's
+ * result differ from its signature's return type.
+ *
+ * TypeScript's `checkCallExpression` gives a `Symbol()`/`Symbol.for()` call a
+ * FRESH `unique symbol` type when the call initializes a `const` declaration or
+ * a `readonly static` property, while the signature it selected still returns
+ * plain `symbol`. That is the language's rule, and this reads the checker's own
+ * two answers to recognize it -- the flags on the published result and on the
+ * selected signature's return type -- rather than re-deriving which callees the
+ * rule applies to from a name. A disagreement of any other shape still fails
+ * closed in `validateInvocationResult`.
+ */
+export declare const isUniqueSymbolFreshType: (checker: ts.TypeChecker, node: ts.Node, signature: ts.Signature | undefined) => boolean;

package/dist/semantics/model/selected-signature.js

@@ -0,0 +1,55 @@
+import ts from 'typescript';
+/**
+ * Fail closed when the invocation result and the selected return type disagree
+ * for a reason the language does not license.
+ *
+ * A divergence that is real must be declared, not inferred downstream. If this
+ * throws, the producer published two answers for one operation.
+ */
+export const validateInvocationResult = (signature, invocationResult, divergence) => {
+    if (divergence.kind !== 'none')
+        return;
+    if (signature.returnType === invocationResult)
+        return;
+    throw new Error(`invocation result ${invocationResult} disagrees with selected return type ${signature.returnType} ` +
+        `for declaration ${signature.declaration} with no declared divergence`);
+};
+/**
+ * Instantiated parameter types, or `null` when the checker withheld the mapper.
+ *
+ * Returning `null` is the fail-closed answer. A caller must handle it by
+ * reporting a missing capability, never by reconstructing substitutions.
+ */
+export const instantiatedParameterTypes = (signature) => {
+    if (signature.typeArguments.kind === 'inferred')
+        return null;
+    return signature.parameters.map((parameter) => parameter.type);
+};
+/**
+ * Whether the checker's own `unique symbol` rule is what made this call's
+ * result differ from its signature's return type.
+ *
+ * TypeScript's `checkCallExpression` gives a `Symbol()`/`Symbol.for()` call a
+ * FRESH `unique symbol` type when the call initializes a `const` declaration or
+ * a `readonly static` property, while the signature it selected still returns
+ * plain `symbol`. That is the language's rule, and this reads the checker's own
+ * two answers to recognize it -- the flags on the published result and on the
+ * selected signature's return type -- rather than re-deriving which callees the
+ * rule applies to from a name. A disagreement of any other shape still fails
+ * closed in `validateInvocationResult`.
+ */
+export const isUniqueSymbolFreshType = (checker, node, signature) => {
+    if (signature === undefined)
+        return false;
+    // STATED, not HOLDS: per the doc comment above, this deliberately compares
+    // two of the CHECKER's own answers (the published result's flags against
+    // the selected signature's return-type flags) to recognize one specific
+    // language rule (a fresh `unique symbol` from `Symbol()`/`Symbol.for()`).
+    // It is not asking what this node holds as a value -- it is asking whether
+    // the checker itself treated this call specially -- so a census substitute
+    // would compare the wrong pair of types and could stop recognizing the
+    // rule. Left as a direct checker call.
+    if ((checker.getTypeAtLocation(node).flags & ts.TypeFlags.UniqueESSymbol) === 0)
+        return false;
+    return (checker.getReturnTypeOfSignature(signature).flags & ts.TypeFlags.ESSymbol) !== 0;
+};

package/dist/semantics/model/structural-type-table.d.ts

@@ -0,0 +1,93 @@
+import type { StructuralTypeId } from '../../identity/ids.js';
+import { type StructuralShape, type StructuralType } from './structural-types.js';
+/**
+ * The interning table for structural types.
+ *
+ * Interning is what makes structural identity decidable: two shapes are the
+ * same type exactly when they intern to the same id. Recursion is handled by
+ * anchoring: a declared shape reserves its id before its members are built, so
+ * a member that refers back to the declaration resolves to an id that already
+ * exists instead of recursing forever.
+ *
+ * An id is a counter, never the shape's key. A key names the whole shape, and a
+ * nested shape's key contains its members' keys -- so embedding the key in the
+ * id would make identity strings grow with the depth of the type, and every
+ * consumer that concatenates two of them grow quadratically. The key stays in
+ * the interning map, where it is compared once.
+ */
+/**
+ * An anchor and whether this call is the one that reserved it.
+ *
+ * `fresh` is the whole answer to "may I complete this?", and it has to come
+ * from the table because the table is the only thing that knows. A caller
+ * keeping its own set of anchors-it-has-marked is a second authority over one
+ * fact, and the two drift: an anchor completed by one walk and then unmarked by
+ * another walk's unwind reads as "not completed" and gets built a second time,
+ * which `complete` then refuses.
+ */
+export interface AnchorReservation {
+    readonly id: StructuralTypeId;
+    /** True exactly when this call created the reservation, so this caller owns completing or abandoning it. */
+    readonly fresh: boolean;
+}
+export interface StructuralTypeTable {
+    /** Intern a shape and return its canonical identity. */
+    readonly intern: (shape: StructuralShape) => StructuralTypeId;
+    /**
+     * Reserve the identity of a recursive declared shape before its members are
+     * known, then complete it. A shape must be completed before the table seals;
+     * an anchor left open is a normalization defect, not an unresolved type.
+     */
+    readonly anchor: (declarationKey: string) => AnchorReservation;
+    readonly complete: (id: StructuralTypeId, shape: StructuralShape) => void;
+    /**
+     * Give up on an anchor whose walk was abandoned.
+     *
+     * A walk can be unwound before it completes an anchor it reserved -- a
+     * self-referential type retrying an outer entry does exactly that
+     * (`semantics/normalize/structural-self-reference.ts`) -- and the retry does
+     * not always reach the same anchor again: a declared anchor's key embeds its
+     * type arguments' ids, and those change when a member that interned as a
+     * union the first time anchors the second. So the reservation would sit open
+     * forever and the table would refuse to seal.
+     *
+     * The id is not deleted: shapes interned during the abandoned walk still name
+     * it, and reading one must answer rather than throw. It is completed with an
+     * `unresolved` shape saying exactly what happened, and its *key* is released
+     * so a retry that asks for the same key gets a fresh, completable anchor.
+     */
+    readonly abandon: (id: StructuralTypeId) => void;
+    /**
+     * Release an anchor's KEY without touching its completed shape, so a later
+     * `anchor()` call for the same declaration mints a fresh id instead of
+     * reusing this one.
+     *
+     * Different from `abandon`: this anchor did not fail -- it completed, and
+     * its shape stays exactly as built, valid forever for anyone who already
+     * captured this id. The hazard is narrower and only visible from outside the
+     * table: this anchor's build may have read another anchor's id while that
+     * OTHER anchor was still open (a legitimate self-reference at the time), and
+     * that other anchor has since been abandoned and, on retry, completes under
+     * a *different* id. Reusing this anchor's key would keep handing out a
+     * shape that cites the abandoned id forever, even though the retry produced
+     * a correct answer nobody asked for again. The caller (`structural.ts`)
+     * knows which ids were touched inside a failed attempt's journal and calls
+     * this for every one of them; only the ones that are still an anchor key
+     * (i.e. really were built by `anchor()`, not `intern()`) do anything -- a
+     * plain content-addressed shape has no such key to release, so this is a
+     * no-op for it and safe to call unconditionally.
+     */
+    readonly releaseKey: (id: StructuralTypeId) => void;
+    readonly get: (id: StructuralTypeId) => StructuralType;
+    /**
+     * Whether this id is an anchor reserved and not yet completed -- the one
+     * state `get` cannot answer. A walk that inspects the shapes behind ids it
+     * was handed while sibling anchors are still open (`structural.ts`'s family
+     * layout, flattening a member's union) asks this first.
+     */
+    readonly isOpen: (id: StructuralTypeId) => boolean;
+    /** Whether the shape at this id reaches an anchor a frame abandoned. See the implementation. */
+    readonly citesAbandoned: (id: StructuralTypeId) => boolean;
+    readonly seal: () => ReadonlyMap<StructuralTypeId, StructuralType>;
+}
+export declare const createStructuralTypeTable: () => StructuralTypeTable;

package/dist/semantics/model/structural-type-table.js

@@ -0,0 +1,237 @@
+import { structuralShapeKey } from './structural-types.js';
+export const createStructuralTypeTable = () => {
+    const byKey = new Map();
+    // The reverse of `byKey`, kept in lockstep. `abandon` and `releaseKey` both
+    // need "what key does this id currently own, if any" -- without this, that
+    // question is a linear scan of `byKey`, paid on every rollback entry.
+    const idToKey = new Map();
+    const byId = new Map();
+    // The CONTENT key a completed anchor also owns, kept apart from `idToKey`
+    // because an anchor owns two keys at once: `anchor:<declaration>`, which is
+    // what recursion resolves through, and its shape's own canonical key, which
+    // is what makes it findable by anyone who builds the identical shape later.
+    const contentKeys = new Map();
+    const openAnchors = new Set();
+    // Which anchors were given up on, and under which key. Kept only so the
+    // completion guard below can say *why* an anchor is closed: "abandoned" and
+    // "completed twice" are different defects with different fixes, and one
+    // message covering both sends the reader to the wrong one.
+    const abandoned = new Map();
+    // A monotonic counter, never `byKey.size`: `abandon` releases a key, and a
+    // size-derived id would then hand the next shape an id already in use --
+    // two unrelated types under one identity, which is not a wrong answer this
+    // table could ever notice.
+    let nextId = 0;
+    let sealed = false;
+    const requireOpen = () => {
+        if (sealed)
+            throw new Error('structural type table is sealed; interning a new shape after seal would create a second answer');
+    };
+    // Union is associative: a synthesized (A | B | undefined) | C | null
+    // names the same values as A | B | C | undefined | null. Keeping the inner
+    // union as an arm hides one absence from carrier selection and gives the
+    // same type different identities depending on how inference grouped it.
+    // Expand only known union shapes. Open anchors remain references; following
+    // an object/class member here would change the type rather than normalize it.
+    const canonicalShape = (shape) => {
+        if (shape.kind !== 'union')
+            return shape;
+        const members = new Set();
+        const expanding = new Set();
+        const visit = (id) => {
+            const member = byId.get(id);
+            if (member?.kind !== 'union' || expanding.has(id)) {
+                members.add(id);
+                return;
+            }
+            expanding.add(id);
+            for (const child of member.members)
+                visit(child);
+            expanding.delete(id);
+        };
+        for (const member of shape.members)
+            visit(member);
+        return { kind: 'union', members: [...members] };
+    };
+    const intern = (input) => {
+        requireOpen();
+        const shape = canonicalShape(input);
+        const key = structuralShapeKey(shape);
+        const existing = byKey.get(key);
+        if (existing)
+            return existing;
+        const id = `type|${nextId++}`;
+        byKey.set(key, id);
+        idToKey.set(id, key);
+        byId.set(id, shape);
+        return id;
+    };
+    const anchor = (declarationKey) => {
+        requireOpen();
+        const key = `anchor:${declarationKey}`;
+        const existing = byKey.get(key);
+        if (existing)
+            return { id: existing, fresh: false };
+        const id = `type|${nextId++}`;
+        byKey.set(key, id);
+        idToKey.set(id, key);
+        openAnchors.add(id);
+        return { id, fresh: true };
+    };
+    const keyOf = (id) => idToKey.get(id) ?? null;
+    const complete = (id, input) => {
+        requireOpen();
+        if (!openAnchors.delete(id)) {
+            const why = abandoned.has(id)
+                ? `it was abandoned (key ${abandoned.get(id) ?? ''})`
+                : `it was already completed (key ${keyOf(id) ?? '<released>'})`;
+            throw new Error(`structural type ${id} is not an open anchor and cannot be completed: ${why}`);
+        }
+        const shape = canonicalShape(input);
+        byId.set(id, shape);
+        // An anchor is reserved by DECLARATION and completed with CONTENT, and
+        // until this line the content was never addressable: `intern` looks a
+        // shape up by `structuralShapeKey`, `complete` only wrote `byId`, so the
+        // very next `intern` of the identical shape missed and minted a second
+        // id for it. One type, two ids -- and every consumer keyed on the id then
+        // sees two carriers where the language has one, which is the
+        // "field X is stored as ... and this read publishes ..." refusal with two
+        // sides that print the same thing.
+        //
+        // Measured on hono: the `H` handler union's own call signature was
+        // anchored as `type|955` and re-interned as `type|1307`, which split the
+        // router's `Result` tuple, its `add`/`match` member conventions and the
+        // `#matchResult` cell into twins in five separate refusals.
+        //
+        // Nominal identity is not at risk: `declared`, `class-instance`,
+        // `class-constructor` and `object-anchor` all carry their declaration in
+        // their key, so two declarations with identical bodies keep two ids. What
+        // this merges is what has no nominal identity to lose -- a signature, an
+        // object body -- which is exactly what interning is for.
+        //
+        // An existing owner wins. A structurally identical shape interned WHILE
+        // this anchor was open is already the id everything built since then
+        // cites, and re-pointing the key would make `byKey` disagree with what is
+        // already in the graph. The anchor stays reachable by its own key either
+        // way.
+        const contentKey = structuralShapeKey(shape);
+        if (!byKey.has(contentKey)) {
+            byKey.set(contentKey, id);
+            contentKeys.set(id, contentKey);
+        }
+    };
+    const abandon = (id) => {
+        requireOpen();
+        if (!openAnchors.delete(id))
+            return;
+        const realKey = idToKey.get(id);
+        const key = realKey ?? '<key already released>';
+        abandoned.set(id, key);
+        if (realKey) {
+            idToKey.delete(id);
+            byKey.delete(realKey);
+        }
+        // The key travels into the reason. An abandoned anchor is only ever seen
+        // downstream as an unresolved member of some other shape, and without the
+        // key that report names neither the type that was being walked nor the
+        // declaration it came from -- which is the whole question when one shows up.
+        byId.set(id, { kind: 'unresolved', reason: `a walk reserved this anchor for ${key} and was unwound before completing it` });
+    };
+    /**
+     * Whether the shape at `id` reaches, through any of the ids it names, an
+     * anchor some frame gave up on.
+     *
+     * This is the question `releaseKey`'s only caller actually has. An unwound
+     * walk has to withdraw the shapes it built *on an abandoned sibling* --
+     * those cite an id that is now an `unresolved` stub -- but withdrawing the
+     * rest is not conservative, it MINTS DUPLICATES: an anchor whose key is
+     * released and whose declaration is walked again by a later specialization
+     * view gets a second id for one type, and every consumer keyed on the id
+     * then sees two carriers where the language has one. Measured on hono:
+     * `Headers` held three ids and `Request` two, which is where
+     * `binding-read-conversion:function-value-dispatch(...)->...(identical...)`
+     * came from -- a conversion between a carrier and itself, unsatisfiable
+     * because there is nothing to convert.
+     *
+     * A structural scan rather than a per-kind walk: this answers a diagnostic
+     * question about ids a shape happens to name, not a semantic one about what
+     * a shape MEANS, so it must not go stale when a shape kind gains a field --
+     * which is exactly what a hand-maintained enumeration would do.
+     */
+    const citesAbandoned = (id) => {
+        const seen = new Set();
+        const pending = [id];
+        while (pending.length > 0) {
+            const next = pending.pop();
+            if (next === undefined || seen.has(next))
+                continue;
+            seen.add(next);
+            if (abandoned.has(next))
+                return true;
+            const shape = byId.get(next);
+            if (!shape)
+                continue;
+            const scan = (value) => {
+                if (typeof value === 'string') {
+                    if (/^type\|\d+$/.test(value))
+                        pending.push(value);
+                    return;
+                }
+                if (Array.isArray(value)) {
+                    for (const element of value)
+                        scan(element);
+                    return;
+                }
+                if (value !== null && typeof value === 'object')
+                    for (const element of Object.values(value))
+                        scan(element);
+            };
+            scan(shape);
+        }
+        return false;
+    };
+    const releaseKey = (id) => {
+        requireOpen();
+        // An anchor still open belongs to `abandon`, not this: it has not
+        // completed yet, and releasing its key out from under an in-flight build
+        // would let a second, concurrent reservation mint a duplicate anchor for
+        // the same declaration. Every caller of `releaseKey` only ever names an
+        // id whose build already returned (see the docstring), so this is a
+        // defensive no-op, not a path this table expects to take.
+        if (openAnchors.has(id))
+            return;
+        // Both keys, for the one reason this function exists: nothing may reach
+        // this id by name again. Leaving the content key behind would keep
+        // handing it out to every later build of the identical shape, which is
+        // precisely the "keeps citing an abandoned id forever" hazard the
+        // docstring describes, reached by the other road.
+        const contentKey = contentKeys.get(id);
+        if (contentKey !== undefined) {
+            contentKeys.delete(id);
+            byKey.delete(contentKey);
+        }
+        const key = idToKey.get(id);
+        if (!key || !key.startsWith('anchor:'))
+            return;
+        idToKey.delete(id);
+        byKey.delete(key);
+    };
+    const get = (id) => {
+        const shape = byId.get(id);
+        if (!shape)
+            throw new Error(`structural type ${id} was referenced before it was interned`);
+        return { id, shape };
+    };
+    const seal = () => {
+        if (openAnchors.size > 0) {
+            throw new Error(`structural type table sealed with ${openAnchors.size} incomplete recursive anchor(s): ${[...openAnchors].join(', ')}`);
+        }
+        sealed = true;
+        const result = new Map();
+        for (const [id, shape] of byId)
+            result.set(id, Object.freeze({ id, shape }));
+        return result;
+    };
+    const isOpen = (id) => openAnchors.has(id);
+    return { intern, anchor, complete, abandon, citesAbandoned, releaseKey, get, isOpen, seal };
+};