@techspokes/typescript-wsdl-client 1.1.5 → 1.1.8

package/dist/compiler/finiteRe01Verification.js

@@ -1,7 +1,8 @@
 import { assertSemanticContext, contextsShareRequest, isSemanticCandidateOf, SemanticContextAccessError } from './semanticContext.js';
 import { checkSchemaDocumentSyntax } from './schemaDocumentSyntax.js';
-import { checkComponentConstruction, assertComponentConstruction } from './schemaConstructionAssessment.js';
-import { checkCandidateCorrespondence, assertCandidateCorrespondence, re01Ancestor } from './re01CandidateCorrespondence.js';
+import { checkComponentConstruction, assertComponentConstruction, checkSimpleRestrictionPredicate, assertSimpleRestrictionPredicate } from './schemaConstructionAssessment.js';
+import { assertStandardElementConstruction } from './standardSchemaConstruction.js';
+import { checkCandidateCorrespondence, assertCandidateCorrespondence, re01Ancestor, checkAdditiveSimpleProperties, assertAdditiveSimpleProperties } from './re01CandidateCorrespondence.js';
 import { immediateTypeBase } from './schemaTypeRelations.js';
 import { XSD_NAMESPACE } from '../loader/orderedSyntax.js';
 import { RE01_DERIVATION_DOMAIN } from './re01TypeProperties.js';
@@ -11,8 +12,10 @@ import { resolveSemanticType, semanticTypeKey } from './schemaTypeIdentity.js';
 import { checkIdentityConstraintFormation } from './schemaIdentityConstraints.js';
 import { deriveActualComplexContent, deriveOriginalComplexPropertyContent } from './complexTypeContent.js';
 import { assertSemanticParticleView, prepareSemanticParticleView } from './particleSemanticView.js';
+import { prepareAdditiveRestrictionRepresentative, prepareAdditiveExtensionMiddle } from './re01CandidateAssignments.js';
 const issued = new WeakMap();
 const issuedPrimitive = new WeakMap();
