@techspokes/typescript-wsdl-client 1.1.3 → 1.1.5

package/dist/compiler/directStructure.js

@@ -0,0 +1,252 @@
+/** Internal direct case of the content-model matcher; never runtime admission. */
+import { inspectDirectOperation } from './directOperation.js';
+import { planDirectRoot } from './directStructurePlan.js';
+const issued = new WeakMap();
+/** Identity is checked before any receipt fields; no retrospective authentication. */
+export function inspectDirectStructuralMatch(match, expectedContract) {
+    if (!match || typeof match !== 'object' || issued.get(match) !== expectedContract)
+        throw new TypeError('Unauthenticated or foreign direct structural match');
+    inspectDirectOperation(expectedContract);
+    return match;
+}
+class Stop extends Error {
+    kind;
+    rule;
+    schemaPath;
+    payloadPath;
+    constructor(kind, rule, schemaPath, payloadPath) {
+        super(rule);
+        this.kind = kind;
+        this.rule = rule;
+        this.schemaPath = schemaPath;
+        this.payloadPath = payloadPath;
+    }
+}
+/**
+ * Data-only SyntaxElement input (plain records/arrays, no proxies/accessors). Malformed
+ * input throws TypeError; XML structure differences return mismatch. No caller is frozen.
+ * Cancellation is synchronous/cooperative, checked at visits and before publication.
+ */
+export function matchDirectOperation(contract, direction, payload, options = {}) {
+    const { context } = inspectDirectOperation(contract);
+    const { budget } = context;
+    const check = () => { budget.chargeWork(); if (options.signal?.aborted)
+        throw new Stop('cancelled', 'cooperative-cancellation'); };
+    const fail = (kind, rule, schemaPath, payloadPath) => { throw new Stop(kind, rule, schemaPath, payloadPath); };
+    const malformed = () => { throw new TypeError('Direct payload requires a data-only ordered syntax tree'); };
+    const field = (value, key) => {
+        budget.chargeWork(96 + key.length);
+        if (!value || typeof value !== 'object')
+            return malformed();
+        const proto = Object.getPrototypeOf(value);
+        if (!Array.isArray(value) && proto !== Object.prototype && proto !== null)
+            return malformed();
+        const d = Object.getOwnPropertyDescriptor(value, key);
+        if (!d || !('value' in d))
+            return malformed();
+        return d.value;
+    };
+    const string = (value) => typeof value === 'string';
+    const record = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+    const sourceShape = (value) => {
+        if (!record(value) || !string(value.uri) || !string(value.digest) || !string(value.path))
+            return false;
+        for (const p of [value.start, value.end])
+            if (!record(p) || ![p.offset, p.line, p.column].every(n => typeof n === 'number' && Number.isSafeInteger(n) && n >= 0))
+                return false;
+        return true;
+    };
+    const nameShape = (value) => record(value) && string(value.namespace) && string(value.local) && value.local.length > 0;
+    try {
+        const guarded = budget.guard(() => {
+            // Reserve fixed closures/state, diagnostics and terminal publication before input work.
+            budget.chargeWork(4096);
+            check();
+            const suppliedDirection = budget.snapshot(direction);
+            if (!record(suppliedDirection))
+                return malformed();
+            if (!['input', 'output', 'fault'].includes(suppliedDirection.kind))
+                return fail('unsupported', 'unknown-direction');
+            const ownedDirection = suppliedDirection.kind === 'fault'
+                ? { kind: 'fault', name: suppliedDirection.name } : { kind: suppliedDirection.kind };
+            let root;
+            if (ownedDirection.kind === 'fault') {
+                budget.chargeWork(64 + contract.faults.length * 32);
+                if (typeof ownedDirection.name !== 'string')
+                    return fail('unsupported', 'unknown-fault');
+                const selected = contract.faults.find(f => budget.compareText(f.name, ownedDirection.name) === 0);
+                if (!selected)
+                    return fail('unsupported', 'unknown-fault');
+                root = selected.root;
+            }
+            else
+                root = contract[ownedDirection.kind];
+            const schemaPath = root.element.context.source.path;
+            const unsupported = () => fail('unsupported', 'native-direct-shape', schemaPath);
+            const { slots, rootBuiltin } = planDirectRoot(context, root, check, unsupported);
+            // Count syntax nodes before copying. Descriptor reads reject accessors without invoking
+            // them. A tree may not reuse a node, including cyclic input; proxies are out of contract.
+            budget.chargeWork(128);
+            const seen = new Set(), stack = [payload];
+            if (field(payload, 'kind') !== 'element')
+                return malformed();
+            while (stack.length) {
+                check();
+                const current = stack.pop();
+                if (!current || typeof current !== 'object' || seen.has(current))
+                    return malformed();
+                budget.reserveNodes(1);
+                budget.chargeWork(64);
+                seen.add(current);
+                const kind = field(current, 'kind');
+                if (kind === 'text')
+                    continue;
+                if (kind !== 'element')
+                    return malformed();
+                const children = field(current, 'children');
+                if (!Array.isArray(children))
+                    return malformed();
+                const length = field(children, 'length');
+                if (typeof length !== 'number')
+                    return malformed();
+                for (let i = 0; i < length; i++) {
+                    check();
+                    budget.chargeWork(32);
+                    stack.push(field(children, String(i)));
+                }
+            }
+            const owned = budget.snapshot(payload);
+            // Snapshot already excludes prototypes/accessors and owns all retained maps and text.
+            budget.chargeWork(64);
+            const visits = [owned];
+            while (visits.length) {
+                check();
+                const node = visits.pop();
+                budget.chargeWork(128);
+                if (!sourceShape(node.source))
+                    return malformed();
+                if (node.kind === 'text') {
+                    if (!string(node.value))
+                        return malformed();
+                    continue;
+                }
+                if (!nameShape(node.name) || !string(node.lexicalName) || !string(node.baseUri) || !record(node.namespaces) || !Array.isArray(node.attributes))
+                    return malformed();
+                for (const key in node.namespaces) {
+                    check();
+                    if (!string(node.namespaces[key]))
+                        return malformed();
+                }
+                for (const a of node.attributes) {
+                    check();
+                    if (!record(a) || !nameShape(a.name) || !string(a.lexicalName) || !string(a.value))
+                        return malformed();
+                }
+                for (const child of node.children) {
+                    check();
+                    budget.chargeWork(32);
+                    visits.push(child);
+                }
+            }
+            const same = (a, b) => budget.compareText(a.namespace, b.namespace) === 0 && budget.compareText(a.local, b.local) === 0;
+            const mismatch = (rule, declaration, path) => fail('mismatch', rule, declaration.context.source.path, path);
+            const attributes = (node, declaration, path) => {
+                check();
+                if (node.attributes.length)
+                    fail('unsupported', 'payload-attributes', declaration.context.source.path, path);
+            };
+            attributes(owned, root.element, '/0');
+            if (!same(owned.name, root.element.name))
+                return mismatch('root-name', root.element, '/0');
+            budget.chargeWork(64);
+            const occurrences = [];
+            const leaf = (node, declaration, builtin, path) => {
+                attributes(node, declaration, path);
+                budget.chargeWork(64);
+                const parts = [];
+                let length = 0;
+                for (const child of node.children) {
+                    check();
+                    if (child.kind !== 'text')
+                        return mismatch('scalar-child', declaration, path);
+                    budget.chargeWork(32 + child.value.length * 4);
+                    parts.push(child.value);
+                    length += child.value.length;
+                }
+                budget.chargeWork(256 + length * 4 + path.length * 4);
+                // Project only typed retained facts. Generic snapshots deliberately preserve
+                // unknown values; caller extension fields must not become receipt authority.
+                const namespaces = Object.create(null);
+                for (const key in node.namespaces) {
+                    if (!Object.hasOwn(node.namespaces, key))
+                        continue;
+                    check();
+                    budget.chargeWork(96 + key.length * 4 + node.namespaces[key].length * 4);
+                    namespaces[key] = node.namespaces[key];
+                }
+                const s = node.source;
+                const payloadSource = budget.snapshot({ uri: s.uri, digest: s.digest, path: s.path,
+                    start: { offset: s.start.offset, line: s.start.line, column: s.start.column },
+                    end: { offset: s.end.offset, line: s.end.line, column: s.end.column } });
+                occurrences.push({ declaration, type: declaration.type, builtin, lexical: parts.join(''), namespaces,
+                    payloadSource, payloadPath: path, schemaPath: declaration.context.source.path });
+            };
+            if (rootBuiltin)
+                leaf(owned, root.element, rootBuiltin, '/0');
+            else {
+                let cursor = 0, count = 0;
+                for (let index = 0; index < owned.children.length; index++) {
+                    check();
+                    const child = owned.children[index];
+                    budget.chargeWork(64);
+                    const path = `/0/children/${index}`;
+                    if (child.kind === 'text') {
+                        budget.chargeWork(child.value.length * 2);
+                        if (/[^\t\r\n ]/.test(child.value))
+                            return mismatch('complex-text', root.element, path);
+                        continue;
+                    }
+                    while (cursor < slots.length && !same(child.name, slots[cursor].element.name)) {
+                        check();
+                        const slot = slots[cursor];
+                        if (slot.particle.occurs.min === '1' && count === 0)
+                            return mismatch('missing-required', slot.element, path);
+                        cursor++;
+                        count = 0;
+                    }
+                    const slot = slots[cursor];
+                    if (!slot)
+                        return mismatch('unexpected-child', root.element, path);
+                    if (slot.particle.occurs.max === '1' && count === 1)
+                        return mismatch('duplicate-singleton', slot.element, path);
+                    leaf(child, slot.element, slot.builtin, path);
+                    count++;
+                }
+                for (; cursor < slots.length; cursor++, count = 0) {
+                    check();
+                    const slot = slots[cursor];
+                    if (slot.particle.occurs.min === '1' && count === 0)
+                        return mismatch('missing-required', slot.element, '/0/end');
+                }
+            }
+            check();
+            budget.chargeWork(512);
+            const result = { kind: 'structural-match', scope: 'structure-only', scalarValidity: 'unassessed', admitted: false,
+                root, contextId: context.contextId, direction: ownedDirection, occurrences, usage: { ...budget.usage() } };
+            budget.freeze(result);
+            check();
+            // Capture final accounting after publication traversal; the record is already reserved.
+            const published = Object.freeze({ ...result, usage: Object.freeze({ ...budget.usage() }) });
+            issued.set(published, contract);
+            return published;
+        });
+        return guarded.kind === 'resource-limit' ? Object.freeze({ kind: 'resource-limit', rule: 'request-budget', usage: budget.usage() }) : guarded;
+    }
+    catch (error) {
+        if (budget.exhausted())
+            return Object.freeze({ kind: 'resource-limit', rule: 'request-budget', usage: budget.usage() });
+        if (error instanceof Stop)
+            return Object.freeze({ kind: error.kind, rule: error.rule, schemaPath: error.schemaPath, payloadPath: error.payloadPath, usage: Object.freeze({ ...budget.usage() }) });
+        throw error;
+    }
+}

