@techspokes/typescript-wsdl-client 1.1.3 → 1.1.5

package/dist/compiler/directValues.js

@@ -0,0 +1,282 @@
+import { directDataOwnership, directLimit } from './directExecutionPolicy.js';
+/** Internal direct value chain. No XML encoding, transport or runtime admission. */
+import { checkSemanticBudget } from './semanticBudget.js';
+import { DataOwnershipLimitError } from './dataOwnership.js';
+import { inspectDirectOperation } from './directOperation.js';
+import { inspectDirectStructuralMatch, matchDirectOperation } from './directStructure.js';
+import { planDirectRoot } from './directStructurePlan.js';
+import { datatypeValues, normalizeWhitespace, whitespaceFor } from './datatypeValues.js';
+/** Inverse construction caps; XML encoding may impose smaller byte/text/node limits. */
+export const DIRECT_VALUE_LIMITS = Object.freeze({ maxText: 1024 * 1024, maxItems: 100_000 });
+export const DIRECT_VALUE_VERSION = 'direct-values-v1';
+export const DIRECT_SCALAR_POLICY = 'direct-string-boolean-int-v1';
+const mappings = new WeakMap();
+const values = new WeakMap();
+const expansions = new WeakMap();
+function authentic(registry, receipt, contract, label) {
+    if (!receipt || typeof receipt !== 'object' || registry.get(receipt) !== contract)
+        throw new TypeError(`Unauthenticated or foreign direct ${label}`);
+    inspectDirectOperation(contract);
+    return receipt;
+}
+/** Inspection is identity-only; operational consumers still check native authority and limits. */
+export function inspectDirectValueMapping(mapping, contract) {
+    return authentic(mappings, mapping, contract, 'mapping');
+}
+export function inspectDirectValue(value, contract) {
+    return authentic(values, value, contract, 'value');
+}
+export function inspectDirectExpandedValue(value, contract) {
+    return authentic(expansions, value, contract, 'expansion');
+}
+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;
+    }
+}
+function run(contract, options, work) {
+    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();
+            return work({ budget, check, publish(value) {
+                    directDataOwnership(budget).freeze(value);
+                    check();
+                    return Object.freeze({ ...value, usage: Object.freeze({ ...budget.usage() }) });
+                } });
+        });
+        if (budget.exhausted())
+            return Object.freeze({ 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, schemaPath: error.schemaPath,
+                payloadPath: error.payloadPath, usage: Object.freeze({ ...budget.usage() }) });
+        throw error;
+    }
+}
+function mappingFor(contract, direction, s) {
+    const { context } = inspectDirectOperation(contract);
+    const { budget, check } = s;
+    const owned = directDataOwnership(budget).snapshot(direction, check);
+    if (!owned || typeof owned !== 'object' || Array.isArray(owned))
+        throw new TypeError('Data-only direct direction required');
+    let root;
+    if (owned.kind === 'input' || owned.kind === 'output')
+        root = contract[owned.kind];
+    else if (owned.kind === 'fault' && typeof owned.name === 'string') {
+        const fault = contract.faults.find(f => budget.compareText(f.name, owned.name) === 0);
+        if (!fault)
+            throw new Stop('unsupported', 'unknown-fault');
+        root = fault.root;
+    }
+    else
+        throw new Stop('unsupported', 'unknown-direction');
+    const plan = planDirectRoot(context, root, check, () => { throw new Stop('unsupported', 'native-direct-shape', root.element.context.source.path); });
+    const mapping = s.publish({ kind: 'direct-mapping', version: DIRECT_VALUE_VERSION, admitted: false,
+        root, direction: owned.kind === 'fault' ? { kind: 'fault', name: owned.name } : { kind: owned.kind }, contextId: context.contextId, ...plan });
+    mappings.set(mapping, contract);
+    return mapping;
+}
+/** Includes absent optional/zero-count slots; no observed payload is needed. */
+export function createDirectValueMapping(contract, direction, options = {}) {
+    return run(contract, options, s => mappingFor(contract, direction, s));
+}
+function scalar(duty, s) {
+    const { budget, check } = s;
+    const fail = (_owner, rule) => { throw new Stop('scalar-invalid', rule, duty.schemaPath, duty.payloadPath); };
+    const unavailable = () => { throw new Stop('unsupported', 'direct-datatype-prerequisite', duty.schemaPath, duty.payloadPath); };
+    // This is a neutral lexical operand, not a schema LexicalValue or checked receipt.
+    const core = datatypeValues({
+        step: (_owner, count = 1) => { check(); budget.chargeWork(count); },
+        text: text => { check(); return text; },
+        fail, unsupported: unavailable, unresolved: unavailable, notation: unavailable,
+    });
+    const result = core.atomic(duty.builtin.local, { value: duty.lexical, context: { namespaces: duty.namespaces, source: duty.payloadSource } }, duty);
+    const value = duty.builtin.local === 'int' ? Number(result.canonical) : duty.builtin.local === 'boolean' ? result.canonical === 'true' : result.canonical;
+    return { ...duty, normalized: normalizeWhitespace(duty.lexical, whitespaceFor(duty.builtin.local)), canonical: result.canonical, value };
+}
+function assessed(contract, structural, mapping, s) {
+    const { budget, check } = s;
+    const operands = [];
+    for (const duty of structural.occurrences) {
+        check();
+        operands.push(scalar(duty, s));
+    }
+    let value;
+    if (mapping.rootBuiltin)
+        value = operands[0].value;
+    else {
+        const record = Object.create(null);
+        let cursor = 0;
+        for (const slot of mapping.slots) {
+            check();
+            const key = slot.element.name.local;
+            if (slot.particle.occurs.max === 'unbounded') {
+                const items = [];
+                record[key] = items;
+                while (cursor < operands.length && operands[cursor].declaration === slot.element) {
+                    check();
+                    items.push(operands[cursor++].value);
+                }
+            }
+            else if (cursor < operands.length && operands[cursor].declaration === slot.element)
+                record[key] = operands[cursor++].value;
+        }
+        value = record;
+    }
+    const receipt = s.publish({ kind: 'direct-value', scope: 'direct-structure-and-scalars', admitted: false,
+        mapping, structural, operands, value });
+    values.set(receipt, contract);
+    return receipt;
+}
+export function assessDirectScalars(contract, match, options = {}) {
+    const structural = inspectDirectStructuralMatch(match, contract);
+    return run(contract, options, s => {
+        s.check();
+        const mapping = mappingFor(contract, structural.direction, s);
+        if (mapping.root !== structural.root)
+            throw new TypeError('Foreign direct root');
+        return assessed(contract, structural, mapping, s);
+    });
+}
+/** Pure shape validation plus lexical reconstruction, followed by existing validators. */
+export function expandDirectValue(contract, suppliedMapping, application, options = {}) {
+    const mapping = inspectDirectValueMapping(suppliedMapping, contract);
+    return run(contract, options, s => {
+        const { budget, check } = s;
+        const invalid = (rule, path = '/value') => { throw new Stop('value-invalid', rule, mapping.root.element.context.source.path, path); };
+        let textUnits = 0, items = 0;
+        const data = (object, key) => {
+            check();
+            const descriptor = Object.getOwnPropertyDescriptor(object, key);
+            if (!descriptor || !('value' in descriptor) || !descriptor.enumerable && !(Array.isArray(object) && key === 'length'))
+                return invalid('own-data-property');
+            return descriptor.value;
+        };
+        const keys = (object, maximum) => {
+            // Refuse extra keys without traversal. Reflect.ownKeys still allocates its
+            // intrinsic vector before we can inspect its size; no hard heap bound is claimed.
+            check();
+            const result = Reflect.ownKeys(object);
+            if (result.length > maximum)
+                return invalid('unknown-key');
+            return result;
+        };
+        const spelling = (value, builtin) => {
+            check();
+            if (builtin.local === 'string') {
+                if (typeof value !== 'string')
+                    return invalid('string-required');
+                if (value.length > (options.maxText ?? directLimit(budget, DIRECT_VALUE_LIMITS.maxText)) - textUnits)
+                    throw new Stop('resource-limit', 'application text limit');
+                textUnits += value.length;
+                return value;
+            }
+            if (builtin.local === 'boolean') {
+                if (typeof value !== 'boolean')
+                    return invalid('boolean-required');
+                return value ? 'true' : 'false';
+            }
+            if (typeof value !== 'number' || !Number.isInteger(value))
+                return invalid('integer-number-required');
+            // Range and XML lexical validity are checked by the same neutral core below.
+            return String(value === 0 ? 0 : value);
+        };
+        const source = (path) => {
+            return { uri: 'urn:typescript-wsdl-client:generated-direct-value', digest: '', path,
+                start: { offset: 0, line: 0, column: 0 }, end: { offset: 0, line: 0, column: 0 } };
+        };
+        const leaf = (name, lexical, path) => {
+            check();
+            if (++items > (options.maxItems ?? directLimit(budget, DIRECT_VALUE_LIMITS.maxItems)))
+                throw new Stop('resource-limit', 'application item limit');
+            return { kind: 'element', name, lexicalName: name.local, namespaces: Object.create(null),
+                baseUri: 'urn:typescript-wsdl-client:generated-direct-value', attributes: [], source: source(path),
+                children: [{ kind: 'text', value: lexical, source: source(path + '/text') }] };
+        };
+        let payload;
+        if (mapping.rootBuiltin)
+            payload = leaf(mapping.root.element.name, spelling(application, mapping.rootBuiltin), '/0');
+        else {
+            if (!application || typeof application !== 'object' || Array.isArray(application))
+                return invalid('record-required');
+            check();
+            const proto = Object.getPrototypeOf(application);
+            if (proto !== Object.prototype && proto !== null)
+                return invalid('plain-record-required');
+            const declared = new Set();
+            for (const slot of mapping.slots) {
+                check();
+                declared.add(slot.element.name.local);
+            }
+            for (const key of keys(application, mapping.slots.length)) {
+                check();
+                if (typeof key !== 'string')
+                    return invalid('unknown-key');
+                if (!declared.has(key))
+                    return invalid('unknown-key');
+                data(application, key);
+            }
+            const children = [];
+            for (const slot of mapping.slots) {
+                check();
+                const key = slot.element.name.local;
+                if (!Object.hasOwn(application, key)) {
+                    if (slot.particle.occurs.max === 'unbounded' || slot.particle.occurs.min === '1')
+                        return invalid('missing-member');
+                    continue;
+                }
+                const value = data(application, key);
+                const append = (item) => { check(); children.push(leaf(slot.element.name, spelling(item, slot.builtin), `/0/children/${children.length}`)); };
+                if (slot.particle.occurs.max === 'unbounded') {
+                    if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype)
+                        return invalid('dense-array-required');
+                    const length = data(value, 'length');
+                    if (length > (options.maxItems ?? directLimit(budget, DIRECT_VALUE_LIMITS.maxItems)) - items)
+                        throw new Stop('resource-limit', 'application item limit');
+                    if (slot.particle.occurs.min === '1' && length === 0)
+                        return invalid('required-repetition');
+                    // Check actual repetition length before key enumeration or inverse construction.
+                    const own = keys(value, length + 1);
+                    if (own.length !== length + 1)
+                        return invalid('dense-array-required');
+                    for (let i = 0; i < length; i++) {
+                        check();
+                        append(data(value, String(i)));
+                    }
+                }
+                else
+                    append(value);
+            }
+            payload = { kind: 'element', name: mapping.root.element.name, lexicalName: mapping.root.element.name.local,
+                namespaces: Object.create(null), baseUri: 'urn:typescript-wsdl-client:generated-direct-value',
+                attributes: [], source: source('/0'), children };
+        }
+        const structural = matchDirectOperation(contract, mapping.direction, payload, options);
+        if (structural.kind !== 'structural-match') {
+            if (structural.kind === 'mismatch')
+                throw new Error('Internal direct expansion violated its source mapping');
+            throw new Stop(structural.kind, structural.rule, structural.schemaPath, structural.payloadPath);
+        }
+        const validated = assessed(contract, structural, mapping, s);
+        const expanded = s.publish({ kind: 'direct-expanded', provenance: 'generated-direct-value', admitted: false, payload, validated });
+        expansions.set(expanded, contract);
+        return expanded;
+    });
+}

