@techspokes/typescript-wsdl-client 1.1.5 → 1.2.0

package/dist/compiler/schemaElementInstance.js

@@ -0,0 +1,45 @@
+/** Fixed standard-element instance clauses; source construction and portable authority remain separate owners. */
+import { XSD_NAMESPACE } from '../loader/orderedSyntax.js';
+import { assessSchemaSourceWildcards } from './schemaSourceWildcards.js';
+class Cancelled extends Error {
+}
+/** Assess borrowed, already owned XML syntax as the dated global xs:schema element.
+ * @remarks Reuses the fixed S4S grammar, scalar and identity owners. It does not compile embedded schemas,
+ *   acquire dependencies, qualify a WSDL source or issue a mapping/codec/portable receipt.
+ *   The supplied schema element is the instance validation root. Callers retain responsibility for XML
+ *   parsing/ownership, any enclosing document identity scope and discharging remaining obligations.
+ * @returns Instance clauses only; a well-formed QName can reference an undeclared application type in schema-as-data.
+ * @throws TypeError For a non-native cancellation signal. Other caller-check failures propagate unchanged.
+ * @see https://www.w3.org/TR/2004/REC-xmlschema-1-20041028/structures.html#element-schema
+ */
+export function assessSchemaElementInstance(root, budget, options = {}) {
+    if (options.signal !== undefined && !(options.signal instanceof AbortSignal))
+        throw new TypeError('Native AbortSignal required');
+    const check = () => {
+        options.check?.();
+        if (options.signal?.aborted)
+            throw new Cancelled();
+        budget.chargeWork();
+    };
+    try {
+        return budget.guard(() => {
+            check();
+            if (root.name.namespace !== XSD_NAMESPACE || root.name.local !== 'schema')
+                return Object.freeze({ kind: 'value-invalid',
+                    rule: 'cvc-elt.1', message: 'The standard schema element requires the exact XML Schema expanded name', source: root.source });
+            const assessed = assessSchemaSourceWildcards(root, budget, check);
+            if (assessed.kind === 'resource-limit')
+                return assessed;
+            if (assessed.kind === 'invalid-schema')
+                return Object.freeze({ ...assessed, kind: 'value-invalid' });
+            check();
+            return Object.freeze({ kind: 'schema-element-instance', scope: 'XSD10-S4S-element-instance-2004',
+                ids: assessed.ids, remaining: assessed.remaining });
+        });
+    }
+    catch (error) {
+        if (error instanceof Cancelled)
+            return Object.freeze({ kind: 'cancelled', rule: 'cooperative-cancellation' });
+        throw error;
+    }
+}

package/dist/compiler/schemaElementProperties.d.ts

@@ -13,4 +13,3 @@ export type RawElementProperties = Readonly<{
     block: readonly ('restriction' | 'extension' | 'substitution')[];
 }>;
 export declare function validateRawElementShape(value: unknown, budget: SemanticBudget): value is RawElementProperties;
-//# sourceMappingURL=schemaElementProperties.d.ts.map

package/dist/compiler/schemaEndpointWordCapacity.d.ts

@@ -33,4 +33,3 @@ export declare function endpointCapacity(metrics: EndpointCapacityMetrics, step:
     jointStates: EndpointCapacityExpression;
     encodedTuple: EndpointCapacityExpression;
 };
-//# sourceMappingURL=schemaEndpointWordCapacity.d.ts.map

package/dist/compiler/schemaExactCalendar.d.ts