package/dist/compiler/directStructurePlan.d.ts

@@ -0,0 +1,16 @@
+/** Single native direct slot interpretation shared by matching and value mapping. */
+import type { DirectMessageRoot } from './directOperation.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { ElementNode, ParticleNode } from './canonicalGraph.js';
+import type { ExpandedName } from '../loader/orderedSyntax.js';
+export interface DirectSlot {
+    readonly element: ElementNode;
+    readonly particle: ParticleNode;
+    readonly builtin: ExpandedName;
+}
+export interface DirectRootPlan {
+    readonly rootBuiltin?: ExpandedName;
+    readonly slots: readonly DirectSlot[];
+}
+export declare function planDirectRoot(context: SemanticContext, root: DirectMessageRoot, check: () => void, unsupported: () => never): DirectRootPlan;
+//# sourceMappingURL=directStructurePlan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"directStructurePlan.d.ts","sourceRoot":"","sources":["../../src/compiler/directStructurePlan.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAC,WAAW,EAAa,YAAY,EAAC,MAAM,qBAAqB,CAAC;AAC9E,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,4BAA4B,CAAC;AAG7D,MAAM,WAAW,UAAU;IAAE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;CAAC;AAC5H,MAAM,WAAW,cAAc;IAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAA;CAAC;AAC5G,wBAAgB,cAAc,CAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,IAAI,EAAE,WAAW,EAAE,MAAM,KAAK,GAAG,cAAc,CA4C7I"}

