@techspokes/typescript-wsdl-client 1.1.3 → 1.1.5

package/dist/compiler/graphTraversal.d.ts

@@ -0,0 +1,11 @@
+/** Typed graph edges shared by resolution and structural companion traversal. */
+import type { GraphNode, NodeId, Reference } from "./canonicalGraph.js";
+export type ReferenceSlot = Readonly<{
+    path: string;
+    reference: Reference;
+}>;
+/** Map typed reference fields only; lexical syntax/provenance remain original data. */
+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/graphTraversal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphTraversal.d.ts","sourceRoot":"","sources":["../../src/compiler/graphTraversal.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,OAAO,KAAK,EAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAEtE,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,SAAS,CAAA;CAAC,CAAC,CAAC;AAE3E,uFAAuF;AACvF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE,SAAS,KAAK,SAAS,GAAG,SAAS,CAYtG;AACD,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,aAAa,EAAE,CAaxE;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,MAAM,EAAE,CAQjE"}

package/dist/compiler/graphTraversal.js

@@ -0,0 +1,37 @@
+/** Map typed reference fields only; lexical syntax/provenance remain original data. */
+export function mapNodeReferences(node, map) {
+    switch (node.kind) {
+        case "element": return { ...node, type: map(node.type), substitutionGroup: node.substitutionGroup ? map(node.substitutionGroup) : undefined };
+        case "attribute": return { ...node, type: map(node.type) };
+        case "attributeUse": return { ...node, declaration: map(node.declaration) };
+        case "attributeGroupUse": return { ...node, reference: map(node.reference) };
+        case "particle": return { ...node, term: node.term.kind === "element" ? { ...node.term, declaration: map(node.term.declaration) } : node.term.kind === "group" ? { ...node.term, reference: map(node.term.reference) } : node.term };
+        case "complexType": return { ...node, derivation: node.derivation ? { ...node.derivation, base: map(node.derivation.base), inlineType: node.derivation.inlineType ? map(node.derivation.inlineType) : undefined } : undefined };
+        case "simpleType": return { ...node, variety: node.variety.kind === "restriction" ? { ...node.variety, base: map(node.variety.base) } : node.variety.kind === "list" ? { ...node.variety, item: map(node.variety.item) } : { ...node.variety, members: node.variety.members.map(map) } };
+        case "wsdl": return { ...node, references: node.references.map(r => ({ ...r, reference: map(r.reference) })) };
+        default: return node;
+    }
+}
+export function referenceSlots(node) {
+    const slot = (path, reference) => ({ path, reference });
+    switch (node.kind) {
+        case "element": return [slot("type", node.type), ...(node.substitutionGroup ? [slot("substitutionGroup", node.substitutionGroup)] : [])];
+        case "attribute": return [slot("type", node.type)];
+        case "attributeUse": return [slot("declaration", node.declaration)];
+        case "attributeGroupUse": return [slot("reference", node.reference)];
+        case "particle": return node.term.kind === "element" ? [slot("term/declaration", node.term.declaration)] : node.term.kind === "group" ? [slot("term/reference", node.term.reference)] : [];
+        case "complexType": return node.derivation ? [slot("derivation/base", node.derivation.base), ...(node.derivation.inlineType ? [slot("derivation/inlineType", node.derivation.inlineType)] : [])] : [];
+        case "simpleType": return node.variety.kind === "restriction" ? [slot("variety/base", node.variety.base)] : node.variety.kind === "list" ? [slot("variety/item", node.variety.item)] : node.variety.members.map((r, i) => slot(`variety/members/${i}`, r));
+        case "wsdl": return node.references.map((r, i) => slot(`references/${i}`, r.reference));
+        default: return [];
+    }
+}
+export function containedNodes(node) {
+    switch (node.kind) {
+        case "group": return [node.content];
+        case "complexType": return [...(node.content ? [node.content] : []), ...node.attributes];
+        case "attributeGroup": return node.attributes;
+        case "particle": return "children" in node.term ? node.term.children : [];
+        default: return [];
+    }
+}

