@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/composeCanonicalGraph.d.ts

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

package/dist/compiler/composeCanonicalGraph.js

@@ -0,0 +1,252 @@
+/** S05 composition views reference declared components; S06 discharges schema legality. */
+import { deepFreeze } from "./canonicalGraph.js";
+import { referenceTarget, SemanticError, semanticBudget } from "./resolveCanonicalGraph.js";
+import { namespaceAllows as allows, namespaceIntersection, namespaceSubset, namespaceUnion, wildcardNamespaces, processContentsRestricts } from "./wildcardAlgebra.js";
+export { namespaceIntersection, namespaceSubset, namespaceUnion, wildcardNamespaces } from "./wildcardAlgebra.js";
+const canonicalSet = (values) => [...new Set(values)].sort();
+const key = (name) => JSON.stringify([name.namespace, name.local]);
+/** Extension concatenates root contributions, retaining each root's exact declared occurrence. */
+export function extendContent(base, local) {
+    return [...base, ...restrictContent(local)];
+}
+/** Restriction replaces child content, including the empty case. No removed base particle is appended. */
+export function restrictContent(local) {
+    return local ? [{ kind: "particle", particle: local }] : [];
+}
+export function composeCanonicalGraph(resolved, limits = {}) {
+    const graph = resolved.graph, budget = semanticBudget(limits);
+    if (graph.nodes.length > budget.maxNodes)
+        throw new SemanticError("resource-limit", `Composition exceeds ${budget.maxNodes} graph nodes`);
+    const nodes = new Map(graph.nodes.map(n => [n.id, n])), composed = new Map();
+    const fail = (node, message) => { throw new SemanticError("invalid-schema", message, node.id, node.context.source); };
+    const get = (id) => nodes.get(id) ?? (() => { throw new SemanticError("invalid-schema", `Missing component ${id}`); })();
+    const count = (node, ...lists) => {
+        for (const list of lists)
+            for (const ignored of list)
+                budget.step(node);
+    };
+    const wildcardCharge = (node) => (amount = 1) => {
+        for (let index = 0; index < amount; index++)
+            budget.step(node);
+    };
+    const copySources = (node, a, b) => {
+        count(node, a, b);
+        return [...a, ...b];
+    };
+    const groups = new Map();
+    const localAttributes = (owner, obligations) => {
+        const frame = (node) => ({ node, index: 0, attributes: new Map(), groups: [], obligations: [] });
+        const stack = [frame(owner)];
+        const add = (current, attribute) => {
+            budget.step(current.node);
+            const existing = current.attributes.get(key(attribute.name));
+            if (existing)
+                current.obligations.push({ kind: "attribute-extension-equivalence", owner: current.node.id, base: existing.declaration, local: attribute.declaration });
+            current.attributes.set(key(attribute.name), existing ? { ...attribute, sources: copySources(current.node, existing.sources, attribute.sources) } : attribute);
+        };
+        while (stack.length) {
+            const current = stack[stack.length - 1], container = current.node;
+            if (current.index < container.attributes.length) {
+                const node = get(container.attributes[current.index]);
+                budget.step(node);
+                if (node.kind === "attributeGroupUse") {
+                    const target = referenceTarget(node.reference, nodes, node), group = target ? get(target) : undefined;
+                    if (group?.kind !== "attributeGroup")
+                        fail(node, "Attribute group reference requires an attribute-group definition");
+                    const plan = groups.get(group.id);
+                    if (!plan) {
+                        stack.push(frame(group));
+                        continue;
+                    }
+                    for (const attribute of plan.attributes)
+                        add(current, attribute);
+                    count(node, plan.obligations);
+                    current.obligations.push(...plan.obligations);
+                    if (plan.wildcard)
+                        current.groups.push(plan.wildcard);
+                }
+                else if (node.kind === "attributeWildcard") {
+                    for (let i = 0; i < node.wildcard.namespace.value.length; i++)
+                        budget.step(node);
+                    if (current.explicit)
+                        fail(node, "Multiple local attribute wildcards");
+                    const namespace = wildcardNamespaces(node.wildcard, wildcardCharge(node));
+                    count(node, namespace.namespaces);
+                    current.explicit = { namespace, processContents: node.wildcard.processContents, sources: [node.id] };
+                }
+                else {
+                    if (node.kind !== "attributeUse")
+                        fail(node, "Expected an attribute use");
+                    const use = node;
+                    // A prohibition inside a group contributes no use. Only a direct type
+                    // restriction can remove an inherited optional attribute.
+                    if (!(container.kind === "attributeGroup" && use.use === "prohibited")) {
+                        const target = referenceTarget(use.declaration, nodes, use), declaration = target ? get(target) : undefined;
+                        if (declaration?.kind !== "attribute")
+                            fail(node, "Attribute use requires an attribute declaration");
+                        const attribute = declaration;
+                        const value = use.value ?? attribute.value;
+                        if (use.value && attribute.value?.kind === "fixed")
+                            current.obligations.push({ kind: "fixed-value-equivalence", owner: container.id, base: attribute.value, local: use.value });
+                        add(current, { name: attribute.name, declaration: attribute.id, type: attribute.type, use: use.use, value, sources: [use.id] });
+                    }
+                }
+                current.index++;
+                continue;
+            }
+            let wildcard = current.groups[0];
+            const intersect = (other) => {
+                if (!wildcard) {
+                    wildcard = other;
+                    return;
+                }
+                count(container, wildcard.namespace.namespaces, other.namespace.namespaces);
+                wildcard = { ...wildcard, namespace: namespaceIntersection(wildcard.namespace, other.namespace, wildcardCharge(container)), sources: copySources(container, wildcard.sources, other.sources) };
+            };
+            for (const other of current.groups.slice(1))
+                intersect(other);
+            if (current.explicit) {
+                const groupProcess = wildcard?.processContents, localProcess = current.explicit.processContents;
+                intersect(current.explicit);
+                if (groupProcess && (typeof groupProcess !== "string" || groupProcess !== localProcess)) {
+                    current.obligations.push({ kind: "group-local-wildcard-process", owner: container.id, local: current.explicit.sources[0] });
+                    wildcard = { ...wildcard, processContents: { kind: "assessment-required", alternatives: canonicalSet([...(typeof groupProcess === "string" ? [groupProcess] : groupProcess.alternatives), localProcess]) } };
+                }
+            }
+            if (wildcard)
+                current.obligations.push({ kind: "wildcard-expressibility", owner: container.id });
+            count(container, [...current.attributes.values()], current.obligations);
+            const result = { attributes: [...current.attributes.values()], wildcard, obligations: current.obligations };
+            stack.pop();
+            if (container.kind === "attributeGroup") {
+                groups.set(container.id, result);
+                continue;
+            }
+            count(owner, result.obligations);
+            obligations.push(...result.obligations);
+            return result;
+        }
+        throw new Error("Attribute composition lost its root");
+    };
+    const compose = (node) => {
+        const obligations = [], local = localAttributes(node, obligations), derivation = node.derivation;
+        let content = restrictContent(node.content), attributes = local.attributes, wildcard = local.wildcard, mixed = node.mixed;
+        let scalar;
+        if (derivation) {
+            const baseId = referenceTarget(derivation.base, nodes, node), baseNode = baseId ? get(baseId) : undefined;
+            const base = baseId ? composed.get(baseId) : derivation.base.kind === "builtin" && derivation.base.name.local === "anyType"
+                ? { content: [{ kind: "builtin", reference: derivation.base }], mixed: true, attributes: [], wildcard: { namespace: { kind: "not", namespaces: [] }, processContents: "lax", sources: [] }, obligations: [] } : undefined;
+            if (derivation.contentKind === "complex" && baseNode?.kind !== "complexType" && !(derivation.base.kind === "builtin" && derivation.base.name.local === "anyType"))
+                fail(node, "Complex content requires a complex base");
+            if (derivation.contentKind === "simple") {
+                if (node.content)
+                    fail(node, "Simple content cannot contribute particles");
+                if (baseNode?.kind === "complexType" && !base?.scalar && (derivation.kind === "extension" || !base?.mixed))
+                    fail(node, "Simple content base has no scalar content");
+                if (derivation.base.kind === "builtin" && derivation.base.name.local === "anyType" && (derivation.kind === "extension" || !derivation.inlineType))
+                    fail(node, "Simple content requires a scalar base or an inline restriction type");
+                if (derivation.kind === "restriction" && !base && baseNode?.kind !== "complexType")
+                    fail(node, "Simple-content restriction requires a complex base");
+                const inherited = base?.scalar;
+                for (const ignored of inherited?.layers ?? [])
+                    budget.step(node);
+                scalar = { base: inherited?.base ?? derivation.inlineType ?? derivation.base, layers: [...(inherited?.layers ?? []), { owner: node.id, facets: derivation.facets, inlineType: derivation.inlineType }] };
+                obligations.push({ kind: "scalar-derivation", owner: node.id, base: derivation.base, local: derivation.inlineType });
+            }
+            if (base) {
+                count(node, base.content, base.attributes, base.obligations);
+                count(node, base.wildcard?.namespace.namespaces ?? []);
+                obligations.push(...base.obligations);
+                if (derivation.kind === "extension") {
+                    if (derivation.contentKind === "complex") {
+                        content = extendContent(base.content, node.content);
+                        if (!node.content)
+                            mixed = base.mixed;
+                    }
+                    const merged = new Map(base.attributes.map(a => [key(a.name), a]));
+                    for (const a of local.attributes) {
+                        budget.step(node);
+                        const prior = merged.get(key(a.name));
+                        if (a.use === "prohibited") {
+                            if (prior)
+                                obligations.push({ kind: "attribute-extension-equivalence", owner: node.id, base: prior.declaration, local: a.declaration });
+                            continue; // Prohibition contributes no use on extension, never deletes base.
+                        }
+                        if (prior && prior.use !== "prohibited") {
+                            if (prior.use === "required" && a.use !== "required")
+                                fail(node, "Extension cannot weaken a required attribute");
+                            obligations.push({ kind: "attribute-extension-equivalence", owner: node.id, base: prior.declaration, local: a.declaration });
+                            if (prior.value?.kind === "fixed")
+                                obligations.push({ kind: "fixed-value-equivalence", owner: node.id, base: prior.value, local: a.value });
+                        }
+                        merged.set(key(a.name), prior ? { ...a, sources: copySources(node, prior.sources, a.sources) } : a);
+                    }
+                    attributes = [...merged.values()];
+                    if (base.wildcard && local.wildcard) {
+                        count(node, local.wildcard.namespace.namespaces);
+                        wildcard = { ...local.wildcard, namespace: namespaceUnion(base.wildcard.namespace, local.wildcard.namespace, wildcardCharge(node)), sources: copySources(node, base.wildcard.sources, local.wildcard.sources) };
+                    }
+                    else
+                        wildcard = local.wildcard ?? base.wildcard;
+                    obligations.push({ kind: "particle-extension", owner: node.id, base: baseId ?? derivation.base, local: node.content });
+                }
+                else {
+                    const merged = new Map(base.attributes.map(a => [key(a.name), a]));
+                    for (const a of local.attributes) {
+                        budget.step(node);
+                        const prior = merged.get(key(a.name));
+                        if (prior?.use === "required" && a.use !== "required")
+                            fail(node, "Restriction cannot weaken or prohibit a required attribute");
+                        if (!prior && a.use !== "prohibited" && (!base.wildcard || !allows(base.wildcard.namespace, a.name.namespace, wildcardCharge(node))))
+                            fail(node, "New restricted attribute is outside the base wildcard");
+                        if (prior?.value?.kind === "fixed")
+                            obligations.push({ kind: "fixed-value-equivalence", owner: node.id, base: prior.value, local: a.value });
+                        if (prior && a.use !== "prohibited")
+                            obligations.push({ kind: "attribute-type-restriction", owner: node.id, base: prior.type, local: a.type });
+                        merged.set(key(a.name), prior ? { ...a, sources: copySources(node, prior.sources, a.sources) } : a);
+                    }
+                    attributes = [...merged.values()];
+                    wildcard = local.wildcard; // Omitted restriction wildcard is removed.
+                    if (wildcard) {
+                        if (!base.wildcard || !namespaceSubset(wildcard.namespace, base.wildcard.namespace, wildcardCharge(node)))
+                            fail(node, "Restricted wildcard is not a subset of its base");
+                        const baseProcess = base.wildcard?.processContents;
+                        if (typeof wildcard.processContents === "string" && typeof baseProcess === "string" && !processContentsRestricts(wildcard.processContents, baseProcess, wildcardCharge(node)))
+                            fail(node, "Restricted wildcard weakens processContents");
+                    }
+                    obligations.push({ kind: "particle-restriction", owner: node.id, base: baseId ?? derivation.base, local: node.content });
+                }
+                obligations.push({ kind: "mixed-content", owner: node.id, base: baseId ?? derivation.base });
+            }
+        }
+        count(node, content, attributes, obligations);
+        return deepFreeze({ id: node.id, content, mixed, attributes, wildcard, scalar, derivation, obligations, assessment: "requires-schema-assessment" });
+    };
+    // Derivation order only, never recursively traverse element/type value graphs.
+    for (const root of graph.nodes) {
+        if (root.kind !== "complexType" || composed.has(root.id))
+            continue;
+        const stack = [root], active = new Set();
+        while (stack.length) {
+            const node = stack[stack.length - 1];
+            budget.step(node);
+            if (composed.has(node.id)) {
+                stack.pop();
+                active.delete(node.id);
+                continue;
+            }
+            const baseId = node.derivation ? referenceTarget(node.derivation.base, nodes, node) : undefined, base = baseId ? get(baseId) : undefined;
+            if (base?.kind === "complexType" && !composed.has(base.id)) {
+                if (active.has(base.id))
+                    fail(node, "Cyclic derivation supplied to composition");
+                active.add(node.id);
+                stack.push(base);
+                continue;
+            }
+            composed.set(node.id, compose(node));
+            stack.pop();
+            active.delete(node.id);
+        }
+    }
+    return deepFreeze({ resolved, types: [...composed.values()].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0), metrics: { steps: budget.steps } });
+}

