@techspokes/typescript-wsdl-client 1.1.3 → 1.1.5

package/dist/compiler/datatypeValues.js

@@ -0,0 +1,275 @@
+import { isXmlNCName, isXmlName, isXmlNmtoken } from "../loader/orderedSyntax.js";
+import { parseCalendar, parseReduced, parseDuration, compareCalendar, compareDuration, ProbeFailure } from "./schemaExactCalendar.js";
+import { schemaUri } from "./schemaUri.js";
+import { normalizeWhitespace } from '../util/xmlWhitespace.js';
+export const builtinListItem = (name) => name === 'NMTOKENS' ? 'NMTOKEN' : name === 'IDREFS' ? 'IDREF' : name === 'ENTITIES' ? 'ENTITY' : undefined;
+export const builtinParents = Object.freeze({
+    normalizedString: "string", token: "normalizedString", language: "token", NMTOKEN: "token", Name: "token", NCName: "Name",
+    ID: "NCName", IDREF: "NCName", ENTITY: "NCName", integer: "decimal", nonPositiveInteger: "integer", negativeInteger: "nonPositiveInteger",
+    long: "integer", int: "long", short: "int", byte: "short", nonNegativeInteger: "integer", unsignedLong: "nonNegativeInteger",
+    unsignedInt: "unsignedLong", unsignedShort: "unsignedInt", unsignedByte: "unsignedShort", positiveInteger: "nonNegativeInteger",
+});
+export const integerBounds = Object.freeze({
+    nonPositiveInteger: [undefined, "0"], negativeInteger: [undefined, "-1"], nonNegativeInteger: ["0", undefined], positiveInteger: ["1", undefined],
+    long: ["-9223372036854775808", "9223372036854775807"], int: ["-2147483648", "2147483647"], short: ["-32768", "32767"], byte: ["-128", "127"],
+    unsignedLong: ["0", "18446744073709551615"], unsignedInt: ["0", "4294967295"], unsignedShort: ["0", "65535"], unsignedByte: ["0", "255"],
+});
+export const builtinPrimitive = (name) => {
+    while (builtinParents[name])
+        name = builtinParents[name];
+    return name;
+};
+export const whitespaceFor = (name) => name === "string" || name === "anySimpleType" ? "preserve" : name === "normalizedString" ? "replace" : "collapse";
+export { normalizeWhitespace } from '../util/xmlWhitespace.js';
+export function datatypeValues(c) {
+    const invalid = (owner, lexical) => c.fail(owner, "cvc-datatype-valid", "Schema operand is outside the datatype's lexical/value space", lexical.context.source);
+    const decimal = (text, owner) => {
+        c.text(text, owner);
+        if (!/^[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)$/.test(text))
+            c.fail(owner, "cvc-datatype-valid", "Schema numeric operand must be an exact decimal");
+        const dot = text.indexOf("."), scale = dot < 0 ? 0 : text.length - dot - 1;
+        c.step(owner, (text.length + 2) ** 2);
+        let coefficient = BigInt(text.replace(".", "")), resultScale = scale;
+        while (resultScale && coefficient % 10n === 0n) {
+            c.step(owner, text.length + 1);
+            coefficient /= 10n;
+            resultScale--;
+        }
+        return { coefficient, scale: resultScale, digits: text.length };
+    };
+    const scaleTo = (value, scale, owner) => {
+        c.step(owner, (scale - value.scale + (value.digits ?? 20) + 2) ** 2);
+        return value.coefficient * 10n ** BigInt(scale - value.scale);
+    };
+    const compareDecimal = (a, b, owner) => {
+        const scale = Math.max(a.scale, b.scale), x = scaleTo(a, scale, owner), y = scaleTo(b, scale, owner);
+        return x === y ? 0 : x < y ? -1 : 1;
+    };
+    const decimalKey = (d, owner) => {
+        c.step(owner, d.scale + (d.digits ?? 20) + 2);
+        const raw = (d.coefficient < 0n ? -d.coefficient : d.coefficient).toString().padStart(d.scale + 1, "0");
+        return `${d.coefficient < 0n ? "-" : ""}${d.scale ? raw.slice(0, -d.scale) + "." + raw.slice(-d.scale) : raw}`;
+    };
+    const addDecimal = (a, b, owner) => {
+        const scale = Math.max(a.scale, b.scale);
+        return { coefficient: scaleTo(a, scale, owner) + scaleTo(b, scale, owner), scale, digits: Math.max((a.digits ?? 20) + scale - a.scale, (b.digits ?? 20) + scale - b.scale) + 1 };
+    };
+    const calendarBudget = (owner) => ({
+        charge: work => c.step(owner, work), arithmetic: digits => c.step(owner, (digits + 2) ** 2), text: value => c.text(value, owner),
+    });
+    const temporal = (name, value, lexical, owner) => {
+        try {
+            const budget = calendarBudget(owner);
+            const calendar = name === "date" || name === "dateTime" ? parseCalendar(name, value, budget) : parseReduced(name, value, budget);
+            return { family: name, canonical: (calendar.zoned ? "zoned:" : "local:") + decimalKey(calendar.seconds, owner), calendar };
+        }
+        catch (error) {
+            if (error instanceof ProbeFailure && error.kind === "invalid-schema")
+                return invalid(owner, lexical);
+            throw error;
+        }
+    };
+    /** Round the exact decimal rational directly to its declared IEEE format. */
+    const ieee = (value, single, owner) => {
+        const negative = value[0] === "-", unsigned = value.replace(/^[+-]/, "");
+        const [mantissa, rawExponent = "0"] = unsigned.split(/[eE]/), dot = mantissa.indexOf(".");
+        const digits = mantissa.replace(".", "").replace(/^0+/, "");
+        if (!digits)
+            return 0;
+        c.step(owner, (rawExponent.length + 2) ** 2);
+        const exponent = BigInt(rawExponent) - BigInt(dot < 0 ? 0 : mantissa.length - dot - 1);
+        const order = exponent + BigInt(digits.length - 1);
+        // Outside these conservative thresholds, exact IEEE rounding is known
+        // without constructing a power from an adversarial exponent literal.
+        if (order > BigInt(single ? 39 : 309))
+            return negative ? -Infinity : Infinity;
+        if (order < BigInt(single ? -47 : -326))
+            return 0;
+        const magnitude = exponent < 0n ? -exponent : exponent;
+        // The inequalities above bound magnitude by input length + 327. Charge
+        // decimal powers and binary representations before constructing either.
+        c.step(owner, (digits.length * 4 + Number(magnitude) * 4 + 32) ** 2);
+        const power = 10n ** magnitude;
+        let numerator = BigInt(digits), denominator = 1n;
+        if (exponent >= 0n)
+            numerator *= power;
+        else
+            denominator = power;
+        const bits = (number) => number.toString(2).length;
+        let binaryExponent = bits(numerator) - bits(denominator);
+        const below = binaryExponent >= 0 ? numerator < denominator << BigInt(binaryExponent) : numerator << BigInt(-binaryExponent) < denominator;
+        if (below)
+            binaryExponent--;
+        const precision = single ? 24 : 53, minimum = single ? -126 : -1022, maximum = single ? 127 : 1023;
+        binaryExponent = Math.max(minimum, binaryExponent);
+        const shift = precision - 1 - binaryExponent;
+        c.step(owner, Math.abs(shift) + 1);
+        if (shift >= 0)
+            numerator <<= BigInt(shift);
+        else
+            denominator <<= BigInt(-shift);
+        let significand = numerator / denominator;
+        const twiceRemainder = numerator % denominator * 2n;
+        if (twiceRemainder > denominator || twiceRemainder === denominator && significand % 2n !== 0n)
+            significand++;
+        if (significand === 1n << BigInt(precision)) {
+            significand >>= 1n;
+            binaryExponent++;
+        }
+        if (binaryExponent > maximum)
+            return negative ? -Infinity : Infinity;
+        const number = Number(significand) * 2 ** (binaryExponent - precision + 1);
+        return negative ? -number : number;
+    };
+    const atomic = (name, lexical, owner, whitespace = whitespaceFor(name)) => {
+        c.text(lexical.value, owner);
+        for (const character of lexical.value) {
+            c.step(owner);
+            const code = character.codePointAt(0);
+            if (!(code === 9 || code === 10 || code === 13 || code >= 0x20 && code <= 0xd7ff || code >= 0xe000 && code <= 0xfffd || code >= 0x10000 && code <= 0x10ffff))
+                return invalid(owner, lexical);
+        }
+        const value = normalizeWhitespace(lexical.value, whitespace), family = builtinPrimitive(name);
+        if (name === "ENTITY")
+            c.unresolved(owner, "datatype:ENTITY", "A schema ENTITY operand requires a DTD declaration context excluded by the loading policy", lexical.context.source);
+        if (family === "decimal") {
+            if (name !== "decimal" && !/^[+-]?[0-9]+$/.test(value))
+                return invalid(owner, lexical);
+            const d = decimal(value, owner), bound = integerBounds[name];
+            if (bound && (bound[0] !== undefined && compareDecimal(d, decimal(bound[0], owner), owner) < 0 || bound[1] !== undefined && compareDecimal(d, decimal(bound[1], owner), owner) > 0))
+                return invalid(owner, lexical);
+            return { family, canonical: decimalKey(d, owner), decimal: d };
+        }
+        if (family === "boolean") {
+            if (!["true", "false", "1", "0"].includes(value))
+                return invalid(owner, lexical);
+            return { family, canonical: value === "true" || value === "1" ? "true" : "false" };
+        }
+        if (family === "float" || family === "double") {
+            if (!["INF", "-INF", "NaN"].includes(value) && !/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(value))
+                return invalid(owner, lexical);
+            const typed = value === "INF" ? Infinity : value === "-INF" ? -Infinity : value === "NaN" ? NaN : ieee(value, family === "float", owner);
+            return { family, canonical: Number.isNaN(typed) ? "NaN" : typed === 0 ? "0" : String(typed) };
+        }
+        if (family === "QName" || family === "NOTATION") {
+            const parts = value.split(":");
+            if (parts.length > 2 || parts.some(p => !isXmlNCName(p)))
+                return invalid(owner, lexical);
+            const prefix = parts.length === 2 ? parts[0] : "", namespace = lexical.context.namespaces[prefix];
+            if (prefix && namespace === undefined)
+                return invalid(owner, lexical);
+            c.text(namespace ?? "", owner);
+            if (family === "NOTATION")
+                c.notation(namespace ?? "", parts.at(-1), owner);
+            return { family, canonical: JSON.stringify([namespace ?? "", parts.at(-1)]) };
+        }
+        if (family === "hexBinary" || family === "base64Binary") {
+            let bytes;
+            if (family === "hexBinary") {
+                if (!/^(?:[0-9a-fA-F]{2})*$/.test(value))
+                    return invalid(owner, lexical);
+                c.step(owner, value.length);
+                bytes = Buffer.from(value, "hex");
+            }
+            else {
+                const compact = value.replace(/[\t\r\n ]/g, "");
+                if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(compact))
+                    return invalid(owner, lexical);
+                c.step(owner, compact.length);
+                bytes = Buffer.from(compact, "base64");
+                if (bytes.toString("base64") !== compact)
+                    return invalid(owner, lexical);
+            }
+            c.step(owner, bytes.length * 2);
+            return { family, canonical: bytes.toString("hex"), length: bytes.length.toString() };
+        }
+        if (["dateTime", "date", "time", "gYearMonth", "gYear", "gMonthDay", "gDay", "gMonth"].includes(family))
+            return temporal(family, value, lexical, owner);
+        if (family === "duration") {
+            try {
+                const duration = parseDuration(value, calendarBudget(owner));
+                return { family, canonical: duration.months + "/" + decimalKey(duration.seconds, owner), duration };
+            }
+            catch (error) {
+                if (error instanceof ProbeFailure && error.kind === "invalid-schema")
+                    return invalid(owner, lexical);
+                throw error;
+            }
+        }
+        if (family === "string" || family === "anySimpleType" || family === "anyURI") {
+            if (name === "language" && !/^[a-zA-Z]{1,8}(?:-[a-zA-Z0-9]{1,8})*$/.test(value))
+                return invalid(owner, lexical);
+            if (["Name", "NCName", "NMTOKEN", "ID", "IDREF", "ENTITY"].includes(name)) {
+                if (!(name === "NMTOKEN" ? isXmlNmtoken(value) : name === "Name" ? isXmlName(value) : isXmlNCName(value)))
+                    return invalid(owner, lexical);
+            }
+            // anyURI is an IRI reference after escaping; relative/empty values are legal.
+            if (family === "anyURI" && !schemaUri(value, owner, c))
+                return invalid(owner, lexical);
+            let length = 0;
+            for (const ignored of value) {
+                c.step(owner);
+                length++;
+            }
+            return { family: family === "anySimpleType" ? "string" : family, canonical: value, length: length.toString() };
+        }
+        return c.unsupported(owner, `datatype:${name}`, "Datatype is outside the approved scalar profile", lexical.context.source);
+    };
+    const sameValue = (a, b, owner) => {
+        c.text(a.canonical, owner);
+        c.text(b.canonical, owner);
+        return a.family === b.family && a.canonical === b.canonical;
+    };
+    const compare = (a, b, owner) => {
+        c.step(owner);
+        if (a.family !== b.family)
+            return undefined;
+        if (a.decimal && b.decimal)
+            return compareDecimal(a.decimal, b.decimal, owner);
+        if (a.family === "float" || a.family === "double") {
+            if (a.canonical === "NaN" || b.canonical === "NaN")
+                return a.canonical === b.canonical ? 0 : undefined;
+            const x = Number(a.canonical), y = Number(b.canonical);
+            return x === y ? 0 : x < y ? -1 : 1;
+        }
+        if (a.calendar && b.calendar || a.duration && b.duration) {
+            const order = a.calendar && b.calendar ? compareCalendar(a.calendar, b.calendar, calendarBudget(owner))
+                : compareDuration(a.duration, b.duration, calendarBudget(owner));
+            return order === "less" ? -1 : order === "greater" ? 1 : order === "equal" ? 0 : undefined;
+        }
+        return sameValue(a, b, owner) ? 0 : undefined;
+    };
+    const listTokens = (lexical, owner) => {
+        c.text(lexical.value, owner);
+        const normalized = normalizeWhitespace(lexical.value, 'collapse');
+        c.step(owner, normalized.length + 3);
+        return { normalized, tokens: normalized ? normalized.split(' ') : [], source: lexical.context.source };
+    };
+    const listOperand = (tokens, items, owner, builtinName) => {
+        c.step(owner, items.length * 2 + 4);
+        if (tokens.tokens.length !== items.length)
+            throw new TypeError('Internally assessed list item count differs from token count');
+        if (builtinName && builtinListItem(builtinName) && !items.length)
+            c.fail(owner, 'cvc-minLength-valid', 'Builtin token list requires at least one item', tokens.source);
+        const keys = [];
+        for (const item of items) {
+            c.step(owner, 8 * (item.family.length + item.canonical.length) + 16);
+            keys.push(JSON.stringify([item.family, item.canonical]));
+        }
+        for (const key of keys)
+            c.step(owner, key.length * 8 + 4);
+        return { family: 'list', canonical: JSON.stringify(keys), length: items.length.toString(), normalized: tokens.normalized, items };
+    };
+    const builtin = (name, lexical, owner) => {
+        c.step(owner);
+        const itemName = builtinListItem(name);
+        if (!itemName)
+            return atomic(name, lexical, owner);
+        const tokens = listTokens(lexical, owner), items = [];
+        c.step(owner, tokens.tokens.length * 3);
+        for (const value of tokens.tokens)
+            items.push(atomic(itemName, { value, context: lexical.context }, owner));
+        return listOperand(tokens, items, owner, name);
+    };
+    return { atomic, builtin, listTokens, listOperand, decimal, decimalKey, compareDecimal, sameValue, compare };
+}