package/dist/compiler/hypotheticalScopedIdentity.d.ts

@@ -0,0 +1,23 @@
+import type { GraphNode, Identity } from './canonicalGraph.js';
+export type IdentityCharge = (units: number) => void;
+export declare const HYPOTHETICAL_SCOPED_TAG = "hypothetical-scoped-v1";
+/** JSON tuple encoding is injective on owner/path/role UTF-16 strings; actual IDs keep legacy encoding. */
+export declare function hypotheticalScopedId(owner: string, path: string, role: string, charge?: IdentityCharge): string;
+/** Private backing only: these tagged IDs are never admitted context members. */
+export declare function privateParticleId(family: 'effective' | 'builtin-anyType', owner: string, path: string, role: string, charge: IdentityCharge): string;
+/** Encoding-independent identity tuple; required to reject legacy/new aliases of one scoped identity. */
+export declare function semanticIdentityTuple(identity: Identity, charge?: IdentityCharge): string;
+/** New acceptance seam ONLY for hypothetical additions; actual/source admission remains native legacy. */
+export declare function matchesHypotheticalNodeId(node: GraphNode, charge?: IdentityCharge): boolean;
+export declare function sameSemanticIdentity(left: GraphNode, right: GraphNode, charge?: IdentityCharge): boolean;
+/** Returns the second record of a duplicate identity tuple; does not conflate distinct tuples sharing a hash. */
+export declare function duplicateIdentityTuple(nodes: Iterable<GraphNode>, charge?: IdentityCharge): string | undefined;
+/** Finite constructive allocation, independent of hash range or collision assumptions. */
+export declare function allocateHypotheticalScopedIdentity(owner: string, role: string, forbiddenIds: ReadonlySet<string>, forbiddenTuples: ReadonlySet<string>, charge?: IdentityCharge): Readonly<{
+    id: string;
+    identity: Extract<Identity, {
+        kind: 'scoped';
+    }>;
+    candidatesTried: bigint;
+}>;
+//# sourceMappingURL=hypotheticalScopedIdentity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hypotheticalScopedIdentity.d.ts","sourceRoot":"","sources":["../../src/compiler/hypotheticalScopedIdentity.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,SAAS,EAAE,QAAQ,EAAC,MAAM,qBAAqB,CAAC;AAE7D,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;AAErD,eAAO,MAAM,uBAAuB,2BAA2B,CAAC;AAEhE,2GAA2G;AAC3G,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,cAAqB,GAAG,MAAM,CAGrH;AAED,iFAAiF;AACjF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,iBAAiB,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAClH,MAAM,EAAE,cAAc,GAAG,MAAM,CAGhC;AAED,yGAAyG;AACzG,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAE,cAAqB,GAAG,MAAM,CAO/F;AAED,0GAA0G;AAC1G,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,GAAE,cAAqB,GAAG,OAAO,CAejG;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,GAAE,cAAqB,GAAG,OAAO,CAG9G;AAED,iHAAiH;AACjH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAE,cAAqB,GAAG,MAAM,GAAG,SAAS,CAUpH;AAED,0FAA0F;AAC1F,wBAAgB,kCAAkC,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAC5E,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,EAAE,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,EAAE,MAAM,GAAE,cAAqB,GACtG,QAAQ,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE;QAAC,IAAI,EAAE,QAAQ,CAAA;KAAC,CAAC,CAAC;IAAC,eAAe,EAAE,MAAM,CAAA;CAAC,CAAC,CAiB/F"}

package/dist/compiler/hypotheticalScopedIdentity.js

