@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/particleDeclarationConsistency.js

@@ -0,0 +1,206 @@
+import { assertSemanticContext } from './semanticContext.js';
+import { effectiveSubstitutionMembers } from './schemaTypeRelations.js';
+import { declaredType, resolveSemanticType } from './schemaTypeIdentity.js';
+import { collectSemanticTypeDependencies } from './semanticTypeDependencies.js';
+import { originalUrWildcardSource } from './complexTypeContent.js';
+class Incomplete extends Error {
+    result;
+    constructor(result) {
+        super('Incomplete EDC premise');
+        this.result = result;
+    }
+}
+class Conflict extends Error {
+    pair;
+    constructor(pair) {
+        super('Inconsistent element declaration particles');
+        this.pair = pair;
+    }
+}
+/**
+ * Repeated group-use edges count distinct positions; numeric repetition does not.
+ * The source mapper's max=0 components are omitted, without restriction-specific
+ * pointless-compositor normalization. Summary sharing prevents DAG unfolding.
+ * Type/declaration validity remains an explicit separately owned prerequisite.
+ */
+export function checkElementDeclarationsConsistent(context, roots) {
+    assertSemanticContext(context);
+    const budget = context.budget;
+    return budget.guard(() => {
+        const typeDependencies = collectSemanticTypeDependencies(context);
+        try {
+            const requested = budget.freeze(budget.snapshot(roots));
+            budget.chargeWork(5);
+            const memo = new Map(), active = new Set();
+            const unresolved = (component, message) => {
+                budget.chargeWork(8 + component.length + message.length);
+                throw new Incomplete(Object.freeze({ kind: 'unresolved', rule: 'cos-element-consistent', component, message }));
+            };
+            const get = (id) => {
+                const result = context.lookup(id);
+                if (result.kind === 'missing') {
+                    const borrowed = context.originalUrWildcard(id);
+                    if (borrowed)
+                        return originalUrWildcardSource(context.originalContext(), borrowed);
+                }
+                return result.kind === 'found' ? result.node : unresolved(id, `Required component is ${result.kind}`);
+            };
+            const target = (ref, owner) => {
+                const result = context.resolve(ref);
+                return result.kind === 'found' ? result.node : unresolved(owner, 'Declaration or group target is not an active component');
+            };
+            const namedType = (declaration) => {
+                const result = resolveSemanticType(context, declaredType(context, declaration));
+                if (result.kind !== 'component' && result.kind !== 'builtin' && result.kind !== 'original-generated')
+                    return unresolved(declaration.id, 'Declared type is unavailable or not a type in the selected context');
+                budget.chargeWork(3);
+                typeDependencies.add([{ contextId: context.contextId, type: result.identity }]);
+                // A generated scalar has no name; its source container is provenance.
+                if (result.kind === 'original-generated')
+                    return undefined;
+                if (result.kind === 'builtin') {
+                    budget.chargeWork(32 + 6 * (result.name.namespace.length + result.name.local.length));
+                    return JSON.stringify(['type', result.name.namespace, result.name.local]);
+                }
+                if (result.node.identity.kind !== 'global')
+                    return undefined;
+                const name = result.node.identity.name;
+                budget.chargeWork(32 + 6 * (name.namespace.length + name.local.length));
+                return JSON.stringify(['type', name.namespace, name.local]);
+            };
+            const merge = (into, summary) => {
+                for (const [name, entry] of summary) {
+                    budget.chargeWork(8 + name.length);
+                    const prior = into.get(name);
+                    budget.chargeWork((prior?.namedType?.length ?? 0) + (entry.namedType?.length ?? 0));
+                    if (prior && (!prior.namedType || !entry.namedType || prior.namedType !== entry.namedType)) {
+                        budget.chargeWork(4);
+                        throw new Conflict(Object.freeze([prior.declaration, entry.declaration]));
+                    }
+                    budget.chargeWork(5);
+                    into.set(name, { declaration: prior?.declaration ?? entry.declaration, count: prior ? 2 : entry.count, namedType: entry.namedType });
+                }
+            };
+            const declared = (particle) => {
+                if (particle.term.kind !== 'element')
+                    return new Map();
+                const selected = context.resolve(particle.term.declaration);
+                if (selected.kind === 'standard-element') {
+                    const declaration = selected.declaration;
+                    budget.chargeWork(48 + 6 * (declaration.name.namespace.length + declaration.name.local.length));
+                    const name = JSON.stringify([declaration.name.namespace, declaration.name.local]);
+                    // The fixed schema element's type is anonymous. Repeated positions
+                    // still require the dated EDC top-level named-type premise.
+                    return new Map([[name, { declaration: declaration.id, count: 1 }]]);
+                }
+                const declaration = target(particle.term.declaration, particle.id);
+                if (declaration.kind !== 'element')
+                    return unresolved(particle.id, 'Element particle does not reference an element declaration');
+                budget.chargeWork(4);
+                const declarations = new Set([declaration.id]);
+                if (declaration.identity.kind === 'global') {
+                    if (context.membership === 'structural-subset')
+                        return unresolved(declaration.id, 'Complete original-plus-fresh substitution universe is required');
+                    const implicit = effectiveSubstitutionMembers(context, declaration.id);
+                    if (implicit.kind !== 'checked')
+                        throw new Incomplete(implicit);
+                    typeDependencies.add(implicit.typeDependencies);
+                    for (const id of implicit.value) {
+                        budget.chargeWork(1 + id.length);
+                        declarations.add(id);
+                    }
+                }
+                budget.chargeWork();
+                const result = new Map();
+                for (const id of declarations) {
+                    const member = get(id);
+                    if (member.kind !== 'element')
+                        return unresolved(id, 'Implicit member is not an element declaration');
+                    budget.chargeWork(48 + 6 * (member.name.namespace.length + member.name.local.length));
+                    const name = JSON.stringify([member.name.namespace, member.name.local]);
+                    const type = namedType(member), prior = result.get(name);
+                    budget.chargeWork((prior?.namedType?.length ?? 0) + (type?.length ?? 0));
+                    if (prior && (!prior.namedType || !type || prior.namedType !== type)) {
+                        budget.chargeWork(4);
+                        throw new Conflict(Object.freeze([prior.declaration, member.id]));
+                    }
+                    budget.chargeWork(5);
+                    result.set(name, { declaration: prior?.declaration ?? member.id, count: prior ? 2 : 1, namedType: type });
+                }
+                return result;
+            };
+            const frame = (id) => {
+                const node = get(id);
+                if (node.kind !== 'particle')
+                    return unresolved(id, 'EDC roots and containment edges must reference particles');
+                budget.chargeWork(7);
+                let children = [];
+                if (node.occurs.max !== '0') {
+                    if ('children' in node.term)
+                        children = node.term.children;
+                    else if (node.term.kind === 'group') {
+                        const group = target(node.term.reference, id);
+                        if (group.kind !== 'group')
+                            return unresolved(id, 'Model-group use does not reference a group');
+                        budget.chargeWork(2);
+                        children = [group.content];
+                    }
+                }
+                return { node, children, index: 0 };
+            };
+            budget.chargeWork();
+            const combined = new Map();
+            for (const root of requested) {
+                budget.chargeWork(3 + root.length);
+                if (!memo.has(root)) {
+                    budget.chargeWork(2);
+                    const stack = [frame(root)];
+                    active.add(root);
+                    while (stack.length) {
+                        budget.chargeWork(3);
+                        const current = stack[stack.length - 1];
+                        if (current.index < current.children.length) {
+                            const id = current.children[current.index++];
+                            budget.chargeWork(3 + id.length);
+                            if (active.has(id))
+                                return unresolved(id, 'Forbidden particle/group containment cycle');
+                            if (!memo.has(id)) {
+                                budget.chargeWork(2);
+                                active.add(id);
+                                stack.push(frame(id));
+                            }
+                            continue;
+                        }
+                        budget.chargeWork();
+                        const summary = new Map();
+                        if (current.node.occurs.max !== '0') {
+                            if (current.node.term.kind === 'element')
+                                merge(summary, declared(current.node));
+                            for (const id of current.children) {
+                                budget.chargeWork(1 + id.length);
+                                merge(summary, memo.get(id));
+                            }
+                        }
+                        budget.chargeWork(4);
+                        memo.set(current.node.id, summary);
+                        active.delete(current.node.id);
+                        stack.pop();
+                    }
+                }
+                merge(combined, memo.get(root));
+            }
+            budget.chargeWork(20 + context.contextId.length);
+            return Object.freeze({ kind: 'checked', value: true, rule: 'cos-element-consistent', contextId: context.contextId,
+                scope: 'declared-particle-roots', obligations: Object.freeze(['component-validity']), typeDependencies: typeDependencies.snapshot() });
+        }
+        catch (error) {
+            if (error instanceof Incomplete)
+                return error.result;
+            if (!(error instanceof Conflict))
+                throw error;
+            budget.chargeWork(24 + context.contextId.length);
+            return Object.freeze({ kind: 'checked', value: false, rule: 'cos-element-consistent', contextId: context.contextId,
+                scope: 'declared-particle-roots', obligations: Object.freeze(['component-validity']), conflict: error.pair, typeDependencies: typeDependencies.snapshot() });
+        }
+    });
+}