+const proofContexts = new WeakMap();
 class VerificationAbort extends Error {
     result;
     constructor(result) {
@@ -265,6 +268,10 @@ function createNativeFrontierOwner(actual) {
                 throw new VerificationAbort(result.kind === 'resource-limit' ? result
                     : { ...result, contextId: result.contextId ?? context.contextId });
             assertComponentConstruction(context, result);
+            for (const standard of result.standardDependencies) {
+                charge();
+                assertStandardElementConstruction(context, standard);
+            }
             for (const pending of result.obligations)
                 rejectPending(context, pending, requireTypes);
             charge(4 + id.length);
@@ -395,13 +402,49 @@ function createNativeFrontierOwner(actual) {
             throw error;
         }
     };
-    const validateAggregate = (proof) => {
+    const inspectAdditive = (context) => {
+        assertSemanticContext(context);
+        if (!contextsShareRequest(actual, context) || !isSemanticCandidateOf(actual, context))
+            return fail('additive-context', 'An authenticated direct child of the actual request is required');
+        const deferredStart = deferred.length, typedStart = typedDependencies.length;
+        for (const id of actual.members) {
+            charge(16 + id.length);
+            const before = actual.lookup(id), after = context.lookup(id);
+            if (before.kind !== 'found' || after.kind !== 'found' || before.node !== after.node
+                || actual.rawTypeProperties(id) !== context.rawTypeProperties(id)
+                || actual.rawSimpleTypeProperties(id) !== context.rawSimpleTypeProperties(id)
+                || actual.rawElementProperties(id) !== context.rawElementProperties(id)
+                || actual.rawAttributeProperties(id) !== context.rawAttributeProperties(id)
+                || actual.rawAttributeGroupProperties(id) !== context.rawAttributeGroupProperties(id)
+                || actual.rawParticleWildcardProperties(id) !== context.rawParticleWildcardProperties(id)
+                || actual.owner(id) !== context.owner(id))
+                return fail('additive-original-preservation', 'An additive construction changed an original component or scope', 'invalid-evidence', context, id);
+        }
+        checkNotations(context);
+        charge(4);
+        const roots = [];
+        for (const id of context.members) {
+            charge(2 + id.length);
+            if (actual.lookup(id).kind !== 'found') {
+                charge();
+                roots.push(id);
+            }
+        }
+        return publish(close(context, roots), undefined, deferredStart, typedStart);
+    };
+    const validateAggregate = (proof, additive = []) => {
         // A research session can inspect rejected alternatives. Only the selected
         // forest contributes aggregate debts; context handles remain exact.
         charge(4 + proof.length * 3);
         const selected = new Set([actual.contextId]);
         for (const step of proof)
             selected.add(step.contextId);
+        for (const context of additive) {
+            charge(4 + context.contextId.length);
+            if (closures.get(context.contextId)?.context !== context)
+                return fail('additive-closure', 'Selected additive context lacks its native checked closure');
+            selected.add(context.contextId);
+        }
         const selectedClosure = (contextId) => selected.has(contextId) ? closures.get(contextId) : undefined;
         // A late property-only fact cannot reopen a closed FULL frontier. Its
         // actual typed support must already be present in that exact context.
@@ -508,7 +551,13 @@ function createNativeFrontierOwner(actual) {
                     return fail(pending.obligation.rule, 'A correspondence scalar premise lacks concrete aggregate discharge', 'unresolved', actual, pending.obligation.component);
             }
     };
-    return { actualClosure, actualNotations, actualFrontier, inspect, primitive, closures, notationReceipts, validateAggregate };
+    const retainActualDependencies = (dependencies) => {
+        for (const dependency of dependencies) {
+            charge(4 + dependency.contextId.length);
+            typedDependencies.push(Object.freeze({ from: actual, dependency }));
+        }
+    };
+    return { actualClosure, actualNotations, actualFrontier, inspect, inspectAdditive, primitive, closures, notationReceipts, validateAggregate, retainActualDependencies };
 }
 const frontierOwners = new WeakMap();
 /** Internal native collection authority shared by supplied verification and research construction. */
@@ -550,6 +599,16 @@ export function assertFinitePrimitiveReceipt(actual, receipt) {
     if (issuedPrimitive.get(receipt) !== actual)
         throw new TypeError('Unauthenticated finite primitive receipt');
 }
+/** Inspect the exact checked contexts in proof order; diagnostic context IDs never reconstruct authority. */
+export function inspectFiniteProofContexts(actual, receipt) {
+    assertSemanticContext(actual);
+    if (issued.get(receipt) !== actual && issuedPrimitive.get(receipt) !== actual)
+        throw new TypeError('Unauthenticated finite proof contexts');
+    const contexts = proofContexts.get(receipt);
+    if (!contexts)
+        throw new TypeError('Checked finite proof contexts unavailable');
+    return contexts;
+}
 export function verifyFiniteRe01Evidence(actual, target, supplied) {
     return verifyFiniteRe01EvidenceWithFrontier(actual, target, supplied);
 }
@@ -786,6 +845,8 @@ export function verifyFiniteRe01EvidenceWithFrontier(actual, target, supplied, p
                 actualComponents: actualClosure.components, actualPrimitiveNoChange: Object.freeze(actualPrimitiveNoChange), proof: Object.freeze(proof),
                 actualScalarSlots: actualClosure.scalarSlots,
                 actualNotations, actualIdentityConstraints: actualClosure.identityConstraints };
+            charge(32 + proof.length * 8);
+            const contexts = Object.freeze(proof.map(step => { charge(8); return nodes.get(step.evidence).context; }));
             if (primitiveRoot) {
                 charge(12);
                 const result = Object.freeze({ ...common, kind: 'checked-primitive',
@@ -793,12 +854,14 @@ export function verifyFiniteRe01EvidenceWithFrontier(actual, target, supplied, p
                     claims: Object.freeze({ actualObligations: 'checked', primitiveTarget: 'checked', universalCoverage: false,
                         completeNegativeAnswer: false, searchTermination: false }) });
                 issuedPrimitive.set(result, actual);
+                proofContexts.set(result, contexts);
                 return result;
             }
             const result = Object.freeze({ ...common, kind: 'checked-candidate',
                 scope: 'supplied-construction-and-finite-evidence', root: root.id,
                 claims: Object.freeze({ actualObligations: 'checked', suppliedCandidate: 'checked', universalCoverage: false, completeNegativeAnswer: false, searchTermination: false }) });
             issued.set(result, actual);
+            proofContexts.set(result, contexts);
             return result;
         }
         catch (error) {
@@ -828,3 +891,327 @@ export function verifyDirectActualSchema(actual) {
         }
     });
 }