@@ -0,0 +1,81 @@
+/** Internal optional injective encoding for genuinely fresh scoped plan identities. */
+import { globalId, scopedId } from './canonicalGraph.js';
+const noop = () => { };
+export const HYPOTHETICAL_SCOPED_TAG = 'hypothetical-scoped-v1';
+/** JSON tuple encoding is injective on owner/path/role UTF-16 strings; actual IDs keep legacy encoding. */
+export function hypotheticalScopedId(owner, path, role, charge = noop) {
+    charge(64 + 6 * (owner.length + path.length + role.length));
+    return JSON.stringify([HYPOTHETICAL_SCOPED_TAG, owner, path, role]);
+}
+/** Private backing only: these tagged IDs are never admitted context members. */
+export function privateParticleId(family, owner, path, role, charge) {
+    charge(96 + 6 * (family.length + owner.length + path.length + role.length));
+    return JSON.stringify(['semantic-private-particle-v1', family, owner, path, role]);
+}
+/** Encoding-independent identity tuple; required to reject legacy/new aliases of one scoped identity. */
+export function semanticIdentityTuple(identity, charge = noop) {
+    if (identity.kind === 'global') {
+        charge(64 + 6 * (identity.role.length + identity.name.namespace.length + identity.name.local.length));
+        return globalId(identity.role, identity.name);
+    }
+    charge(64 + 6 * (identity.owner.length + identity.path.length + identity.role.length));
+    return JSON.stringify(['scoped-identity', identity.owner, identity.path, identity.role]);
+}
+/** New acceptance seam ONLY for hypothetical additions; actual/source admission remains native legacy. */
+export function matchesHypotheticalNodeId(node, charge = noop) {
+    const identity = node.identity;
+    if (identity.kind === 'global') {
+        charge(64 + 6 * (identity.role.length + identity.name.namespace.length + identity.name.local.length));
+        const expected = globalId(identity.role, identity.name);
+        charge(node.id.length + expected.length + 1);
+        return node.id === expected;
+    }
+    charge(HYPOTHETICAL_SCOPED_TAG.length + 4);
+    if (node.id.startsWith('["' + HYPOTHETICAL_SCOPED_TAG + '"')) {
+        const expected = hypotheticalScopedId(identity.owner, identity.path, identity.role, charge);
+        charge(node.id.length + expected.length + 1);
+        return node.id === expected;
+    }
+    charge(64 + 6 * (identity.owner.length + identity.path.length + identity.role.length));
+    const legacy = scopedId(identity.owner, identity.path, identity.role);
+    charge(node.id.length + legacy.length + 1);
+    return node.id === legacy;
+}
+export function sameSemanticIdentity(left, right, charge = noop) {
+    const a = semanticIdentityTuple(left.identity, charge), b = semanticIdentityTuple(right.identity, charge);
+    charge(a.length + b.length + 1);
+    return a === b;
+}
+/** Returns the second record of a duplicate identity tuple; does not conflate distinct tuples sharing a hash. */
+export function duplicateIdentityTuple(nodes, charge = noop) {
+    charge(4);
+    const seen = new Map();
+    for (const node of nodes) {
+        const tuple = semanticIdentityTuple(node.identity, charge);
+        charge(tuple.length + node.id.length + 3);
+        const prior = seen.get(tuple);
+        if (prior !== undefined && prior !== node.id)
+            return node.id;
+        seen.set(tuple, node.id);
+    }
+    return undefined;
+}
+/** Finite constructive allocation, independent of hash range or collision assumptions. */
+export function allocateHypotheticalScopedIdentity(owner, role, forbiddenIds, forbiddenTuples, charge = noop) {
+    charge(64);
+    const blocked = BigInt(forbiddenIds.size) + BigInt(forbiddenTuples.size);
+    for (let index = 0n; index <= blocked; index += 1n) {
+        // Set.size is a safe integer, so index has at most 17 decimal digits.
+        charge(64);
+        const path = '/$hypothetical/' + index.toString();
+        charge(8 + owner.length + path.length + role.length);
+        const identity = { kind: 'scoped', owner, path, role };
+        const id = hypotheticalScopedId(owner, path, role, charge), tuple = semanticIdentityTuple(identity, charge);
+        charge(6 + id.length + tuple.length);
+        if (!forbiddenIds.has(id) && !forbiddenTuples.has(tuple)) {
+            charge(4);
+            return Object.freeze({ id, identity, candidatesTried: index + 1n });
+        }
+    }
+    throw new Error('Finite injective allocation invariant violated');
+}