package/dist/compiler/particleExtension.d.ts

@@ -0,0 +1,21 @@
+/** Raw cos-particle-extend: original component identity or exact base-first construction. */
+import type { SemanticContext } from './semanticContext.js';
+import type { AttributeFailure } from './schemaAttributeUses.js';
+import type { ScalarFailure } from './schemaScalarKernel.js';
+import type { ScalarObligation } from './scalarSchemaAssessment.js';
+import type { ParticleContentView } from './complexTypeContent.js';
+import type { RelationFailure } from './schemaTypeRelations.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+import type { SemanticTypeDependency } from './semanticTypeReference.js';
+import type { IdentityConstraintDependency } from './schemaIdentityConstraints.js';
+export type ParticleExtensionResult = Readonly<{
+    kind: 'checked';
+    value: boolean;
+    rule: 'cos-particle-extend';
+    contextId: string;
+    obligations: readonly string[];
+    scalarObligations: readonly ScalarObligation[];
+    typeDependencies: readonly SemanticTypeDependency[];
+    identityConstraintDependencies: readonly IdentityConstraintDependency[];
+}> | RelationFailure | ScalarFailure | AttributeFailure | ResourceLimitFailure;
+export declare function checkRawParticleExtension(context: SemanticContext, derived: ParticleContentView, base: ParticleContentView): ParticleExtensionResult;