@@ -70,4 +70,3 @@ export declare function addDuration(start: Calendar, duration: Duration, budget:
 export declare function compareDuration(a: Duration, b: Duration, budget: CalendarBudget): Order;
 /** Exact output for tests only; canonical strings never replace retained lexicals. */
 export declare function showInstant(value: Decimal, budget: CalendarBudget): string;
-//# sourceMappingURL=schemaExactCalendar.d.ts.map

package/dist/compiler/schemaFacetAnnotation.d.ts

@@ -29,4 +29,3 @@ export declare function validateFacetAnnotation(value: unknown, budget: Semantic
 export declare function projectFacetAnnotation(node: SyntaxElement, budget: SemanticBudget): FacetAnnotation;
 /** A structural mismatch that may share an abstract annotation is unresolved. */
 export declare function compareFacetAnnotation(left: FacetAnnotation, right: FacetAnnotation, budget: SemanticBudget): 'equal' | 'different' | 'unresolved';
-//# sourceMappingURL=schemaFacetAnnotation.d.ts.map

package/dist/compiler/schemaGeneratedScalarShape.d.ts

@@ -32,4 +32,3 @@ export type OriginalGeneratedScalarShape = Readonly<{
 }>;
 export declare function resolveOriginalScalarIdentity(context: SemanticContext, reference: SemanticTypeReference): OriginalScalarShapeResult<SemanticTypeIdentity>;
 export declare function originalGeneratedShape(context: SemanticContext, slot: OriginalGeneratedScalarReference): OriginalScalarShapeResult<OriginalGeneratedScalarShape>;
-//# sourceMappingURL=schemaGeneratedScalarShape.d.ts.map

package/dist/compiler/schemaGeneratedScalarShape.js

@@ -42,6 +42,8 @@ function sourceShape(context, input) {
             b.chargeWork(found.name.local.length + 2);
             return { key: `builtin:${found.name.local}`, builtin: found.name.local };
         }
+        if (found.kind === 'standard-element')
+            throw new ShapeProblem('original-scalar-role', 'An element declaration has no scalar type identity', found.declaration.id);
         if (found.kind !== 'found')
             throw new ShapeProblem('original-scalar-reference', 'Original scalar reference is unavailable', found.id);
         if (context.originalSourceComponentAbsent(found.node.id))

package/dist/compiler/schemaIdentityConstraints.d.ts

@@ -70,4 +70,3 @@ export declare function collectIdentityConstraintDependencies(context: SemanticC
     add(dependencies: readonly IdentityConstraintDependency[]): void;
     snapshot(): readonly IdentityConstraintDependency[];
 }>;
-//# sourceMappingURL=schemaIdentityConstraints.d.ts.map

package/dist/compiler/schemaIeeeLanguage.d.ts

@@ -40,4 +40,3 @@ export declare function schemaIeeeLanguages<Owner>(c: SchemaPatternContext<Owner
     unsignedExponentialLanguage: (source: RegularLanguage, intervals: readonly IeeeInputInterval[], owner: Owner) => RegularLanguage;
 };
 export {};
-//# sourceMappingURL=schemaIeeeLanguage.d.ts.map

package/dist/compiler/schemaIntegerImages.d.ts

@@ -8,4 +8,3 @@ export declare function schemaIntegerImages<Owner>(c: SchemaPatternContext<Owner
         weight: number;
     }[], owner: Owner, initialCarry?: number) => RegularLanguage;
 };
-//# sourceMappingURL=schemaIntegerImages.d.ts.map

package/dist/compiler/schemaLexicalPredicates.d.ts

@@ -26,4 +26,3 @@ export declare function schemaLexicalPredicates<Owner>(c: SchemaPatternContext<O
     exists: (predicate: LexicalPredicate, source: RegularLanguage, owner: Owner) => boolean;
     witness: (predicate: LexicalPredicate, source: RegularLanguage, owner: Owner) => string | undefined;
 };
-//# sourceMappingURL=schemaLexicalPredicates.d.ts.map

package/dist/compiler/schemaNotationProperties.d.ts

@@ -29,4 +29,3 @@ export declare function notationNameKey(name: ExpandedName, budget: SemanticBudg
 /** Complete property equality: absent identifiers never fill from another tuple. */
 export declare function equalNotationProperties(left: SchemaNotationProperties, right: SchemaNotationProperties, budget: SemanticBudget): boolean;
 export {};
-//# sourceMappingURL=schemaNotationProperties.d.ts.map

package/dist/compiler/schemaNumericImageConditions.d.ts

@@ -21,4 +21,3 @@ export declare function schemaNumericImageConditions<Owner>(c: SchemaPatternCont
     numericWitness: (language: RegularLanguage, condition: NumericImageCondition, owner: Owner) => string | undefined;
     witness: (language: RegularLanguage, condition: NumericImageCondition, owner: Owner) => string | undefined;
 };
-//# sourceMappingURL=schemaNumericImageConditions.d.ts.map

package/dist/compiler/schemaParticleWildcardProperties.d.ts

@@ -17,4 +17,3 @@ export type SelectedParticleWildcard = Readonly<{
 export declare function prepareRawParticleWildcardProperties(input: unknown, budget: SemanticBudget): RawParticleWildcardProperties;
 /** All semantic particle owners select the same tuple; source-private inputs stay lexical. */
 export declare function readParticleWildcard(context: SemanticContext, particle: ParticleNode): SelectedParticleWildcard;
-//# sourceMappingURL=schemaParticleWildcardProperties.d.ts.map

package/dist/compiler/schemaPattern.d.ts

@@ -1059,4 +1059,3 @@ export declare function intrinsicBuiltinPatterns<Owner>(c: SchemaPatternContext<
         }>, owner: Owner) => Generator<string>;
     };
 };