package/dist/compiler/finiteRe01Verification.d.ts

@@ -0,0 +1,140 @@
+/** Complete verification of supplied finite evidence, never universal witness search. */
+import type { NodeId } from './canonicalGraph.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+import type { ComponentConstructionReceipt, ConstructionObligation } from './schemaConstructionAssessment.js';
+import type { CorrespondenceReceipt, CorrespondenceFailure } from './re01CandidateCorrespondence.js';
+import { RE01_DERIVATION_DOMAIN } from './re01TypeProperties.js';
+import type { SchemaNotationProperties } from './schemaNotationProperties.js';
+import type { GeneratedScalarResult } from './schemaScalarKernel.js';
+import type { SemanticTypeDependency, SemanticTypeReference } from './semanticTypeReference.js';
+import type { IdentityConstraintReceipt } from './schemaIdentityConstraints.js';
+export type FiniteScalarSlotReceipt = Extract<GeneratedScalarResult, {
+    kind: 'checked';
+}>;
+export type FiniteRe01EvidenceNode = Readonly<{
+    id: string;
+    parent: SemanticContext;
+    context: SemanticContext;
+    target: NodeId;
+    intermediate: NodeId;
+    ancestor: SemanticTypeReference;
+    /** References to concrete evidence for generated hypothetical RE01 premises. */
+    premises: readonly string[];
+}>;
+export type FiniteRe01Evidence = Readonly<{
+    root: string;
+    nodes: readonly FiniteRe01EvidenceNode[];
+}>;
+/** The existing primitive identity rule needs no hypothetical endpoint. */
+export type FiniteRe01PrimitiveEvidence = Readonly<{
+    root: Readonly<{
+        kind: 'primitive-no-change';
+    }>;
+    /** Supplied constructions for any other nonprimitive actual obligations. */
+    nodes: readonly FiniteRe01EvidenceNode[];
+}>;
+export type FiniteVerificationFailure = CorrespondenceFailure & Readonly<{
+    contextId?: string;
+}>;
+export type FiniteNotationReceipt = Readonly<{
+    contextId: string;
+    properties: SchemaNotationProperties;
+    origin: 'original' | 'addition';
+}>;
+export type FiniteProofStep = Readonly<{
+    evidence: string;
+    parentContext: string;
+    contextId: string;
+    target: NodeId;
+    correspondence: CorrespondenceReceipt;
+    components: readonly ComponentConstructionReceipt[];
+    scalarSlots: readonly FiniteScalarSlotReceipt[];
+    notations: readonly FiniteNotationReceipt[];
+    identityConstraints: readonly IdentityConstraintReceipt[];
+    premises: readonly string[];
+    primitiveNoChange: readonly NodeId[];
+}>;
+export type FiniteCandidateReceipt = Readonly<{
+    kind: 'checked-candidate';
+    authority: 'RE01-finite-evidence-v1';
+    domain: typeof RE01_DERIVATION_DOMAIN;
+    scope: 'supplied-construction-and-finite-evidence';
+    actualContextId: string;
+    target: NodeId;
+    root: string;
+    actualComponents: readonly ComponentConstructionReceipt[];
+    actualPrimitiveNoChange: readonly NodeId[];
+    actualScalarSlots: readonly FiniteScalarSlotReceipt[];
+    actualNotations: readonly FiniteNotationReceipt[];
+    actualIdentityConstraints: readonly IdentityConstraintReceipt[];
+    proof: readonly FiniteProofStep[];
+    claims: Readonly<{
+        actualObligations: 'checked';
+        suppliedCandidate: 'checked';
+        universalCoverage: false;
+        completeNegativeAnswer: false;
+        searchTermination: false;
+    }>;
+}>;
+export type FiniteVerificationResult = FiniteCandidateReceipt | FiniteVerificationFailure | ResourceLimitFailure;
+export type FinitePrimitiveReceipt = Omit<FiniteCandidateReceipt, 'kind' | 'scope' | 'root' | 'claims'> & Readonly<{
+    kind: 'checked-primitive';
+    scope: 'primitive-no-change-and-finite-evidence';
+    root: 'primitive-no-change';
+    claims: Readonly<{
+        actualObligations: 'checked';
+        primitiveTarget: 'checked';
+        universalCoverage: false;
+        completeNegativeAnswer: false;
+        searchTermination: false;
+    }>;
+}>;
+export type FinitePrimitiveVerificationResult = FinitePrimitiveReceipt | FiniteVerificationFailure | ResourceLimitFailure;
+/** A requirement inspection is not a successful finite witness. */
+export type FiniteRe01Frontier = Readonly<{
+    kind: 'inspected-frontier';
+    context: SemanticContext;
+    requirements: readonly Readonly<{
+        target: NodeId;
+        ancestor: SemanticTypeReference;
+        primitive: boolean;
+    }>[];
+    components: readonly ComponentConstructionReceipt[];
+    scalarSlots: readonly FiniteScalarSlotReceipt[];
+    notations: readonly FiniteNotationReceipt[];
+    identityConstraints: readonly IdentityConstraintReceipt[];
+    correspondence?: CorrespondenceReceipt;
+    deferred: readonly Readonly<{
+        context: SemanticContext;
+        obligation: ConstructionObligation;
+    }>[];
+    typeDependencies: readonly Readonly<{
+        from: SemanticContext;
+        dependency: SemanticTypeDependency;
+    }>[];
+}>;
+export type FiniteRe01Hypothesis = Omit<FiniteRe01EvidenceNode, 'id' | 'premises'>;
+export type FiniteRe01FrontierResult = FiniteRe01Frontier | FiniteVerificationFailure | ResourceLimitFailure;
+export type FiniteRe01FrontierSession = Readonly<{
+    kind: 'native-frontier-session';
+    actual: FiniteRe01Frontier;
+    inspectCandidate(hypothesis: FiniteRe01Hypothesis): FiniteRe01FrontierResult;
+}>;
+export declare function assertFiniteRe01Frontier(context: SemanticContext, frontier: FiniteRe01Frontier): void;
+/** Internal native collection authority shared by supplied verification and research construction. */
+export declare function prepareFiniteRe01Frontier(actual: SemanticContext): FiniteRe01FrontierSession | FiniteVerificationFailure | ResourceLimitFailure;
+export declare function assertFiniteCandidateReceipt(actual: SemanticContext, receipt: FiniteCandidateReceipt): void;
+export declare function assertFinitePrimitiveReceipt(actual: SemanticContext, receipt: FinitePrimitiveReceipt): void;
+export declare function verifyFiniteRe01Evidence(actual: SemanticContext, target: NodeId, supplied: FiniteRe01Evidence): FiniteVerificationResult;
+export declare function verifyFiniteRe01Evidence(actual: SemanticContext, target: NodeId, supplied: FiniteRe01PrimitiveEvidence): FinitePrimitiveVerificationResult;
+export declare function verifyFiniteRe01Evidence(actual: SemanticContext, target: NodeId, supplied: FiniteRe01Evidence | FiniteRe01PrimitiveEvidence): FiniteVerificationResult | FinitePrimitiveVerificationResult;
+/** Reuse native actual preparation within one authenticated research request. */
+export declare function verifyFiniteRe01EvidenceWithFrontier(actual: SemanticContext, target: NodeId, supplied: FiniteRe01Evidence | FiniteRe01PrimitiveEvidence, prepared?: FiniteRe01FrontierSession): FiniteVerificationResult | FinitePrimitiveVerificationResult;
+/** Product direct strategy: no hypothetical candidates and no search-negative claim. */
+export declare function verifyDirectActualSchema(actual: SemanticContext): Readonly<{
+    kind: 'checked-direct' | 'inconclusive-direct';
+    frontier: FiniteRe01Frontier;
+    unresolved: readonly NodeId[];
+}> | FiniteVerificationFailure | ResourceLimitFailure;
+//# sourceMappingURL=finiteRe01Verification.d.ts.map

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

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