package/dist/compiler/particleExtension.js

@@ -0,0 +1,123 @@
+import { compareComponentProperties } from './schemaComponentEquality.js';
+import { assertParticleContentView } from './complexTypeContent.js';
+import { prepareSemanticParticleView } from './particleSemanticView.js';
+import { checkDeclaredParticleLegality } from './particleLocalAssessment.js';
+import { SemanticError } from './resolveCanonicalGraph.js';
+import { collectSemanticTypeDependencies } from './semanticTypeDependencies.js';
+import { collectIdentityConstraintDependencies } from './schemaIdentityConstraints.js';
+export function checkRawParticleExtension(context, derived, base) {
+    assertParticleContentView(context, derived);
+    assertParticleContentView(context, base);
+    const budget = context.budget, charge = (n = 1) => budget.chargeWork(n);
+    return budget.guard(() => {
+        const typeDependencies = collectSemanticTypeDependencies(context);
+        const identityConstraintDependencies = collectIdentityConstraintDependencies(context);
+        const obligations = ['component-validity'];
+        const scalarObligations = [];
+        const done = (value) => {
+            charge(10);
+            return Object.freeze({ kind: 'checked', value, rule: 'cos-particle-extend', contextId: context.contextId,
+                obligations: budget.freeze(budget.snapshot(obligations)),
+                scalarObligations: budget.freeze(budget.snapshot(scalarObligations)), typeDependencies: typeDependencies.snapshot(),
+                identityConstraintDependencies: identityConstraintDependencies.snapshot() });
+        };
+        const unresolved = (rule, component, message) => {
+            charge(10 + rule.length + component.length + message.length);
+            return Object.freeze({ kind: 'unresolved', rule, component, message });
+        };
+        try {
+            const extension = prepareSemanticParticleView(context, derived, 'declared');
+            if (extension.kind !== 'checked')
+                return extension;
+            typeDependencies.add(extension.view.typeDependencies);
+            const original = prepareSemanticParticleView(context, base, 'declared');
+            if (original.kind !== 'checked')
+                return original;
+            typeDependencies.add(original.view.typeDependencies);
+            const legal = checkDeclaredParticleLegality(context, extension.view);
+            if (legal.kind !== 'checked')
+                return legal;
+            typeDependencies.add(legal.typeDependencies);
+            if (!legal.value)
+                return done(false);
+            const e = extension.view.root, b = original.view.root;
+            charge(6);
+            if (e === b || e.originalParticle !== undefined && e.originalParticle === b.originalParticle)
+                return done(true);
+            if (e.kind !== 'sequence' || e.occurs.min !== '1' || e.occurs.max !== '1' || !e.children.length)
+                return done(false);
+            charge(3);
+            const stack = [[e.children[0], b]];
+            const seen = new Map();
+            let distinctDeclaration;
+            while (stack.length) {
+                charge(5);
+                const [x, y] = stack.pop();
+                if (x === y || x.originalParticle !== undefined && x.originalParticle === y.originalParticle)
+                    continue;
+                let row = seen.get(x);
+                if (!row) {
+                    charge(2);
+                    row = new Set();
+                    seen.set(x, row);
+                }
+                if (row.has(y))
+                    continue;
+                charge();
+                row.add(y);
+                charge(x.occurs.min.length + y.occurs.min.length + x.occurs.max.length + y.occurs.max.length);
+                if (x.kind !== y.kind || x.occurs.min !== y.occurs.min || x.occurs.max !== y.occurs.max || x.children.length !== y.children.length)
+                    return done(false);
+                if (x.standardElement || y.standardElement) {
+                    if (x.standardElement !== y.standardElement)
+                        return unresolved('fixed-standard-declaration-correspondence', x.source, 'Extension requires the same acquired standard declaration');
+                }
+                else if (x.element && y.element) {
+                    charge(2 + x.element.id.length + y.element.id.length);
+                    if (x.element.id !== y.element.id) {
+                        const same = compareComponentProperties(context, x.element, y.element);
+                        if (same.kind !== 'checked')
+                            return same;
+                        typeDependencies.add(same.typeDependencies);
+                        identityConstraintDependencies.add(same.identityConstraintDependencies);
+                        if (!same.value)
+                            return done(false);
+                        charge(2 + same.obligations.length + same.scalarObligations.length);
+                        for (const item of same.scalarObligations) {
+                            charge();
+                            scalarObligations.push(item);
+                        }
+                        for (const required of same.obligations) {
+                            charge(1 + required.length);
+                            if (required === 'component-validity')
+                                continue;
+                            if (required.startsWith('element-default-mixed-emptiable:'))
+                                obligations.push(required);
+                            else
+                                distinctDeclaration ??= x.element.id;
+                        }
+                    }
+                }
+                else if (x.wildcard && y.wildcard) {
+                    if (x.wildcard.processContents !== y.wildcard.processContents)
+                        return done(false);
+                    const a = x.wildcard.namespace, z = y.wildcard.namespace;
+                    if (a.kind !== z.kind || a.namespaces.length !== z.namespaces.length)
+                        return done(false);
+                    for (let i = 0; i < a.namespaces.length; i++)
+                        if (budget.compareText(a.namespaces[i], z.namespaces[i]) !== 0)
+                            return done(false);
+                }
+                charge(x.children.length * 3);
+                for (let i = 0; i < x.children.length; i++)
+                    stack.push([x.children[i], y.children[i]]);
+            }
+            return distinctDeclaration ? unresolved('raw-declaration-property-correspondence', distinctDeclaration, 'Recursive component equality retains unresolved local-property prerequisites') : done(true);
+        }
+        catch (error) {
+            if (error instanceof SemanticError)
+                return unresolved('cos-particle-extend', error.component ?? derived.type, error.message);
+            throw error;
+        }
+    });
+}

