@techspokes/typescript-wsdl-client 1.1.5 → 1.1.8

package/dist/compiler/particleExtension.js

@@ -68,7 +68,11 @@ export function checkRawParticleExtension(context, derived, base) {
                 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.element && y.element) {
+                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);

package/dist/compiler/particleLocalAssessment.d.ts

@@ -17,4 +17,3 @@ export type ParticleLocalResult = Readonly<{
 }> | RelationFailure | ResourceLimitFailure;
 export declare function checkDeclaredParticleLegality(context: SemanticContext, view: SemanticParticleView): ParticleLocalResult;
 export declare function checkComplexParticleContent(context: SemanticContext, content: ParticleContentView): ParticleLocalResult;
-//# sourceMappingURL=particleLocalAssessment.d.ts.map

package/dist/compiler/particleRestriction.d.ts

@@ -21,4 +21,3 @@ export type ParticleRestrictionResult = Readonly<{
 export declare function checkParticleRestriction(context: SemanticContext, derived: SemanticParticleView, base: SemanticParticleView, options?: Readonly<{
     deferScalarObligations?: boolean;
 }>): ParticleRestrictionResult;
-//# sourceMappingURL=particleRestriction.d.ts.map

package/dist/compiler/particleRestriction.js

@@ -212,7 +212,7 @@ export function checkParticleRestriction(context, derived, base, options = {}) {
                     if (!source)
                         return unresolved(p, 'Semantic particle provenance is unavailable');
                     decisions.set(p, Object.freeze({ owner: Object.freeze({ id: p.source, context: Object.freeze({ source }) }), kind: p.kind, occurs: p.occurs,
-                        total: p.summary.effectiveTotalRange, members: Object.freeze(p.children.map(child => decisions.get(child))), namespace: p.element?.name.namespace,
+                        total: p.summary.effectiveTotalRange, members: Object.freeze(p.children.map(child => decisions.get(child))), namespace: p.element?.name.namespace ?? p.standardElement?.name.namespace,
                         wildcard: p.wildcard ? Object.freeze({ constraint: p.wildcard.namespace, processContents: p.wildcard.processContents,
                             lexical: Object.freeze({ value: p.wildcard.lexical.value, effectiveNamespace: p.wildcard.lexical.context.effectiveNamespace }) }) : undefined }));
                 }
@@ -223,6 +223,11 @@ export function checkParticleRestriction(context, derived, base, options = {}) {
                 if (r === b || r.originalParticle !== undefined && r.originalParticle === b.originalParticle)
                     return true;
                 if (r.kind === 'element' && b.kind === 'element') {
+                    if (r.standardElement || b.standardElement) {
+                        if (r.standardElement && r.standardElement === b.standardElement)
+                            return within(r.occurs, b.occurs);
+                        return unresolved(r, 'Restriction between fixed standard and application declarations is not implemented');
+                    }
                     const x = r.element, y = b.element;
                     charge(x.name.namespace.length + y.name.namespace.length + x.name.local.length + y.name.local.length);
                     if (x.name.namespace !== y.name.namespace || x.name.local !== y.name.local || !within(r.occurs, b.occurs))

package/dist/compiler/particleSemanticView.d.ts

@@ -7,6 +7,7 @@ import type { ParticleSummary } from './occurrenceAnalysis.js';
 import type { RelationFailure } from './schemaTypeRelations.js';
 import type { ResourceLimitFailure } from './semanticBudget.js';
 import type { SemanticTypeDependency } from './semanticTypeReference.js';
+import type { StandardSchemaElementDeclaration } from './standardSchemaComponents.js';
 type GroupKind = 'sequence' | 'choice' | 'all';
 /** Explicit positions survive flattening; only each implicit block is a set. */
 export type SemanticParticleOrderBlock = Readonly<{
@@ -29,6 +30,7 @@ export type SemanticParticle = Readonly<{
     orderBlocks: readonly SemanticParticleOrderBlock[];
     element?: ElementNode;
     wildcard?: SelectedParticleWildcard;
+    standardElement?: StandardSchemaElementDeclaration;
     summary: ParticleSummary;
     urTypeWildcard: boolean;
     orderUnspecified: boolean;
@@ -47,4 +49,3 @@ export type ParticleViewResult = Readonly<{
 export declare function assertSemanticParticleView(context: SemanticContext, view: SemanticParticleView): void;
 export declare function prepareSemanticParticleView(context: SemanticContext, content: ParticleContentView, purpose: SemanticParticleView['purpose']): ParticleViewResult;
 export {};
-//# sourceMappingURL=particleSemanticView.d.ts.map

package/dist/compiler/particleSemanticView.js

@@ -106,7 +106,12 @@ export function prepareSemanticParticleView(context, content, purpose) {
                     || content.synthetic.includes(node.id))
                     p.originalParticle = node.id;
                 if (term.term.kind === 'element') {
-                    const declaration = target(term.term.declaration, node.id);
+                    const selected = context.resolve(term.term.declaration);
+                    if (selected.kind === 'standard-element') {
+                        p.standardElement = selected.declaration;
+                        return p;
+                    }
+                    const declaration = selected.kind === 'found' ? selected.node : fail(node.id, 'Element target unavailable');
                     if (declaration.kind !== 'element')
                         return fail(node.id, 'Element particle requires an element declaration');
                     p.element = declaration;
@@ -220,18 +225,26 @@ export function prepareSemanticParticleView(context, content, purpose) {
             }
             charge(3 + shapes.size * 2);
             const nodes = [], declarations = new Map();
+            const standardElements = new Map();
             for (const p of shapes.values())
                 if (p.element) {
                     charge(2 + p.element.id.length);
                     declarations.set(p.element.id, p.element);
                 }
+            for (const p of shapes.values())
+                if (p.standardElement) {
+                    charge(2 + p.standardElement.id.length);
+                    standardElements.set(p.standardElement.id, p.standardElement);
+                }
             charge(declarations.size);
             nodes.push(...declarations.values());
             let wildcardRealization;
             for (const p of shapes.values()) {
                 const original = get(p.source);
                 charge(20 + p.children.length);
-                const term = p.kind === 'element' ? Object.freeze({ kind: 'element', declaration: Object.freeze({ kind: 'local', target: p.element.id }) })
+                const term = p.kind === 'element' ? Object.freeze({ kind: 'element', declaration: p.standardElement
+                        ? original.kind === 'particle' && original.term.kind === 'element' ? original.term.declaration : fail(p.source, 'Standard element source unavailable')
+                        : Object.freeze({ kind: 'local', target: p.element.id }) })
                     : p.kind === 'any' ? Object.freeze({ kind: 'any', wildcard: Object.freeze({ namespace: p.wildcard.lexical,
                             processContents: p.wildcard.processContents }) })
                         : Object.freeze({ kind: p.kind, children: Object.freeze(p.children.map(child => child.id)) });
@@ -248,7 +261,7 @@ export function prepareSemanticParticleView(context, content, purpose) {
             charge(18);
             const graph = Object.freeze({ ...semanticContextGraphMetadata(context), nodes: Object.freeze(nodes), globals: EMPTY });
             const composed = Object.freeze({ resolved: Object.freeze({ graph, links: EMPTY, metrics: Object.freeze({ steps: 0 }) }), types: EMPTY, metrics: Object.freeze({ steps: 0 }) });
-            const analysis = analyzeOccurrences(composed, { maxNodes: Number.MAX_SAFE_INTEGER, maxSteps: Number.MAX_SAFE_INTEGER }, { budget, wildcardRealization });
+            const analysis = analyzeOccurrences(composed, { maxNodes: Number.MAX_SAFE_INTEGER, maxSteps: Number.MAX_SAFE_INTEGER }, { budget, wildcardRealization, standardElements });
             if (analysis.kind === 'resource-limit')
                 return analysis;
             if (analysis.kind === 'failure')

package/dist/compiler/particleWildcardRelation.d.ts

@@ -85,4 +85,3 @@ export type QualifiedWildcardResult = Readonly<{
  * adapter and is deliberately not inferred from ##any or lax spelling here.
  */
 export declare function restrictParticleToWildcard(context: SemanticContext, root: DecisionParticle, base: DecisionParticle): QualifiedWildcardResult;
-//# sourceMappingURL=particleWildcardRelation.d.ts.map

package/dist/compiler/projectionScalar.d.ts

@@ -0,0 +1,32 @@
+import type { SemanticContext } from './semanticContext.js';
+import type { AttributeNode, ElementNode } from './canonicalGraph.js';
+import type { DatatypeOperand } from './datatypeValues.js';
+import type { ExpandedName } from '../loader/orderedSyntax.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+import type { DatatypeLexicalOperand } from './schemaValueContext.js';
+type Declaration = AttributeNode | ElementNode;
+export type ProjectionScalarFailure = Readonly<{
+    kind: 'unavailable' | 'scalar-invalid';
+    rule: string;
+}>;
+export interface ProjectionScalarList {
+    readonly builtin: ExpandedName;
+    readonly whitespace: 'preserve' | 'replace' | 'collapse';
+    readonly retainLexical?: true;
+}
+export type ProjectionScalarDescription = Readonly<{
+    kind: 'projection-scalar-type';
+    builtin: ExpandedName;
+    retainLexical?: true;
+    list?: ProjectionScalarList;
+}>;
+type DescriptionResult = ProjectionScalarDescription | ProjectionScalarFailure | ResourceLimitFailure;
+type OperandResult = Readonly<{
+    kind: 'projection-scalar-operand';
+    operand: DatatypeOperand;
+}> | ProjectionScalarFailure | ResourceLimitFailure;
+/** Native declaration lookup and source-type formation precede any payload calculation. */
+export declare function describeProjectionScalar(context: SemanticContext, declaration: Declaration, check?: () => void): DescriptionResult;
+/** A successful calculation is payload-only data; it grants no schema, operation or portable artifact authority. */
+export declare function assessProjectionScalarOperand(context: SemanticContext, declaration: Declaration, lexical: DatatypeLexicalOperand, check?: () => void): OperandResult;
+export {};

package/dist/compiler/projectionScalar.js

@@ -0,0 +1,184 @@
+/** Payload facade over the existing native scalar implementation; no source-validity or admission receipt. */
+import { assertSemanticContext } from './semanticContext.js';
+import { schemaScalarContext, SchemaAssessmentError, SchemaOperandContextError } from './schemaScalarContext.js';
+import { scalarSchemaAssessment } from './scalarSchemaAssessment.js';
+import { XSD_NAMESPACE } from '../loader/orderedSyntax.js';
+import { types } from 'node:util';
+import { occurrenceAlgebra } from './occurrenceAnalysis.js';
+import { deriveActualComplexContent } from './complexTypeContent.js';
+const kernels = new WeakMap();
+function kernel(context) {
+    const base = schemaScalarContext(context);
+    let callerCheck;
+    let interrupted = false;
+    const check = () => {
+        try {
+            callerCheck?.();
+        }
+        catch (error) {
+            interrupted = true;
+            throw error;
+        }
+    };
+    const c = { ...base,
+        step(owner, count = 1) { check(); base.step(owner, count); },
+        text(value, owner) { check(); return base.text(value, owner); },
+        algebra: occurrenceAlgebra(() => { check(); base.step(); }), };
+    // The default scalar profile excludes document-wide identity/DTD/NOTATION duties.
+    // SOURCE formation remains the existing implementation; payload operands never become schema evidence.
+    const core = scalarSchemaAssessment(c);
+    const descriptions = new Map();
+    const references = new Map();
+    const owner = (declaration) => {
+        if (types.isProxy(declaration))
+            throw new TypeError('Expected exact native scalar declaration');
+        const id = Object.getOwnPropertyDescriptor(declaration, 'id');
+        if (!id || !('value' in id) || typeof id.value !== 'string')
+            throw new TypeError('Expected exact native scalar declaration');
+        const found = context.lookup(id.value);
+        if (found.kind !== 'found' || found.node !== declaration)
+            throw new TypeError('Expected exact native scalar declaration');
+        return declaration;
+    };
+    const describe = (declaration) => {
+        owner(declaration);
+        const cached = descriptions.get(declaration.id);
+        if (cached)
+            return cached;
+        let reference = declaration.type;
+        const type = context.resolve(declaration.type);
+        if (type.kind === 'found' && type.node.kind === 'complexType') {
+            const content = deriveActualComplexContent(context, type.node.id);
+            if (content.kind !== 'checked' || content.view.content.kind !== 'simple')
+                return Object.freeze({ kind: 'unavailable', rule: 'scalar-content-reference' });
+            reference = content.view.content.type;
+        }
+        const plan = core.ensure(reference, declaration);
+        const stringUnion = (candidate) => {
+            if (candidate.variety !== 'union' || !candidate.members?.length || candidate.obligations?.length)
+                return false;
+            for (const reference of candidate.members) {
+                check();
+                c.step(declaration);
+                const member = core.ensure(reference, declaration);
+                if (member.variety !== 'atomic' || member.primitive !== 'string' || member.obligations?.length)
+                    return false;
+            }
+            return true;
+        };
+        const union = plan.variety === 'union';
+        if (union && !stringUnion(plan))
+            return Object.freeze({ kind: 'unavailable', rule: 'declared-scalar-union' });
+        if (plan.obligations?.length)
+            return Object.freeze({ kind: 'unavailable', rule: 'scalar-source-obligations' });
+        let item;
+        if (plan.variety === 'list') {
+            if (!plan.item)
+                return Object.freeze({ kind: 'unavailable', rule: 'scalar-list-item' });
+            const member = core.ensure(plan.item, declaration);
+            const unionItem = stringUnion(member);
+            if (member.variety !== 'atomic' && !unionItem)
+                return Object.freeze({ kind: 'unavailable', rule: 'scalar-list-item-' + member.variety });
+            if (member.obligations?.length || member.whitespace === 'member' && !unionItem)
+                return Object.freeze({ kind: 'unavailable', rule: 'scalar-list-item-source-obligations' });
+            const local = unionItem ? 'string' : member.builtin ?? member.primitive;
+            if (!local)
+                return Object.freeze({ kind: 'unavailable', rule: 'scalar-list-item-representation' });
+            context.budget.chargeWork(64);
+            item = Object.freeze({ builtin: Object.freeze({ namespace: XSD_NAMESPACE, local }), whitespace: unionItem ? 'preserve' : member.whitespace,
+                ...(unionItem || member.layers.some(layer => layer.patterns.length > 0) ? { retainLexical: true } : {}) });
+        }
+        const local = union ? 'string' : item?.builtin.local ?? plan.builtin ?? plan.primitive;
+        if (!local)
+            return Object.freeze({ kind: 'unavailable', rule: 'scalar-representation' });
+        context.budget.chargeWork(64 + declaration.id.length);
+        const retainLexical = union || plan.layers.some(layer => layer.patterns.length > 0);
+        const result = Object.freeze({ kind: 'projection-scalar-type', builtin: Object.freeze({ namespace: XSD_NAMESPACE, local }),
+            ...(retainLexical ? { retainLexical: true } : {}), ...(item ? { list: item } : {}) });
+        descriptions.set(declaration.id, result);
+        references.set(declaration.id, reference);
+        return result;
+    };
+    const failure = (error, operand) => {
+        if (error instanceof SchemaOperandContextError)
+            return Object.freeze({ kind: 'unavailable', rule: error.rule });
+        if (!(error instanceof SchemaAssessmentError))
+            throw error;
+        return Object.freeze({ kind: operand && error.category === 'invalid-schema' ? 'scalar-invalid' : 'unavailable', rule: error.rule });
+    };
+    return {
+        describe(declaration, cooperative) {
+            const previous = callerCheck;
+            callerCheck = cooperative;
+            interrupted = false;
+            try {
+                return context.budget.guard(() => {
+                    try {
+                        return describe(declaration);
+                    }
+                    catch (error) {
+                        return failure(error, false);
+                    }
+                });
+            }
+            finally {
+                if (interrupted)
+                    kernels.delete(context);
+                callerCheck = previous;
+            }
+        },
+        assess(declaration, supplied, cooperative) {
+            const previous = callerCheck;
+            callerCheck = cooperative;
+            interrupted = false;
+            try {
+                return context.budget.guard(() => {
+                    let operand = false;
+                    try {
+                        const description = describe(declaration);
+                        if (description.kind !== 'projection-scalar-type')
+                            return description;
+                        const input = context.budget.freeze(context.budget.snapshot(supplied));
+                        // GraphContext here is calculation data, not a source/context receipt. Namespace and source facts come from the payload.
+                        const lexical = { value: input.value, context: { ...declaration.context,
+                                namespaces: input.context.namespaces, source: input.context.source, baseUri: input.context.source.uri } };
+                        operand = true;
+                        const value = core.assess(references.get(declaration.id), lexical, declaration);
+                        context.budget.chargeWork(16);
+                        return Object.freeze({ kind: 'projection-scalar-operand', operand: value });
+                    }
+                    catch (error) {
+                        return failure(error, operand);
+                    }
+                });
+            }
+            finally {
+                if (interrupted)
+                    kernels.delete(context);
+                callerCheck = previous;
+            }
+        },
+    };
+}
+function get(context) {
+    assertSemanticContext(context);
+    if (context.kind !== 'actual')
+        throw new TypeError('Payload scalar projection requires actual source');
+    let result = kernels.get(context);
+    if (!result) {
+        context.budget.chargeWork(16);
+        result = kernel(context);
+        kernels.set(context, result);
+    }
+    return result;
+}
+/** Native declaration lookup and source-type formation precede any payload calculation. */
+export function describeProjectionScalar(context, declaration, check) {
+    assertSemanticContext(context);
+    return context.budget.guard(() => get(context).describe(declaration, check));
+}
+/** A successful calculation is payload-only data; it grants no schema, operation or portable artifact authority. */
+export function assessProjectionScalarOperand(context, declaration, lexical, check) {
+    assertSemanticContext(context);
+    return context.budget.guard(() => get(context).assess(declaration, lexical, check));
+}

package/dist/compiler/re01CandidateAssignments.d.ts

@@ -0,0 +1,95 @@
+import type { NodeId } from './canonicalGraph.js';
+import type { CandidatePreparation, SemanticCandidateDelta, SemanticContext } from './semanticContext.js';
+import type { CorrespondenceFailure } from './re01CandidateCorrespondence.js';
+import type { SemanticTypeReference, SemanticTypeDependency } from './semanticTypeReference.js';
+import type { ScalarObligation } from './scalarSchemaAssessment.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+import type { FiniteRe01EvidenceNode } from './finiteRe01Verification.js';
+/**
+ * The retained context plus one native delta is the shared physical assignment.
+ * BASE/TYPE/SCOPE/SG, BODY/CODE, scalar first modes, providers, WORD/maps and
+ * VALUE slots retain their actual identities; no projected scalar palette is
+ * copied into a second graph. New producers must assemble their choices into
+ * this same native representation before replay, not supply independent receipts.
+ */
+export type SharedRe01Assignment = Readonly<{
+    kind: 'prepared-local-assignment';
+    family: 'inherited-primitive-middle-v1' | 'fresh-source-middle-v1';
+    actual: SemanticContext;
+    parent: SemanticContext;
+    target: NodeId;
+    intermediate: NodeId;
+    ancestor: SemanticTypeReference;
+    delta: SemanticCandidateDelta;
+    /** Preparation duties remain pending until the complete native forest checks. */
+    scalarObligations: readonly ScalarObligation[];
+    typeDependencies: readonly SemanticTypeDependency[];
+    introducedStoredNonprimitive: 0;
+}>;
+export type InheritedAssignments = Readonly<{
+    kind: 'prepared-inherited-assignments';
+    assignments: readonly SharedRe01Assignment[];
+    /** Exhausting this subfamily cannot establish full nonexistence. */
+    universalCoverage: false;
+}>;
+export type AssignmentPreparation = InheritedAssignments | CorrespondenceFailure | ResourceLimitFailure;
+/** Derive every retained E-over-designated-ancestor middle, without a caller roster or old witness. */
+export declare function prepareInheritedMiddleAssignments(actual: SemanticContext, parent: SemanticContext, target: NodeId): AssignmentPreparation;
+export type FreshAssignments = Readonly<{
+    kind: 'prepared-fresh-assignments';
+    assignments: readonly SharedRe01Assignment[];
+    universalCoverage: false;
+}>;
+/**
+ * Propose one fresh E from native target properties over the designated ancestor.
+ * @remarks E preserves target attribute identities; its body is supplied by native source properties,
+ *   or the simple ancestor itself. For particle content, native extension checking must establish the retained prefix.
+ *   Native correspondence and finite closure decide legality.
+ *   Declining this limited family proves no nonexistence or dated-XSD eligibility.
+ */
+export declare function prepareFreshMiddleAssignments(actual: SemanticContext, parent: SemanticContext, target: NodeId): FreshAssignments | CorrespondenceFailure | ResourceLimitFailure;
+/** Replay only. A local node must be placed in its enclosing actual-root forest. */
+export declare function replaySharedAssignment(assignment: SharedRe01Assignment): Readonly<{
+    kind: 'prepared-local-evidence';
+    evidence: FiniteRe01EvidenceNode;
+}> | Exclude<CandidatePreparation, {
+    kind: 'prepared';
+}>;
+export type AdditiveRestrictionPreparation = Readonly<{
+    kind: 'prepared-additive-restriction';
+    actual: SemanticContext;
+    context: SemanticContext;
+    target: NodeId;
+    intermediate: NodeId;
+    representative: NodeId;
+    scalarObligations: readonly ScalarObligation[];
+    typeDependencies: readonly SemanticTypeDependency[];
+}>;
+export type AdditiveMiddlePreparation = Readonly<{
+    kind: 'prepared-additive-middle';
+    actual: SemanticContext;
+    context: SemanticContext;
+    target: NodeId;
+    intermediate: NodeId;
+    ancestor: SemanticTypeReference;
+    scalarObligations: readonly ScalarObligation[];
+    typeDependencies: readonly SemanticTypeDependency[];
+}>;
+/** Propose only a fresh extension middle; the actual target is never replaced or represented by another type.
+ * @remarks Native local construction, dependency closure and any paired restriction predicate remain separate checks.
+ * @returns An additive native context or explicit unavailability/resource result.
+ * @throws TypeError For a non-actual context.
+ */
+export declare function prepareAdditiveExtensionMiddle(actual: SemanticContext, target: NodeId): AdditiveMiddlePreparation | CorrespondenceFailure | ResourceLimitFailure | Exclude<CandidatePreparation, {
+    kind: 'prepared';
+}>;
+/** Propose fresh extension and restriction representatives without replacing any actual component.
+ * @remarks The restriction representative has the target's effective properties with a fresh identity and base.
+ *   This is construction input, not a derivation or correspondence certificate. Native checking, dependency closure
+ *   and the relation between the representative and the original target remain separate obligations.
+ * @returns A native prepared additive context or an explicit unavailable/resource result.
+ * @throws TypeError For a non-actual context.
+ */
+export declare function prepareAdditiveRestrictionRepresentative(actual: SemanticContext, target: NodeId): AdditiveRestrictionPreparation | CorrespondenceFailure | ResourceLimitFailure | Exclude<CandidatePreparation, {
+    kind: 'prepared';
+}>;