+const extensionChains = new WeakMap();
+/** Authenticate actual-only extension ancestry; saved or copied receipt fields grant no authority. */
+export function assertExtensionChainReceipt(actual, receipt) {
+    assertSemanticContext(actual);
+    if (extensionChains.get(receipt) !== actual)
+        throw new TypeError('Fresh matching extension-chain receipt required');
+}
+/** Close actual RE01 duties whose ancestry has no restriction after the designated ancestor.
+ * @remarks The 2004 Structures cos-ct-extends.1.5 note identifies this sufficient case as trivial.
+ *   All component premises and aggregate dependencies are still checked by the existing native owner.
+ *   No candidate context, endpoint replacement or primitive relabelling is used. The existing direct preview is unchanged.
+ * @returns Authenticated actual-only closure, an unresolved duty inventory, or the native failure.
+ * @throws TypeError For a non-actual context. Explicit request exhaustion remains sticky.
+ * @see https://www.w3.org/TR/2004/REC-xmlschema-1-20041028/#cos-ct-extends
+ */
+export function verifyExtensionChainActualSchema(actual) {
+    assertSemanticContext(actual);
+    if (actual.kind !== 'actual')
+        throw new TypeError('Actual source context required');
+    const { budget } = actual;
+    return budget.guard(() => {
+        try {
+            const owner = createNativeFrontierOwner(actual);
+            const extensionOnly = [], unresolved = [];
+            for (const requirement of owner.actualFrontier.requirements) {
+                budget.chargeWork(8);
+                if (requirement.primitive)
+                    continue;
+                let reference = { kind: 'local', target: requirement.target };
+                const seen = new Set();
+                let established = false;
+                while (true) {
+                    budget.chargeWork(8);
+                    const resolved = resolveSemanticType(actual, reference);
+                    if (resolved.kind !== 'component' || resolved.node.kind !== 'complexType')
+                        break;
+                    const node = resolved.node;
+                    budget.chargeWork(4 + node.id.length);
+                    if (seen.has(node.id))
+                        break;
+                    seen.add(node.id);
+                    const next = immediateTypeBase(actual, reference);
+                    if (next.kind === 'resource-limit')
+                        throw new VerificationAbort(next);
+                    if (next.kind !== 'checked' || !next.value)
+                        break;
+                    const base = resolveSemanticType(actual, next.value);
+                    // @why The first derivation from anyType may be a restriction; every later edge must extend.
+                    if (base.kind === 'builtin' && base.name.namespace === XSD_NAMESPACE && base.name.local === 'anyType') {
+                        const designated = resolveSemanticType(actual, requirement.ancestor);
+                        established = designated.kind === 'component' && designated.node === node;
+                        break;
+                    }
+                    if (node.derivation?.kind !== 'extension')
+                        break;
+                    reference = next.value;
+                }
+                budget.chargeWork(2 + requirement.target.length);
+                (established ? extensionOnly : unresolved).push(requirement.target);
+            }
+            owner.validateAggregate([]);
+            budget.chargeWork(64 + extensionOnly.length + unresolved.length);
+            const result = Object.freeze({ kind: unresolved.length ? 'inconclusive-extension-chain' : 'checked-extension-chain',
+                basis: 'XSD-2004-extension-only-ancestry', frontier: owner.actualFrontier,
+                extensionOnly: Object.freeze(extensionOnly), unresolved: Object.freeze(unresolved) });
+            extensionChains.set(result, actual);
+            return result;
+        }
+        catch (error) {
+            if (error instanceof VerificationAbort)
+                return error.result;
+            throw error;
+        }
+    });
+}
+const additiveLocalClosures = new WeakMap();
+/** Authenticate the exact native local closure; neither target correspondence nor actual RE01 is asserted. */
+export function assertAdditiveLocalClosure(actual, receipt) {
+    assertSemanticContext(actual);
+    if (additiveLocalClosures.get(receipt) !== actual)
+        throw new TypeError('Fresh matching additive local closure required');
+    if (receipt.nativeProperties)
+        assertAdditiveSimpleProperties(actual, receipt.frontier.context, receipt.nativeProperties);
+}
+/** Check fresh extension/restriction representatives and their complete native dependencies without endpoint shadowing.
+ * @remarks Every original component and scope owner remains unchanged. This establishes local construction and
+ *   aggregate discharge only; the representative-to-target correspondence and actual RE01 remain unassessed.
+ * @returns An authenticated local closure or explicit native unavailability/resource failure; never admission.
+ */
+export function verifyAdditiveRestrictionLocalClosure(actual, target) {
+    assertSemanticContext(actual);
+    const b = actual.budget;
+    return b.guard(() => {
+        try {
+            const owner = createNativeFrontierOwner(actual);
+            const prepared = prepareAdditiveRestrictionRepresentative(actual, target);
+            if (prepared.kind === 'resource-limit')
+                return prepared;
+            if (prepared.kind !== 'prepared-additive-restriction')
+                return Object.freeze({ kind: 'unresolved', rule: 'additive-preparation',
+                    component: target, contextId: actual.contextId, message: 'The limited additive construction was unavailable' });
+            const frontier = owner.inspectAdditive(prepared.context);
+            if (frontier.requirements.some(requirement => !requirement.primitive))
+                return Object.freeze({ kind: 'unresolved',
+                    rule: 'additive-nonprimitive-dependency', component: target, contextId: prepared.context.contextId,
+                    message: 'The additive local closure still requires a nonprimitive derivation proof' });
+            // Preparation debts are additional obligations, never successful producer annotations.
+            if (prepared.scalarObligations.length)
+                return Object.freeze({ kind: 'unresolved', rule: 'additive-preparation-scalar-obligations',
+                    component: target, contextId: actual.contextId, message: 'The proposal has scalar preparation obligations outside this local route' });
+            owner.retainActualDependencies(prepared.typeDependencies);
+            let nativeProperties;
+            if (prepared.context.rawTypeProperties(prepared.representative)?.content.kind === 'simple') {
+                const properties = checkAdditiveSimpleProperties(actual, prepared.context, target, prepared.intermediate, prepared.representative);
+                if (properties.kind !== 'checked-additive-simple-properties')
+                    return properties;
+                assertAdditiveSimpleProperties(actual, prepared.context, properties);
+                if (properties.scalarObligations.length)
+                    return Object.freeze({ kind: 'unresolved', rule: 'additive-property-scalar-obligations',
+                        component: target, contextId: actual.contextId, message: 'Native property correspondence retains scalar obligations' });
+                owner.retainActualDependencies(properties.typeDependencies);
+                nativeProperties = properties;
+            }
+            owner.validateAggregate([], [prepared.context]);
+            b.chargeWork(128);
+            const result = Object.freeze({ kind: 'checked-additive-local-closure',
+                actual: owner.actualFrontier, frontier, target, intermediate: prepared.intermediate, representative: prepared.representative,
+                ...(nativeProperties ? { nativeProperties } : {}),
+                targetCorrespondence: 'unassessed', actualRe01: 'unassessed', admitted: false });
+            additiveLocalClosures.set(result, actual);
+            return result;
+        }
+        catch (error) {
+            if (error instanceof VerificationAbort)
+                return error.result;
+            throw error;
+        }
+    });
+}
+const additiveSimplePredicates = new WeakMap();
+const simpleExtensionConstructions = new WeakMap();
+/** Authenticate the complete native premises; saved fields grant neither source nor runtime admission. */
+export function assertSimpleExtensionConstruction(actual, receipt) {
+    assertSemanticContext(actual);
+    if (simpleExtensionConstructions.get(receipt) !== actual)
+        throw new TypeError('Fresh matching simple-extension construction required');
+    assertExtensionChainReceipt(actual, receipt.complex);
+    for (const predicate of receipt.simple)
+        assertAdditiveSimplePredicate(actual, predicate);
+}
+/** Check the sufficient simple-content extension spine and its original-target alternative restriction.
+ * @remarks Complex ancestry must consist solely of simple-content extensions and terminate at a simple type.
+ *   The designated ancestor is exactly anySimpleType; its fresh extension is independently constructed and
+ *   all original target restriction predicates and aggregate dependencies pass without replacing original bindings.
+ *   This collects native premises; the dated in-principle interpretation remains a separate qualification duty.
+ * @returns Authenticated premises or unresolved targets/native failure, never admission or a general negative answer.
+ * @see https://www.w3.org/TR/2004/REC-xmlschema-1-20041028/#cos-ct-extends
+ */
+export function verifySimpleExtensionConstruction(actual) {
+    assertSemanticContext(actual);
+    const b = actual.budget;
+    return b.guard(() => {
+        const complex = verifyExtensionChainActualSchema(actual);
+        if (!('frontier' in complex))
+            return complex;
+        const simple = [], unresolved = [];
+        for (const target of complex.unresolved) {
+            b.chargeWork(16 + target.length);
+            const designated = re01Ancestor(actual, target);
+            if (designated.kind === 'resource-limit')
+                return designated;
+            const ancestor = designated.kind === 'checked' ? resolveSemanticType(actual, designated.ancestor) : undefined;
+            let supported = ancestor?.kind === 'builtin' && ancestor.name.namespace === XSD_NAMESPACE && ancestor.name.local === 'anySimpleType';
+            let reference = { kind: 'local', target };
+            const seen = new Set();
+            while (supported) {
+                b.chargeWork(16);
+                const selected = resolveSemanticType(actual, reference);
+                if (selected.kind === 'builtin') {
+                    supported = selected.name.namespace === XSD_NAMESPACE && selected.name.local !== 'anyType';
+                    break;
+                }
+                if (selected.kind !== 'component') {
+                    supported = false;
+                    break;
+                }
+                if (selected.node.kind === 'simpleType')
+                    break;
+                if (selected.node.kind !== 'complexType' || seen.has(selected.node.id)
+                    || selected.node.derivation?.kind !== 'extension') {
+                    supported = false;
+                    break;
+                }
+                b.chargeWork(4 + selected.node.id.length);
+                seen.add(selected.node.id);
+                const content = deriveActualComplexContent(actual, selected.node.id);
+                if (content.kind === 'resource-limit')
+                    return content;
+                if (content.kind !== 'checked' || content.view.content.kind !== 'simple') {
+                    supported = false;
+                    break;
+                }
+                const next = immediateTypeBase(actual, reference);
+                if (next.kind === 'resource-limit')
+                    return next;
+                if (next.kind !== 'checked' || !next.value) {
+                    supported = false;
+                    break;
+                }
+                reference = next.value;
+            }
+            if (!supported) {
+                unresolved.push(target);
+                continue;
+            }
+            const paired = verifyAdditiveSimplePredicate(actual, target);
+            if (paired.kind === 'resource-limit')
+                return paired;
+            if (paired.kind !== 'checked-additive-simple-predicate') {
+                unresolved.push(target);
+                continue;
+            }
+            assertAdditiveSimplePredicate(actual, paired);
+            const middle = paired.frontier.context.rawTypeProperties(paired.intermediate);
+            const base = middle ? resolveSemanticType(paired.frontier.context, middle.derivation.base) : undefined;
+            if (middle?.derivation.method !== 'extension' || base?.kind !== 'builtin'
+                || base.name.namespace !== XSD_NAMESPACE || base.name.local !== 'anySimpleType') {
+                unresolved.push(target);
+                continue;
+            }
+            b.chargeWork(4);
+            simple.push(paired);
+        }
+        b.chargeWork(64 + unresolved.length + simple.length);
+        const result = Object.freeze({
+            kind: unresolved.length ? 'inconclusive-simple-extension-construction' : 'checked-simple-extension-construction',
+            basis: 'XSD-2004-simple-extension-spine', complex, simple: Object.freeze(simple), unresolved: Object.freeze(unresolved),
+            datedInterpretation: 'unassessed', admitted: false
+        });
+        simpleExtensionConstructions.set(result, actual);
+        return result;
+    });
+}
+/** Authenticate the actual-target predicate and fresh-middle closure; this grants no dated or runtime admission. */
+export function assertAdditiveSimplePredicate(actual, receipt) {
+    assertSemanticContext(actual);
+    if (additiveSimplePredicates.get(receipt) !== actual)
+        throw new TypeError('Fresh matching additive simple predicate required');
+    assertSimpleRestrictionPredicate(receipt.frontier.context, receipt.predicate);
+}
+/** Close a fresh middle and evaluate the original target's simple restriction predicate without a renamed representative.
+ * @remarks All original bindings are preserved and all consumed native dependencies are aggregated. The standards
+ *   interpretation of the alternative derivation remains unassessed; this is not actual RE01 or source eligibility.
+ * @returns A fresh native paired predicate/closure or explicit unavailability/resource failure.
+ */
+export function verifyAdditiveSimplePredicate(actual, target) {
+    assertSemanticContext(actual);
+    const b = actual.budget;
+    return b.guard(() => {
+        try {
+            const owner = createNativeFrontierOwner(actual);
+            const prepared = prepareAdditiveExtensionMiddle(actual, target);
+            if (prepared.kind === 'resource-limit')
+                return prepared;
+            if (prepared.kind !== 'prepared-additive-middle')
+                return Object.freeze({ kind: 'unresolved', rule: 'additive-middle-preparation',
+                    component: target, contextId: actual.contextId, message: 'The limited additive middle was unavailable' });
+            for (const id of prepared.context.members) {
+                b.chargeWork(4 + id.length);
+                if (actual.lookup(id).kind === 'found')
+                    continue;
+                const found = prepared.context.lookup(id);
+                let valid = found.kind === 'found';
+                if (found.kind === 'found' && id === prepared.intermediate)
+                    valid = found.node.kind === 'complexType';
+                else if (found.kind === 'found' && (found.node.kind === 'attribute' || found.node.kind === 'attributeUse')) {
+                    valid = prepared.context.owner(id) === prepared.intermediate;
+                    if (found.node.kind === 'attribute')
+                        valid &&= found.node.value === undefined;
+                    else {
+                        const declaration = prepared.context.resolve(found.node.declaration);
+                        valid &&= declaration.kind === 'found' && declaration.node.kind === 'attribute'
+                            && (declaration.node.identity.kind === 'global' || prepared.context.owner(declaration.node.id) === prepared.intermediate);
+                    }
+                }
+                else
+                    valid = false;
+                if (!valid)
+                    return Object.freeze({ kind: 'unresolved', rule: 'additive-owned-attribute-scope', component: id,
+                        contextId: prepared.context.contextId, message: 'The simple middle family requires fresh-owned local declarations and uses' });
+            }
+            const frontier = owner.inspectAdditive(prepared.context);
+            if (frontier.requirements.some(requirement => !requirement.primitive))
+                return Object.freeze({ kind: 'unresolved',
+                    rule: 'additive-middle-nonprimitive-dependency', component: target, contextId: prepared.context.contextId,
+                    message: 'The additive middle has an unresolved nonprimitive dependency' });
+            const predicate = checkSimpleRestrictionPredicate(prepared.context, target, prepared.intermediate);
+            if (predicate.kind === 'resource-limit')
+                return predicate;
+            if (predicate.kind !== 'checked-simple-restriction-predicate')
+                return Object.freeze({ kind: 'unresolved', rule: predicate.rule,
+                    component: target, contextId: prepared.context.contextId, message: 'The actual-target simple restriction predicate was unavailable' });
+            assertSimpleRestrictionPredicate(prepared.context, predicate);
+            if (prepared.scalarObligations.length || predicate.scalarObligations.length)
+                return Object.freeze({ kind: 'unresolved',
+                    rule: 'additive-predicate-scalar-obligations', component: target, contextId: prepared.context.contextId,
+                    message: 'The additive predicate retains scalar obligations outside this local strategy' });
+            owner.retainActualDependencies(prepared.typeDependencies);
+            owner.retainActualDependencies(predicate.typeDependencies);
+            owner.validateAggregate([], [prepared.context]);
+            b.chargeWork(128);
+            const result = Object.freeze({ kind: 'checked-additive-simple-predicate',
+                actual: owner.actualFrontier, frontier, target, intermediate: prepared.intermediate, predicate,
+                actualRe01: 'unassessed', datedInterpretation: 'unassessed', admitted: false });
+            additiveSimplePredicates.set(result, actual);
+            return result;
+        }
+        catch (error) {
+            if (error instanceof VerificationAbort)
+                return error.result;
+            throw error;
+        }
+    });
+}