package/dist/compiler/particleLocalAssessment.d.ts

@@ -0,0 +1,19 @@
+/** All placement, shared EDC and exact marked-automaton UPA on the declared view. */
+import type { SemanticContext } from './semanticContext.js';
+import type { ParticleContentView } from './complexTypeContent.js';
+import type { SemanticParticleView } from './particleSemanticView.js';
+import type { RelationFailure } from './schemaTypeRelations.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+import type { SemanticTypeDependency } from './semanticTypeReference.js';
+export type ParticleLocalResult = Readonly<{
+    kind: 'checked';
+    value: boolean;
+    rule: 'particle-local-legality';
+    contextId: string;
+    failedRule?: 'cos-all-limited' | 'cos-element-consistent' | 'cos-nonambig';
+    component?: string;
+    obligations: readonly ['component-validity'];
+    typeDependencies: readonly SemanticTypeDependency[];
+}> | RelationFailure | ResourceLimitFailure;
+export declare function checkDeclaredParticleLegality(context: SemanticContext, view: SemanticParticleView): ParticleLocalResult;
+export declare function checkComplexParticleContent(context: SemanticContext, content: ParticleContentView): ParticleLocalResult;

package/dist/compiler/particleLocalAssessment.js

@@ -0,0 +1,92 @@
+import { prepareSemanticParticleView, assertSemanticParticleView } from './particleSemanticView.js';
+import { checkElementDeclarationsConsistent } from './particleDeclarationConsistency.js';
+import { checkParticleAttribution } from './particleAttribution.js';
+import { collectSemanticTypeDependencies } from './semanticTypeDependencies.js';
+class Incomplete extends Error {
+    result;
+    constructor(result) {
+        super(result.kind);
+        this.result = result;
+    }
+}
+export function checkDeclaredParticleLegality(context, view) {
+    assertSemanticParticleView(context, view);
+    const budget = context.budget, charge = (n = 1) => budget.chargeWork(n);
+    return budget.guard(() => {
+        const typeDependencies = collectSemanticTypeDependencies(context);
+        typeDependencies.add(view.typeDependencies);
+        const result = (value, failedRule, component) => {
+            charge(14);
+            return Object.freeze({ kind: 'checked', value, rule: 'particle-local-legality', contextId: context.contextId,
+                failedRule, component, obligations: Object.freeze(['component-validity']), typeDependencies: typeDependencies.snapshot() });
+        };
+        const unresolved = (component, message) => {
+            charge(10 + component.length + message.length);
+            throw new Incomplete(Object.freeze({ kind: 'unresolved', rule: 'particle-local-legality', component, message }));
+        };
+        try {
+            charge(18);
+            if (view.purpose !== 'declared')
+                return unresolved(view.root.source, 'Declared particle view required for all placement, EDC and UPA');
+            const root = view.root;
+            charge(2);
+            const pending = [root], seen = new Set();
+            while (pending.length) {
+                charge(3);
+                const p = pending.pop();
+                if (seen.has(p))
+                    continue;
+                seen.add(p);
+                if (p.kind === 'all') {
+                    if (p !== root || p.occurs.max !== '1' || p.occurs.min !== '0' && p.occurs.min !== '1')
+                        return result(false, 'cos-all-limited', p.source);
+                    for (const child of p.children) {
+                        charge(3);
+                        if (child.kind !== 'element' || !['0', '1'].includes(child.occurs.min) || !['0', '1'].includes(child.occurs.max))
+                            return result(false, 'cos-all-limited', child.source);
+                    }
+                }
+                charge(p.children.length);
+                pending.push(...p.children);
+            }
+            // Cut synthetic effective extension wrappers at actual contextual roots.
+            // The EDC owner preserves incidence when the same root occurs twice.
+            charge(3);
+            const edcRoots = [], roots = [root];
+            while (roots.length) {
+                charge(3);
+                const p = roots.pop(), found = context.lookup(p.source);
+                if (found.kind === 'found' && found.node.kind === 'particle') {
+                    charge();
+                    edcRoots.push(p.source);
+                }
+                else {
+                    charge(p.children.length);
+                    roots.push(...p.children);
+                }
+            }
+            const edc = checkElementDeclarationsConsistent(context, edcRoots);
+            if (edc.kind !== 'checked')
+                return edc;
+            typeDependencies.add(edc.typeDependencies);
+            if (!edc.value)
+                return result(false, 'cos-element-consistent', edc.conflict?.[1]);
+            const attribution = checkParticleAttribution(context, view);
+            if (attribution.kind !== 'checked')
+                return attribution;
+            typeDependencies.add(attribution.typeDependencies);
+            if (!attribution.value)
+                return result(false, 'cos-nonambig', attribution.component);
+            return result(true);
+        }
+        catch (error) {
+            if (error instanceof Incomplete)
+                return error.result;
+            throw error;
+        }
+    });
+}
+export function checkComplexParticleContent(context, content) {
+    const view = prepareSemanticParticleView(context, content, 'declared');
+    return view.kind === 'checked' ? checkDeclaredParticleLegality(context, view.view) : view;
+}