package/dist/compiler/directCodec.d.ts

@@ -0,0 +1,59 @@
+import type { DirectOperationContract } from './directOperation.js';
+import type { DirectValueMapping, DirectValueReceipt, DirectValueFailure, DirectExpandedValue } from './directValues.js';
+import type { SyntaxElement, SyntaxSource } from '../loader/orderedSyntax.js';
+import type { ResolverUsage } from './semanticBudget.js';
+export interface DirectXmlLimits {
+    readonly maxBytes?: number;
+    readonly maxDepth?: number;
+    readonly maxNodes?: number;
+    /** Aggregate parsed/emitted text in UTF-16 units, excluding markup. */
+    readonly maxText?: number;
+}
+export declare const DIRECT_XML_LIMITS: Readonly<{
+    maxBytes: number;
+    maxDepth: 256;
+    maxNodes: 100000;
+    maxText: number;
+}>;
+type Options = Readonly<{
+    signal?: AbortSignal;
+    limits?: DirectXmlLimits;
+}>;
+/** Internal protocol selection over the same parsed observed document. */
+export interface DirectPayloadSelection {
+    readonly payload: SyntaxElement;
+    readonly mapping: DirectValueMapping;
+}
+export interface DirectCodecFailure {
+    readonly kind: DirectValueFailure['kind'] | 'xml-invalid' | 'mismatch';
+    readonly rule: string;
+    readonly source?: SyntaxSource;
+    readonly schemaPath?: string;
+    readonly payloadPath?: string;
+    readonly usage: ResolverUsage;
+}
+export interface DirectEncodedXml {
+    readonly kind: 'direct-encoded';
+    readonly admitted: false;
+    readonly encoding: 'utf-8';
+    /** Owned mutable output bytes; bytes are data, never receipt authority. */
+    readonly bytes: Uint8Array;
+    readonly expanded: DirectExpandedValue;
+    readonly usage: ResolverUsage;
+}
+export interface DirectDecodedXml {
+    readonly kind: 'direct-decoded';
+    readonly admitted: false;
+    readonly payload: SyntaxElement;
+    readonly validated: DirectValueReceipt;
+    readonly usage: ResolverUsage;
+}
+/** Validate fresh values using the delivered inverse, then emit deterministic UTF-8. */
+export declare function encodeDirectXml(contract: DirectOperationContract, mapping: unknown, application: unknown, options?: Options): DirectEncodedXml | DirectCodecFailure;
+/** Bounded observed bytes -> ordered syntax -> existing structural/scalar checks. */
+export declare function decodeDirectXml(contract: DirectOperationContract, mapping: unknown, bytes: Uint8Array, options?: Options & Readonly<{
+    uri?: string;
+    selectPayload?: (root: SyntaxElement) => DirectPayloadSelection;
+}>): DirectDecodedXml | DirectCodecFailure;
+export {};
+//# sourceMappingURL=directCodec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"directCodec.d.ts","sourceRoot":"","sources":["../../src/compiler/directCodec.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,sBAAsB,CAAC;AAElE,OAAO,KAAK,EAAC,kBAAkB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,mBAAmB,EAAC,MAAM,mBAAmB,CAAC;AAGvH,OAAO,KAAK,EAAC,aAAa,EAAE,YAAY,EAAC,MAAM,4BAA4B,CAAC;AAC5E,OAAO,KAAK,EAAiB,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAEvE,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,uEAAuE;IACvE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AACD,eAAO,MAAM,iBAAiB;;;;;EAAiG,CAAC;AAChI,KAAK,OAAO,GAAG,QAAQ,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAAC,MAAM,CAAC,EAAE,eAAe,CAAA;CAAC,CAAC,CAAC;AAC1E,0EAA0E;AAC1E,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;CACtC;AACD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,GAAG,aAAa,GAAG,UAAU,CAAC;IACvE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;CAC/B;AACD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IACtF,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;CAC/B;AACD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;IAC1D,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,kBAAkB,CAAC;IACxE,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;CAC/B;AA0DD,wFAAwF;AACxF,wBAAgB,eAAe,CAAC,QAAQ,EAAE,uBAAuB,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,GAAE,OAAY,GAAG,gBAAgB,GAAG,kBAAkB,CAqDvK;AAED,qFAAqF;AACrF,wBAAgB,eAAe,CAAC,QAAQ,EAAE,uBAAuB,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EACpG,OAAO,GAAE,OAAO,GAAG,QAAQ,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,sBAAsB,CAAA;CAAC,CAAM,GAAG,gBAAgB,GAAG,kBAAkB,CAoC1J"}