package/dist/compiler/directStructurePlan.js

@@ -0,0 +1,58 @@
+import { XSD_NAMESPACE } from '../loader/orderedSyntax.js';
+import { occurrenceAlgebra } from './occurrenceAnalysis.js';
+export function planDirectRoot(context, root, check, unsupported) {
+    const { budget } = context;
+    const lookup = (id) => {
+        check();
+        const result = context.lookup(id);
+        if (result.kind !== 'found')
+            return unsupported();
+        return result.node;
+    };
+    const scalar = (element) => {
+        check();
+        const type = context.resolve(element.type);
+        if (element.nillable || element.abstract || element.value || element.substitutionGroup || type.kind !== 'builtin' || type.name.namespace !== XSD_NAMESPACE || !['string', 'int', 'boolean'].includes(type.name.local))
+            return unsupported();
+        return type.name;
+    };
+    budget.chargeWork(128);
+    const slots = [];
+    const resolved = context.resolve(root.type);
+    let rootBuiltin;
+    if (resolved.kind === 'builtin')
+        rootBuiltin = scalar(root.element);
+    else {
+        if (resolved.kind !== 'found' || resolved.node.kind !== 'complexType')
+            return unsupported();
+        const type = resolved.node;
+        if (type.mixed || type.abstract || type.derivation || type.attributes.length || !type.content)
+            return unsupported();
+        const sequence = lookup(type.content);
+        if (sequence.kind !== 'particle' || sequence.term.kind !== 'sequence' || sequence.occurs.min !== '1' || sequence.occurs.max !== '1')
+            return unsupported();
+        budget.chargeWork(64);
+        const names = new Set();
+        const algebra = occurrenceAlgebra(check);
+        for (const id of sequence.term.children) {
+            check();
+            const particle = lookup(id);
+            if (particle.kind !== 'particle' || particle.term.kind !== 'element')
+                return unsupported();
+            algebra.validate(particle.occurs);
+            if (!['0', '1'].includes(particle.occurs.min) || !['1', 'unbounded'].includes(particle.occurs.max))
+                return unsupported();
+            const declaration = context.resolve(particle.term.declaration);
+            if (declaration.kind !== 'found' || declaration.node.kind !== 'element')
+                return unsupported();
+            const element = declaration.node;
+            budget.chargeWork(128 + element.name.local.length * 4);
+            if (names.has(element.name.local))
+                return unsupported();
+            names.add(element.name.local);
+            const builtin = scalar(element);
+            slots.push({ element, particle, builtin });
+        }
+    }
+    return { rootBuiltin, slots };
+}

