@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/schemaScalarContext.d.ts

@@ -0,0 +1,85 @@
+/** Compatibility adapter for shared pure schema rules; no aggregate assessment. */
+import type { GraphNode, NodeId, Reference } from './canonicalGraph.js';
+import type { SyntaxSource } from '../loader/orderedSyntax.js';
+import type { SemanticContext } from './semanticContext.js';
+export declare class SchemaOperandContextError extends Error {
+    readonly component: string;
+    readonly rule: string;
+    constructor(component: string, rule: string);
+}
+export declare class SchemaAssessmentError extends Error {
+    readonly category: 'invalid-schema' | 'unsupported-capability' | 'scalar-indeterminate' | 'missing-prerequisite';
+    readonly rule: string;
+    readonly node: GraphNode;
+    readonly source: SyntaxSource;
+    readonly related: readonly SyntaxSource[];
+    constructor(category: 'invalid-schema' | 'unsupported-capability' | 'scalar-indeterminate' | 'missing-prerequisite', rule: string, message: string, node: GraphNode, source?: SyntaxSource, related?: readonly SyntaxSource[]);
+}
+export declare function schemaScalarContext(context: SemanticContext): {
+    context: Readonly<{
+        contextId: string;
+        profileVersion: typeof import("./canonicalGraph.js").GRAPH_MODEL;
+        contractVersion: typeof import("./semanticContext.js").SEMANTIC_CONTEXT_CONTRACT;
+        kind: "actual" | "candidate";
+        acceptance: "structural-only";
+        membership: "complete-actual-plus-additions" | "structural-subset";
+        budget: import("./semanticBudget.js").SemanticBudget;
+        members: readonly NodeId[];
+        scalarSlots: readonly import("./semanticTypeReference.js").OriginalGeneratedScalarReference[];
+        scalarSlotMembership: "complete-original" | "structural-subset";
+        lookupScalarSlot(reference: import("./semanticTypeReference.js").OriginalGeneratedScalarReference): import("./semanticContext.js").ContextScalarSlotLookup;
+        notationMembers: readonly import("../loader/orderedSyntax.js").ExpandedName[];
+        notationMembership: "complete-original-plus-additions" | "structural-subset";
+        notationUniverse: "source-bound" | "retained-only";
+        lookupNotation(name: import("../loader/orderedSyntax.js").ExpandedName): import("./semanticContext.js").ContextNotationLookup;
+        originalIdentityConstraints(): import("./schemaIdentityConstraints.js").OriginalIdentityConstraintRegistry;
+        lookup(id: NodeId): import("./semanticContext.js").ContextLookup;
+        standardElement(id: NodeId): import("./standardSchemaComponents.js").StandardSchemaElementDeclaration | undefined;
+        standardLibraryIds(): readonly string[];
+        ownTypeReference(reference: import("./semanticTypeReference.js").SemanticTypeReference): import("./semanticTypeReference.js").SemanticTypeReference;
+        resolve(reference: Reference): import("./semanticContext.js").ContextResolution;
+        sourceNode(id: NodeId): GraphNode | undefined;
+        originalDeclarationSource(id: NodeId): Extract<GraphNode, {
+            kind: "element" | "attribute";
+        }> | undefined;
+        originalSourceComponentAbsent(id: NodeId): boolean;
+        originalComplexPropertySource(id: NodeId): import("./canonicalGraph.js").ComplexTypeNode | undefined;
+        originalComplexContentSource(id: NodeId): import("./canonicalGraph.js").ComplexTypeNode | undefined;
+        originalCompositorChildren(id: NodeId): readonly NodeId[] | undefined;
+        originalUrWildcards(): readonly import("./re01TypeProperties.js").OriginalUrWildcardHandle[];
+        originalUrWildcard(id: NodeId): import("./re01TypeProperties.js").OriginalUrWildcardHandle | undefined;
+        originalContext(): SemanticContext;
+        sourceSchemaRetained(): import("./canonicalGraph.js").CanonicalGraph["schemaRetained"];
+        rawTypeProperties(id: NodeId): import("./re01TypeProperties.js").RawComplexTypeProperties | undefined;
+        rawSimpleTypeProperties(id: NodeId): import("./schemaSimpleTypeProperties.js").RawSimpleTypeProperties | undefined;
+        rawElementProperties(id: NodeId): import("./schemaElementProperties.js").RawElementProperties | undefined;
+        rawAttributeProperties(id: NodeId): import("./schemaAttributeProperties.js").RawAttributeProperties | undefined;
+        rawAttributeGroupProperties(id: NodeId): import("./schemaAttributeGroupProperties.js").RawAttributeGroupProperties | undefined;
+        rawParticleWildcardProperties(id: NodeId): import("./schemaParticleWildcardProperties.js").RawParticleWildcardProperties | undefined;
+        references(id: NodeId): readonly import("./semanticContext.js").SemanticReferenceSlot[];
+        owner(id: NodeId): NodeId | undefined;
+        incomingAffiliates(id: NodeId): readonly NodeId[];
+    }>;
+    notation: (namespace: string, local: string, owner: GraphNode) => void;
+    budget: import("./semanticBudget.js").ResolverBudget;
+    step: (_node?: GraphNode | undefined, count?: number) => void;
+    text: (value: string, node?: GraphNode | undefined) => string;
+    get: (id: NodeId) => GraphNode;
+    target: (reference: Reference, owner: GraphNode) => NodeId | undefined;
+    fail: (node: GraphNode, rule: string, message: string, source?: SyntaxSource, related?: readonly SyntaxSource[]) => never;
+    unsupported: (node: GraphNode, rule: string, message: string, source?: SyntaxSource) => never;
+    unresolved: (node: GraphNode, rule: string, message: string, source?: SyntaxSource) => never;
+    indeterminate: (node: GraphNode, rule: string, source?: SyntaxSource) => never;
+    setCurrent(node: GraphNode): void;
+    algebra: {
+        compare: (a: import("./occurrenceAnalysis.js").Bound, b: import("./occurrenceAnalysis.js").Bound) => number;
+        validate: (range: import("./canonicalGraph.js").Occurs) => void;
+        add: (a: import("./occurrenceAnalysis.js").Bound, b: import("./occurrenceAnalysis.js").Bound) => import("./occurrenceAnalysis.js").Bound;
+        multiply: (a: import("./occurrenceAnalysis.js").Bound, b: import("./occurrenceAnalysis.js").Bound) => import("./occurrenceAnalysis.js").Bound;
+        count: (value: string) => bigint;
+        sum: (a: import("./canonicalGraph.js").Occurs, b: import("./canonicalGraph.js").Occurs) => import("./canonicalGraph.js").Occurs;
+        product: (a: import("./canonicalGraph.js").Occurs, b: import("./canonicalGraph.js").Occurs) => import("./canonicalGraph.js").Occurs;
+        alternative: (a: import("./canonicalGraph.js").Occurs, b: import("./canonicalGraph.js").Occurs) => import("./canonicalGraph.js").Occurs;
+    };
+};
+export type AssessmentContext = ReturnType<typeof schemaScalarContext>;