-//# sourceMappingURL=schemaPattern.d.ts.map

package/dist/compiler/schemaRegularLanguage.d.ts

@@ -64,4 +64,3 @@ export declare function schemaRegularLanguages<Owner>(c: SchemaPatternContext<Ow
     words: (language: RegularLanguage, owner: Owner) => Generator<string>;
 };
 export {};
-//# sourceMappingURL=schemaRegularLanguage.d.ts.map

package/dist/compiler/schemaScalarContext.d.ts

@@ -34,9 +34,14 @@ export declare function schemaScalarContext(context: SemanticContext): {
         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;
@@ -78,4 +83,3 @@ export declare function schemaScalarContext(context: SemanticContext): {
     };
 };
 export type AssessmentContext = ReturnType<typeof schemaScalarContext>;
-//# sourceMappingURL=schemaScalarContext.d.ts.map

package/dist/compiler/schemaScalarKernel.d.ts

@@ -179,4 +179,3 @@ export declare function compareSchemaFacetProperties(leftContext: SemanticContex
 export declare function checkOriginalGeneratedScalar(context: SemanticContext, slot: OriginalGeneratedScalarReference): GeneratedScalarResult;
 export declare function assertOriginalGeneratedScalarReceipt(context: SemanticContext, receipt: GeneratedScalarReceipt): void;
 export {};
-//# sourceMappingURL=schemaScalarKernel.d.ts.map

package/dist/compiler/schemaScalarWitnesses.d.ts

@@ -3,4 +3,3 @@ import type { GraphNode, LexicalValue } from './canonicalGraph.js';
 import type { SchemaOperand } from './schemaDatatypeValues.js';
 import type { AssessmentContext } from './schemaScalarContext.js';
 export declare function schemaScalarWitnesses(value: SchemaOperand, original: LexicalValue, owner: GraphNode, c: AssessmentContext): Generator<LexicalValue>;
-//# sourceMappingURL=schemaScalarWitnesses.d.ts.map

package/dist/compiler/schemaSimpleTypeProperties.d.ts

@@ -92,4 +92,3 @@ export type RawSimpleTypeProperties = Readonly<{
     }>;
 }> & RawSimpleFacetInput;
 export declare function validateRawSimpleTypeShape(value: unknown, budget: SemanticBudget): value is RawSimpleTypeProperties;
-//# sourceMappingURL=schemaSimpleTypeProperties.d.ts.map

package/dist/compiler/schemaSourceGrammar.d.ts

@@ -24,4 +24,3 @@ export type SourceGrammarResult = Readonly<{
 }>;
 /** Immediate clauses only. The owned walk preserves roles, values and all scopes. */
 export declare function assessSourceGrammar(role: SourceGrammarRole, node: SyntaxElement, budget: SemanticBudget): SourceGrammarResult;
-//# sourceMappingURL=schemaSourceGrammar.d.ts.map

package/dist/compiler/schemaSourceLexical.d.ts

@@ -1,4 +1,3 @@
 export declare function schemaBooleanLexical(value: string): boolean;
 export declare function schemaNonNegativeIntegerLexical(value: string): boolean;
 export declare function schemaPositiveIntegerLexical(value: string): boolean;
-//# sourceMappingURL=schemaSourceLexical.d.ts.map

package/dist/compiler/schemaSourceValues.d.ts

@@ -48,4 +48,3 @@ export declare function createSchemaSourceValues(budget: SemanticBudget): Readon
     assess: (type: FixedSimpleTypeHandle, lexical: SchemaLexicalOperand, owner: SyntaxElement) => SourceValueResult;
 }>;
 export {};
-//# sourceMappingURL=schemaSourceValues.d.ts.map

package/dist/compiler/schemaSourceWildcards.d.ts

@@ -24,5 +24,4 @@ export type SourceWildcardResult = Readonly<{
 /** The dated October 2004 XML import declares lang as xs:language. */
 export declare function validSchemaXmlLanguage(value: string, budget: SemanticBudget): boolean;
 /** Pure borrowed-syntax clauses. Only the authentic document owner issues aggregate authority. */
-export declare function assessSchemaSourceWildcards(root: SyntaxElement, budget: SemanticBudget): SourceWildcardResult;
-//# sourceMappingURL=schemaSourceWildcards.d.ts.map
+export declare function assessSchemaSourceWildcards(root: SyntaxElement, budget: SemanticBudget, check?: () => void): SourceWildcardResult;

package/dist/compiler/schemaSourceWildcards.js

@@ -27,7 +27,7 @@ class SourceProblem extends Error {
     }
 }
 /** Pure borrowed-syntax clauses. Only the authentic document owner issues aggregate authority. */