package/dist/compiler/occurrenceAnalysis.d.ts

@@ -0,0 +1,65 @@
+import type { NodeId, Occurs } from "./canonicalGraph.js";
+import type { ExpandedName } from "../loader/orderedSyntax.js";
+import type { ComposedGraph } from "./composeCanonicalGraph.js";
+import { SemanticError } from "./resolveCanonicalGraph.js";
+import type { SemanticLimits } from "./resolveCanonicalGraph.js";
+import type { ResourceLimitFailure, SemanticBudget } from './semanticBudget.js';
+export type Bound = Occurs["max"];
+export declare const ZERO_OCCURS: Occurs;
+/** Charge operand and result work before BigInt conversion or arithmetic allocation. */
+export declare function occurrenceAlgebra(charge: () => void): {
+    compare: (a: Bound, b: Bound) => number;
+    validate: (range: Occurs) => void;
+    add: (a: Bound, b: Bound) => Bound;
+    multiply: (a: Bound, b: Bound) => Bound;
+    count: (value: string) => bigint;
+    sum: (a: Occurs, b: Occurs) => Occurs;
+    product: (a: Occurs, b: Occurs) => Occurs;
+    alternative: (a: Occurs, b: Occurs) => Occurs;
+};
+export type PropertyContribution = Readonly<{
+    name: ExpandedName;
+    occurs: Occurs;
+    declarations: readonly NodeId[];
+    particles: readonly NodeId[];
+}>;
+export type ParticleSummary = Readonly<{
+    id: NodeId;
+    nullable: boolean;
+    hasRealization: boolean;
+    elements: readonly PropertyContribution[];
+    wildcard: Occurs;
+    /** XSD's formal ETR / Particle Emptiable predicate, not language emptiness. */
+    effectiveTotalRange: Occurs;
+    schemaEmptiable: boolean;
+}>;
+export type TypeSummary = Readonly<{
+    id: NodeId;
+    children: Omit<ParticleSummary, "id">;
+    /** All child summaries, including ETR, cover declared particles only beside opaque builtin content. */
+    scope: "declared-particles" | "declared-particles-with-opaque-builtin";
+}>;
+export type OccurrenceAnalysis = Readonly<{
+    composed: ComposedGraph;
+    particles: readonly ParticleSummary[];
+    types: readonly TypeSummary[];
+    assessment: "requires-schema-assessment";
+    metrics: Readonly<{
+        steps: number;
+    }>;
+}>;
+export type AnalysisResult = Readonly<{
+    kind: "analyzed";
+    analysis: OccurrenceAnalysis;
+} | {
+    kind: "failure";
+    diagnostic: SemanticError;
+}>;
+/** Pure bounded DAG evaluation. Element/type value recursion is an atomic element boundary. */
+export declare function analyzeOccurrences(composed: ComposedGraph, limits?: SemanticLimits): AnalysisResult;
+export declare function analyzeOccurrences(composed: ComposedGraph, limits: SemanticLimits, accounting: Readonly<{
+    /** Selected semantic projection data; omission preserves canonical analysis's qualified ANY default. */
+    budget: SemanticBudget;
+    wildcardRealization?: ReadonlyMap<NodeId, boolean>;
+}>): AnalysisResult | ResourceLimitFailure;
+//# sourceMappingURL=occurrenceAnalysis.d.ts.map

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

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

package/dist/compiler/occurrenceAnalysis.js