package/dist/compiler/schemaScalarContext.js

@@ -0,0 +1,78 @@
+import { occurrenceAlgebra } from './occurrenceAnalysis.js';
+import { checkNotationProperties } from './schemaNotationProperties.js';
+import { assertSemanticContext } from './semanticContext.js';
+export class SchemaOperandContextError extends Error {
+    component;
+    rule;
+    constructor(component, rule) {
+        super('Scalar operand is outside the authenticated context');
+        this.component = component;
+        this.rule = rule;
+    }
+}
+export class SchemaAssessmentError extends Error {
+    category;
+    rule;
+    node;
+    source;
+    related;
+    constructor(category, rule, message, node, source = node.context.source, related = []) {
+        super(message);
+        this.category = category;
+        this.rule = rule;
+        this.node = node;
+        this.source = source;
+        this.related = related;
+        this.name = 'SchemaAssessmentError';
+    }
+}
+export function schemaScalarContext(context) {
+    assertSemanticContext(context);
+    let current;
+    const step = (_node = current, count = 1) => context.budget.chargeWork(count);
+    const text = (value, node = current) => { step(node, 4 * value.length + 1); return value; };
+    const get = (id) => {
+        const result = context.lookup(id);
+        if (result.kind !== 'found')
+            throw new SchemaOperandContextError(id, result.kind);
+        return result.node;
+    };
+    const fail = (node, rule, message, source, related) => {
+        throw new SchemaAssessmentError('invalid-schema', rule, message, node, source, related);
+    };
+    const unsupported = (node, rule, message, source) => {
+        throw new SchemaAssessmentError('unsupported-capability', rule, message, node, source);
+    };
+    const unresolved = (node, rule, message, source) => {
+        throw new SchemaAssessmentError('missing-prerequisite', rule, message, node, source);
+    };
+    const indeterminate = (node, rule, source) => {
+        throw new SchemaAssessmentError('scalar-indeterminate', rule, 'Scalar ordering is indeterminate', node, source);
+    };
+    const target = (reference, owner) => {
+        const result = context.resolve(reference);
+        if (result.kind === 'builtin')
+            return undefined;
+        if (result.kind !== 'found')
+            return unresolved(owner, 'src-resolve', `Reference is ${result.kind}`);
+        return result.node.id;
+    };
+    const notation = (namespace, local, owner) => {
+        text(namespace, owner);
+        text(local, owner);
+        const result = context.lookupNotation({ namespace, local });
+        if (result.kind === 'found') {
+            const properties = checkNotationProperties(result.properties, context.budget);
+            if (properties.kind !== 'checked')
+                return fail(owner, properties.rule, properties.message);
+            return;
+        }
+        if (result.kind === 'unresolved')
+            return unresolved(owner, result.rule, 'NOTATION membership requires complete authenticated component properties');
+        if (result.kind === 'outside-context')
+            return unresolved(owner, 'notation-context-membership', 'NOTATION declaration is outside the active context');
+        return fail(owner, 'cvc-datatype-valid', 'NOTATION operand names no declared notation');
+    };
+    return { context, notation, budget: context.budget, step, text, get, target, fail, unsupported, unresolved, indeterminate,
+        setCurrent(node) { current = node; }, algebra: occurrenceAlgebra(() => step()) };
+}

