@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/complexTypeContent.d.ts

@@ -0,0 +1,58 @@
+import type { CanonicalGraph, GraphNode, NodeId, ParticleNode } from './canonicalGraph.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { OriginalComplexParticleHandle, OriginalUrWildcardHandle, RawComplexContent } from './re01TypeProperties.js';
+import type { RelationFailure } from './schemaTypeRelations.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+export type ParticleContentView = Readonly<{
+    contextId: string;
+    type: NodeId;
+    scope: 'actual-source-mapping' | 'candidate-raw-properties' | 'original-property-projection' | 'builtin-type' | 'model-group';
+    /** Effective scalar reference, not a scalar/component-validity receipt.
+     * @remarks Actual and retained-source views preserve the source mapper's scalar reference;
+     *   restrictions retain their registered GSC1 slot and extensions may inherit a named/builtin type.
+     *   The scalar owner establishes properties, identity and remaining obligations. RAW views carry the supplied reference.
+     */
+    content: RawComplexContent;
+    /** Optional diagnostic materialization, charged on first access; semantic consumers use particleContentNode. */
+    graph: CanonicalGraph;
+    synthetic: readonly NodeId[];
+    urTypeWildcards: readonly NodeId[];
+}>;
+export type ContentViewResult = Readonly<{
+    kind: 'checked';
+    view: ParticleContentView;
+}> | RelationFailure | ResourceLimitFailure;
+export declare function assertParticleContentView(context: SemanticContext, view: ParticleContentView): void;
+/** Constant-time authenticated semantic lookup, without a whole-graph projection. */
+export declare function particleContentNode(context: SemanticContext, view: ParticleContentView, id: NodeId): GraphNode | undefined;
+/** Source mapping is meaningful only in the actual source context. */
+export declare function deriveActualComplexContent(context: SemanticContext, type: NodeId): ContentViewResult;
+export type OriginalParticleResult = Readonly<{
+    kind: 'checked';
+    content: Extract<RawComplexContent, {
+        particle: NodeId;
+    }>;
+}> | RelationFailure | ResourceLimitFailure;
+/** Select the same source component, conditional on the separate actual-source
+ * qualification. Neither the source owner's nor its current-H validity is imported. */
+export declare function deriveOriginalComplexParticle(context: SemanticContext, type: NodeId): OriginalParticleResult;
+/** Private issuer authentication used before the context factory snapshots raw data. */
+export declare function originalComplexParticleSource(context: SemanticContext, handle: OriginalComplexParticleHandle): ParticleContentView;
+export type OriginalUrWildcardResult = Readonly<{
+    kind: 'checked';
+    handle: OriginalUrWildcardHandle;
+}> | RelationFailure | ResourceLimitFailure;
+/** Select one unchanged native leaf from an authenticated actual SOURCE whole. */
+export declare function deriveOriginalUrWildcard(context: SemanticContext, original: OriginalComplexParticleHandle, particle: NodeId): OriginalUrWildcardResult;
+/** Private authentication used by preparation and same-H content owners. */
+export declare function originalUrWildcardSource(context: SemanticContext, handle: OriginalUrWildcardHandle): ParticleNode;
+/** Raw candidate properties are read directly; their component validity remains a separate prerequisite. */
+export declare function deriveRawComplexContent(context: SemanticContext, type: NodeId): ContentViewResult;
+/** Retained source properties interpreted in H; scalar identities remain unchanged and full hypothetical validity stays separate. */
+export declare function deriveOriginalComplexPropertyContent(context: SemanticContext, type: NodeId): ContentViewResult;
+/** Same-H private subtree input for local predicates, never a component-validity receipt. */
+export declare function deriveOriginalContentSubtree(context: SemanticContext, source: ParticleContentView, particle: NodeId): ContentViewResult;
+/** The primary ur-type component, never inferred from an ordinary wildcard's spelling. */
+export declare function deriveBuiltinAnyTypeContent(context: SemanticContext, anchor: NodeId): ContentViewResult;
+/** Local model-group constraints also apply to definitions unused by any type. */
+export declare function deriveModelGroupContent(context: SemanticContext, component: NodeId): ContentViewResult;

package/dist/compiler/complexTypeContent.js