package/dist/compiler/generateCatalog.d.ts

@@ -18,4 +18,3 @@ import type { CompiledCatalog } from "./schemaCompiler.js";
  * @param {CompiledCatalog} compiled - The compiled WSDL catalog to write
  */
 export declare function generateCatalog(outFile: string, compiled: CompiledCatalog): void;
-//# sourceMappingURL=generateCatalog.d.ts.map

package/dist/compiler/graphTraversal.d.ts

@@ -8,4 +8,3 @@ export type ReferenceSlot = Readonly<{
 export declare function mapNodeReferences(node: GraphNode, map: (reference: Reference) => Reference): GraphNode;
 export declare function referenceSlots(node: GraphNode): readonly ReferenceSlot[];
 export declare function containedNodes(node: GraphNode): readonly NodeId[];
-//# sourceMappingURL=graphTraversal.d.ts.map

package/dist/compiler/hypotheticalScopedIdentity.d.ts

@@ -20,4 +20,3 @@ export declare function allocateHypotheticalScopedIdentity(owner: string, role:
     }>;
     candidatesTried: bigint;
 }>;
-//# sourceMappingURL=hypotheticalScopedIdentity.d.ts.map

package/dist/compiler/occurrenceAnalysis.d.ts

@@ -4,6 +4,7 @@ import type { ComposedGraph } from "./composeCanonicalGraph.js";
 import { SemanticError } from "./resolveCanonicalGraph.js";
 import type { SemanticLimits } from "./resolveCanonicalGraph.js";
 import type { ResourceLimitFailure, SemanticBudget } from './semanticBudget.js';