package/dist/compiler/directCodec.js

@@ -0,0 +1,192 @@
+import { directDataOwnership, directLimit } from './directExecutionPolicy.js';
+/** Internal, buffered, bare-root XML codec. No SOAP envelope or dispatch. */
+import { checkSemanticBudget } from './semanticBudget.js';
+import { DataOwnershipLimitError } from './dataOwnership.js';
+import { types } from 'node:util';
+import { inspectDirectOperation } from './directOperation.js';
+import { inspectDirectValueMapping, expandDirectValue, assessDirectScalars } from './directValues.js';
+import { matchDirectOperation } from './directStructure.js';
+import { parseOrderedSyntax, SchemaLoadingError, XML_NAMESPACE } from '../loader/orderedSyntax.js';
+export const DIRECT_XML_LIMITS = Object.freeze({ maxBytes: 1024 * 1024, maxDepth: 256, maxNodes: 100_000, maxText: 1024 * 1024 });
+class Stop extends Error {
+    kind;
+    rule;
+    constructor(kind, rule) {
+        super(rule);
+        this.kind = kind;
+        this.rule = rule;
+    }
+}
+function run(contract, supplied, options, work) {
+    // Identity before all property reads, including version checks.
+    const mapping = inspectDirectValueMapping(supplied, contract);
+    const { budget } = inspectDirectOperation(contract).context;
+    const check = () => { checkSemanticBudget(budget); if (options.signal?.aborted)
+        throw new Stop('cancelled', 'cooperative-cancellation'); };
+    try {
+        const result = budget.guard(() => {
+            check();
+            if (mapping.version !== 'direct-values-v1' || mapping.contextId !== contract.contextId
+                || contract.basis !== 'native-direct-premises-v1' || contract.correspondence !== 'dated-XSD-2004-direct-v1'
+                || contract.binding.version !== '1.1' || contract.binding.style !== 'document' || contract.binding.use !== 'literal'
+                || contract.binding.transport !== 'http://schemas.xmlsoap.org/soap/http')
+                throw new Stop('unsupported', 'direct-codec-version');
+            const direction = mapping.direction;
+            const root = direction.kind === 'fault' ? contract.faults.find(f => {
+                check();
+                return budget.compareText(f.name, direction.name) === 0;
+            })?.root : contract[direction.kind];
+            if (mapping.root !== root)
+                throw new TypeError('Incompatible direct codec root');
+            const configured = options.limits === undefined ? {} : directDataOwnership(budget).snapshot(options.limits, check);
+            if (!configured || typeof configured !== 'object' || Array.isArray(configured))
+                throw new TypeError('Data-only XML limits required');
+            for (const key of Reflect.ownKeys(configured)) {
+                if (typeof key !== 'string' || !['maxBytes', 'maxDepth', 'maxNodes', 'maxText'].includes(key))
+                    throw new TypeError('Unknown XML limit');
+            }
+            const limits = {
+                maxBytes: directLimit(budget, DIRECT_XML_LIMITS.maxBytes), maxDepth: directLimit(budget, DIRECT_XML_LIMITS.maxDepth),
+                maxNodes: directLimit(budget, DIRECT_XML_LIMITS.maxNodes), maxText: directLimit(budget, DIRECT_XML_LIMITS.maxText),
+            };
+            for (const key of ['maxBytes', 'maxDepth', 'maxNodes', 'maxText']) {
+                const value = configured[key];
+                if (value !== undefined) {
+                    if (!Number.isSafeInteger(value) || value < 1)
+                        throw new RangeError('XML limits must be positive safe integers');
+                    limits[key] = value;
+                }
+            }
+            const result = work(mapping, { budget, limits, check });
+            // Native failures remain terminal even though publication has no synthetic work price.
+            check();
+            return Object.freeze({ ...result, usage: Object.freeze({ ...budget.usage() }) });
+        });
+        if (budget.exhausted())
+            return { kind: 'resource-limit', rule: 'request-budget', usage: budget.usage() };
+        return result;
+    }
+    catch (error) {
+        if (budget.exhausted())
+            return { kind: 'resource-limit', rule: 'request-budget', usage: budget.usage() };
+        if (error instanceof DataOwnershipLimitError)
+            return { kind: 'resource-limit', rule: error.message, usage: budget.usage() };
+        if (error instanceof Stop)
+            return Object.freeze({ kind: error.kind, rule: error.rule, usage: Object.freeze({ ...budget.usage() }) });
+        if (error instanceof SchemaLoadingError)
+            return Object.freeze({ kind: error.category === 'invalid-schema' ? 'xml-invalid'
+                    : error.category === 'resource-limit' ? 'resource-limit' : 'unsupported', rule: error.message, source: error.source,
+                usage: Object.freeze({ ...budget.usage() }) });
+        throw error;
+    }
+}
+/** Validate fresh values using the delivered inverse, then emit deterministic UTF-8. */
+export function encodeDirectXml(contract, mapping, application, options = {}) {
+    return run(contract, mapping, options, (owned, { budget, limits, check }) => {
+        const expanded = expandDirectValue(contract, owned, application, { ...options, maxText: Math.min(limits.maxText, limits.maxBytes), maxItems: Math.min(limits.maxNodes, limits.maxBytes) });
+        if (expanded.kind !== 'direct-expanded')
+            return expanded;
+        const pieces = [];
+        let byteLength = 0, nodes = 0, textUnits = 0, nextPrefix = 0;
+        const prefixes = new Map();
+        const append = (text) => {
+            check();
+            const size = Buffer.byteLength(text, 'utf8');
+            if (size > limits.maxBytes - byteLength)
+                throw new Stop('resource-limit', 'XML byte limit');
+            byteLength += size;
+            pieces.push(text);
+        };
+        const escape = (text, attribute = false) => {
+            check();
+            return text.replace(/[&<>\r"\t\n]/g, c => c === '&' ? '&amp;' : c === '<' ? '&lt;' : c === '>' ? '&gt;'
+                : c === '\r' ? '&#13;' : attribute && c === '"' ? '&quot;' : attribute && c === '\t' ? '&#9;'
+                    : attribute && c === '\n' ? '&#10;' : c);
+        };
+        const emit = (node, depth) => {
+            check();
+            budget.reserveNodes(1);
+            if (++nodes > limits.maxNodes || depth > limits.maxDepth)
+                throw new Stop('resource-limit', 'XML node/depth limit');
+            const namespace = node.name.namespace;
+            let prefix = namespace === XML_NAMESPACE ? 'xml' : prefixes.get(namespace);
+            if (namespace && prefix === undefined) {
+                prefix = `n${nextPrefix++}`;
+                prefixes.set(namespace, prefix);
+            }
+            // Bind at each use: a prefix first encountered on one sibling is not in
+            // scope at its next sibling. Never use a default namespace, so local
+            // unqualified children need no inherited-default reset.
+            const declaration = namespace && prefix !== 'xml' ? ` xmlns:${prefix}="${escape(namespace, true)}"` : '';
+            const name = prefix ? `${prefix}:${node.name.local}` : node.name.local;
+            append(`<${name}${declaration}>`);
+            for (const child of node.children) {
+                check();
+                if (child.kind === 'element')
+                    emit(child, depth + 1);
+                else {
+                    budget.reserveNodes(1);
+                    if (++nodes > limits.maxNodes || child.value.length > limits.maxText - textUnits)
+                        throw new Stop('resource-limit', 'XML node/text limit');
+                    textUnits += child.value.length;
+                    append(escape(child.value));
+                }
+            }
+            append(`</${name}>`);
+        };
+        emit(expanded.payload, 1);
+        // Actual output bytes were bounded by append; bytes are caller-owned data, not authority.
+        check();
+        const bytes = Buffer.from(pieces.join(''), 'utf8');
+        check();
+        return Object.freeze({ kind: 'direct-encoded', admitted: false, encoding: 'utf-8',
+            bytes, expanded, usage: Object.freeze({ ...budget.usage() }) });
+    });
+}
+/** Bounded observed bytes -> ordered syntax -> existing structural/scalar checks. */
+export function decodeDirectXml(contract, mapping, bytes, options = {}) {
+    return run(contract, mapping, options, (owned, { budget, limits, check }) => {
+        if (!types.isUint8Array(bytes) || types.isProxy(bytes))
+            throw new TypeError('XML requires Uint8Array bytes');
+        // Use native internal-slot access, avoiding subclass/own length, buffer and
+        // iterator getters. Shared backing stores are outside the data-only contract.
+        const typed = Object.getPrototypeOf(Uint8Array.prototype);
+        const length = Object.getOwnPropertyDescriptor(typed, 'byteLength').get.call(bytes);
+        const backing = Object.getOwnPropertyDescriptor(typed, 'buffer').get.call(bytes);
+        if (types.isSharedArrayBuffer(backing))
+            throw new TypeError('Shared XML bytes are unsupported');
+        if (length > limits.maxBytes)
+            throw new Stop('resource-limit', 'XML byte limit');
+        check();
+        const input = new Uint8Array(length);
+        Uint8Array.prototype.set.call(input, bytes);
+        const uri = options.uri ?? 'urn:typescript-wsdl-client:observed-direct-xml';
+        if (typeof uri !== 'string')
+            throw new TypeError('XML source URI must be a string');
+        check();
+        const root = parseOrderedSyntax(input, uri, { ...limits, xml10Only: true,
+            chargeWork: () => check(), reserveNode: () => { check(); budget.reserveNodes(1); } }).root;
+        const selection = options.selectPayload?.(root) ?? { payload: root, mapping: owned };
+        const payload = selection.payload;
+        const selectedMapping = inspectDirectValueMapping(selection.mapping, contract);
+        // Protocol selection may only return an actual node from this parse, never
+        // a synthetic tree relabeled with the observed document's provenance.
+        const contains = (node) => {
+            check();
+            return node === payload || node.children.some(child => child.kind === 'element' && contains(child));
+        };
+        if (!contains(root))
+            throw new TypeError('Protocol payload must belong to the observed document');
+        const structural = matchDirectOperation(contract, selectedMapping.direction, payload, options);
+        if (structural.kind !== 'structural-match')
+            return structural;
+        const validated = assessDirectScalars(contract, structural, options);
+        if (validated.kind !== 'direct-value')
+            return validated;
+        check();
+        directDataOwnership(budget).freeze(payload);
+        check();
+        return Object.freeze({ kind: 'direct-decoded', admitted: false, payload, validated,
+            usage: Object.freeze({ ...budget.usage() }) });
+    });
+}

package/dist/compiler/directExecutionPolicy.d.ts

@@ -0,0 +1,10 @@
+import type { SemanticBudget } from './semanticBudget.js';
+import type { LoadingLimits } from '../loader/schemaResources.js';
+export declare const DIRECT_REPRESENTATION_MAX: number;
+export declare function directDataOwnership(budget: SemanticBudget): Readonly<{
+    snapshot: <T>(value: T, check?: () => void) => T;
+    freeze: <T>(value: T) => Readonly<T>;
+}>;
+export declare function directLimit(budget: SemanticBudget, boundedProfile: number): number;
+export declare function directLoadingLimits(budget: SemanticBudget, overrides?: Partial<LoadingLimits>): Partial<LoadingLimits>;
+//# sourceMappingURL=directExecutionPolicy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"directExecutionPolicy.d.ts","sourceRoot":"","sources":["../../src/compiler/directExecutionPolicy.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAExD,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,8BAA8B,CAAC;AAEhE,eAAO,MAAM,yBAAyB,QAA0B,CAAC;AACjE,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,cAAc;;;GAEzD;AACD,wBAAgB,WAAW,CAAC,MAAM,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM,CAElF;AACD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAItH"}

package/dist/compiler/directExecutionPolicy.js

@@ -0,0 +1,17 @@
+/** Application-selected resource policy; numeric maxima below are representation ceilings, not quotas. */
+import { createDataOwnership, dataOwnership } from './dataOwnership.js';
+import { isApplicationUnmetered } from './semanticBudget.js';
+import { DEFAULT_LOADING_LIMITS } from '../loader/schemaResources.js';
+const unrestrictedData = createDataOwnership(() => { });
+export const DIRECT_REPRESENTATION_MAX = Number.MAX_SAFE_INTEGER;
+export function directDataOwnership(budget) {
+    return isApplicationUnmetered(budget) ? unrestrictedData : dataOwnership;
+}
+export function directLimit(budget, boundedProfile) {
+    return isApplicationUnmetered(budget) ? DIRECT_REPRESENTATION_MAX : boundedProfile;
+}
+export function directLoadingLimits(budget, overrides) {
+    if (!isApplicationUnmetered(budget))
+        return overrides ?? {};
+    return { ...Object.fromEntries(Object.keys(DEFAULT_LOADING_LIMITS).map(key => [key, key === 'resourceMs' || key === 'totalIoMs' ? 0 : DIRECT_REPRESENTATION_MAX])), ...overrides };
+}

package/dist/compiler/directOperation.d.ts

@@ -0,0 +1,72 @@
+import type { SchemaInput, SchemaInputOptions } from '../loader/schemaInput.js';
+import type { ExpandedName, SyntaxSource } from '../loader/orderedSyntax.js';
+import type { ElementNode, Reference } from './canonicalGraph.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { SemanticBudget, SemanticBudgetLimits, ResolverUsage } from './semanticBudget.js';
+import type { DirectSourceQualification } from './checkedSourcePreparation.js';
+export interface DirectOperationSelector {
+    readonly portType: ExpandedName;
+    readonly binding: ExpandedName;
+    readonly operation: string;
+}
+export interface DirectMessageRoot {
+    readonly message: ExpandedName;
+    readonly part: string;
+    readonly element: ElementNode;
+    readonly type: Reference;
+    readonly source: SyntaxSource;
+}
+export interface DirectOperationContract {
+    readonly selector: DirectOperationSelector;
+    readonly contextId: string;
+    readonly basis: 'native-direct-premises-v1';
+    readonly correspondence: 'dated-XSD-2004-direct-v1';
+    readonly binding: Readonly<{
+        version: '1.1';
+        style: 'document';
+        use: 'literal';
+        transport: string;
+        action: string;
+        source: SyntaxSource;
+    }>;
+    readonly input: DirectMessageRoot;
+    readonly output: DirectMessageRoot;
+    readonly faults: readonly Readonly<{
+        name: string;
+        root: DirectMessageRoot;
+    }>[];
+    readonly missingCapabilities: readonly string[];
+    readonly admitted: false;
+}
+export type DirectOperationResult = Readonly<{
+    kind: 'selected';
+    contract: DirectOperationContract;
+    usage: ResolverUsage;
+}> | Readonly<{
+    kind: 'invalid-schema' | 'inconclusive' | 'unsupported' | 'selection-refused' | 'loading-refused' | 'resource-limit' | 'cancelled';
+    rule: string;
+    usage: ResolverUsage;
+}>;
+export interface DirectOperationInspection {
+    readonly contract: DirectOperationContract;
+    readonly context: SemanticContext;
+    readonly source: SchemaInput;
+    readonly evidence: Extract<DirectSourceQualification, {
+        kind: 'qualified-source';
+    }>;
+}
+/** Object identity authenticates the exact issued roots; context IDs and digests do not. */
+export declare function inspectDirectOperation(contract: DirectOperationContract, expectedContext?: SemanticContext): DirectOperationInspection;
+/** One load, whole-source qualification, explicit selection and publication on one sticky budget. */
+export declare function selectDirectOperation(source: string, selector: DirectOperationSelector, options: Readonly<{
+    loading: SchemaInputOptions;
+    limits?: SemanticBudgetLimits;
+    signal?: AbortSignal;
+}>): Promise<DirectOperationResult>;
+/** Private-module composition seam: portable reading and selection share one request. */
+export declare function selectDirectOperationInRequest(source: string, selector: DirectOperationSelector, options: Readonly<{
+    loading: SchemaInputOptions;
+    limits?: SemanticBudgetLimits;
+    signal?: AbortSignal;
+}>, budget: SemanticBudget): Promise<DirectOperationResult>;
+//# sourceMappingURL=directOperation.d.ts.map

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

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