@@ -0,0 +1,558 @@
+/** Concrete effective-content mapping, separate from source and raw component validity. */
+import { privateParticleId } from './hypotheticalScopedIdentity.js';
+import { assertSemanticContext, graphForSemanticContext, storedIdentityOccupant } from './semanticContext.js';
+const authorities = new WeakMap();
+const generatedNodes = new WeakMap();
+const actualCaches = new WeakMap();
+const candidateCaches = new WeakMap();
+const originalPropertyCaches = new WeakMap();
+const originalParticles = new WeakMap();
+const originalParticleCaches = new WeakMap();
+const originalRawViews = new WeakSet();
+const originalUrWildcards = new WeakMap();
+const originalUrCaches = new WeakMap();
+const ONE = Object.freeze({ min: '1', max: '1' });
+const OPTIONAL_MANY = Object.freeze({ min: '0', max: 'unbounded' });
+const EMPTY = Object.freeze({ kind: 'empty' });
+const NONE = Object.freeze([]);
+class MappingFailure extends Error {
+    result;
+    constructor(result) {
+        super(result.message);
+        this.result = result;
+    }
+}
+export function assertParticleContentView(context, view) {
+    assertSemanticContext(context);
+    if (authorities.get(view) !== context)
+        throw new TypeError('Unauthenticated or foreign particle content view');
+}
+/** Constant-time authenticated semantic lookup, without a whole-graph projection. */
+export function particleContentNode(context, view, id) {
+    assertParticleContentView(context, view);
+    context.budget.chargeWork(2 + id.length);
+    const generated = generatedNodes.get(view).get(id);
+    if (generated)
+        return generated;
+    const actual = context.lookup(id);
+    return actual.kind === 'found' ? actual.node : undefined;
+}
+function issueContentView(context, fields, additions) {
+    const budget = context.budget;
+    budget.chargeWork(18 + additions.length * 2);
+    const generated = new Map();
+    for (const node of additions) {
+        budget.chargeWork(2 + node.id.length);
+        generated.set(node.id, node);
+    }
+    const borrowed = context.originalUrWildcards();
+    if (borrowed.length) {
+        budget.chargeWork(8 + fields.synthetic.length + fields.urTypeWildcards.length + borrowed.length * 3);
+        const synthetic = new Set(fields.synthetic), markers = new Set(fields.urTypeWildcards);
+        for (const handle of borrowed) {
+            const node = originalUrWildcardSource(context.originalContext(), handle), prior = generated.get(node.id);
+            if (node.term.kind !== 'any')
+                throw new TypeError('Invalid original UR wildcard backing');
+            if (prior && (prior.kind !== 'particle' || prior.term.kind !== 'any' || prior.id !== node.id
+                || prior.identity.kind !== 'scoped' || node.identity.kind !== 'scoped'
+                || prior.identity.owner !== node.identity.owner || prior.identity.path !== node.identity.path || prior.identity.role !== node.identity.role
+                || prior.occurs.min !== node.occurs.min || prior.occurs.max !== node.occurs.max
+                || prior.term.wildcard.namespace.value !== '##any' || prior.term.wildcard.processContents !== 'lax'
+                || prior.context !== node.context || prior.term.wildcard.namespace.context !== node.term.wildcard.namespace.context))
+                throw new TypeError('Conflicting original UR wildcard backing');
+            generated.set(node.id, node);
+            synthetic.add(node.id);
+            markers.add(node.id);
+        }
+        fields = { ...fields, synthetic: Object.freeze([...synthetic]), urTypeWildcards: Object.freeze([...markers]) };
+    }
+    let projection;
+    const view = Object.freeze({ ...fields, get graph() {
+            budget.chargeWork();
+            if (projection)
+                return projection;
+            const source = graphForSemanticContext(context);
+            if (!generated.size)
+                return projection = source;
+            budget.chargeWork(12 + source.nodes.length + generated.size);
+            projection = Object.freeze({ ...source, nodes: Object.freeze([...source.nodes, ...generated.values()]) });
+            return projection;
+        } });
+    authorities.set(view, context);
+    generatedNodes.set(view, generated);
+    return view;
+}
+/** Source mapping is meaningful only in the actual source context. */
+export function deriveActualComplexContent(context, type) {
+    assertSemanticContext(context);
+    const budget = context.budget;
+    return budget.guard(() => {
+        const fail = (component, message) => {
+            budget.chargeWork(8 + component.length + message.length);
+            throw new MappingFailure(Object.freeze({ kind: 'unresolved', rule: 'effective-complex-content', component, message }));
+        };
+        try {
+            budget.chargeWork(10 + type.length);
+            if (context.kind !== 'actual')
+                return fail(type, 'Actual-source content mapping requires the actual context');
+            let cache = actualCaches.get(context);
+            if (!cache) {
+                budget.chargeWork(2);
+                cache = new Map();
+                actualCaches.set(context, cache);
+            }
+            const cached = cache.get(type);
+            if (cached) {
+                budget.chargeWork(3);
+                return Object.freeze({ kind: 'checked', view: cached });
+            }
+            budget.chargeWork(8);
+            const mapped = new Map(), active = new Set();
+            const additions = [], urTypeWildcards = [];
+            const get = (id) => {
+                const found = context.lookup(id);
+                return found.kind === 'found' ? found.node : fail(id, `Required component is ${found.kind}`);
+            };
+            const complex = (id) => {
+                const node = get(id);
+                return node.kind === 'complexType' ? node : fail(id, 'Content mapping requires a complex type');
+            };
+            const synthetic = (owner, term, occurs = ONE) => {
+                budget.reserveNodes(1);
+                const path = `$semantic-content/${context.contextId}/${additions.length}`;
+                const identity = Object.freeze({ kind: 'scoped', owner: owner.id, path, role: 'particle' });
+                const id = privateParticleId('effective', owner.id, path, 'particle', budget.chargeWork);
+                if (context.lookup(id).kind === 'found')
+                    return fail(id, 'Synthetic semantic identity collision');
+                const occupied = storedIdentityOccupant(context, identity);
+                if (occupied !== undefined && context.lookup(occupied).kind === 'found')
+                    return fail(id, 'Synthetic semantic tuple collision');
+                budget.chargeWork(16 + id.length);
+                additions.push(Object.freeze({ id, identity, kind: 'particle', occurs, term, context: owner.context,
+                    declaredAttributes: NONE, annotations: NONE, retained: NONE, syntaxDetails: NONE }));
+                return id;
+            };
+            const sequence = (owner, children) => {
+                budget.chargeWork(4 + children.length);
+                return synthetic(owner, Object.freeze({ kind: 'sequence', children: Object.freeze([...children]) }));
+            };
+            const particleContent = (node, particle) => {
+                budget.chargeWork(4);
+                return Object.freeze({ kind: node.mixed ? 'mixed' : 'element-only', particle });
+            };
+            const local = (node) => {
+                if (!node.content)
+                    return node.mixed ? particleContent(node, sequence(node, NONE)) : EMPTY;
+                const particle = get(node.content);
+                if (particle.kind !== 'particle')
+                    return fail(node.id, 'Declared content is not a particle');
+                budget.chargeWork(4 + particle.occurs.min.length + particle.occurs.max.length);
+                const absent = particle.occurs.max === '0' || 'children' in particle.term && particle.term.children.length === 0
+                    && (particle.term.kind !== 'choice' || particle.occurs.min === '0');
+                if (absent)
+                    return node.mixed ? particleContent(node, sequence(node, NONE)) : EMPTY;
+                return particleContent(node, particle.id);
+            };
+            const builtin = (owner, reference) => {
+                if (reference.kind !== 'builtin' || reference.name.local !== 'anyType')
+                    return fail(owner.id, 'Complex content requires a complex base');
+                budget.chargeWork(10);
+                const wildcard = Object.freeze({ namespace: Object.freeze({ value: '##any', context: owner.context }), processContents: 'lax' });
+                const id = synthetic(owner, Object.freeze({ kind: 'any', wildcard }), OPTIONAL_MANY);
+                budget.chargeWork();
+                urTypeWildcards.push(id);
+                budget.chargeWork(4);
+                return Object.freeze({ kind: 'mixed', particle: sequence(owner, [id]) });
+            };
+            budget.chargeWork(4);
+            const stack = [{ node: complex(type), entered: false }];
+            while (stack.length) {
+                budget.chargeWork(5);
+                const frame = stack[stack.length - 1], node = frame.node;
+                if (!frame.entered) {
+                    budget.chargeWork(2 + node.id.length);
+                    if (active.has(node.id))
+                        return fail(node.id, 'Forbidden type derivation cycle');
+                    active.add(node.id);
+                    frame.entered = true;
+                    if (node.derivation) {
+                        const target = context.resolve(node.derivation.base);
+                        if (target.kind === 'found') {
+                            if (target.node.kind !== 'complexType') {
+                                if (node.derivation.contentKind === 'complex' || target.node.kind !== 'simpleType')
+                                    return fail(node.id, 'Content derivation requires an appropriate type base');
+                            }
+                            else {
+                                frame.base = target.node;
+                                if (!mapped.has(target.node.id)) {
+                                    budget.chargeWork(4);
+                                    stack.push({ node: target.node, entered: false });
+                                    continue;
+                                }
+                            }
+                        }
+                        else if (target.kind !== 'builtin')
+                            return fail(node.id, 'Base is unavailable in the actual context');
+                    }
+                }
+                let content;
+                if (node.derivation?.contentKind === 'simple') {
+                    const inherited = frame.base ? mapped.get(frame.base.id) : undefined;
+                    const scalar = inherited?.kind === 'simple' ? inherited.type : !frame.base ? node.derivation.base : undefined;
+                    if (node.derivation.kind === 'extension') {
+                        if (!scalar || scalar.kind === 'builtin' && scalar.name.local === 'anyType')
+                            return fail(node.id, 'Simple-content extension requires simple content');
+                        budget.chargeWork(4);
+                        content = Object.freeze({ kind: 'simple', type: scalar });
+                    }
+                    else {
+                        const base = node.derivation.inlineType ?? scalar;
+                        if (!base)
+                            return fail(node.id, 'Simple-content restriction requires a mapped simple base or explicit inline type');
+                        // This is only the authentic source slot selector. The scalar
+                        // owner separately maps its properties and assesses local legality.
+                        budget.chargeWork(4);
+                        const slot = context.lookupScalarSlot({ kind: 'original-generated', owner: node.id });
+                        if (slot.kind !== 'found')
+                            return fail(node.id, 'Original generated scalar slot is unavailable');
+                        budget.chargeWork(3);
+                        content = Object.freeze({ kind: 'simple', type: slot.slot });
+                    }
+                }
+                else {
+                    const declared = local(node);
+                    if (node.derivation?.kind !== 'extension')
+                        content = declared;
+                    else {
+                        const base = frame.base ? mapped.get(frame.base.id) : builtin(node, node.derivation.base);
+                        if (base.kind === 'simple' || base.kind === 'opaque-builtin')
+                            return fail(node.id, 'Complex-content extension cannot extend scalar or unresolved builtin content');
+                        if (declared.kind === 'empty')
+                            content = base;
+                        else if (base.kind === 'empty')
+                            content = declared;
+                        else if ('particle' in declared)
+                            content = particleContent(node, sequence(node, [base.particle, declared.particle]));
+                        else
+                            return fail(node.id, 'Complex content unexpectedly mapped to scalar content');
+                    }
+                }
+                budget.chargeWork(3);
+                mapped.set(node.id, content);
+                active.delete(node.id);
+                stack.pop();
+            }
+            budget.chargeWork(24 + 2 * additions.length + urTypeWildcards.length);
+            const view = issueContentView(context, { contextId: context.contextId, type, scope: 'actual-source-mapping', content: mapped.get(type),
+                synthetic: Object.freeze(additions.map(node => node.id)), urTypeWildcards: Object.freeze(urTypeWildcards) }, additions);
+            cache.set(type, view);
+            return Object.freeze({ kind: 'checked', view });
+        }
+        catch (error) {
+            if (error instanceof MappingFailure)
+                return error.result;
+            throw error;
+        }
+    });
+}
+/** Select the same source component, conditional on the separate actual-source
+ * qualification. Neither the source owner's nor its current-H validity is imported. */
+export function deriveOriginalComplexParticle(context, type) {
+    assertSemanticContext(context);
+    return context.budget.guard(() => {
+        const b = context.budget;
+        b.chargeWork(12 + type.length);
+        if (!context.originalComplexContentSource(type))
+            return Object.freeze({ kind: 'unresolved',
+                rule: 'original-particle-source', component: type, message: 'Authentic actual complex source mapping required' });
+        const source = deriveActualComplexContent(context, type);
+        if (source.kind !== 'checked')
+            return source;
+        if (!('particle' in source.view.content))
+            return Object.freeze({ kind: 'unresolved',
+                rule: 'original-particle-source', component: type, message: 'Original content must be a particle' });
+        let cache = originalParticleCaches.get(context);
+        if (!cache) {
+            b.chargeWork(2);
+            cache = new Map();
+            originalParticleCaches.set(context, cache);
+        }
+        let handle = cache.get(type);
+        if (!handle) {
+            b.chargeWork(8 + type.length + source.view.content.particle.length);
+            handle = Object.freeze({ owner: type, particle: source.view.content.particle });
+            originalParticles.set(handle, { context, view: source.view });
+            cache.set(type, handle);
+        }
+        b.chargeWork(5);
+        return Object.freeze({ kind: 'checked', content: Object.freeze({ ...source.view.content, original: handle }) });
+    });
+}
+/** Private issuer authentication used before the context factory snapshots raw data. */
+export function originalComplexParticleSource(context, handle) {
+    assertSemanticContext(context);
+    context.budget.chargeWork(4);
+    const source = originalParticles.get(handle);
+    if (!source || source.context !== context || context.kind !== 'actual')
+        throw new TypeError('Unauthenticated or foreign original particle handle');
+    return source.view;
+}
+/** Select one unchanged native leaf from an authenticated actual SOURCE whole. */
+export function deriveOriginalUrWildcard(context, original, particle) {
+    assertSemanticContext(context);
+    return context.budget.guard(() => {
+        const b = context.budget, source = originalComplexParticleSource(context, original);
+        b.chargeWork(16 + particle.length + source.synthetic.length + source.urTypeWildcards.length);
+        const node = particleContentNode(context, source, particle);
+        if (!source.synthetic.includes(particle) || !source.urTypeWildcards.includes(particle) || node?.kind !== 'particle' || node.identity.kind !== 'scoped'
+            || node.term.kind !== 'any' || node.occurs.min !== '0' || node.occurs.max !== 'unbounded'
+            || node.term.wildcard.namespace.value !== '##any' || node.term.wildcard.processContents !== 'lax')
+            return Object.freeze({ kind: 'unresolved', rule: 'original-ur-wildcard', component: particle, message: 'An unchanged actual-source native UR wildcard is required' });
+        let cache = originalUrCaches.get(context);
+        if (!cache) {
+            b.chargeWork(2);
+            cache = new Map();
+            originalUrCaches.set(context, cache);
+        }
+        let handle = cache.get(particle);
+        if (!handle) {
+            b.reserveNodes(1);
+            b.chargeWork(8 + node.identity.owner.length + particle.length);
+            handle = Object.freeze({ owner: node.identity.owner, particle });
+            originalUrWildcards.set(handle, Object.freeze({ context, node }));
+            cache.set(particle, handle);
+        }
+        return Object.freeze({ kind: 'checked', handle });
+    });
+}
+/** Private authentication used by preparation and same-H content owners. */
+export function originalUrWildcardSource(context, handle) {
+    assertSemanticContext(context);
+    context.budget.chargeWork(4);
+    const source = originalUrWildcards.get(handle);
+    if (!source || source.context !== context || context.kind !== 'actual')
+        throw new TypeError('Unauthenticated or foreign original UR wildcard handle');
+    return source.node;
+}
+/** Raw candidate properties are read directly; their component validity remains a separate prerequisite. */
+export function deriveRawComplexContent(context, type) {
+    assertSemanticContext(context);
+    const budget = context.budget;
+    return budget.guard(() => {
+        budget.chargeWork(10 + type.length);
+        let cache = candidateCaches.get(context);
+        if (!cache) {
+            budget.chargeWork(2);
+            cache = new Map();
+            candidateCaches.set(context, cache);
+        }
+        const cached = cache.get(type);
+        if (cached) {
+            budget.chargeWork(3);
+            return Object.freeze({ kind: 'checked', view: cached });
+        }
+        const properties = context.rawTypeProperties(type);
+        if (context.kind !== 'candidate' || !properties) {
+            budget.chargeWork(8);
+            return Object.freeze({ kind: 'unresolved', rule: 'effective-complex-content', component: type, message: 'Candidate raw type properties are required' });
+        }
+        const additions = [];
+        let synthetic = NONE, urTypeWildcards = NONE;
+        const original = 'particle' in properties.content ? properties.content.original : undefined;
+        if (original) {
+            const actual = context.originalContext(), source = originalComplexParticleSource(actual, original);
+            const owner = context.lookup(original.owner);
+            if (owner.kind !== 'found' || owner.node.kind !== 'complexType' || !('particle' in properties.content)
+                || properties.content.particle !== original.particle)
+                throw new TypeError('Invalid original particle selection');
+            synthetic = source.synthetic;
+            urTypeWildcards = source.urTypeWildcards;
+            for (const id of synthetic) {
+                budget.chargeWork(3 + id.length);
+                if (context.lookup(id).kind !== 'missing')
+                    return Object.freeze({ kind: 'unresolved', rule: 'original-property-synthetic-collision',
+                        component: id, message: 'Original particle identity is occupied' });
+                const node = particleContentNode(actual, source, id);
+                if (!node)
+                    throw new TypeError('Missing original particle backing');
+                if (storedIdentityOccupant(context, node.identity) !== undefined)
+                    return Object.freeze({ kind: 'unresolved',
+                        rule: 'original-property-synthetic-collision', component: id, message: 'Original particle semantic identity is occupied' });
+                additions.push(node);
+            }
+        }
+        else if ('particle' in properties.content) {
+            const particle = context.lookup(properties.content.particle);
+            if (particle.kind !== 'found' || particle.node.kind !== 'particle') {
+                budget.chargeWork(8);
+                return Object.freeze({ kind: 'unresolved', rule: 'effective-complex-content', component: type, message: 'Raw content particle is unavailable' });
+            }
+        }
+        budget.chargeWork(12);
+        const view = issueContentView(context, { contextId: context.contextId, type, scope: 'candidate-raw-properties', content: properties.content,
+            synthetic, urTypeWildcards }, additions);
+        if (original)
+            originalRawViews.add(view);
+        cache.set(type, view);
+        return Object.freeze({ kind: 'checked', view });
+    });
+}
+/** Retained source properties interpreted in H; scalar identities remain unchanged and full hypothetical validity stays separate. */
+export function deriveOriginalComplexPropertyContent(context, type) {
+    assertSemanticContext(context);
+    const budget = context.budget;
+    return budget.guard(() => {
+        budget.chargeWork(10 + type.length);
+        const owner = context.lookup(type);
+        const fail = (rule, component = type) => {
+            budget.chargeWork(8 + rule.length + component.length);
+            return Object.freeze({ kind: 'unresolved', rule, component, message: 'Original property projection is unavailable' });
+        };
+        if (owner.kind !== 'found' || owner.node.kind !== 'complexType')
+            return fail('component-complex-properties');
+        if (context.rawTypeProperties(type))
+            return deriveRawComplexContent(context, type);
+        if (!context.originalComplexPropertySource(type))
+            return fail('component-complex-properties');
+        let cache = originalPropertyCaches.get(context);
+        if (!cache) {
+            budget.chargeWork(2);
+            cache = new Map();
+            originalPropertyCaches.set(context, cache);
+        }
+        const prior = cache.get(type);
+        if (prior) {
+            budget.chargeWork(3);
+            return Object.freeze({ kind: 'checked', view: prior });
+        }
+        const source = deriveActualComplexContent(context.originalContext(), type);
+        if (source.kind !== 'checked')
+            return source;
+        if (source.view.content.kind === 'opaque-builtin')
+            return fail('component-content-properties');
+        const additions = [];
+        for (const id of source.view.synthetic) {
+            budget.chargeWork(3 + id.length);
+            if (context.lookup(id).kind !== 'missing')
+                return fail('original-property-synthetic-collision', id);
+            const node = particleContentNode(context.originalContext(), source.view, id);
+            if (!node)
+                return fail('original-property-synthetic-component', id);
+            if (storedIdentityOccupant(context, node.identity) !== undefined)
+                return fail('original-property-synthetic-collision', id);
+            additions.push(node);
+        }
+        const view = issueContentView(context, { contextId: context.contextId, type, scope: 'original-property-projection',
+            content: source.view.content, synthetic: source.view.synthetic, urTypeWildcards: source.view.urTypeWildcards }, additions);
+        cache.set(type, view);
+        return Object.freeze({ kind: 'checked', view });
+    });
+}
+/** Same-H private subtree input for local predicates, never a component-validity receipt. */
+export function deriveOriginalContentSubtree(context, source, particle) {
+    assertParticleContentView(context, source);
+    const budget = context.budget;
+    return budget.guard(() => {
+        budget.chargeWork(12 + particle.length + source.synthetic.length);
+        if (!(originalRawViews.has(source) || source.scope === 'original-property-projection' && context.originalComplexPropertySource(source.type)
+            || context.originalUrWildcard(particle))
+            || !source.synthetic.includes(particle) || context.lookup(particle).kind !== 'missing')
+            return Object.freeze({ kind: 'unresolved', rule: 'original-content-subtree', component: particle, message: 'Authentic private original subtree required' });
+        const node = particleContentNode(context, source, particle);
+        if (node?.kind !== 'particle')
+            return Object.freeze({ kind: 'unresolved', rule: 'original-content-subtree', component: particle, message: 'Private subtree must be a particle' });
+        budget.chargeWork(source.synthetic.length + 4);
+        return Object.freeze({ kind: 'checked', view: issueContentView(context, { contextId: context.contextId, type: source.type,
+                scope: source.scope, content: Object.freeze({ kind: 'element-only', particle }), synthetic: source.synthetic,
+                urTypeWildcards: source.urTypeWildcards }, [...generatedNodes.get(source).values()]) });
+    });
+}
+const builtinCaches = new WeakMap();
+/** The primary ur-type component, never inferred from an ordinary wildcard's spelling. */
+export function deriveBuiltinAnyTypeContent(context, anchor) {
+    assertSemanticContext(context);
+    const budget = context.budget;
+    return budget.guard(() => {
+        budget.chargeWork(12 + anchor.length);
+        let cache = builtinCaches.get(context);
+        if (!cache) {
+            budget.chargeWork(2);
+            cache = new Map();
+            builtinCaches.set(context, cache);
+        }
+        const prior = cache.get(anchor);
+        if (prior) {
+            budget.chargeWork(3);
+            return Object.freeze({ kind: 'checked', view: prior });
+        }
+        const owner = context.lookup(anchor);
+        if (owner.kind !== 'found') {
+            budget.chargeWork(8);
+            return Object.freeze({ kind: 'unresolved', rule: 'builtin-anyType-content', component: anchor, message: 'Active diagnostic anchor required' });
+        }
+        budget.reserveNodes(2);
+        const path = '$semantic-builtin-anyType/' + context.contextId;
+        budget.chargeWork(180 + 12 * (anchor.length + path.length));
+        const anyId = privateParticleId('builtin-anyType', anchor, path + '/any', 'particle', budget.chargeWork), groupId = privateParticleId('builtin-anyType', anchor, path + '/sequence', 'particle', budget.chargeWork);
+        if (context.lookup(anyId).kind === 'found' || context.lookup(groupId).kind === 'found') {
+            budget.chargeWork(8);
+            return Object.freeze({ kind: 'unresolved', rule: 'builtin-anyType-content', component: anchor, message: 'Synthetic ur-type identity collision' });
+        }
+        const common = { kind: 'particle', context: owner.node.context, declaredAttributes: NONE, annotations: NONE, retained: NONE, syntaxDetails: NONE };
+        const wildcard = Object.freeze({ namespace: Object.freeze({ value: '##any', context: owner.node.context }), processContents: 'lax' });
+        const any = Object.freeze({ ...common, id: anyId, identity: Object.freeze({ kind: 'scoped', owner: anchor, path: path + '/any', role: 'particle' }),
+            occurs: OPTIONAL_MANY, term: Object.freeze({ kind: 'any', wildcard }) });
+        const sequence = Object.freeze({ ...common, id: groupId, identity: Object.freeze({ kind: 'scoped', owner: anchor, path: path + '/sequence', role: 'particle' }),
+            occurs: ONE, term: Object.freeze({ kind: 'sequence', children: Object.freeze([anyId]) }) });
+        budget.chargeWork(4);
+        for (const node of [any, sequence]) {
+            budget.chargeWork(3);
+            const occupied = storedIdentityOccupant(context, node.identity);
+            if (occupied !== undefined && context.lookup(occupied).kind === 'found')
+                return Object.freeze({ kind: 'unresolved',
+                    rule: 'builtin-anyType-content', component: anchor, message: 'Synthetic ur-type semantic identity collision' });
+        }
+        budget.chargeWork(25);
+        const view = issueContentView(context, { contextId: context.contextId, type: anchor, scope: 'builtin-type',
+            content: Object.freeze({ kind: 'mixed', particle: groupId }),
+            synthetic: Object.freeze([anyId, groupId]), urTypeWildcards: Object.freeze([anyId]) }, [any, sequence]);
+        cache.set(anchor, view);
+        return Object.freeze({ kind: 'checked', view });
+    });
+}
+const groupCaches = new WeakMap();
+/** Local model-group constraints also apply to definitions unused by any type. */
+export function deriveModelGroupContent(context, component) {
+    assertSemanticContext(context);
+    const budget = context.budget;
+    return budget.guard(() => {
+        budget.chargeWork(10 + component.length);
+        let cache = groupCaches.get(context);
+        if (!cache) {
+            budget.chargeWork(2);
+            cache = new Map();
+            groupCaches.set(context, cache);
+        }
+        const prior = cache.get(component);
+        if (prior) {
+            budget.chargeWork(3);
+            return Object.freeze({ kind: 'checked', view: prior });
+        }
+        const node = context.lookup(component);
+        if (node.kind !== 'found' || node.node.kind !== 'group' && node.node.kind !== 'particle') {
+            budget.chargeWork(8);
+            return Object.freeze({ kind: 'unresolved', rule: 'coss-modelGroup', component, message: 'An active model-group definition or particle is required' });
+        }
+        const particle = node.node.kind === 'group' ? node.node.content : node.node.id;
+        const root = context.lookup(particle);
+        if (root.kind !== 'found' || root.node.kind !== 'particle') {
+            budget.chargeWork(8);
+            return Object.freeze({ kind: 'unresolved', rule: 'coss-modelGroup', component, message: 'Model-group root is not an active particle' });
+        }
+        budget.chargeWork(13);
+        const view = issueContentView(context, { contextId: context.contextId, type: component, scope: 'model-group',
+            content: Object.freeze({ kind: 'element-only', particle }), synthetic: NONE, urTypeWildcards: NONE }, NONE);
+        cache.set(component, view);
+        return Object.freeze({ kind: 'checked', view });
+    });
+}