+import type { StandardSchemaElementDeclaration } from './standardSchemaComponents.js';
 export type Bound = Occurs["max"];
 export declare const ZERO_OCCURS: Occurs;
 /** Charge operand and result work before BigInt conversion or arithmetic allocation. */
@@ -61,5 +62,5 @@ export declare function analyzeOccurrences(composed: ComposedGraph, limits: Sema
     /** Selected semantic projection data; omission preserves canonical analysis's qualified ANY default. */
     budget: SemanticBudget;
     wildcardRealization?: ReadonlyMap<NodeId, boolean>;
+    standardElements?: ReadonlyMap<NodeId, StandardSchemaElementDeclaration>;
 }>): AnalysisResult | ResourceLimitFailure;
-//# sourceMappingURL=occurrenceAnalysis.d.ts.map

package/dist/compiler/occurrenceAnalysis.js

@@ -1,6 +1,7 @@
 /** Exact S06 summaries of child particles. Intervals never describe the full language. */
 import { deepFreeze } from "./canonicalGraph.js";
 import { referenceTarget, SemanticError, semanticBudget } from "./resolveCanonicalGraph.js";
+import { inspectStandardSchemaElement } from './standardSchemaComponents.js';
 export const ZERO_OCCURS = Object.freeze({ min: "0", max: "0" });
 const ONE_OCCURS = Object.freeze({ min: "1", max: "1" });
 /** Charge operand and result work before BigInt conversion or arithmetic allocation. */
