@techspokes/typescript-wsdl-client 1.1.4 → 1.1.5

package/dist/compiler/semanticContext.js

@@ -0,0 +1,1168 @@
+/** Internal structural contexts. Preparation never certifies actual or hypothetical XSD legality. */
+import { GRAPH_MODEL, globalId, isBuiltinType, scopedId } from './canonicalGraph.js';
+import { duplicateIdentityTuple, matchesHypotheticalNodeId, sameSemanticIdentity, semanticIdentityTuple } from './hypotheticalScopedIdentity.js';
+import { containedNodes, referenceSlots } from './graphTraversal.js';
+import { XSD_NAMESPACE } from '../loader/orderedSyntax.js';
+import { createSemanticBudget } from './semanticBudget.js';
+import { assertRawComplexTypeShape } from './re01TypeProperties.js';
+import { originalComplexParticleSource, originalUrWildcardSource, particleContentNode } from './complexTypeContent.js';
+import { validateRawSimpleTypeShape } from './schemaSimpleTypeProperties.js';
+import { validateRawElementShape } from './schemaElementProperties.js';
+import { validateRawAttributeGroupShape } from './schemaAttributeGroupProperties.js';
+import { equalNotationProperties, notationNameKey, readSourceNotationProperties, sourceNotationNamespace } from './schemaNotationProperties.js';
+import { sourceSchemasForResolvedGraph } from './sourceSchemaBinding.js';
+import { assertSemanticTypeReferenceShape } from './semanticTypeReference.js';
+import { validateRawAttributeShape } from './schemaAttributeProperties.js';
+import { computeOriginalSourceAbsence } from './originalSourceMembership.js';
+import { prepareRawParticleWildcardProperties } from './schemaParticleWildcardProperties.js';
+import { createOriginalIdentityConstraintRegistry } from './schemaIdentityConstraints.js';
+export const SEMANTIC_CONTEXT_CONTRACT = 'RE01-domain-boundary-v1';
+const contexts = new WeakSet();
+const identityOccupants = new WeakMap();
+/** Full stored-tuple lookup, independent of ID spelling and active membership.
+ * Each caller retains its own active-only or any-stored collision policy.
+ */
+export function storedIdentityOccupant(context, identity) {
+    assertSemanticContext(context);
+    context.budget.chargeWork(2);
+    return identityOccupants.get(context)(identity);
+}
+const requests = new WeakMap();
+const parents = new WeakMap();
+export function isSemanticCandidateOf(parent, child) {
+    assertSemanticContext(parent);
+    assertSemanticContext(child);
+    parent.budget.chargeWork();
+    return parents.get(child) === parent;
+}
+/** Genuine handles must also have been prepared by the same request. */
+export function contextsShareRequest(a, b) {
+    assertSemanticContext(a);
+    assertSemanticContext(b);
+    a.budget.chargeWork();
+    return requests.get(a) === requests.get(b);
+}
+const metadata = new WeakMap();
+const projections = new WeakMap();
+/** Borrowed original metadata only; never projects or indexes active members. */
+export function semanticContextGraphMetadata(context) {
+    assertSemanticContext(context);
+    context.budget.chargeWork();
+    return metadata.get(context);
+}
+const forks = new WeakMap();
+/** Persistent candidate overlay with the original request's source universe and budget. */
+export function forkSemanticCandidate(parent, delta) {
+    assertSemanticContext(parent);
+    return forks.get(parent)(delta);
+}
+/** Structural active-node projection; does not authenticate a persisted source catalog. */
+export function graphForSemanticContext(context) {
+    assertSemanticContext(context);
+    return projections.get(context)();
+}
+let nextRequest = 0;
+/** Runtime identity, not a caller-supplied authority string or a copied property brand. */
+export function assertSemanticContext(context) {
+    if (!contexts.has(context))
+        throw new TypeError('Unauthenticated semantic context');
+}
+class InvalidContext extends Error {
+    code;
+    component;
+    constructor(code, component) {
+        super(code);
+        this.code = code;
+        this.component = component;
+    }
+}
+export class SemanticContextAccessError extends Error {
+    code;
+    component;
+    constructor(code, component) {
+        super(`Semantic context ${code}${component ? `: ${component}` : ''}`);
+        this.code = code;
+        this.component = component;
+        this.name = 'SemanticContextAccessError';
+    }
+}
+/**
+ * The resolved input is a structural source entry, not a schema-validity receipt.
+ * Source/loader/catalog costs precede this adapter and retain their existing budgets.
+ * This request owns snapshotting, indexes, deltas and all subsequent consumer work.
+ */
+export function prepareSemanticRequest(resolved, options = {}) {
+    const budget = options.budget ?? createSemanticBudget();
+    return budget.guard(() => {
+        const dataField = (value, name) => {
+            budget.chargeWork(44 + name.length);
+            if (!value || typeof value !== 'object')
+                throw new InvalidContext('representation');
+            const field = Object.getOwnPropertyDescriptor(value, name);
+            if (field === undefined)
+                return undefined;
+            if (!('value' in field))
+                throw new InvalidContext('representation');
+            return field.value;
+        };
+        try {
+            budget.chargeWork(3);
+            // Private exact-handle binding is read before snapshotting loses that identity.
+            // Availability of all source roots is distinct from source/component validity.
+            const sourceSchemas = sourceSchemasForResolvedGraph(resolved);
+            let identityConstraints;
+            const originalIdentityConstraints = () => identityConstraints ??= createOriginalIdentityConstraintRegistry(sourceSchemas, budget);
+            const inputGraph = dataField(resolved, 'graph');
+            const inputNodes = dataField(inputGraph, 'nodes');
+            if (dataField(inputGraph, 'model') !== GRAPH_MODEL || !Array.isArray(inputNodes)) {
+                throw new InvalidContext('representation');
+            }
+            budget.reserveNodes(dataField(inputNodes, 'length'));
+            // An exact source-bound resolved handle owns a deeply frozen graph from
+            // the resolver. The generic catalog entry still snapshots caller data.
+            const graph = sourceSchemas !== undefined ? inputGraph
+                : budget.freeze(budget.snapshot(inputGraph));
+            budget.chargeWork(6);
+            const originals = new Map();
+            const originalNames = new Map();
+            const originalSlots = new Map();
+            const originalEdges = new Map();
+            const knownReferences = new WeakSet();
+            const ownedTypeReferences = new WeakSet();
+            const requestAuthority = Object.freeze({});
+            const requestId = `semantic-request:${++nextRequest}`;
+            let serial = 0;
+            const originalScalarSlots = new Map();
+            const absentOriginals = computeOriginalSourceAbsence(graph.nodes, budget);
+            const originalNotations = new Map();
+            const states = new WeakMap();
+            const key = (id) => {
+                budget.chargeWork();
+                if (typeof id !== 'string')
+                    throw new TypeError('Semantic component IDs must be strings');
+                budget.chargeWork(id.length);
+            };
+            const notationField = (value, field) => {
+                budget.chargeWork(44 + field.length);
+                if (!value || typeof value !== 'object' || Array.isArray(value))
+                    throw new TypeError('Notation properties require data records');
+                const descriptor = Object.getOwnPropertyDescriptor(value, field);
+                if (!descriptor || !('value' in descriptor))
+                    throw new TypeError('Notation properties require explicit own data fields');
+                return descriptor.value;
+            };
+            const notationName = (value) => {
+                if (typeof notationField(value, 'namespace') !== 'string' || typeof notationField(value, 'local') !== 'string')
+                    throw new TypeError('Notation QName fields must be strings');
+                return value;
+            };
+            const notationProperties = (value) => {
+                notationName(notationField(value, 'name'));
+                const publicIdentifier = notationField(value, 'publicIdentifier'), systemIdentifier = notationField(value, 'systemIdentifier');
+                if ((publicIdentifier !== undefined && typeof publicIdentifier !== 'string') || (systemIdentifier !== undefined && typeof systemIdentifier !== 'string'))
+                    throw new TypeError('Notation identifiers must be strings or explicit undefined');
+                return value;
+            };
+            const retainNotation = (syntax, namespace) => {
+                // Each physical representation allocates a tuple, even if later coalesced.
+                budget.reserveNodes(1);
+                const mapped = readSourceNotationProperties(syntax, namespace, budget);
+                if (mapped.kind !== 'properties')
+                    return; // Missing names remain source-grammar failures.
+                const id = notationNameKey(mapped.properties.name, budget), prior = originalNotations.get(id);
+                budget.chargeWork(4);
+                if (!prior)
+                    originalNotations.set(id, { properties: mapped.properties, conflicting: false });
+                else if (!equalNotationProperties(prior.properties, mapped.properties, budget))
+                    prior.conflicting = true;
+            };
+            if (sourceSchemas !== undefined) {
+                for (const schema of sourceSchemas) {
+                    budget.chargeWork();
+                    const namespace = sourceNotationNamespace(schema, budget);
+                    for (const child of schema.syntax.children) {
+                        budget.chargeWork(4);
+                        if (child.kind === 'element') {
+                            budget.chargeWork(child.name.namespace.length + child.name.local.length);
+                            if (child.name.namespace === XSD_NAMESPACE && child.name.local === 'notation')
+                                retainNotation(child, namespace);
+                        }
+                    }
+                }
+            }
+            else {
+                for (const retained of graph.schemaRetained) {
+                    budget.chargeWork(4 + retained.syntax.name.namespace.length + retained.syntax.name.local.length);
+                    if (retained.syntax.name.namespace === XSD_NAMESPACE && retained.syntax.name.local === 'notation')
+                        retainNotation(retained.syntax, retained.context.effectiveNamespace);
+                }
+            }
+            budget.chargeWork(5 + originalNotations.size * 3);
+            const actualNotations = { additions: new Map(), active: new Set(originalNotations.keys()),
+                members: Object.freeze([...originalNotations.values()].map(row => row.properties.name)) };
+            const identityId = (node) => {
+                if (node.identity.kind === 'global') {
+                    const role = node.kind === 'simpleType' || node.kind === 'complexType' ? 'type' : node.kind === 'wsdl' ? node.role : node.kind;
+                    if (node.identity.role !== role)
+                        throw new InvalidContext('identity', node.id);
+                    if (node.kind === 'element' || node.kind === 'attribute' || node.kind === 'wsdl') {
+                        budget.chargeWork(4 + node.name.namespace.length + node.name.local.length + node.identity.name.namespace.length + node.identity.name.local.length);
+                        if (node.name.namespace !== node.identity.name.namespace || node.name.local !== node.identity.name.local)
+                            throw new InvalidContext('identity', node.id);
+                    }
+                    budget.chargeWork(64 + 6 * (node.identity.role.length + node.identity.name.namespace.length + node.identity.name.local.length));
+                    return globalId(node.identity.role, node.identity.name);
+                }
+                budget.chargeWork(64 + 6 * (node.identity.owner.length + node.identity.path.length + node.identity.role.length));
+                return scopedId(node.identity.owner, node.identity.path, node.identity.role);
+            };
+            const indexNode = (node, slots, edges) => {
+                budget.chargeWork(12);
+                // Precharge variable slot/containment arrays before the shared traversal allocates them.
+                if (node.kind === 'simpleType' && node.variety.kind === 'union')
+                    budget.chargeWork(node.variety.members.length * 4);
+                if (node.kind === 'wsdl')
+                    budget.chargeWork(node.references.length * 4);
+                if (node.kind === 'complexType' || node.kind === 'attributeGroup')
+                    budget.chargeWork(node.attributes.length * 2);
+                if (node.kind === 'particle' && 'children' in node.term)
+                    budget.chargeWork(node.term.children.length * 2);
+                const references = referenceSlots(node);
+                // Original operands were frozen once with the graph/delta snapshot. Only
+                // freeze new slot records here; walking their provenance again is wasteful.
+                for (const slot of references) {
+                    budget.chargeWork(3 + slot.path.length);
+                    Object.freeze(slot);
+                    knownReferences.add(slot.reference);
+                }
+                slots.set(node.id, Object.freeze(references));
+                edges.set(node.id, Object.freeze(containedNodes(node)));
+            };
+            for (const node of graph.nodes) {
+                key(node.id);
+                if (originals.has(node.id) || node.id !== identityId(node))
+                    throw new InvalidContext('identity', node.id);
+                budget.chargeWork(2);
+                originals.set(node.id, node);
+                if (node.identity.kind === 'global')
+                    originalNames.set(node.id, node.id);
+                indexNode(node, originalSlots, originalEdges);
+                if (node.kind === 'complexType' && node.derivation?.contentKind === 'simple' && node.derivation.kind === 'restriction' && !absentOriginals.has(node.id)) {
+                    budget.reserveNodes(1);
+                    budget.chargeWork(5 + node.id.length);
+                    const slot = Object.freeze({ kind: 'original-generated', owner: node.id });
+                    assertSemanticTypeReferenceShape(slot, budget);
+                    budget.chargeWork();
+                    ownedTypeReferences.add(slot);
+                    originalScalarSlots.set(node.id, slot);
+                }
+            }
+            budget.chargeWork(4 + originalScalarSlots.size * 2);
+            const actualScalarSlots = { active: new Set(originalScalarSlots.keys()), members: Object.freeze([...originalScalarSlots.values()]) };
+            budget.chargeWork(12);
+            const sharedMetadata = Object.freeze({ model: graph.model, origins: graph.origins,
+                schemaAnnotations: graph.schemaAnnotations, schemaRetained: graph.schemaRetained, loading: graph.loading });
+            budget.chargeWork(2);
+            const noParticleWildcards = new Map();
+            const noOriginalUrWildcards = new Map();
+            const buildContext = (kind, members, changes, changedSlots, changedEdges, rawTypes = [], rawSimpleTypes = [], rawElements = [], rawGroups = [], notations = actualNotations, scalarSlots = actualScalarSlots, rawAttributes = [], particleWildcards = noParticleWildcards, borrowedUr = noOriginalUrWildcards) => {
+                budget.chargeWork(5);
+                const membership = new Set();
+                const rawProperties = new Map();
+                const rawSimpleProperties = new Map();
+                const rawSimpleSlots = new Map();
+                const rawComplexSlots = new Map(), rawComplexEdges = new Map();
+                const rawElementProperties = new Map();
+                const rawAttributeProperties = new Map();
+                const rawGroupProperties = new Map();
+                let expectedMembers = originals.size, hasEncodedIdentity = false;
+                for (const [id, node] of changes) {
+                    key(id);
+                    if (!originals.has(id))
+                        expectedMembers++;
+                    // Every stored change has already passed the exact legacy/new ID gate.
+                    // Inactive inherited changes still participate in this scan.
+                    budget.chargeWork(3);
+                    if (node.identity.kind === 'scoped' && id[0] === '[')
+                        hasEncodedIdentity = true;
+                }
+                const reverse = new Map();
+                const slotsFor = (id) => rawComplexSlots.get(id) ?? rawSimpleSlots.get(id) ?? changedSlots.get(id) ?? originalSlots.get(id) ?? [];
+                const edgesFor = (id) => {
+                    const edges = rawComplexEdges.get(id) ?? changedEdges.get(id) ?? originalEdges.get(id) ?? [];
+                    const node = changes.get(id) ?? originals.get(id);
+                    if (!borrowedUr.size || node?.kind !== 'particle' || !('children' in node.term))
+                        return edges;
+                    budget.chargeWork(3 + edges.length);
+                    return edges.filter(child => !borrowedUr.has(child));
+                };
+                const record = (id) => changes.get(id) ?? originals.get(id);
+                budget.chargeWork(6);
+                function* identityRecords() { yield* originals.values(); yield* changes.values(); }
+                let changedIdentityIndex;
+                const identityOccupant = (identity) => {
+                    budget.chargeWork(2);
+                    if (!changedIdentityIndex) {
+                        budget.chargeWork(4);
+                        const completed = new Map();
+                        for (const node of changes.values()) {
+                            const tuple = semanticIdentityTuple(node.identity, budget.chargeWork);
+                            budget.chargeWork(4 + tuple.length + node.id.length);
+                            completed.set(tuple, node.id);
+                        }
+                        // Final changes include inactive rows. Never publish an exhausted partial index.
+                        changedIdentityIndex = completed;
+                    }
+                    const wanted = semanticIdentityTuple(identity, budget.chargeWork);
+                    budget.chargeWork(2 + wanted.length);
+                    const changed = changedIdentityIndex.get(wanted);
+                    if (changed !== undefined)
+                        return changed;
+                    // Originals admit only exact native IDs. Tuple lookup needs no second
+                    // source index, but must distinguish tuples sharing a legacy hash.
+                    if (identity.kind === 'scoped')
+                        budget.chargeWork(64 + 6 * (identity.owner.length + identity.path.length + identity.role.length));
+                    const originalId = identity.kind === 'global' ? wanted : scopedId(identity.owner, identity.path, identity.role);
+                    key(originalId);
+                    const original = originals.get(originalId);
+                    if (!original)
+                        return undefined;
+                    const actual = semanticIdentityTuple(original.identity, budget.chargeWork);
+                    budget.chargeWork(1 + wanted.length + actual.length);
+                    return wanted === actual ? original.id : undefined;
+                };
+                if (hasEncodedIdentity) {
+                    const duplicateIdentity = duplicateIdentityTuple(identityRecords(), budget.chargeWork);
+                    if (duplicateIdentity !== undefined)
+                        throw new InvalidContext('identity', duplicateIdentity);
+                }
+                for (const id of members) {
+                    key(id);
+                    if (membership.has(id))
+                        throw new InvalidContext('identity', id);
+                    if (!record(id))
+                        throw new InvalidContext('missing', id);
+                    budget.chargeWork(2);
+                    membership.add(id);
+                }
+                const requireMember = (id) => {
+                    key(id);
+                    const node = record(id);
+                    if (!node)
+                        throw new InvalidContext('missing', id);
+                    if (!membership.has(id))
+                        throw new InvalidContext('outside-context', id);
+                    return node;
+                };
+                for (const [id, handle] of borrowedUr) {
+                    const node = originalUrWildcardSource(actual, handle);
+                    key(id);
+                    budget.chargeWork(10);
+                    if (id !== handle.particle || node.id !== id || requireMember(handle.owner).kind !== 'complexType')
+                        throw new InvalidContext('reference', id);
+                    if (record(id))
+                        throw new InvalidContext('identity', id);
+                    const occupied = identityOccupant(node.identity);
+                    if (occupied !== undefined)
+                        throw new InvalidContext('identity', occupied);
+                    if (node.identity.kind !== 'scoped' || requireMember(node.identity.owner).kind !== 'complexType')
+                        throw new InvalidContext('reference', id);
+                    if (particleWildcards.has(id))
+                        throw new InvalidContext('representation', id);
+                }
+                const originalParticleEdges = (handle, root) => {
+                    const source = originalComplexParticleSource(actual, handle);
+                    if (root !== handle.particle || requireMember(handle.owner).kind !== 'complexType')
+                        throw new InvalidContext('reference', root);
+                    budget.chargeWork(6 + source.synthetic.length * 2);
+                    const privateIds = new Set(source.synthetic), pending = [root], seen = new Set(), frontier = [];
+                    for (const id of privateIds) {
+                        key(id);
+                        if (record(id))
+                            throw new InvalidContext(membership.has(id) ? 'identity' : 'outside-context', id);
+                        const backing = particleContentNode(actual, source, id);
+                        if (!backing)
+                            throw new InvalidContext('representation', id);
+                        const occupied = identityOccupant(backing.identity);
+                        if (occupied !== undefined)
+                            throw new InvalidContext('identity', occupied);
+                    }
+                    while (pending.length) {
+                        budget.chargeWork(4);
+                        const id = pending.pop();
+                        if (seen.has(id))
+                            continue;
+                        seen.add(id);
+                        if (!privateIds.has(id)) {
+                            if (requireMember(id).kind !== 'particle')
+                                throw new InvalidContext('reference', id);
+                            budget.chargeWork();
+                            frontier.push(id);
+                            continue;
+                        }
+                        const node = particleContentNode(actual, source, id);
+                        if (node?.kind !== 'particle')
+                            throw new InvalidContext('reference', id);
+                        if ('children' in node.term) {
+                            budget.chargeWork(node.term.children.length);
+                            pending.push(...node.term.children);
+                        }
+                        else if (node.term.kind !== 'any')
+                            throw new InvalidContext('representation', id);
+                    }
+                    return Object.freeze(frontier);
+                };
+                for (const properties of rawTypes) {
+                    assertRawComplexTypeShape(properties, budget);
+                    key(properties.type);
+                    if (requireMember(properties.type).kind !== 'complexType' || rawProperties.has(properties.type))
+                        throw new InvalidContext('representation', properties.type);
+                    budget.chargeWork(8 + properties.attributeUses.length);
+                    rawProperties.set(properties.type, properties);
+                    const references = [Object.freeze({ path: '$raw/derivation/base', reference: properties.derivation.base })];
+                    if (properties.content.kind === 'simple' || properties.content.kind === 'opaque-builtin') {
+                        budget.chargeWork(3);
+                        references.push(Object.freeze({ path: '$raw/content/type', reference: properties.content.type }));
+                    }
+                    rawComplexSlots.set(properties.type, Object.freeze(references));
+                    const children = [...properties.attributeUses];
+                    if ('particle' in properties.content) {
+                        budget.chargeWork();
+                        if (properties.content.original)
+                            children.push(...originalParticleEdges(properties.content.original, properties.content.particle));
+                        else
+                            children.push(properties.content.particle);
+                    }
+                    rawComplexEdges.set(properties.type, Object.freeze(children));
+                }
+                for (const properties of rawSimpleTypes) {
+                    if (!validateRawSimpleTypeShape(properties, budget))
+                        throw new InvalidContext('representation');
+                    key(properties.type);
+                    if (requireMember(properties.type).kind !== 'simpleType' || rawSimpleProperties.has(properties.type))
+                        throw new InvalidContext('representation', properties.type);
+                    budget.chargeWork(5);
+                    rawSimpleProperties.set(properties.type, properties);
+                    const rawSlots = [Object.freeze({ path: '$raw/base', reference: properties.base })];
+                    if (properties.variety.kind === 'list') {
+                        budget.chargeWork(3);
+                        rawSlots.push(Object.freeze({ path: '$raw/item', reference: properties.variety.item }));
+                    }
+                    if (properties.variety.kind === 'union')
+                        for (let i = 0; i < properties.variety.members.length; i++) {
+                            budget.chargeWork(12);
+                            rawSlots.push(Object.freeze({ path: '$raw/members/' + i, reference: properties.variety.members[i] }));
+                        }
+                    rawSimpleSlots.set(properties.type, Object.freeze(rawSlots));
+                }
+                for (const properties of rawElements) {
+                    if (!validateRawElementShape(properties, budget))
+                        throw new InvalidContext('representation');
+                    key(properties.element);
+                    if (requireMember(properties.element).kind !== 'element' || rawElementProperties.has(properties.element))
+                        throw new InvalidContext('representation', properties.element);
+                    budget.chargeWork();
+                    rawElementProperties.set(properties.element, properties);
+                    if (properties.type) {
+                        const original = changedSlots.get(properties.element) ?? originalSlots.get(properties.element) ?? [];
+                        budget.chargeWork(5 + original.length * 2);
+                        rawComplexSlots.set(properties.element, Object.freeze([...original.filter(slot => slot.path !== 'type'), Object.freeze({ path: '$raw/type', reference: properties.type })]));
+                    }
+                }
+                for (const properties of rawAttributes) {
+                    if (!validateRawAttributeShape(properties, budget))
+                        throw new InvalidContext('representation');
+                    key(properties.attribute);
+                    if (requireMember(properties.attribute).kind !== 'attribute' || rawAttributeProperties.has(properties.attribute))
+                        throw new InvalidContext('representation', properties.attribute);
+                    budget.chargeWork(5);
+                    rawAttributeProperties.set(properties.attribute, properties);
+                    rawComplexSlots.set(properties.attribute, Object.freeze([Object.freeze({ path: '$raw/type', reference: properties.type })]));
+                }
+                for (const properties of rawGroups) {
+                    validateRawAttributeGroupShape(properties, budget);
+                    key(properties.group);
+                    if (requireMember(properties.group).kind !== 'attributeGroup' || rawGroupProperties.has(properties.group))
+                        throw new InvalidContext('representation', properties.group);
+                    budget.chargeWork(4 + properties.attributeUses.length);
+                    rawGroupProperties.set(properties.group, properties);
+                    for (const id of properties.attributeUses)
+                        if (requireMember(id).kind !== 'attributeUse')
+                            throw new InvalidContext('reference', properties.group);
+                    for (const id of properties.wildcard?.sources ?? [])
+                        requireMember(id);
+                    rawComplexSlots.set(properties.group, Object.freeze([]));
+                    rawComplexEdges.set(properties.group, Object.freeze([...properties.attributeUses]));
+                }
+                const target = (reference) => {
+                    budget.chargeWork(4);
+                    if (!reference || typeof reference !== 'object')
+                        throw new InvalidContext('reference');
+                    if (reference.kind === 'builtin') {
+                        if (!reference.name || typeof reference.name.namespace !== 'string' || typeof reference.name.local !== 'string')
+                            throw new InvalidContext('reference');
+                        budget.chargeWork(reference.name.namespace.length + reference.name.local.length);
+                        if (reference.name.namespace !== XSD_NAMESPACE || !isBuiltinType(reference.name.local))
+                            throw new InvalidContext('reference');
+                        return undefined;
+                    }
+                    // Canonical local references are direct IDs; S05 does not require a
+                    // scoped target. They can coherently reference a replaced endpoint.
+                    if (reference.kind === 'local') {
+                        if (typeof reference.target !== 'string')
+                            throw new InvalidContext('reference');
+                        return reference.target;
+                    }
+                    if (reference.kind !== 'symbol' || typeof reference.role !== 'string' || !reference.name
+                        || typeof reference.name.namespace !== 'string' || typeof reference.name.local !== 'string')
+                        throw new InvalidContext('reference');
+                    budget.chargeWork(64 + 6 * (reference.role.length + reference.name.namespace.length + reference.name.local.length));
+                    const id = globalId(reference.role, reference.name);
+                    if (reference.target !== undefined && reference.target !== id)
+                        throw new InvalidContext('reference', id);
+                    return id;
+                };
+                const rawEdges = new Map();
+                const requireScalarSlot = (reference, original = false) => {
+                    key(reference.owner);
+                    if (!originalScalarSlots.has(reference.owner))
+                        throw new InvalidContext('missing', reference.owner);
+                    if (!original && !scalarSlots.active.has(reference.owner))
+                        throw new InvalidContext('outside-context', reference.owner);
+                };
+                const rawReference = (owner, reference, edges, original = false) => {
+                    assertSemanticTypeReferenceShape(reference, budget);
+                    // These records came from the frozen graph/delta snapshot, never the
+                    // mutable caller. Ownership is not selected-context resolution.
+                    budget.chargeWork();
+                    ownedTypeReferences.add(reference);
+                    if (reference.kind === 'original-generated') {
+                        requireScalarSlot(reference, original);
+                        return;
+                    }
+                    const id = target(reference);
+                    if (id === undefined)
+                        return;
+                    const node = original ? originals.get(id) : requireMember(id);
+                    if (!node)
+                        throw new InvalidContext('reference', owner);
+                    if ((node.kind !== 'simpleType' && node.kind !== 'complexType') || reference.kind === 'symbol' && reference.role !== 'type')
+                        throw new InvalidContext('reference', owner);
+                    if (!original) {
+                        budget.chargeWork();
+                        edges.push(id);
+                    }
+                };
+                for (const properties of rawSimpleTypes) {
+                    budget.chargeWork(3);
+                    const edges = [];
+                    rawReference(properties.type, properties.base, edges);
+                    if (properties.variety.kind === 'list')
+                        rawReference(properties.type, properties.variety.item, edges);
+                    if (properties.variety.kind === 'union')
+                        for (const member of properties.variety.members)
+                            rawReference(properties.type, member, edges);
+                    if (properties.facetBinding)
+                        rawReference(properties.type, properties.facetBinding.type, [], true);
+                    for (const layer of properties.facetLayers ?? properties.facetComponentSet ?? [])
+                        if ('facets' in layer)
+                            for (const facet of layer.facets) {
+                                budget.chargeWork(2);
+                                const operand = facet.operand;
+                                if (!operand)
+                                    continue;
+                                if (operand.context === 'active') {
+                                    requireMember(operand.owner);
+                                    rawReference(properties.type, operand.type, edges);
+                                }
+                                else {
+                                    key(operand.owner);
+                                    if (!originals.has(operand.owner))
+                                        throw new InvalidContext('reference', properties.type);
+                                    rawReference(properties.type, operand.type, [], true);
+                                }
+                            }
+                    rawEdges.set(properties.type, edges);
+                }
+                for (const properties of rawElements)
+                    if (properties.type)
+                        rawReference(properties.element, properties.type, []);
+                for (const properties of rawAttributes)
+                    rawReference(properties.attribute, properties.type, []);
+                for (const properties of rawTypes) {
+                    budget.chargeWork(3);
+                    const edges = [];
+                    rawReference(properties.type, properties.derivation.base, edges);
+                    if (properties.content.kind === 'simple' || properties.content.kind === 'opaque-builtin')
+                        rawReference(properties.type, properties.content.type, []);
+                    if ('particle' in properties.content && !properties.content.original
+                        && requireMember(properties.content.particle).kind !== 'particle')
+                        throw new InvalidContext('reference', properties.type);
+                    for (const id of properties.attributeUses)
+                        if (requireMember(id).kind !== 'attributeUse')
+                            throw new InvalidContext('reference', properties.type);
+                    for (const id of properties.wildcard?.sources ?? [])
+                        requireMember(id);
+                    rawEdges.set(properties.type, edges);
+                }
+                // Validate closure and ownership without unfolding recursive element/type references.
+                for (const id of members) {
+                    const node = requireMember(id);
+                    if (node.identity.kind === 'scoped')
+                        requireMember(node.identity.owner);
+                    for (const child of edgesFor(id))
+                        requireMember(child);
+                    for (const slot of slotsFor(id)) {
+                        if (slot.reference.kind === 'original-generated') {
+                            requireScalarSlot(slot.reference);
+                            continue;
+                        }
+                        const refId = target(slot.reference);
+                        if (refId !== undefined) {
+                            const referred = requireMember(refId);
+                            if (slot.reference.kind === 'symbol' && (referred.identity.kind !== 'global' || referred.identity.role !== slot.reference.role))
+                                throw new InvalidContext('reference', id);
+                            if (node.kind === 'element' && slot.path === 'substitutionGroup') {
+                                if (referred.kind !== 'element')
+                                    throw new InvalidContext('reference', id);
+                                budget.chargeWork(4);
+                                const incoming = reverse.get(refId) ?? [];
+                                incoming.push(id);
+                                reverse.set(refId, incoming);
+                            }
+                        }
+                    }
+                }
+                const forbidden = (id) => {
+                    const node = requireMember(id);
+                    budget.chargeWork(1 + edgesFor(id).length);
+                    const result = [...edgesFor(id)];
+                    for (const raw of rawEdges.get(id) ?? []) {
+                        budget.chargeWork();
+                        result.push(raw);
+                    }
+                    for (const slot of slotsFor(id)) {
+                        budget.chargeWork();
+                        // A scalar slot is a distinct component. Its lazy property owner
+                        // checks scalar dependency cycles; the provenance owner is no edge.
+                        if (slot.reference.kind === 'original-generated')
+                            continue;
+                        const expands = node.kind === 'simpleType' || node.kind === 'complexType' || node.kind === 'attributeGroupUse'
+                            || (node.kind === 'particle' && node.term.kind === 'group') || (node.kind === 'element' && slot.path === 'substitutionGroup');
+                        if (expands) {
+                            const refId = target(slot.reference);
+                            if (refId !== undefined) {
+                                budget.chargeWork();
+                                result.push(refId);
+                            }
+                        }
+                    }
+                    return result;
+                };
+                const acyclic = (edges) => {
+                    budget.chargeWork(3);
+                    const done = new Set(), active = new Set();
+                    const stack = [];
+                    for (const root of members) {
+                        key(root);
+                        if (done.has(root))
+                            continue;
+                        budget.chargeWork(5);
+                        active.add(root);
+                        stack.push({ id: root, edges: edges(root), index: 0 });
+                        while (stack.length) {
+                            budget.chargeWork(3);
+                            const top = stack[stack.length - 1];
+                            if (top.index === top.edges.length) {
+                                budget.chargeWork(3);
+                                active.delete(top.id);
+                                done.add(top.id);
+                                stack.pop();
+                                continue;
+                            }
+                            const id = top.edges[top.index++];
+                            key(id);
+                            if (active.has(id))
+                                throw new InvalidContext('cycle', id);
+                            if (!done.has(id)) {
+                                budget.chargeWork(5);
+                                active.add(id);
+                                stack.push({ id, edges: edges(id), index: 0 });
+                            }
+                        }
+                    }
+                };
+                acyclic(forbidden);
+                acyclic(id => {
+                    const node = requireMember(id);
+                    budget.chargeWork(2);
+                    return node.identity.kind === 'scoped' ? [node.identity.owner] : [];
+                });
+                for (const entries of reverse.values()) {
+                    budget.chargeWork(1 + entries.length);
+                    Object.freeze(entries);
+                }
+                budget.chargeWork(100 + members.length);
+                const frozenMembers = Object.freeze([...members]);
+                budget.chargeWork(2 + borrowedUr.size);
+                const frozenUrWildcards = Object.freeze([...borrowedUr.values()]);
+                const contextId = `${requestId}:${kind}:${++serial}`;
+                let context;
+                let compositorChildren;
+                const authenticate = () => { assertSemanticContext(context); budget.chargeWork(); };
+                const lookup = (id) => {
+                    authenticate();
+                    key(id);
+                    budget.chargeWork(3);
+                    const node = record(id);
+                    return Object.freeze(!node ? { kind: 'missing', id } : !membership.has(id) ? { kind: 'outside-context', id } : { kind: 'found', node });
+                };
+                const checked = (id) => {
+                    const result = lookup(id);
+                    if (result.kind !== 'found') {
+                        budget.chargeWork(4 + id.length);
+                        throw new SemanticContextAccessError(result.kind, id);
+                    }
+                    return result.node;
+                };
+                const empty = Object.freeze([]);
+                const ownTypeReference = (input) => {
+                    authenticate();
+                    budget.chargeWork(3);
+                    if (ownedTypeReferences.has(input))
+                        return input;
+                    // Canonical known references also include non-type symbols. Reuse
+                    // their immutable storage only after the semantic shape/role gate.
+                    const safe = knownReferences.has(input) ? input : budget.freeze(budget.snapshot(input));
+                    assertSemanticTypeReferenceShape(safe, budget);
+                    budget.chargeWork();
+                    ownedTypeReferences.add(safe);
+                    return safe;
+                };
+                context = Object.freeze({
+                    contextId, profileVersion: GRAPH_MODEL, contractVersion: SEMANTIC_CONTEXT_CONTRACT,
+                    originalIdentityConstraints() {
+                        assertSemanticContext(this);
+                        if (this !== context)
+                            throw new TypeError('Foreign identity-constraint context');
+                        authenticate();
+                        return originalIdentityConstraints();
+                    },
+                    kind, acceptance: 'structural-only', membership: membership.size === expectedMembers ? 'complete-actual-plus-additions' : 'structural-subset', budget, members: frozenMembers,
+                    scalarSlots: scalarSlots.members,
+                    scalarSlotMembership: scalarSlots.active.size === originalScalarSlots.size ? 'complete-original' : 'structural-subset',
+                    lookupScalarSlot(input) {
+                        const selected = ownTypeReference(input);
+                        if (selected.kind !== 'original-generated')
+                            throw new SemanticContextAccessError('reference');
+                        key(selected.owner);
+                        budget.chargeWork(5);
+                        const slot = originalScalarSlots.get(selected.owner);
+                        return Object.freeze(!slot ? { kind: 'missing', slot: selected }
+                            : !scalarSlots.active.has(selected.owner) ? { kind: 'outside-context', slot } : { kind: 'found', slot });
+                    },
+                    notationMembers: notations.members,
+                    notationMembership: notations.active.size === originalNotations.size + notations.additions.size ? 'complete-original-plus-additions' : 'structural-subset',
+                    notationUniverse: sourceSchemas !== undefined ? 'source-bound' : 'retained-only',
+                    lookupNotation(input) {
+                        authenticate();
+                        const name = notationName(budget.freeze(budget.snapshot(input)));
+                        const id = notationNameKey(name, budget), original = originalNotations.get(id), addition = notations.additions.get(id);
+                        budget.chargeWork(12);
+                        if ((original || addition) && !notations.active.has(id))
+                            return Object.freeze({ kind: 'outside-context', name });
+                        if (original)
+                            return original.conflicting ? Object.freeze({ kind: 'unresolved', name, rule: 'notation-original-properties' })
+                                : Object.freeze({ kind: 'found', properties: original.properties, origin: 'original' });
+                        if (sourceSchemas === undefined)
+                            return Object.freeze({ kind: 'unresolved', name, rule: 'notation-source-universe' });
+                        if (addition)
+                            return Object.freeze({ kind: 'found', properties: addition, origin: 'addition' });
+                        if (notations.active.size !== originalNotations.size + notations.additions.size)
+                            return Object.freeze({ kind: 'unresolved', name, rule: 'notation-active-membership' });
+                        return Object.freeze({ kind: 'missing', name });
+                    },
+                    lookup,
+                    ownTypeReference,
+                    resolve(reference) {
+                        authenticate();
+                        try {
+                            budget.chargeWork(2);
+                            const safe = knownReferences.has(reference) || ownedTypeReferences.has(reference) ? reference : budget.freeze(budget.snapshot(reference));
+                            const id = target(safe);
+                            if (id !== undefined) {
+                                const result = lookup(id);
+                                if (result.kind === 'found' && safe.kind === 'symbol'
+                                    && (result.node.identity.kind !== 'global' || result.node.identity.role !== safe.role))
+                                    throw new InvalidContext('reference', id);
+                                return result;
+                            }
+                            if (safe.kind !== 'builtin')
+                                throw new InvalidContext('reference');
+                            budget.chargeWork(4 + safe.name.namespace.length + safe.name.local.length);
+                            return Object.freeze({ kind: 'builtin', name: Object.freeze({ ...safe.name }) });
+                        }
+                        catch (error) {
+                            if (error instanceof InvalidContext || error instanceof TypeError) {
+                                budget.chargeWork(4);
+                                throw new SemanticContextAccessError('reference', error instanceof InvalidContext ? error.component : undefined);
+                            }
+                            throw error;
+                        }
+                    },
+                    sourceNode(id) { authenticate(); key(id); return originals.get(id); },
+                    originalSourceComponentAbsent(id) { authenticate(); key(id); return absentOriginals.has(id); },
+                    originalComplexPropertySource(id) {
+                        authenticate();
+                        key(id);
+                        budget.chargeWork(7);
+                        const original = originals.get(id);
+                        return kind === 'candidate' && sourceSchemas !== undefined && membership.has(id) && original?.kind === 'complexType'
+                            && !rawProperties.has(id) && !changes.has(id) && !absentOriginals.has(id) ? original : undefined;
+                    },
+                    originalComplexContentSource(id) {
+                        assertSemanticContext(this);
+                        if (this !== context)
+                            throw new TypeError('Foreign original-content context');
+                        authenticate();
+                        key(id);
+                        budget.chargeWork(5);
+                        const original = originals.get(id);
+                        return kind === 'actual' && sourceSchemas !== undefined && membership.has(id) && original?.kind === 'complexType'
+                            && !absentOriginals.has(id) ? original : undefined;
+                    },
+                    originalCompositorChildren(id) {
+                        assertSemanticContext(this);
+                        if (this !== context)
+                            throw new TypeError('Foreign compositor context');
+                        authenticate();
+                        key(id);
+                        budget.chargeWork(10);
+                        const original = originals.get(id);
+                        if (kind !== 'candidate' || sourceSchemas === undefined || !membership.has(id) || original?.kind !== 'particle'
+                            || !('children' in original.term) || absentOriginals.has(id) || changes.has(id) || record(id) !== original)
+                            return undefined;
+                        const prior = compositorChildren?.get(id);
+                        if (prior) {
+                            budget.chargeWork(2);
+                            return prior;
+                        }
+                        const children = [];
+                        for (const child of original.term.children) {
+                            key(child);
+                            budget.chargeWork(5 + child.length);
+                            if (originals.get(child)?.kind !== 'particle')
+                                return undefined;
+                            if (!absentOriginals.has(child))
+                                children.push(child);
+                        }
+                        budget.chargeWork(4 + children.length);
+                        const result = Object.freeze(children);
+                        if (!compositorChildren) {
+                            budget.chargeWork(2);
+                            compositorChildren = new Map();
+                        }
+                        compositorChildren.set(id, result);
+                        return result;
+                    },
+                    originalUrWildcards() { authenticate(); return frozenUrWildcards; },
+                    originalUrWildcard(id) { authenticate(); key(id); return borrowedUr.get(id); },
+                    originalContext() { authenticate(); return actual; },
+                    sourceSchemaRetained() { authenticate(); return graph.schemaRetained; },
+                    rawTypeProperties(id) { checked(id); return rawProperties.get(id); },
+                    rawSimpleTypeProperties(id) { checked(id); return rawSimpleProperties.get(id); },
+                    rawElementProperties(id) { checked(id); return rawElementProperties.get(id); },
+                    rawAttributeProperties(id) { checked(id); return rawAttributeProperties.get(id); },
+                    rawAttributeGroupProperties(id) { checked(id); return rawGroupProperties.get(id); },
+                    rawParticleWildcardProperties(id) { checked(id); return particleWildcards.get(id); },
+                    references(id) { checked(id); return slotsFor(id); },
+                    owner(id) { const node = checked(id); return node.identity.kind === 'scoped' ? node.identity.owner : undefined; },
+                    incomingAffiliates(id) { checked(id); return reverse.get(id) ?? empty; },
+                });
+                contexts.add(context);
+                metadata.set(context, sharedMetadata);
+                budget.chargeWork(4);
+                identityOccupants.set(context, identityOccupant);
+                requests.set(context, requestAuthority);
+                states.set(context, { changes, slots: changedSlots, edges: changedEdges, raw: rawProperties, simple: rawSimpleProperties,
+                    elements: rawElementProperties, attributes: rawAttributeProperties, groups: rawGroupProperties, particleWildcards, originalUrWildcards: borrowedUr, notations, scalarSlots });
+                forks.set(context, input => candidate(input, context));
+                let projection;
+                projections.set(context, () => {
+                    authenticate();
+                    if (projection)
+                        return projection;
+                    budget.chargeWork(12 + 2 * frozenMembers.length);
+                    const nodes = [], globals = [];
+                    for (const id of frozenMembers) {
+                        key(id);
+                        const node = record(id);
+                        nodes.push(node);
+                        if (node.identity.kind === 'global')
+                            globals.push(id);
+                    }
+                    projection = Object.freeze({ ...graph, nodes: Object.freeze(nodes), globals: Object.freeze(globals) });
+                    return projection;
+                });
+                return context;
+            };
+            budget.chargeWork(4 + graph.nodes.length);
+            const actual = buildContext('actual', graph.nodes.map(node => node.id), new Map(), new Map(), new Map());
+            const candidate = (input, from = actual) => budget.guard(() => {
+                try {
+                    budget.chargeWork(8);
+                    assertSemanticContext(from);
+                    if (requests.get(from) !== requestAuthority)
+                        throw new InvalidContext('representation');
+                    const parent = states.get(from);
+                    const candidateKey = dataField(input, 'key'), candidateActive = dataField(input, 'active');
+                    const additions = dataField(input, 'additions'), endpoint = dataField(input, 'endpoint'), rawTypes = dataField(input, 'rawTypes');
+                    const rawSimpleTypes = dataField(input, 'rawSimpleTypes'), rawElements = dataField(input, 'rawElements'), rawGroups = dataField(input, 'rawAttributeGroups');
+                    const rawAttributes = dataField(input, 'rawAttributes'), inputScalarSlots = dataField(input, 'scalarSlots');
+                    const rawParticleWildcards = dataField(input, 'rawParticleWildcards');
+                    const inputUrWildcards = dataField(input, 'originalUrWildcards');
+                    const notationDelta = dataField(input, 'notations');
+                    const notationActive = notationDelta === undefined ? undefined : dataField(notationDelta, 'active');
+                    const notationAdditions = notationDelta === undefined ? undefined : dataField(notationDelta, 'additions');
+                    if (typeof candidateKey !== 'string' || !Array.isArray(candidateActive)
+                        || (additions !== undefined && !Array.isArray(additions)) || (rawTypes !== undefined && !Array.isArray(rawTypes))
+                        || (rawGroups !== undefined && !Array.isArray(rawGroups)) || (rawSimpleTypes !== undefined && !Array.isArray(rawSimpleTypes)) || (rawElements !== undefined && !Array.isArray(rawElements))
+                        || (rawAttributes !== undefined && !Array.isArray(rawAttributes)) || (inputScalarSlots !== undefined && !Array.isArray(inputScalarSlots))
+                        || (rawParticleWildcards !== undefined && !Array.isArray(rawParticleWildcards))
+                        || (inputUrWildcards !== undefined && !Array.isArray(inputUrWildcards)))
+                        throw new InvalidContext('representation');
+                    if (notationDelta !== undefined && (!Array.isArray(notationActive) || (notationAdditions !== undefined && !Array.isArray(notationAdditions))))
+                        throw new InvalidContext('representation');
+                    budget.reserveNodes((additions ? dataField(additions, 'length') : 0) + (endpoint ? 1 : 0)
+                        + (notationAdditions ? dataField(notationAdditions, 'length') : 0));
+                    // Snapshot data, but retain the identity of privately issued source
+                    // selectors only after authenticating them against this exact Γ.
+                    const originalHandles = new Map();
+                    const urHandles = [];
+                    for (let index = 0; index < (inputUrWildcards?.length ?? 0); index++) {
+                        const handle = dataField(inputUrWildcards, String(index));
+                        originalUrWildcardSource(actual, handle);
+                        budget.chargeWork(2);
+                        urHandles.push(handle);
+                    }
+                    for (let index = 0; index < (rawTypes?.length ?? 0); index++) {
+                        const row = dataField(rawTypes, String(index)), content = dataField(row, 'content');
+                        if (dataField(content, 'original') === undefined)
+                            continue;
+                        assertRawComplexTypeShape(row, budget);
+                        if (!('particle' in row.content) || !row.content.original)
+                            throw new InvalidContext('representation');
+                        originalComplexParticleSource(actual, row.content.original);
+                        if (row.content.particle !== row.content.original.particle)
+                            throw new InvalidContext('reference', row.type);
+                        budget.chargeWork(3);
+                        originalHandles.set(index, row.content.original);
+                    }
+                    const delta = budget.freeze(budget.snapshot(input));
+                    budget.chargeWork(12 + delta.active.length + parent.changes.size * 2 + parent.slots.size * 2 + parent.edges.size * 2
+                        + parent.raw.size * 2 + parent.simple.size * 2 + parent.elements.size * 2 + parent.attributes.size * 2 + parent.groups.size * 2);
+                    const changes = new Map(parent.changes), slots = new Map(parent.slots), edges = new Map(parent.edges);
+                    const raw = new Map(parent.raw), simple = new Map(parent.simple), elements = new Map(parent.elements), attributes = new Map(parent.attributes), groups = new Map(parent.groups);
+                    budget.chargeWork(2 + parent.particleWildcards.size * 2);
+                    const particleWildcards = new Map(parent.particleWildcards);
+                    budget.chargeWork(3 + parent.originalUrWildcards.size + urHandles.length);
+                    const borrowedUr = new Map(parent.originalUrWildcards);
+                    for (const handle of urHandles) {
+                        key(handle.particle);
+                        if (borrowedUr.has(handle.particle))
+                            throw new InvalidContext('identity', handle.particle);
+                        budget.chargeWork(2);
+                        borrowedUr.set(handle.particle, handle);
+                    }
+                    const active = new Set(delta.active);
+                    let scalarSlots = parent.scalarSlots;
+                    if (delta.scalarSlots !== undefined) {
+                        budget.chargeWork(4);
+                        const selected = new Set(), members = [];
+                        for (const reference of delta.scalarSlots) {
+                            assertSemanticTypeReferenceShape(reference, budget);
+                            if (reference.kind !== 'original-generated')
+                                throw new InvalidContext('representation');
+                            key(reference.owner);
+                            const slot = originalScalarSlots.get(reference.owner);
+                            if (!slot)
+                                throw new InvalidContext('missing', reference.owner);
+                            if (selected.has(reference.owner))
+                                throw new InvalidContext('identity', reference.owner);
+                            budget.chargeWork(2);
+                            selected.add(reference.owner);
+                            members.push(slot);
+                        }
+                        budget.chargeWork(2 + members.length);
+                        scalarSlots = { active: selected, members: Object.freeze(members) };
+                    }
+                    let notations = parent.notations;
+                    if (delta.notations !== undefined) {
+                        budget.chargeWork(4 + parent.notations.additions.size * 2);
+                        const additions = new Map(parent.notations.additions), selected = new Set(), names = [];
+                        for (const rawName of delta.notations.active) {
+                            const name = notationName(rawName), id = notationNameKey(name, budget);
+                            if (selected.has(id))
+                                throw new InvalidContext('identity', id);
+                            budget.chargeWork(2);
+                            selected.add(id);
+                            names.push(name);
+                        }
+                        for (const rawProperties of delta.notations.additions ?? []) {
+                            const properties = notationProperties(rawProperties), id = notationNameKey(properties.name, budget);
+                            if (originalNotations.has(id) || additions.has(id))
+                                throw new InvalidContext('identity', id);
+                            if (!selected.has(id))
+                                throw new InvalidContext('outside-context', id);
+                            budget.chargeWork();
+                            additions.set(id, properties);
+                        }
+                        for (const id of selected) {
+                            key(id);
+                            if (!originalNotations.has(id) && !additions.has(id))
+                                throw new InvalidContext('missing', id);
+                        }
+                        budget.chargeWork(4 + names.length);
+                        notations = { additions, active: selected, members: Object.freeze(names) };
+                    }
+                    for (const node of delta.additions ?? []) {
+                        key(node.id);
+                        if (originals.has(node.id) || changes.has(node.id) || originalNames.has(identityId(node)) || !matchesHypotheticalNodeId(node, budget.chargeWork))
+                            throw new InvalidContext('identity', node.id);
+                        if (!active.has(node.id))
+                            throw new InvalidContext('outside-context', node.id);
+                        budget.chargeWork();
+                        changes.set(node.id, node);
+                        indexNode(node, slots, edges);
+                    }
+                    if (delta.endpoint) {
+                        const node = delta.endpoint;
+                        key(node.id);
+                        const original = parent.changes.get(node.id) ?? originals.get(node.id);
+                        if (from.lookup(node.id).kind !== 'found' || !original || original.kind !== 'complexType' || node.kind !== 'complexType'
+                            || !sameSemanticIdentity(original, node, budget.chargeWork) || !matchesHypotheticalNodeId(node, budget.chargeWork)
+                            || !active.has(node.id))
+                            throw new InvalidContext('endpoint', node.id);
+                        budget.chargeWork();
+                        changes.set(node.id, node);
+                        indexNode(node, slots, edges);
+                    }
+                    const permittedProperty = (id) => {
+                        key(id);
+                        if (from.kind === 'candidate' && id !== delta.endpoint?.id && (originals.has(id) || parent.changes.has(id)))
+                            throw new InvalidContext('endpoint', id);
+                    };
+                    budget.chargeWork(4);
+                    const seenRaw = new Set(), seenSimple = new Set(), seenElements = new Set(), seenAttributes = new Set(), seenGroups = new Set();
+                    const unique = (id, seen) => { key(id); if (seen.has(id))
+                        throw new InvalidContext('identity', id); budget.chargeWork(); seen.add(id); };
+                    for (const supplied of delta.rawParticleWildcards ?? []) {
+                        const row = prepareRawParticleWildcardProperties(supplied, budget), node = changes.get(row.particle);
+                        key(row.particle);
+                        budget.chargeWork(6);
+                        // Stored inactive additions count too: an inherited particle never acquires or replaces this role.
+                        if (originals.has(row.particle) || parent.changes.has(row.particle) || particleWildcards.has(row.particle)
+                            || !active.has(row.particle) || node?.kind !== 'particle' || node.term.kind !== 'any')
+                            throw new InvalidContext('representation', row.particle);
+                        budget.chargeWork();
+                        particleWildcards.set(row.particle, row);
+                    }
+                    for (const [index, copied] of (delta.rawTypes ?? []).entries()) {
+                        const original = originalHandles.get(index);
+                        budget.chargeWork(5);
+                        const row = original && 'particle' in copied.content
+                            ? Object.freeze({ ...copied, content: Object.freeze({ ...copied.content, original }) }) : copied;
+                        assertRawComplexTypeShape(row, budget);
+                        budget.chargeWork(6);
+                        // A first row may reify an untouched original's latent properties.
+                        // Preparation stays structural; correspondence must authenticate
+                        // those properties before aggregate acceptance in the child.
+                        const lateOriginal = from.kind === 'candidate' && originals.get(row.type)?.kind === 'complexType'
+                            && !parent.raw.has(row.type) && !parent.changes.has(row.type) && !absentOriginals.has(row.type);
+                        if (!lateOriginal)
+                            permittedProperty(row.type);
+                        unique(row.type, seenRaw);
+                        budget.chargeWork();
+                        raw.set(row.type, row);
+                    }
+                    for (const row of delta.rawSimpleTypes ?? []) {
+                        if (!validateRawSimpleTypeShape(row, budget))
+                            throw new InvalidContext('representation');
+                        if (row.facetComponentSet) {
+                            budget.chargeWork(row.facetComponentSet.length + 2);
+                            if (row.facetComponentSet.some(entry => !('facets' in entry))
+                                && (originals.has(row.type) || parent.changes.has(row.type) || parent.simple.has(row.type)
+                                    || changes.get(row.type)?.kind !== 'simpleType'))
+                                throw new InvalidContext('representation', row.type);
+                        }
+                        permittedProperty(row.type);
+                        unique(row.type, seenSimple);
+                        budget.chargeWork();
+                        simple.set(row.type, row);
+                    }
+                    for (const row of delta.rawElements ?? []) {
+                        if (!validateRawElementShape(row, budget))
+                            throw new InvalidContext('representation');
+                        if ((row.identityConstraints !== undefined || parent.elements.get(row.element)?.identityConstraints !== undefined)
+                            && (originals.has(row.element) || parent.changes.has(row.element)
+                                || parent.elements.has(row.element) || changes.get(row.element)?.kind !== 'element'))
+                            throw new InvalidContext('representation', row.element);
+                        if (row.identityConstraints?.length) {
+                            const registry = originalIdentityConstraints();
+                            budget.chargeWork(4 + row.identityConstraints.length * (registry.identities.length + 1));
+                            if (!registry.sourceBound || row.identityConstraints.some(identity => !registry.identities.includes(identity)))
+                                throw new InvalidContext('reference', row.element);
+                        }
+                        permittedProperty(row.element);
+                        unique(row.element, seenElements);
+                        budget.chargeWork();
+                        elements.set(row.element, row);
+                    }
+                    for (const row of delta.rawAttributes ?? []) {
+                        if (!validateRawAttributeShape(row, budget))
+                            throw new InvalidContext('representation');
+                        permittedProperty(row.attribute);
+                        unique(row.attribute, seenAttributes);
+                        budget.chargeWork();
+                        attributes.set(row.attribute, row);
+                    }
+                    for (const row of delta.rawAttributeGroups ?? []) {
+                        validateRawAttributeGroupShape(row, budget);
+                        permittedProperty(row.group);
+                        unique(row.group, seenGroups);
+                        budget.chargeWork();
+                        groups.set(row.group, row);
+                    }
+                    budget.chargeWork(5 + raw.size + simple.size + elements.size + attributes.size + groups.size);
+                    const context = buildContext('candidate', delta.active, changes, slots, edges, [...raw.values()], [...simple.values()], [...elements.values()], [...groups.values()], notations, scalarSlots, [...attributes.values()], particleWildcards, borrowedUr);
+                    budget.chargeWork();
+                    parents.set(context, from);
+                    budget.chargeWork(3);
+                    return Object.freeze({ kind: 'prepared', context });
+                }
+                catch (error) {
+                    if (error instanceof TypeError) {
+                        budget.chargeWork(4);
+                        return Object.freeze({ kind: 'candidate-rejected', code: 'representation' });
+                    }
+                    if (!(error instanceof InvalidContext))
+                        throw error;
+                    budget.chargeWork(4);
+                    return Object.freeze({ kind: 'candidate-rejected', code: error.code, component: error.component });
+                }
+            });
+            budget.chargeWork(8);
+            return Object.freeze({ kind: 'prepared', request: Object.freeze({ graph, actual, budget, candidate }) });
+        }
+        catch (error) {
+            if (error instanceof TypeError) {
+                budget.chargeWork(4);
+                return Object.freeze({ kind: 'input-error', code: 'representation' });
+            }
+            if (!(error instanceof InvalidContext))
+                throw error;
+            budget.chargeWork(4);
+            return Object.freeze({ kind: 'input-error', code: error.code, component: error.component });
+        }
+    });
+}