package/dist/compiler/componentCorrespondence.d.ts

@@ -0,0 +1,32 @@
+/** Sufficient dated correspondence for ordinary source components without endpoint-shadowing witnesses. */
+import type { SchemaInput } from '../loader/schemaInput.js';
+import type { NativeSourceConstruction } from './checkedSourcePreparation.js';
+import type { ResourceLimitFailure, ResolverUsage } from './semanticBudget.js';
+export declare const COMPONENT_CORRESPONDENCE: "dated-XSD-2004-components-v1";
+export interface ComponentCorrespondence {
+    readonly kind: 'component-correspondence';
+    readonly basis: typeof COMPONENT_CORRESPONDENCE;
+    readonly scope: 'ordinary-source-components';
+    readonly interpretations: number;
+    readonly constructedContexts: number;
+    readonly usage: ResolverUsage;
+}
+export type ComponentCorrespondenceResult = ComponentCorrespondence | ResourceLimitFailure | Readonly<{
+    kind: 'inconclusive-correspondence';
+    rule: string;
+    path?: string;
+    usage: ResolverUsage;
+}>;
+/** Receipt identity binds correspondence to the exact fresh native construction, never a diagnostic digest. */
+export declare function inspectComponentCorrespondence(value: ComponentCorrespondence, construction: NativeSourceConstruction): ComponentCorrespondence;
+/** Audit a closed representation fragment after whole native construction; this is not a second schema checker.
+ * @remarks Source syntax/values and component legality remain the native S4S, construction and aggregate owners.
+ *   This sufficient route excludes redefine/chameleon, identity/substitution, non-string unions and wider faceted families,
+ *   source complex restrictions, contextual/explicit ur-type references, foreign attributes and endpoint-shadowing witnesses.
+ *   Endpoint-shadowing witnesses remain inconclusive until component-valued TYPE/SCOPE interpretation is established.
+ * @returns An authenticated correspondence or an inconclusive scope/resource result; never a schema-invalid judgment.
+ * @throws TypeError For copied/foreign construction or source. Cancellation callbacks propagate unchanged.
+ */
+export declare function checkComponentCorrespondence(input: SchemaInput, supplied: NativeSourceConstruction, options?: Readonly<{
+    check?: () => void;
+}>): ComponentCorrespondenceResult;