@@ -50,9 +51,9 @@ export function occurrenceAlgebra(charge) {
     };
 }
 export function analyzeOccurrences(composed, limits = {}, accounting) {
-    return accounting ? accounting.budget.guard(() => analyzeOwnedOccurrences(composed, limits, accounting.budget, accounting.wildcardRealization)) : analyzeOwnedOccurrences(composed, limits);
+    return accounting ? accounting.budget.guard(() => analyzeOwnedOccurrences(composed, limits, accounting.budget, accounting.wildcardRealization, accounting.standardElements)) : analyzeOwnedOccurrences(composed, limits);
 }
-function analyzeOwnedOccurrences(composed, limits, request, wildcardRealization) {
+function analyzeOwnedOccurrences(composed, limits, request, wildcardRealization, standardElements) {
     let current;
     const allocate = (units) => request?.chargeWork(units);
     try {
@@ -71,6 +72,22 @@ function analyzeOwnedOccurrences(composed, limits, request, wildcardRealization)
             allocate(2);
             nodes.set(n.id, n);
         }
+        for (const [id, declaration] of standardElements ?? []) {
+            budget.step();
+            allocate(4);
+            inspectStandardSchemaElement(declaration);
+            if (id !== declaration.id || nodes.has(id))
+                throw new SemanticError('unsupported-capability', 'Conflicting acquired standard occurrence declaration', id);
+        }
+        const element = (id) => {
+            const node = nodes.get(id);
+            if (node?.kind === 'element')
+                return node;
+            const declaration = standardElements?.get(id);
+            if (!declaration)
+                throw new SemanticError('invalid-schema', 'Element particle requires an element declaration', id, current?.context.source);
+            return inspectStandardSchemaElement(declaration);
+        };
         const summaries = new Map(), active = new Set();
         const algebra = occurrenceAlgebra(() => budget.step(current));
         const get = (id) => nodes.get(id) ?? (() => { throw new SemanticError("invalid-schema", "Missing structural component", id, current?.context.source); })();
@@ -86,7 +103,7 @@ function analyzeOwnedOccurrences(composed, limits, request, wildcardRealization)
                 for (const value of [reference.role, reference.name.namespace, reference.name.local])
                     for (let i = 0; i < value.length; i++)
                         budget.step(owner);
-            return referenceTarget(reference, nodes, owner);
+            return referenceTarget(reference, nodes, owner, standardElements);
         };
         const copyIds = (a, b) => {
             allocate(1);
@@ -170,8 +187,9 @@ function analyzeOwnedOccurrences(composed, limits, request, wildcardRealization)
             }
             if (node.term.kind === "element") {
                 const id = target(node.term.declaration, node);
-                if (!id || get(id).kind !== "element")
+                if (!id)
                     throw new SemanticError("invalid-schema", "Element particle requires an element declaration", node.id, node.context.source);
+                element(id);
             }
             allocate(1);
             return [];
@@ -203,9 +221,7 @@ function analyzeOwnedOccurrences(composed, limits, request, wildcardRealization)
                 const node = f.node;
                 let content;
                 if (node.term.kind === "element") {
-                    const id = target(node.term.declaration, node), declaration = get(id);
-                    if (declaration.kind !== "element")
-                        throw new Error("Checked element target changed");
+                    const id = target(node.term.declaration, node), declaration = element(id);
                     allocate(20);
                     content = { nullable: false, hasRealization: true, elements: [{ name: declaration.name, occurs: ONE_OCCURS, declarations: [id], particles: [node.id] }], wildcard: ZERO_OCCURS, effectiveTotalRange: ONE_OCCURS, schemaEmptiable: false };
                 }

package/dist/compiler/originalSourceMembership.d.ts

@@ -3,4 +3,3 @@ import type { GraphNode, NodeId } from './canonicalGraph.js';
 import type { SemanticBudget } from './semanticBudget.js';
 /** Called on the private immutable original graph inside the request guard. */
 export declare function computeOriginalSourceAbsence(input: readonly GraphNode[], budget: SemanticBudget): ReadonlySet<NodeId>;
-//# sourceMappingURL=originalSourceMembership.d.ts.map

package/dist/compiler/particleAttribution.d.ts

@@ -14,4 +14,3 @@ export type AttributionResult = Readonly<{
 }> | RelationFailure | ResourceLimitFailure;
 /** Counted iteration preserves each leaf incidence tag; shared child edges remain distinct. */
 export declare function checkParticleAttribution(context: SemanticContext, view: SemanticParticleView): AttributionResult;
-//# sourceMappingURL=particleAttribution.d.ts.map

package/dist/compiler/particleAttribution.js

@@ -81,6 +81,13 @@ export function checkParticleAttribution(context, view) {
                         namespaces.add(ns);
                     }
                 }
