@techspokes/typescript-wsdl-client 1.1.5 → 1.2.0

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/legacyDeclarations.d.ts

@@ -0,0 +1,26 @@
+import { type NodeId } from "./declarationIdentity.js";
+export type LegacyGlobal = Readonly<{
+    kind: "complex" | "simple" | "element";
+    name: string;
+    ns: string;
+    node: unknown;
+    prefixes: Record<string, string>;
+}>;
+/** Index legacy declarations without importing the checked loader's source or acceptance policies.
+ * @constraints Paths count equal role/name peers within a parent, never text nodes or unrelated global declarations.
+ * @constraints Name allocation is local to this compilation; independent catalogs still require conservative conflict checks.
+ */
+export declare class LegacyDeclarations {
+    private readonly declarations;
+    private readonly names;
+    private readonly surfaces;
+    private readonly inlineByOwner;
+    constructor(globals: readonly LegacyGlobal[]);
+    type(ns: string, name: string): NodeId;
+    element(ns: string, name: string): NodeId;
+    surface(ns: string, name: string): NodeId;
+    name(id: NodeId): string;
+    inline(owner: NodeId, element: unknown): NodeId;
+    private walk;
+    private allocate;
+}

package/dist/compiler/legacyDeclarations.js

@@ -0,0 +1,144 @@
+import { createHash } from "node:crypto";
+import { globalId, scopedId } from "./declarationIdentity.js";
+import { pascal, resolveQName } from "../util/tools.js";
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const local = (key) => key.slice(key.indexOf(":") + 1);
+const attribute = (node, name) => object(node) && typeof node[`@_${name}`] === "string" ? node[`@_${name}`] : "";
+const children = (node, role) => object(node) ? Object.entries(node)
+    .filter(([key]) => local(key) === role).flatMap(([, value]) => Array.isArray(value) ? value : [value]) : [];
+/** Index legacy declarations without importing the checked loader's source or acceptance policies.
+ * @constraints Paths count equal role/name peers within a parent, never text nodes or unrelated global declarations.
+ * @constraints Name allocation is local to this compilation; independent catalogs still require conservative conflict checks.
+ */
+export class LegacyDeclarations {
+    declarations = new Map();
+    names = new Map();
+    surfaces = new Map();
+    inlineByOwner = new Map();
+    constructor(globals) {
+        const named = new Set(globals.filter(g => g.kind !== "element").map(g => this.type(g.ns, g.name)));
+        for (const g of globals) {
+            const id = g.kind === "element" ? this.element(g.ns, g.name) : this.type(g.ns, g.name);
+            if (g.kind === "element") {
+                const target = attribute(g.node, "type");
+                const q = target ? resolveQName(target, g.ns, g.prefixes) : undefined;
+                if (q && q.ns === g.ns && q.local === g.name && named.has(this.type(q.ns, q.local))) {
+                    this.surfaces.set(id, this.type(q.ns, q.local));
+                    continue;
+                }
+            }
+            const body = g.kind === "element" ? children(g.node, "complexType")[0] : g.node;
+            const surface = g.kind === "element" && body ? scopedId(id, "complexType", "type") : id;
+            this.surfaces.set(id, surface);
+            this.declarations.set(surface, { id: surface, candidate: pascal(g.name), stem: pascal(g.name), anonymous: false });
+            if (body && g.kind !== "simple")
+                this.walk(surface, body, pascal(g.name), []);
+        }
+        this.allocate();
+    }
+    type(ns, name) { return globalId("type", { namespace: ns, local: name }); }
+    element(ns, name) { return globalId("element", { namespace: ns, local: name }); }
+    surface(ns, name) {
+        const id = this.element(ns, name);
+        return this.surfaces.get(id) ?? id;
+    }
+    name(id) {
+        const name = this.names.get(id);
+        if (!name)
+            throw new Error(`Missing legacy declaration name: ${id}`);
+        return name;
+    }
+    inline(owner, element) {
+        const id = object(element) ? this.inlineByOwner.get(owner)?.get(element) : undefined;
+        if (!id)
+            throw new Error(`Missing inline declaration in ${owner}`);
+        return id;
+    }
+    walk(owner, node, stem, path) {
+        if (!object(node))
+            return;
+        const peers = new Map();
+        for (const [key, value] of Object.entries(node)) {
+            const role = local(key);
+            if (!["sequence", "choice", "all", "element", "complexContent", "simpleContent", "extension", "restriction"].includes(role))
+                continue;
+            for (const child of Array.isArray(value) ? value : [value]) {
+                const xmlName = attribute(child, "name") || attribute(child, "ref").split(":").at(-1) || "";
+                const peer = JSON.stringify([role, xmlName]);
+                const ordinal = peers.get(peer) ?? 0;
+                peers.set(peer, ordinal + 1);
+                const childPath = [...path, JSON.stringify([role, xmlName, ordinal])];
+                if (role === "element") {
+                    const body = children(child, "complexType")[0];
+                    if (!body || !object(child))
+                        continue;
+                    const elementId = scopedId(owner, JSON.stringify(childPath), "element");
+                    const id = scopedId(elementId, "complexType", "type");
+                    const candidate = pascal(xmlName);
+                    const childStem = `${stem}${candidate}`;
+                    this.declarations.set(id, { id, candidate, stem: childStem, anonymous: true });
+                    let byNode = this.inlineByOwner.get(owner);
+                    if (!byNode)
+                        this.inlineByOwner.set(owner, byNode = new WeakMap());
+                    byNode.set(child, id);
+                    this.walk(id, body, childStem, []);
+                }
+                else
+                    this.walk(owner, child, stem, childPath);
+            }
+        }
+    }
+    allocate() {
+        const groups = new Map();
+        for (const d of this.declarations.values()) {
+            const group = groups.get(d.candidate) ?? [];
+            group.push(d);
+            groups.set(d.candidate, group);
+        }
+        const proposed = new Map();
+        const fixed = new Set();
+        const preserved = new Set();
+        for (const [candidate, group] of groups) {
+            const named = group.filter(d => !d.anonymous);
+            if (group.length === 1 || named.length === 1) {
+                const declaration = group.length === 1 ? group[0] : named[0];
+                proposed.set(declaration.id, candidate);
+                preserved.add(declaration.id);
+                fixed.add(candidate);
+            }
+            for (const d of group) {
+                if (!proposed.has(d.id))
+                    proposed.set(d.id, d.anonymous ? d.stem : d.candidate);
+            }
+        }
+        // @why No traversal-order winner: every unresolved member of a collision receives an identity-derived suffix.
+        const counts = new Map();
+        for (const name of proposed.values())
+            counts.set(name, (counts.get(name) ?? 0) + 1);
+        const pending = [];
+        for (const d of this.declarations.values()) {
+            const name = proposed.get(d.id);
+            if (preserved.has(d.id) || (counts.get(name) === 1 && !fixed.has(name)))
+                this.names.set(d.id, name);
+            else
+                pending.push(d);
+        }
+        const used = new Set(this.names.values());
+        for (let length = 12; pending.length > 0; length += 4) {
+            if (length > 64)
+                throw new Error("Cannot allocate unique legacy declaration names");
+            const candidates = pending.map(d => `${proposed.get(d.id)}_${createHash("sha256").update(d.id).digest("hex").slice(0, length)}`);
+            const occurrences = new Map();
+            for (const name of candidates)
+                occurrences.set(name, (occurrences.get(name) ?? 0) + 1);
+            for (let i = pending.length - 1; i >= 0; i--) {
+                const name = candidates[i];
+                if (used.has(name) || occurrences.get(name) > 1)
+                    continue;
+                this.names.set(pending[i].id, name);
+                used.add(name);
+                pending.splice(i, 1);
+            }
+        }
+    }
+}