package/dist/compiler/schemaScalarKernel.d.ts

@@ -0,0 +1,181 @@
+import type { SemanticTypeReference as Reference, SemanticTypeDependency, OriginalGeneratedScalarReference } from './semanticTypeReference.js';
+/** Declared-type schema operand facade. Private primitive assessment also forms facets; payload validation remains #184. */
+import type { LexicalValue, NodeId, ValueConstraint } from './canonicalGraph.js';
+import type { SyntaxSource } from '../loader/orderedSyntax.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+import type { ScalarObligation, ScalarFacetAnnotationPresence, ScalarContentProperties, RegularBinaryWordView, PrivateAliasEndpointTupleInput, FiniteImageBinaryWordView } from './scalarSchemaAssessment.js';
+import type { SchemaOperand } from './schemaDatatypeValues.js';
+export type ScalarFailure = Readonly<{
+    kind: 'invalid-schema' | 'unsupported-capability' | 'unresolved';
+    rule: string;
+    message: string;
+    component: NodeId;
+    source?: SyntaxSource;
+    contextId?: string;
+}>;
+export type ScalarResult<T> = Readonly<{
+    kind: 'checked';
+    value: T;
+    contextId: string;
+    authority: 'XSD10-schema-scalars-DT01-A-v1';
+    obligations: readonly ScalarObligation[];
+    typeDependencies: readonly SemanticTypeDependency[];
+}> | ScalarFailure | ResourceLimitFailure;
+export type AssessedSchemaOperand = Readonly<{
+    type: Reference;
+    lexical: LexicalValue;
+    owner: NodeId;
+    operand: SchemaOperand;
+    obligations?: readonly ScalarObligation[];
+}>;
+export type ScalarOrder = 'less' | 'equal' | 'greater' | 'indeterminate';
+export type CrossFacetOperand = Readonly<{
+    contextId: string;
+    reference: Reference;
+    owner: NodeId;
+}>;
+export type CrossFacetObligation = ScalarObligation & Readonly<{
+    contextId: string;
+}>;
+type CrossFacetReceipt = Readonly<{
+    operands: Readonly<{
+        left: CrossFacetOperand;
+        right: CrossFacetOperand;
+    }>;
+    obligations: readonly CrossFacetObligation[];
+    typeDependencies: readonly SemanticTypeDependency[];
+}>;
+export type CrossFacetResult = (CrossFacetReceipt & (Readonly<{
+    kind: 'checked';
+    value: boolean;
+    authority: 'XSD10-schema-scalar-facet-properties-v1';
+    annotationCorrespondence: 'equal' | 'different' | 'unresolved';
+    sourceFacetAnnotations: Readonly<{
+        left: ScalarFacetAnnotationPresence;
+        right: ScalarFacetAnnotationPresence;
+    }>;
+}> | (ScalarFailure & Readonly<{
+    side: 'left' | 'right';
+    contextId: string;
+}>) | Readonly<{
+    kind: 'unresolved';
+    side: 'comparison';
+    rule: string;
+    message: string;
+}>)) | ResourceLimitFailure;
+export type GeneratedScalarReceipt = Readonly<{
+    kind: 'checked';
+    slot: OriginalGeneratedScalarReference;
+    contextId: string;
+    authority: 'XSD10-original-generated-scalar-v1';
+    properties: ScalarContentProperties;
+    typeDependencies: readonly SemanticTypeDependency[];
+    obligations: readonly ScalarObligation[];
+}>;
+export type GeneratedScalarResult = GeneratedScalarReceipt | ScalarFailure | ResourceLimitFailure;
+declare function makeKernel(context: SemanticContext): {
+    finiteImageBinaryWordViews: (views: readonly FiniteImageBinaryWordView[], owner: NodeId) => ScalarResult<import("./scalarSchemaAssessment.js").FiniteImageBinaryWordViews>;
+    regularBinaryWordViews: (views: readonly RegularBinaryWordView[], owner: NodeId) => ScalarResult<import("./scalarSchemaAssessment.js").RegularBinaryWordViews>;
+    privateAliasEndpointAdmission: (reference: Reference, owner: NodeId) => ScalarResult<import("./scalarSchemaAssessment.js").PrivateAliasEndpointAdmission>;
+    privateAliasEndpointTuples: (inputTuple: PrivateAliasEndpointTupleInput, owner: NodeId) => ScalarResult<import("./scalarSchemaAssessment.js").PrivateAliasEndpointTuples>;
+    privateAliasEndpointWordCapacity: (reference: Reference, owner: NodeId) => ScalarResult<{
+        inventory: {
+            ordinal: number;
+            kind: string;
+            fixed: readonly boolean[];
+            annotation: ScalarFacetAnnotationPresence;
+        }[];
+        maskAuthority: "current-atomic-admission";
+        kind: "finite-capacity";
+        family: string;
+        roles: number;
+        formulaLeaves: number;
+        maskStates: number;
+        constants: number;
+        equations: number;
+        tracks: number;
+        fieldStates: import("./schemaEndpointWordCapacity.js").EndpointCapacityExpression;
+        jointStates: import("./schemaEndpointWordCapacity.js").EndpointCapacityExpression;
+        encodedTuple: import("./schemaEndpointWordCapacity.js").EndpointCapacityExpression;
+        maximumWordUnits?: undefined;
+        encodedTupleUnits?: undefined;
+    } | {
+        kind: "finite-ieee-capacity";
+        family: string;
+        roles: number;
+        maximumWordUnits: number;
+        encodedTupleUnits: number;
+        inventory: {
+            ordinal: number;
+            kind: string;
+            fixed: readonly boolean[];
+            annotation: ScalarFacetAnnotationPresence;
+        }[];
+        maskAuthority: "current-ieee-spelling-and-finite-inverse";
+    }>;
+    describe: (reference: Reference, owner: NodeId) => ScalarResult<Readonly<{
+        obligations?: readonly ScalarObligation[];
+        id: NodeId;
+        reference: Reference;
+        variety: "atomic" | "list" | "union";
+        primitive?: string;
+        builtin?: string;
+        item?: Reference;
+        members?: readonly Reference[];
+        layers: readonly import("./scalarSchemaAssessment.js").ScalarConstraintLayer[];
+        declaredMembers?: readonly Reference[];
+        unionMapping?: "xsd10-flattened";
+        whitespace: "preserve" | "replace" | "collapse" | "member";
+        enforcement: readonly import("./scalarSchemaAssessment.js").ScalarEnforcement[];
+        runtimeOwner: "#184";
+        consumers: readonly ["#188", "#189", "#198"];
+    }>>;
+    contentIdentity: (reference: Reference, owner: NodeId) => ScalarResult<{
+        definition: string;
+        reference?: Reference;
+    }>;
+    contentProperties: (reference: Reference, owner: NodeId) => ScalarResult<Readonly<{
+        definition: string;
+        name?: import("../loader/orderedSyntax.js").ExpandedName;
+        targetNamespace: string;
+        final: readonly string[];
+        base?: Reference;
+        variety: "atomic" | "list" | "union" | "absent";
+        primitive?: string;
+        item?: Reference;
+        members?: readonly Reference[];
+        generatedPolicy?: "GSC1";
+        annotation: "absent" | "source";
+    }>>;
+    contentDerivation: (derived: Reference, base: Reference, owner: NodeId) => ScalarResult<boolean>;
+    facetPropertiesEquivalent: (a: Reference, b: Reference, owner: NodeId) => ScalarResult<boolean>;
+    assess: (reference: Reference, lexical: LexicalValue, owner: NodeId) => ScalarResult<AssessedSchemaOperand>;
+    assessValue: (reference: Reference, constraint: ValueConstraint, owner: NodeId) => ScalarResult<AssessedSchemaOperand>;
+    checkValue: (reference: Reference, constraint: ValueConstraint, owner: NodeId) => ScalarResult<{
+        enforcement: import("./scalarSchemaAssessment.js").ScalarEnforcement[];
+        obligations?: readonly ScalarObligation[];
+        id: NodeId;
+        reference: Reference;
+        variety: "atomic" | "list" | "union";
+        primitive?: string;
+        builtin?: string;
+        item?: Reference;
+        members?: readonly Reference[];
+        layers: readonly import("./scalarSchemaAssessment.js").ScalarConstraintLayer[];
+        declaredMembers?: readonly Reference[];
+        unionMapping?: "xsd10-flattened";
+        whitespace: "preserve" | "replace" | "collapse" | "member";
+        runtimeOwner: "#184";
+        consumers: readonly ["#188", "#189", "#198"];
+    }>;
+    equivalent: (aType: Reference, a: LexicalValue, bType: Reference, b: LexicalValue, owner: NodeId) => ScalarResult<boolean>;
+    compare: (aType: Reference, a: LexicalValue, bType: Reference, b: LexicalValue, owner: NodeId) => ScalarResult<ScalarOrder>;
+};
+export declare function createSchemaScalarKernel(context: SemanticContext): ReturnType<typeof makeKernel>;
+/** Facet-only equality of two authentic contexts in one request. Annotations
+ * are reported separately; this is not complete component correspondence. */
+export declare function compareSchemaFacetProperties(leftContext: SemanticContext, leftReference: Reference, leftOwner: NodeId, rightContext: SemanticContext, rightReference: Reference, rightOwner: NodeId): CrossFacetResult;
+export declare function checkOriginalGeneratedScalar(context: SemanticContext, slot: OriginalGeneratedScalarReference): GeneratedScalarResult;
+export declare function assertOriginalGeneratedScalarReceipt(context: SemanticContext, receipt: GeneratedScalarReceipt): void;
+export {};