package/dist/compiler/dataOwnership.d.ts

@@ -0,0 +1,21 @@
+export declare class DataOwnershipLimitError extends RangeError {
+}
+export interface DataOwnershipLimits {
+    readonly maxEntries: number;
+    readonly maxText: number;
+    readonly maxDepth: number;
+}
+export declare const DIRECT_METADATA_LIMITS: Readonly<{
+    maxEntries: 100000;
+    maxText: number;
+    maxDepth: 256;
+}>;
+export declare function createDataOwnership(chargeWork: (amount?: number) => void, limits?: DataOwnershipLimits): {
+    snapshot: <T>(value: T, check?: () => void) => T;
+    freeze: <T>(value: T) => Readonly<T>;
+};
+/** Routine data copies do not pretend to reserve CPU or heap. Owners enforce their input caps. */
+export declare const dataOwnership: Readonly<{
+    snapshot: <T>(value: T, check?: () => void) => T;
+    freeze: <T>(value: T) => Readonly<T>;
+}>;

package/dist/compiler/dataOwnership.js

@@ -0,0 +1,167 @@
+/** Shared data ownership; the callback supplies cancellation or semantic accounting. */
+import { types } from 'node:util';
+export class DataOwnershipLimitError extends RangeError {
+}
+export const DIRECT_METADATA_LIMITS = Object.freeze({ maxEntries: 100_000, maxText: 1024 * 1024, maxDepth: 256 });
+export function createDataOwnership(chargeWork, limits) {
+    // @why Canonical preparation revisits shared immutable source subtrees; only this owner's completed traversals are reusable.
+    const frozen = new WeakSet();
+    function arrayIndex(index) {
+        // Array positions are bounded by JavaScript's array length, so this is a
+        // constant-size numeric decision, followed by a precharged text conversion.
+        const digits = index < 10 ? 1 : index < 100 ? 2 : index < 1_000 ? 3 :
+            index < 10_000 ? 4 : index < 100_000 ? 5 : index < 1_000_000 ? 6 :
+                index < 10_000_000 ? 7 : index < 100_000_000 ? 8 : index < 1_000_000_000 ? 9 : 10;
+        chargeWork(1 + digits);
+        return String(index);
+    }
+    function snapshot(value, check) {
+        // Explicit stacks preserve sharing without recursive call-stack expansion.
+        chargeWork(3); // Identity map and source/target stacks.
+        const copied = new Map();
+        const sources = [];
+        const targets = [];
+        const depths = [];
+        let entries = 0, text = 0;
+        const countText = (length) => {
+            if (limits && length > limits.maxText - text)
+                throw new DataOwnershipLimitError('metadata text limit');
+            text += length;
+        };
+        function copy(current, depth = 0) {
+            check?.();
+            if (limits && (++entries > limits.maxEntries || depth > limits.maxDepth))
+                throw new DataOwnershipLimitError('metadata entry/depth limit');
+            chargeWork(); // Value access.
+            if (typeof current === 'string') {
+                countText(current.length);
+                chargeWork(current.length); // Produced/inspected immutable text.
+                return current;
+            }
+            if (current === null || typeof current !== 'object')
+                return current;
+            if (types.isProxy(current))
+                throw new TypeError('Metadata requires data records and arrays');
+            chargeWork(); // Identity-map read.
+            const prior = copied.get(current);
+            if (prior !== undefined)
+                return prior;
+            chargeWork(); // Array classification.
+            const array = Array.isArray(current);
+            if (!array)
+                chargeWork(); // Prototype introspection.
+            const prototype = array ? undefined : Object.getPrototypeOf(current);
+            if (!array && prototype !== Object.prototype && prototype !== null) {
+                throw new TypeError('RE01 snapshots require data records and arrays');
+            }
+            chargeWork(4); // Container, map insertion and two stack pushes.
+            const result = array ? [] : {};
+            copied.set(current, result);
+            sources.push(current);
+            targets.push(result);
+            depths.push(depth);
+            return result;
+        }
+        const result = copy(value);
+        while (sources.length > 0) {
+            chargeWork(2); // Both stack pops.
+            const source = sources.pop();
+            const target = targets.pop();
+            const depth = depths.pop();
+            chargeWork(); // Array classification for the traversal.
+            if (Array.isArray(source)) {
+                chargeWork(); // Length read.
+                const length = source.length;
+                if (limits && length > limits.maxEntries - entries)
+                    throw new DataOwnershipLimitError('metadata entry limit');
+                for (let index = 0; index < length; index += 1) {
+                    // Introspection plus its descriptor (record/four fields/35 key units),
+                    // followed by the input value read and output entry.
+                    chargeWork(43);
+                    const descriptor = Object.getOwnPropertyDescriptor(source, arrayIndex(index));
+                    if (descriptor === undefined || !('value' in descriptor)) {
+                        throw new TypeError('RE01 arrays require present data entries');
+                    }
+                    target[index] = copy(descriptor.value, depth + 1);
+                }
+            }
+            else {
+                for (const key in source) {
+                    chargeWork(); // Own-field introspection.
+                    if (!Object.hasOwn(source, key))
+                        continue;
+                    countText(key.length);
+                    // The property descriptor is an allocated record with four fields
+                    // and 35 field-name units, as well as the inspected/copied field.
+                    chargeWork(83 + key.length);
+                    const descriptor = Object.getOwnPropertyDescriptor(source, key);
+                    if (descriptor === undefined || !('value' in descriptor)) {
+                        throw new TypeError('RE01 records require data fields');
+                    }
+                    Object.defineProperty(target, key, {
+                        value: copy(descriptor.value, depth + 1),
+                        enumerable: true, configurable: true, writable: true,
+                    });
+                }
+            }
+        }
+        return result;
+    }
+    function freeze(value) {
+        chargeWork(2); // Visited set and traversal stack.
+        const seen = new Set();
+        const stack = [];
+        chargeWork();
+        stack.push(value);
+        while (stack.length > 0) {
+            chargeWork(); // Pop.
+            const current = stack.pop();
+            if (current === null || typeof current !== 'object')
+                continue;
+            chargeWork(); // Set read.
+            if (seen.has(current))
+                continue;
+            chargeWork();
+            if (frozen.has(current))
+                continue;
+            chargeWork(2); // Visit-state insertion and freeze traversal.
+            seen.add(current);
+            chargeWork(); // Array classification.
+            if (Array.isArray(current)) {
+                chargeWork(); // Length read.
+                const length = current.length;
+                for (let index = 0; index < length; index += 1) {
+                    chargeWork(43); // Descriptor inspection/allocation, value read and push.
+                    const descriptor = Object.getOwnPropertyDescriptor(current, arrayIndex(index));
+                    if (descriptor === undefined || !('value' in descriptor)) {
+                        throw new TypeError('RE01 arrays require present data entries');
+                    }
+                    stack.push(descriptor.value);
+                }
+            }
+            else {
+                for (const key in current) {
+                    chargeWork(43 + key.length); // Descriptor, field access, name inspection and push.
+                    const descriptor = Object.getOwnPropertyDescriptor(current, key);
+                    if (descriptor === undefined)
+                        continue;
+                    if (!('value' in descriptor)) {
+                        throw new TypeError('RE01 records require data fields');
+                    }
+                    stack.push(descriptor.value);
+                }
+            }
+            Object.freeze(current);
+        }
+        // @constraints A shallow external freeze or interrupted traversal supplies no reusable deep-freeze evidence.
+        for (const current of seen) {
+            chargeWork(2);
+            if (!types.isProxy(current))
+                frozen.add(current);
+        }
+        return value;
+    }
+    return { snapshot, freeze };
+}
+/** Routine data copies do not pretend to reserve CPU or heap. Owners enforce their input caps. */
+export const dataOwnership = Object.freeze(createDataOwnership(() => { }, DIRECT_METADATA_LIMITS));