@@ -0,0 +1,300 @@
+/** Exact S06 summaries of child particles. Intervals never describe the full language. */
+import { deepFreeze } from "./canonicalGraph.js";
+import { referenceTarget, SemanticError, semanticBudget } from "./resolveCanonicalGraph.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. */
+export function occurrenceAlgebra(charge) {
+    const work = (length) => { for (let i = 0; i < length; i++)
+        charge(); };
+    const compare = (a, b) => {
+        work(a.length + b.length);
+        return a === b ? 0 : a === "unbounded" ? 1 : b === "unbounded" ? -1 : a.length === b.length ? (a < b ? -1 : 1) : a.length < b.length ? -1 : 1;
+    };
+    const finite = (value) => {
+        work(value.length);
+        return value === "unbounded" || /^(0|[1-9][0-9]*)$/.test(value);
+    };
+    const validate = (range) => {
+        if (range.min === "unbounded" || !finite(range.min) || !finite(range.max) || compare(range.min, range.max) > 0) {
+            throw new SemanticError("invalid-schema", "Malformed occurrence range");
+        }
+    };
+    const add = (a, b) => {
+        work(a.length + b.length + 1);
+        return a === "unbounded" || b === "unbounded" ? "unbounded" : (BigInt(a) + BigInt(b)).toString();
+    };
+    const multiply = (a, b) => {
+        work(a.length + b.length);
+        if (a === "0" || b === "0")
+            return "0";
+        if (a === "unbounded" || b === "unbounded")
+            return "unbounded";
+        // Conservative decimal multiplication work also bounds the result's digit allocation.
+        for (let i = 0; i < a.length; i++)
+            work(b.length);
+        return (BigInt(a) * BigInt(b)).toString();
+    };
+    const count = (value) => {
+        // Conservative quadratic decimal conversion work is charged before BigInt.
+        for (let i = 0; i < value.length; i++)
+            work(value.length);
+        if (!finite(value) || value === 'unbounded')
+            throw new SemanticError('invalid-schema', 'Finite occurrence count required');
+        return BigInt(value);
+    };
+    return { compare, validate, add, multiply, count,
+        sum: (a, b) => ({ min: add(a.min, b.min), max: add(a.max, b.max) }),
+        product: (a, b) => ({ min: multiply(a.min, b.min), max: multiply(a.max, b.max) }),
+        alternative: (a, b) => ({ min: compare(a.min, b.min) <= 0 ? a.min : b.min, max: compare(a.max, b.max) >= 0 ? a.max : b.max }),
+    };
+}
+export function analyzeOccurrences(composed, limits = {}, accounting) {
+    return accounting ? accounting.budget.guard(() => analyzeOwnedOccurrences(composed, limits, accounting.budget, accounting.wildcardRealization)) : analyzeOwnedOccurrences(composed, limits);
+}
+function analyzeOwnedOccurrences(composed, limits, request, wildcardRealization) {
+    let current;
+    const allocate = (units) => request?.chargeWork(units);
+    try {
+        allocate(128); // Fixed local closures, budget facade and algebra/state containers.
+        const graph = composed.resolved.graph, local = semanticBudget(limits);
+        const budget = request ? { maxNodes: local.maxNodes, get steps() { return local.steps; }, step(node) {
+                request.chargeWork();
+                local.step(node);
+            } } : local;
+        if (graph.nodes.length > budget.maxNodes)
+            throw new SemanticError("resource-limit", `Analysis exceeds ${budget.maxNodes} graph nodes`);
+        allocate(3);
+        const nodes = new Map();
+        for (const n of graph.nodes) {
+            budget.step(n);
+            allocate(2);
+            nodes.set(n.id, n);
+        }
+        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); })();
+        const key = (name) => {
+            for (const value of [name.namespace, name.local])
+                for (let i = 0; i < value.length; i++)
+                    budget.step(current);
+            allocate(8 + 6 * (name.namespace.length + name.local.length));
+            return JSON.stringify([name.namespace, name.local]);
+        };
+        const target = (reference, owner) => {
+            if (reference.kind === "symbol")
+                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);
+        };
+        const copyIds = (a, b) => {
+            allocate(1);
+            const unique = new Set();
+            for (const list of [a, b])
+                for (const id of list) {
+                    budget.step(current);
+                    for (let i = 0; i < id.length; i++)
+                        budget.step(current);
+                    unique.add(id);
+                }
+            allocate(1 + unique.size);
+            return [...unique];
+        };
+        const empty = () => { allocate(8); return { nullable: true, hasRealization: true, elements: [], wildcard: ZERO_OCCURS, effectiveTotalRange: ZERO_OCCURS, schemaEmptiable: true }; };
+        const combine = (input, choice) => {
+            allocate(5);
+            const parts = [];
+            let effectiveTotalRange = ZERO_OCCURS;
+            for (let i = 0; i < input.length; i++) {
+                const part = input[i];
+                budget.step(current);
+                // Formal ETR includes all declared alternatives, even an empty choice.
+                effectiveTotalRange = choice ? i === 0 ? part.effectiveTotalRange : algebra.alternative(effectiveTotalRange, part.effectiveTotalRange) : algebra.sum(effectiveTotalRange, part.effectiveTotalRange);
+                if (!choice || part.hasRealization) {
+                    allocate(1);
+                    parts.push(part);
+                }
+            }
+            const formal = { effectiveTotalRange, schemaEmptiable: effectiveTotalRange.min === "0" };
+            const elements = new Map();
+            let wildcard = ZERO_OCCURS, nullable = !choice;
+            const hasRealization = choice ? parts.length > 0 : parts.every(p => p.hasRealization);
+            if (!hasRealization) {
+                allocate(8);
+                return { ...formal, nullable: false, hasRealization: false, elements: [], wildcard: ZERO_OCCURS };
+            }
+            for (let i = 0; i < parts.length; i++) {
+                budget.step(current);
+                allocate(1);
+                const part = parts[i], present = new Set();
+                nullable = choice ? nullable || part.nullable : nullable && part.nullable;
+                wildcard = choice && i > 0 ? algebra.alternative(wildcard, part.wildcard) : choice ? part.wildcard : algebra.sum(wildcard, part.wildcard);
+                for (const p of part.elements) {
+                    budget.step(current);
+                    const k = key(p.name);
+                    present.add(k);
+                    const prior = elements.get(k);
+                    const occurs = prior ? (choice ? algebra.alternative(prior.occurs, p.occurs) : algebra.sum(prior.occurs, p.occurs)) : choice && i > 0 ? algebra.alternative(ZERO_OCCURS, p.occurs) : p.occurs;
+                    allocate(8);
+                    elements.set(k, { name: p.name, occurs, declarations: copyIds(prior?.declarations ?? [], p.declarations), particles: copyIds(prior?.particles ?? [], p.particles) });
+                }
+                if (choice)
+                    for (const [k, p] of elements) {
+                        budget.step(current);
+                        if (!present.has(k)) {
+                            allocate(8);
+                            elements.set(k, { ...p, occurs: algebra.alternative(p.occurs, ZERO_OCCURS) });
+                        }
+                    }
+            }
+            allocate(8 + elements.size);
+            return { ...formal, nullable, hasRealization, elements: [...elements.values()], wildcard };
+        };
+        const dependencies = (node) => {
+            if ("children" in node.term) {
+                allocate(1 + node.term.children.length);
+                const result = [];
+                for (const id of node.term.children) {
+                    budget.step(node);
+                    result.push(id);
+                }
+                return result;
+            }
+            if (node.term.kind === "group") {
+                const id = target(node.term.reference, node), group = id ? get(id) : undefined;
+                if (group?.kind !== "group")
+                    throw new SemanticError("invalid-schema", "Group particle requires a model group", node.id, node.context.source);
+                allocate(2);
+                return [group.content];
+            }
+            if (node.term.kind === "element") {
+                const id = target(node.term.declaration, node);
+                if (!id || get(id).kind !== "element")
+                    throw new SemanticError("invalid-schema", "Element particle requires an element declaration", node.id, node.context.source);
+            }
+            allocate(1);
+            return [];
+        };
+        const frame = (node) => { current = node; algebra.validate(node.occurs); allocate(4); return { node, children: dependencies(node), index: 0 }; };
+        for (const root of graph.nodes) {
+            if (root.kind !== "particle" || summaries.has(root.id))
+                continue;
+            allocate(3);
+            const stack = [frame(root)];
+            active.add(root.id);
+            while (stack.length) {
+                const f = stack[stack.length - 1];
+                current = f.node;
+                budget.step(current);
+                if (f.index < f.children.length) {
+                    const id = f.children[f.index++], child = get(id);
+                    if (child.kind !== "particle")
+                        throw new SemanticError("invalid-schema", "Content requires a particle", id, child.context.source);
+                    if (active.has(id))
+                        throw new SemanticError("invalid-schema", "Forbidden particle expansion cycle", id, child.context.source);
+                    if (!summaries.has(id)) {
+                        allocate(2);
+                        active.add(id);
+                        stack.push(frame(child));
+                    }
+                    continue;
+                }
+                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");
+                    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 };
+                }
+                else if (node.term.kind === "any") {
+                    let hasRealization = true;
+                    if (wildcardRealization) {
+                        allocate(2);
+                        hasRealization = wildcardRealization.get(node.id) ?? true;
+                    }
+                    allocate(8);
+                    content = { nullable: false, hasRealization, elements: [], wildcard: hasRealization ? ONE_OCCURS : ZERO_OCCURS,
+                        effectiveTotalRange: ONE_OCCURS, schemaEmptiable: false };
+                }
+                else {
+                    allocate(1 + f.children.length);
+                    const parts = [];
+                    for (const id of f.children) {
+                        budget.step(node);
+                        // XSD syntax with 0..0 maps to no particle. Traverse it above for
+                        // diagnostics, but never create an epsilon *choice alternative*.
+                        const child = get(id);
+                        if (node.term.kind === "choice" && child.kind === "particle" && child.occurs.max === "0")
+                            continue;
+                        parts.push(summaries.get(id));
+                    }
+                    content = combine(parts, node.term.kind === "choice");
+                }
+                allocate(1 + content.elements.length * 6);
+                const elements = [];
+                for (const p of content.elements) {
+                    budget.step(node);
+                    elements.push({ ...p, occurs: algebra.product(p.occurs, node.occurs) });
+                }
+                const effectiveTotalRange = algebra.product(content.effectiveTotalRange, node.occurs);
+                allocate(12);
+                summaries.set(node.id, { id: node.id, nullable: node.occurs.min === "0" || content.nullable, hasRealization: node.occurs.min === "0" || content.hasRealization, elements, wildcard: algebra.product(content.wildcard, node.occurs), effectiveTotalRange, schemaEmptiable: effectiveTotalRange.min === "0" });
+                active.delete(node.id);
+                stack.pop();
+            }
+        }
+        allocate(1 + composed.types.length * 5);
+        const types = [];
+        for (const type of composed.types) {
+            current = get(type.id);
+            budget.step(current);
+            allocate(1 + type.content.length);
+            const parts = [];
+            let opaque = false;
+            for (const contribution of type.content) {
+                budget.step(current);
+                if (contribution.kind === "builtin") {
+                    opaque = true;
+                    continue;
+                }
+                const summary = summaries.get(contribution.particle);
+                if (!summary)
+                    throw new SemanticError("invalid-schema", "Missing composed particle", type.id, current.context.source);
+                parts.push(summary);
+            }
+            types.push({ id: type.id, children: parts.length ? combine(parts, false) : empty(), scope: opaque ? "declared-particles-with-opaque-builtin" : "declared-particles" });
+        }
+        allocate(12 + summaries.size);
+        const result = { kind: "analyzed", analysis: { composed, particles: [...summaries.values()], types, assessment: "requires-schema-assessment", metrics: { steps: budget.steps } } };
+        if (!request)
+            return deepFreeze(result);
+        // Freeze new owned output only; the immutable composed input is borrowed.
+        request.chargeWork(3);
+        const stack = [result], seen = new Set();
+        while (stack.length) {
+            request.chargeWork(3);
+            const item = stack.pop();
+            if (!item || typeof item !== 'object' || item === composed || Object.isFrozen(item) || seen.has(item))
+                continue;
+            request.chargeWork(2);
+            seen.add(item);
+            for (const name in item) {
+                request.chargeWork(2 + name.length);
+                if (Object.hasOwn(item, name))
+                    stack.push(item[name]);
+            }
+            Object.freeze(item);
+        }
+        return result;
+    }
+    catch (error) {
+        if (error instanceof SemanticError) {
+            allocate(10 + error.message.length);
+            return Object.freeze({ kind: "failure", diagnostic: error.component || !current ? error : new SemanticError(error.category, error.message, current.id, current.context.source, error.related) });
+        }
+        throw error;
+    }
+}