package/dist/compiler/particleRestriction.d.ts

@@ -0,0 +1,23 @@
+import type { SemanticContext } from './semanticContext.js';
+import type { SemanticParticleView } from './particleSemanticView.js';
+import type { RelationFailure } from './schemaTypeRelations.js';
+import type { ScalarFailure } from './schemaScalarKernel.js';
+import type { ScalarObligation } from './scalarSchemaAssessment.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+import type { SemanticTypeDependency } from './semanticTypeReference.js';
+import type { IdentityConstraintDependency } from './schemaIdentityConstraints.js';
+export type ParticleRestrictionResult = Readonly<{
+    kind: 'checked';
+    value: boolean;
+    rule: 'cos-particle-restrict';
+    contextId: string;
+    obligations: readonly ['component-validity', 'particle-local-legality'];
+    scalarObligations: readonly Readonly<ScalarObligation & {
+        contextId: string;
+    }>[];
+    typeDependencies: readonly SemanticTypeDependency[];
+    identityConstraintDependencies: readonly IdentityConstraintDependency[];
+}> | RelationFailure | ScalarFailure | ResourceLimitFailure;
+export declare function checkParticleRestriction(context: SemanticContext, derived: SemanticParticleView, base: SemanticParticleView, options?: Readonly<{
+    deferScalarObligations?: boolean;
+}>): ParticleRestrictionResult;