-export function assessSchemaSourceWildcards(root, budget) {
+export function assessSchemaSourceWildcards(root, budget, check) {
     return budget.guard(() => {
         budget.chargeWork(30);
         const remaining = [], ids = [], references = [];
@@ -58,6 +58,7 @@ export function assessSchemaSourceWildcards(root, budget) {
             }
         };
         const assess = (node, type, lexical, name, category) => {
+            check?.();
             budget.chargeWork(6);
             const result = values.assess(type, { value: lexical, context: { namespaces: node.namespaces, source: node.source } }, node);
             if (result.kind === 'resource-limit') {
@@ -79,6 +80,7 @@ export function assessSchemaSourceWildcards(root, budget) {
         };
         try {
             while (stack.length) {
+                check?.();
                 budget.chargeWork(12);
                 const frame = stack.pop(), { node, payload } = frame;
                 const category = payload ? 'annotation-payload-assessment' : 'foreign-attribute-assessment';

package/dist/compiler/schemaSymbolicSequences.d.ts

@@ -13,4 +13,3 @@ export type SymbolicSequence<Label> = Readonly<{
 export declare function schemaSymbolicSequences<Owner, Label>(c: SchemaPatternContext<Owner>, satisfiable: (positive: readonly Label[], negative: readonly Label[], owner: Owner) => boolean, family?: (label: Label) => string): {
     differenceExists: (a: SymbolicSequence<Label>, b: SymbolicSequence<Label>, owner: Owner) => boolean;
 };
-//# sourceMappingURL=schemaSymbolicSequences.d.ts.map

package/dist/compiler/schemaSymbolicValueSets.d.ts

@@ -29,4 +29,3 @@ export declare function schemaSymbolicValueSets<Owner>(c: SchemaPatternContext<O
     }>, owner: Owner) => SchemaOperand | undefined;
     satisfiable: (positive: readonly ScalarValueSet[], negative: readonly ScalarValueSet[], owner: Owner) => boolean;
 };
-//# sourceMappingURL=schemaSymbolicValueSets.d.ts.map

package/dist/compiler/schemaSyntaxAssessment.d.ts

@@ -22,4 +22,3 @@ export type ActualSyntaxResult = Readonly<{
  * schema-for-schemas validator, and has no hypothetical-construction authority.
  */
 export declare function checkActualSchemaSyntax(context: SemanticContext, nodeId: NodeId): ActualSyntaxResult;
-//# sourceMappingURL=schemaSyntaxAssessment.d.ts.map

package/dist/compiler/schemaTemporalAliases.d.ts

@@ -3,4 +3,3 @@ import type { SchemaPatternContext } from './schemaValueContext.js';
 export declare function calendarAliasExpressions<Owner>(calendar: Calendar, owner: Owner, c: SchemaPatternContext<Owner>): Generator<string>;
 /** Finite field decompositions, each with its complete infinite zero aliases. */
 export declare function durationAliasExpressions<Owner>(duration: Duration, owner: Owner, c: SchemaPatternContext<Owner>, canMatch: (expression: string) => boolean): Generator<string>;
-//# sourceMappingURL=schemaTemporalAliases.d.ts.map

package/dist/compiler/schemaTokenImages.d.ts

@@ -6,4 +6,3 @@ import type { SymbolicSequence } from './schemaSymbolicSequences.js';
 export declare function schemaTokenImages<Owner, Label>(c: SchemaPatternContext<Owner>, regular: ReturnType<typeof schemaRegularLanguages<Owner>>, token: (owner: Owner) => RegularLanguage, labels: (paths: RegularLanguage, position: number, rejected: readonly number[], owner: Owner) => readonly Label[], whitespace: (codepoint: number, owner: Owner) => Label): {
     image: (source: RegularLanguage, rejectedCount: number, maximumPosition: number, mode: "list" | "string", owner: Owner) => SymbolicSequence<Label>;
 };
-//# sourceMappingURL=schemaTokenImages.d.ts.map

package/dist/compiler/schemaTypeIdentity.d.ts

@@ -36,4 +36,3 @@ export declare function resolveSemanticType(context: SemanticContext, reference:
 export declare function declaredType(context: SemanticContext, node: ElementNode | AttributeNode): SemanticTypeReference;
 /** Collision-free key only; supplied identity data is not lookup authority. */
 export declare function semanticTypeKey(context: SemanticContext, identity: SemanticTypeIdentity): string;
-//# sourceMappingURL=schemaTypeIdentity.d.ts.map

package/dist/compiler/schemaTypeIdentity.js

@@ -27,6 +27,8 @@ export function resolveSemanticType(context, reference) {
             throw new TypeError('Unknown builtin type');
         return Object.freeze({ kind: 'builtin', name: found.name, identity: Object.freeze({ kind: 'builtin', name: found.name }) });
     }
+    if (found.kind === 'standard-element')
+        return Object.freeze({ kind: 'wrong-role', reference: budget.freeze(budget.snapshot(reference)), component: found.declaration.id });
     if (found.kind !== 'found')
         return Object.freeze({ kind: found.kind, reference: budget.freeze(budget.snapshot(reference)) });
     if (context.originalSourceComponentAbsent(found.node.id) || found.node.kind !== 'simpleType' && found.node.kind !== 'complexType')

package/dist/compiler/schemaTypeRelations.d.ts

@@ -35,4 +35,3 @@ export declare const checkImmediateTypeFinal: (context: SemanticContext, derived
 export declare const immediateTypeBase: (context: SemanticContext, reference: Reference) => RelationResult<Reference | undefined>;
 export declare const checkSubstitution: (context: SemanticContext, member: NodeId, head: NodeId, options: SubstitutionOptions) => RelationResult;
 export declare const effectiveSubstitutionMembers: (context: SemanticContext, head: NodeId) => RelationResult<readonly NodeId[]>;
-//# sourceMappingURL=schemaTypeRelations.d.ts.map

package/dist/compiler/schemaUri.d.ts

@@ -10,4 +10,3 @@ export declare function schemaUriExpression<Owner>(owner: Owner, c: {
 export declare function schemaUri<Owner>(value: string, owner: Owner, c: {
     step(node: Owner, count?: number): void;
 }): boolean;
-//# sourceMappingURL=schemaUri.d.ts.map

package/dist/compiler/schemaValueContext.d.ts

@@ -23,4 +23,3 @@ export type SchemaPatternContext<Owner> = Pick<SchemaValueContext<Owner>, 'step'
 /** Schema-facing aliases preserve existing ownership contracts. */
 export type SchemaLexicalOperand = DatatypeLexicalOperand;
 export type SchemaValueContext<Owner> = DatatypeValueContext<Owner>;
-//# sourceMappingURL=schemaValueContext.d.ts.map

package/dist/compiler/schemaValueImages.d.ts

@@ -7,4 +7,3 @@ export declare function schemaValueImages<Owner>(c: SchemaPatternContext<Owner>,
     duration: (source: RegularLanguage, owner: Owner) => RegularLanguage;
     simple: (source: RegularLanguage, family: string, owner: Owner) => RegularLanguage | undefined;
 };
-//# sourceMappingURL=schemaValueImages.d.ts.map

package/dist/compiler/schemaValueSequences.d.ts

@@ -12,4 +12,3 @@ export declare function schemaValueSequences<Owner>(context: SchemaUnionContext<
         value: SchemaOperand;
     } | undefined, SchemaOperand>;
 };
-//# sourceMappingURL=schemaValueSequences.d.ts.map

package/dist/compiler/semanticBudget.d.ts

@@ -37,6 +37,24 @@ export declare class ResolverInvalidLimitsError extends RangeError {
     constructor();
 }
 export declare function createResolverBudget(limits?: ResolverLimits): ResolverBudget;
+/**
+ * Measure diagnostic work relative to a target without treating that target as a cutoff.
+ * @param targets Comparative work target and an independently enforced node limit.
+ * @returns The same accounting owner plus an observational snapshot that grants no semantic authority.
+ * @constraints Explicit enforced budgets and ordinary application execution retain their existing policies.
+ */
+export declare function createSemanticProfiler(targets?: ResolverLimits): {
+    budget: ResolverBudget;
+    measurement: () => {
+        targetWork: number;
+        usage: {
+            nodes: number;
+            work: number;
+        };
+        relativeWork: number;
+        aboveTarget: boolean;
+    };
+};
 /** Shared production owner; historical research names remain source-compatible. */
 export type SemanticBudget = ResolverBudget;
 export type SemanticBudgetLimits = ResolverLimits;
@@ -47,4 +65,3 @@ export declare function checkSemanticBudget(budget: SemanticBudget): void;
 export declare function createApplicationBudget(limits?: SemanticBudgetLimits): SemanticBudget;
 /** Internal identity marker, never source/transport authorization. */
 export declare function isApplicationUnmetered(budget: SemanticBudget): boolean;
-//# sourceMappingURL=semanticBudget.d.ts.map

package/dist/compiler/semanticBudget.js

@@ -42,6 +42,21 @@ function limit(limits, key, fallback) {
     return value;
 }
 export function createResolverBudget(limits = NO_LIMITS) {
+    return createBudget(limits, false);
+}
+/**
+ * Measure diagnostic work relative to a target without treating that target as a cutoff.
+ * @param targets Comparative work target and an independently enforced node limit.
+ * @returns The same accounting owner plus an observational snapshot that grants no semantic authority.
+ * @constraints Explicit enforced budgets and ordinary application execution retain their existing policies.
+ */
+export function createSemanticProfiler(targets = NO_LIMITS) {
+    const targetWork = limit(targets, 'maxWork', DEFAULT_MAX_WORK);
+    const budget = createBudget(targets, true);
+    return { budget, measurement: () => ({ targetWork, usage: { ...budget.usage() },
+            relativeWork: budget.usage().work / targetWork, aboveTarget: budget.usage().work > targetWork }) };
+}
+function createBudget(limits, observeWork) {
     const maxNodes = limit(limits, 'maxNodes', DEFAULT_MAX_NODES);
     const maxWork = limit(limits, 'maxWork', DEFAULT_MAX_WORK);
     if (!validLimit(maxNodes) || !validLimit(maxWork))
@@ -64,7 +79,7 @@ export function createResolverBudget(limits = NO_LIMITS) {
             throw new RangeError('RE01 charges must be nonnegative safe integers');
         }
         const used = limit === 'nodes' ? nodes : work;
-        const maximum = limit === 'nodes' ? maxNodes : maxWork;
+        const maximum = limit === 'nodes' ? maxNodes : observeWork ? Number.MAX_SAFE_INTEGER : maxWork;
         // Subtraction is checked before adding: no overflow and inclusive limits.
         if (amount > maximum - used) {
             failed = limit;
@@ -128,7 +143,7 @@ export function createResolverBudget(limits = NO_LIMITS) {
     const { snapshot, freeze } = createDataOwnership(chargeWork);
     // Budgets smaller than the reservation fail without performing graph work;
     // their one constant terminal envelope remains the reserved escape path.
-    if (maxWork < TERMINAL_RESERVATION_WORK)
+    if (!observeWork && maxWork < TERMINAL_RESERVATION_WORK)
         failed = 'work';
     else
         work = TERMINAL_RESERVATION_WORK;

package/dist/compiler/semanticCatalog.d.ts

@@ -58,8 +58,8 @@ export declare function deriveCompatibilityView(graph: CanonicalGraph): {
     model: "xsd10-faithful-v1";
     symbols: {
         id: string;
-        kind: "element" | "attribute" | "group" | "attributeGroup" | "particle" | "attributeUse" | "attributeGroupUse" | "attributeWildcard" | "simpleType" | "complexType" | "wsdl";
-        identity: import("./canonicalGraph.js").Identity;
+        kind: "element" | "attribute" | "wsdl" | "group" | "attributeGroup" | "complexType" | "simpleType" | "attributeWildcard" | "particle" | "attributeUse" | "attributeGroupUse";
+        identity: import("./declarationIdentity.js").Identity;
     }[];
 };
 /** Internal faithful companion dispatch. Regeneration never fabricates missing structure. */
@@ -119,4 +119,3 @@ export declare function prepareResolvedCompilationInput(input: Parameters<typeof
         }>;
     };
 }>;
-//# sourceMappingURL=semanticCatalog.d.ts.map

package/dist/compiler/semanticContext.d.ts

@@ -2,6 +2,7 @@
 import { GRAPH_MODEL } from './canonicalGraph.js';
 import type { CanonicalGraph, ComplexTypeNode, GraphNode, Identity, NodeId, Reference } from './canonicalGraph.js';
 import type { ResolvedGraph } from './resolveCanonicalGraph.js';
+import type { StandardSchemaElementDeclaration } from './standardSchemaComponents.js';
 import type { ExpandedName } from '../loader/orderedSyntax.js';
 import type { ResourceLimitFailure, SemanticBudget } from './semanticBudget.js';
 import type { OriginalUrWildcardHandle, RawComplexTypeProperties } from './re01TypeProperties.js';
@@ -24,6 +25,9 @@ export type ContextLookup = Readonly<{
 export type ContextResolution = ContextLookup | Readonly<{
     kind: 'builtin';
     name: ExpandedName;
+}> | Readonly<{
+    kind: 'standard-element';
+    declaration: StandardSchemaElementDeclaration;
 }>;
 export type SemanticReferenceSlot = Readonly<{
     path: string;
@@ -68,10 +72,18 @@ export type SemanticContext = Readonly<{
     /** Private SOURCE universe, distinct from graph/TYPE membership and FULL owners. */
     originalIdentityConstraints(): OriginalIdentityConstraintRegistry;
     lookup(id: NodeId): ContextLookup;
+    /** Explicit acquired universe, separate from application nodes and their source/component validity. */
+    standardElement(id: NodeId): StandardSchemaElementDeclaration | undefined;
+    /** Descriptive identifiers of the exact native acquired universe; never a component-validity receipt. */
+    standardLibraryIds(): readonly string[];
     /** Owns immutable selector data only; every resolution still checks current membership. */
     ownTypeReference(reference: SemanticTypeReference): SemanticTypeReference;
     resolve(reference: Reference): ContextResolution;
     sourceNode(id: NodeId): GraphNode | undefined;
+    /** Original declaration SOURCE input only; unbound graph records and fresh components supply no source mapping. */
+    originalDeclarationSource(id: NodeId): Extract<GraphNode, {
+        kind: 'element' | 'attribute';
+    }> | undefined;
     originalSourceComponentAbsent(id: NodeId): boolean;
     /** Eligibility for reading retained original properties, never a validity receipt. */
     originalComplexPropertySource(id: NodeId): ComplexTypeNode | undefined;
@@ -169,4 +181,3 @@ export declare class SemanticContextAccessError extends Error {
 export declare function prepareSemanticRequest(resolved: ResolvedGraph, options?: Readonly<{
     budget?: SemanticBudget;
 }>): SemanticPreparation;
-//# sourceMappingURL=semanticContext.d.ts.map

package/dist/compiler/semanticContext.js

@@ -2,6 +2,8 @@
 import { GRAPH_MODEL, globalId, isBuiltinType, scopedId } from './canonicalGraph.js';
 import { duplicateIdentityTuple, matchesHypotheticalNodeId, sameSemanticIdentity, semanticIdentityTuple } from './hypotheticalScopedIdentity.js';
 import { containedNodes, referenceSlots } from './graphTraversal.js';
+import { standardSchemaLibrariesForResolved } from './resolveCanonicalGraph.js';
+import { standardSchemaElement } from './standardSchemaComponents.js';
 import { XSD_NAMESPACE } from '../loader/orderedSyntax.js';
 import { createSemanticBudget } from './semanticBudget.js';
 import { assertRawComplexTypeShape } from './re01TypeProperties.js';
@@ -110,6 +112,15 @@ export function prepareSemanticRequest(resolved, options = {}) {
             // Private exact-handle binding is read before snapshotting loses that identity.
             // Availability of all source roots is distinct from source/component validity.
             const sourceSchemas = sourceSchemasForResolvedGraph(resolved);
+            const standardElements = new Map();
+            for (const library of standardSchemaLibrariesForResolved(resolved) ?? []) {
+                budget.chargeWork(8);
+                const declaration = standardSchemaElement(library, { namespace: XSD_NAMESPACE, local: 'schema' });
+                if (!declaration || standardElements.has(declaration.id))
+                    throw new InvalidContext('representation');
+                standardElements.set(declaration.id, declaration);
+            }
+            const standardLibraryIds = Object.freeze((standardSchemaLibrariesForResolved(resolved) ?? []).map(library => library.id).sort());
             let identityConstraints;
             const originalIdentityConstraints = () => identityConstraints ??= createOriginalIdentityConstraintRegistry(sourceSchemas, budget);
             const inputGraph = dataField(resolved, 'graph');
@@ -240,6 +251,8 @@ export function prepareSemanticRequest(resolved, options = {}) {
             };
             for (const node of graph.nodes) {
                 key(node.id);
+                if (standardElements.has(node.id))
+                    throw new InvalidContext('identity', node.id);
                 if (originals.has(node.id) || node.id !== identityId(node))
                     throw new InvalidContext('identity', node.id);
                 budget.chargeWork(2);
@@ -277,6 +290,8 @@ export function prepareSemanticRequest(resolved, options = {}) {
                 const rawGroupProperties = new Map();
                 let expectedMembers = originals.size, hasEncodedIdentity = false;
                 for (const [id, node] of changes) {
+                    if (standardElements.has(id))
+                        throw new InvalidContext('identity', id);
                     key(id);
                     if (!originals.has(id))
                         expectedMembers++;
@@ -619,6 +634,14 @@ export function prepareSemanticRequest(resolved, options = {}) {
                         }
                         const refId = target(slot.reference);
                         if (refId !== undefined) {
+                            if (standardElements.has(refId)) {
+                                // Fixed acquired definitions are outside the application graph. This
+                                // closes references only; their native clauses remain separate duties.
+                                if (slot.reference.kind !== 'symbol' || slot.reference.role !== 'element'
+                                    || node.kind === 'element' && slot.path === 'substitutionGroup')
+                                    throw new InvalidContext('reference', id);
+                                continue;
+                            }
                             const referred = requireMember(refId);
                             if (slot.reference.kind === 'symbol' && (referred.identity.kind !== 'global' || referred.identity.role !== slot.reference.role))
                                 throw new InvalidContext('reference', id);
@@ -783,6 +806,8 @@ export function prepareSemanticRequest(resolved, options = {}) {
                         return Object.freeze({ kind: 'missing', name });
                     },
                     lookup,
+                    standardElement(id) { authenticate(); key(id); return standardElements.get(id); },
+                    standardLibraryIds() { authenticate(); return standardLibraryIds; },
                     ownTypeReference,
                     resolve(reference) {
                         authenticate();
@@ -791,6 +816,12 @@ export function prepareSemanticRequest(resolved, options = {}) {
                             const safe = knownReferences.has(reference) || ownedTypeReferences.has(reference) ? reference : budget.freeze(budget.snapshot(reference));
                             const id = target(safe);
                             if (id !== undefined) {
+                                const declaration = standardElements.get(id);
+                                if (declaration) {
+                                    if (safe.kind !== 'symbol' || safe.role !== 'element')
+                                        throw new InvalidContext('reference', id);
+                                    return Object.freeze({ kind: 'standard-element', declaration });
+                                }
                                 const result = lookup(id);
                                 if (result.kind === 'found' && safe.kind === 'symbol'
                                     && (result.node.identity.kind !== 'global' || result.node.identity.role !== safe.role))
@@ -811,6 +842,14 @@ export function prepareSemanticRequest(resolved, options = {}) {
                         }
                     },
                     sourceNode(id) { authenticate(); key(id); return originals.get(id); },
+                    originalDeclarationSource(id) {
+                        authenticate();
+                        key(id);
+                        budget.chargeWork(7);
+                        const original = originals.get(id);
+                        return sourceSchemas !== undefined && membership.has(id) && !absentOriginals.has(id)
+                            && (original?.kind === 'element' || original?.kind === 'attribute') ? original : undefined;
+                    },
                     originalSourceComponentAbsent(id) { authenticate(); key(id); return absentOriginals.has(id); },
                     originalComplexPropertySource(id) {
                         authenticate();

package/dist/compiler/semanticTypeDependencies.d.ts

@@ -5,4 +5,3 @@ export declare function collectSemanticTypeDependencies(context: SemanticContext
     add(required: readonly SemanticTypeDependency[]): void;
     snapshot(): readonly SemanticTypeDependency[];
 }>;
-//# sourceMappingURL=semanticTypeDependencies.d.ts.map

package/dist/compiler/semanticTypeReference.d.ts

@@ -21,4 +21,3 @@ export type SemanticTypeDependency = Readonly<{
 }>;
 /** Checks only reference shape; authenticated context resolution owns membership. */
 export declare function assertSemanticTypeReferenceShape(value: unknown, budget: SemanticBudget): asserts value is SemanticTypeReference;
-//# sourceMappingURL=semanticTypeReference.d.ts.map

package/dist/compiler/shapeResolver.d.ts

@@ -16,4 +16,3 @@ export interface ApplyShapeCatalogsOptions {
  * the current catalog.
  */
 export declare function applyShapeCatalogs(compiled: CompiledCatalog, streamConfig: StreamConfig, options?: ApplyShapeCatalogsOptions): Promise<void>;
-//# sourceMappingURL=shapeResolver.d.ts.map

package/dist/compiler/soapHeaders.d.ts

@@ -0,0 +1,16 @@
+/** SOAP 1.1 response-header clauses for the component transport's default ultimate-receiver role. */
+import type { ExpandedName, SyntaxElement } from '../loader/orderedSyntax.js';
+export type ComponentSoapHeaderResult = Readonly<{
+    kind: 'ignored-optional-headers';
+    headers: readonly ExpandedName[];
+} | {
+    kind: 'protocol' | 'unsupported';
+    rule: string;
+}>;
+/** Assess borrowed parsed Header syntax without claiming unknown block semantics.
+ * @remarks SOAP 1.1 sections 4.2 through 4.2.3 require qualified block names and define absent mustUnderstand
+ *   as 0. Only immediate block attributes govern header processing. Actor-directed processing and mandatory
+ *   block semantics remain unsupported; no security/header emission capability is acquired here.
+ * @see https://www.w3.org/TR/2000/NOTE-SOAP-20000508/
+ */
+export declare function assessComponentSoapHeader(header: SyntaxElement, check: () => void): ComponentSoapHeaderResult;