package/dist/compiler/originalSourceMembership.d.ts

@@ -0,0 +1,6 @@
+/** Original source projections suppressed by XSD mapping, not candidate validity. */
+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/originalSourceMembership.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"originalSourceMembership.d.ts","sourceRoot":"","sources":["../../src/compiler/originalSourceMembership.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,OAAO,KAAK,EAAC,SAAS,EAAE,MAAM,EAAC,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAExD,+EAA+E;AAC/E,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,MAAM,EAAE,cAAc,GAAG,WAAW,CAAC,MAAM,CAAC,CAqBrH"}

package/dist/compiler/originalSourceMembership.js

@@ -0,0 +1,31 @@
+/** Called on the private immutable original graph inside the request guard. */
+export function computeOriginalSourceAbsence(input, budget) {
+    budget.chargeWork(3);
+    const roots = [], nodes = [], result = new Set();
+    for (const original of input) {
+        budget.chargeWork();
+        if (original.identity.kind === 'global')
+            continue;
+        budget.chargeWork();
+        nodes.push(original);
+        if (original.kind === 'attributeUse' && original.use === 'prohibited' ||
+            original.kind === 'particle' && original.occurs.min === '0' && original.occurs.max === '0') {
+            budget.chargeWork();
+            roots.push(original);
+        }
+    }
+    for (const node of nodes)
+        for (const root of roots) {
+            const a = node.context, z = root.context, p = a.source.path, q = z.source.path;
+            budget.chargeWork(10 + p.length + q.length + a.source.uri.length + z.source.uri.length + a.source.digest.length + z.source.digest.length
+                + a.effectiveNamespace.length + z.effectiveNamespace.length + a.baseUri.length + z.baseUri.length);
+            if (a.source.uri === z.source.uri && a.source.digest === z.source.digest && a.effectiveNamespace === z.effectiveNamespace &&
+                a.baseUri === z.baseUri && a.chameleon === z.chameleon &&
+                (p === q || p.startsWith(q + '/'))) {
+                budget.chargeWork();
+                result.add(node.id);
+                break;
+            }
+        }
+    return result;
+}

