@techspokes/typescript-wsdl-client 1.1.4 → 1.1.5

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; never full hypothetical type validity. */
+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 === 'simple' || 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/composeCanonicalGraph.d.ts

@@ -0,0 +1,69 @@
+import type { AttributeUseNode, ComplexTypeNode, Facet, NodeId, Reference, ValueConstraint, Wildcard } from "./canonicalGraph.js";
+import type { ExpandedName } from "../loader/orderedSyntax.js";
+import type { ResolvedGraph, SemanticLimits } from "./resolveCanonicalGraph.js";
+import type { NamespaceConstraint } from "./wildcardAlgebra.js";
+export { namespaceIntersection, namespaceSubset, namespaceUnion, wildcardNamespaces } from "./wildcardAlgebra.js";
+export type { NamespaceConstraint } from "./wildcardAlgebra.js";
+export type WildcardProcess = Wildcard["processContents"];
+export type WildcardPlan = Readonly<{
+    namespace: NamespaceConstraint;
+    processContents: WildcardProcess | Readonly<{
+        kind: "assessment-required";
+        alternatives: readonly WildcardProcess[];
+    }>;
+    sources: readonly NodeId[];
+}>;
+export type AttributePlan = Readonly<{
+    name: ExpandedName;
+    declaration: NodeId;
+    type: Reference;
+    use: AttributeUseNode["use"];
+    value?: ValueConstraint;
+    sources: readonly NodeId[];
+}>;
+/** These obligations are not a schema-validity certificate. #179 must discharge them before planning. */
+export type DerivationObligation = Readonly<{
+    kind: "particle-extension" | "particle-restriction" | "attribute-type-restriction" | "attribute-extension-equivalence" | "fixed-value-equivalence" | "wildcard-expressibility" | "group-local-wildcard-process" | "scalar-derivation" | "mixed-content";
+    owner: NodeId;
+    base?: NodeId | Reference | ValueConstraint;
+    local?: NodeId | Reference | ValueConstraint;
+}>;
+export type ComposedType = Readonly<{
+    id: NodeId;
+    /** Sequence of declared root particles, not flattened children or occurrence summaries. */
+    content: readonly ContentContribution[];
+    mixed: boolean;
+    attributes: readonly AttributePlan[];
+    wildcard?: WildcardPlan;
+    scalar?: Readonly<{
+        base: Reference;
+        layers: readonly Readonly<{
+            owner: NodeId;
+            facets: readonly Facet[];
+            inlineType?: Reference;
+        }>[];
+    }>;
+    derivation?: ComplexTypeNode["derivation"];
+    obligations: readonly DerivationObligation[];
+    assessment: "requires-schema-assessment";
+}>;
+export type ComposedGraph = Readonly<{
+    resolved: ResolvedGraph;
+    types: readonly ComposedType[];
+    metrics: Readonly<{
+        steps: number;
+    }>;
+}>;
+export type ContentContribution = Readonly<{
+    kind: "particle";
+    particle: NodeId;
+} | {
+    kind: "builtin";
+    reference: Reference;
+}>;
+/** Extension concatenates root contributions, retaining each root's exact declared occurrence. */
+export declare function extendContent(base: readonly ContentContribution[], local: NodeId | undefined): readonly ContentContribution[];
+/** Restriction replaces child content, including the empty case. No removed base particle is appended. */
+export declare function restrictContent(local: NodeId | undefined): readonly ContentContribution[];
+export declare function composeCanonicalGraph(resolved: ResolvedGraph, limits?: SemanticLimits): ComposedGraph;
+//# sourceMappingURL=composeCanonicalGraph.d.ts.map

package/dist/compiler/composeCanonicalGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composeCanonicalGraph.d.ts","sourceRoot":"","sources":["../../src/compiler/composeCanonicalGraph.ts"],"names":[],"mappings":"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"}