+                else if (p.standardElement) {
+                    // Fixed acquired declarations block substitution; their dependency is
+                    // checked separately by native standard-component construction.
+                    charge(3);
+                    names.push(p.standardElement.name);
+                    addName(p.standardElement.name);
+                }
                 else {
                     const element = p.element;
                     if (element.identity.kind === 'global') {
@@ -152,6 +159,19 @@ export function checkParticleAttribution(context, view) {
                 counters.push({ min, max, digits: Math.max(p.particle.occurs.min.length, max === undefined ? 1 : p.particle.occurs.max.length) });
                 facts.set(p, { counter });
             }
+            // @why Disjoint full alphabet quotients admit at most one leaf incidence for any next QName, independently of counter reachability.
+            charge(2);
+            const attributedTokens = new Set();
+            let disjoint = true;
+            for (const label of labels)
+                for (const token of label.tokens) {
+                    charge(3);
+                    if (attributedTokens.has(token))
+                        disjoint = false;
+                    attributedTokens.add(token);
+                }
+            if (disjoint)
+                return done(true);
             charge(2);
             const states = [];
             const state = () => { charge(7); const id = states.length; states.push({ epsilon: [], consuming: [] }); return id; };

package/dist/compiler/particleDeclarationConsistency.d.ts

@@ -21,4 +21,3 @@ export type ElementConsistencyResult = Readonly<{
  * Type/declaration validity remains an explicit separately owned prerequisite.
  */
 export declare function checkElementDeclarationsConsistent(context: SemanticContext, roots: readonly NodeId[]): ElementConsistencyResult;
-//# sourceMappingURL=particleDeclarationConsistency.d.ts.map

package/dist/compiler/particleDeclarationConsistency.js

@@ -84,6 +84,15 @@ export function checkElementDeclarationsConsistent(context, roots) {
             const declared = (particle) => {
                 if (particle.term.kind !== 'element')
                     return new Map();
+                const selected = context.resolve(particle.term.declaration);
+                if (selected.kind === 'standard-element') {
+                    const declaration = selected.declaration;
+                    budget.chargeWork(48 + 6 * (declaration.name.namespace.length + declaration.name.local.length));
+                    const name = JSON.stringify([declaration.name.namespace, declaration.name.local]);
+                    // The fixed schema element's type is anonymous. Repeated positions
+                    // still require the dated EDC top-level named-type premise.
+                    return new Map([[name, { declaration: declaration.id, count: 1 }]]);
+                }
                 const declaration = target(particle.term.declaration, particle.id);
                 if (declaration.kind !== 'element')
                     return unresolved(particle.id, 'Element particle does not reference an element declaration');

package/dist/compiler/particleExtension.d.ts

@@ -19,4 +19,3 @@ export type ParticleExtensionResult = Readonly<{
     identityConstraintDependencies: readonly IdentityConstraintDependency[];
 }> | RelationFailure | ScalarFailure | AttributeFailure | ResourceLimitFailure;
 export declare function checkRawParticleExtension(context: SemanticContext, derived: ParticleContentView, base: ParticleContentView): ParticleExtensionResult;
-//# sourceMappingURL=particleExtension.d.ts.map