package/dist/compiler/datatypeValues.d.ts

@@ -0,0 +1,46 @@
+/** Neutral datatype calculations. No schema or payload authority/receipt is conferred here. */
+import type { SemanticTypeReference as Reference } from "./semanticTypeReference.js";
+import type { DatatypeLexicalOperand, DatatypeValueContext } from "./schemaValueContext.js";
+import type { SyntaxSource } from '../loader/orderedSyntax.js';
+import type { Calendar, Duration } from "./schemaExactCalendar.js";
+export type DecimalOperand = Readonly<{
+    coefficient: bigint;
+    scale: number; /** Conservative digit bound, charged before conversion/copying. */
+    digits?: number;
+}>;
+export type DatatypeOperand = Readonly<{
+    family: string;
+    canonical: string;
+    length?: string;
+    decimal?: DecimalOperand;
+    ordered?: readonly DecimalOperand[];
+    zoned?: boolean;
+    /** Successful datatype/member normalization, only for schema operand checks. */
+    normalized?: string;
+    calendar?: Calendar;
+    duration?: Duration;
+    items?: readonly DatatypeOperand[];
+    selectedMembers?: readonly Reference[];
+}>;
+export type DatatypeListTokens = Readonly<{
+    normalized: string;
+    tokens: readonly string[];
+    source: SyntaxSource;
+}>;
+export declare const builtinListItem: (name: string) => "NMTOKEN" | "IDREF" | "ENTITY" | undefined;
+export declare const builtinParents: Readonly<Record<string, string>>;
+export declare const integerBounds: Readonly<Record<string, readonly [string | undefined, string | undefined]>>;
+export declare const builtinPrimitive: (name: string) => string;
+export declare const whitespaceFor: (name: string) => "preserve" | "replace" | "collapse";
+export { normalizeWhitespace } from '../util/xmlWhitespace.js';
+export declare function datatypeValues<Owner>(c: DatatypeValueContext<Owner>): {
+    atomic: (name: string, lexical: DatatypeLexicalOperand, owner: Owner, whitespace?: "replace" | "preserve" | "collapse") => DatatypeOperand;
+    builtin: (name: string, lexical: DatatypeLexicalOperand, owner: Owner) => DatatypeOperand;
+    listTokens: (lexical: DatatypeLexicalOperand, owner: Owner) => DatatypeListTokens;
+    listOperand: (tokens: DatatypeListTokens, items: readonly DatatypeOperand[], owner: Owner, builtinName?: string) => DatatypeOperand;
+    decimal: (text: string, owner: Owner) => DecimalOperand;
+    decimalKey: (d: DecimalOperand, owner: Owner) => string;
+    compareDecimal: (a: DecimalOperand, b: DecimalOperand, owner: Owner) => number;
+    sameValue: (a: DatatypeOperand, b: DatatypeOperand, owner: Owner) => boolean;
+    compare: (a: DatatypeOperand, b: DatatypeOperand, owner: Owner) => number | undefined;
+};