package/dist/compiler/particleAttribution.d.ts

@@ -0,0 +1,17 @@
+import type { SemanticContext } from './semanticContext.js';
+import type { SemanticParticleView } from './particleSemanticView.js';
+import type { RelationFailure } from './schemaTypeRelations.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+import type { SemanticTypeDependency } from './semanticTypeReference.js';
+export type AttributionResult = Readonly<{
+    kind: 'checked';
+    value: boolean;
+    rule: 'cos-nonambig';
+    contextId: string;
+    component?: string;
+    obligations: readonly ['component-validity'];
+    typeDependencies: readonly SemanticTypeDependency[];
+}> | 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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particleAttribution.d.ts","sourceRoot":"","sources":["../../src/compiler/particleAttribution.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAmB,oBAAoB,EAAC,MAAM,2BAA2B,CAAC;AAEtF,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,0BAA0B,CAAC;AAG9D,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,qBAAqB,CAAC;AAI9D,OAAO,KAAK,EAAC,sBAAsB,EAAC,MAAM,4BAA4B,CAAC;AAEvE,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,cAAc,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IACjH,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,SAAS,CAAC,oBAAoB,CAAC,CAAC;IAAC,gBAAgB,EAAE,SAAS,sBAAsB,EAAE,CAAA;CAAC,CAAC,GAAG,eAAe,GAAG,oBAAoB,CAAC;AAGnK,+FAA+F;AAC/F,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,oBAAoB,GAAG,iBAAiB,CAyRhH"}