package/dist/compiler/directValues.d.ts

@@ -0,0 +1,69 @@
+import type { DirectOperationContract, DirectMessageRoot } from './directOperation.js';
+import type { DirectDirection, DirectScalarDuty, DirectStructuralMatch } from './directStructure.js';
+import type { DirectRootPlan } from './directStructurePlan.js';
+import type { ResolverUsage } from './semanticBudget.js';
+import type { SyntaxElement } from '../loader/orderedSyntax.js';
+export type DirectPrimitive = string | boolean | number;
+/** Inverse construction caps; XML encoding may impose smaller byte/text/node limits. */
+export declare const DIRECT_VALUE_LIMITS: Readonly<{
+    maxText: number;
+    maxItems: 100000;
+}>;
+export declare const DIRECT_VALUE_VERSION = "direct-values-v1";
+export declare const DIRECT_SCALAR_POLICY = "direct-string-boolean-int-v1";
+export type DirectApplicationValue = DirectPrimitive | Readonly<Record<string, DirectPrimitive | readonly DirectPrimitive[]>>;
+export interface DirectValueMapping extends DirectRootPlan {
+    readonly kind: 'direct-mapping';
+    readonly version: typeof DIRECT_VALUE_VERSION;
+    readonly admitted: false;
+    readonly root: DirectMessageRoot;
+    readonly direction: DirectDirection;
+    readonly contextId: string;
+    readonly usage: ResolverUsage;
+}
+export interface DirectAssessedScalar extends DirectScalarDuty {
+    readonly normalized: string;
+    readonly canonical: string;
+    readonly value: DirectPrimitive;
+}
+export interface DirectValueReceipt {
+    readonly kind: 'direct-value';
+    readonly scope: 'direct-structure-and-scalars';
+    readonly admitted: false;
+    readonly mapping: DirectValueMapping;
+    readonly structural: DirectStructuralMatch;
+    readonly operands: readonly DirectAssessedScalar[];
+    readonly value: DirectApplicationValue;
+    readonly usage: ResolverUsage;
+}
+export interface DirectExpandedValue {
+    readonly kind: 'direct-expanded';
+    readonly provenance: 'generated-direct-value';
+    readonly admitted: false;
+    readonly payload: SyntaxElement;
+    readonly validated: DirectValueReceipt;
+    readonly usage: ResolverUsage;
+}
+export interface DirectValueFailure {
+    readonly kind: 'scalar-invalid' | 'value-invalid' | 'unsupported' | 'cancelled' | 'resource-limit';
+    readonly rule: string;
+    readonly schemaPath?: string;
+    readonly payloadPath?: string;
+    readonly usage: ResolverUsage;
+}
+type Options = Readonly<{
+    signal?: AbortSignal;
+    maxText?: number;
+    maxItems?: number;
+}>;
+/** Inspection is identity-only; operational consumers still check native authority and limits. */
+export declare function inspectDirectValueMapping(mapping: unknown, contract: DirectOperationContract): DirectValueMapping;
+export declare function inspectDirectValue(value: unknown, contract: DirectOperationContract): DirectValueReceipt;
+export declare function inspectDirectExpandedValue(value: unknown, contract: DirectOperationContract): DirectExpandedValue;
+/** Includes absent optional/zero-count slots; no observed payload is needed. */
+export declare function createDirectValueMapping(contract: DirectOperationContract, direction: DirectDirection, options?: Options): DirectValueMapping | DirectValueFailure;
+export declare function assessDirectScalars(contract: DirectOperationContract, match: unknown, options?: Options): DirectValueReceipt | DirectValueFailure;
+/** Pure shape validation plus lexical reconstruction, followed by existing validators. */
+export declare function expandDirectValue(contract: DirectOperationContract, suppliedMapping: unknown, application: unknown, options?: Options): DirectExpandedValue | DirectValueFailure;
+export {};
+//# sourceMappingURL=directValues.d.ts.map

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

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