@techspokes/typescript-wsdl-client 1.1.5 → 1.1.8

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,7 +58,7 @@ 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";
+        kind: "element" | "attribute" | "wsdl" | "complexType" | "simpleType" | "attributeWildcard" | "group" | "attributeGroup" | "particle" | "attributeUse" | "attributeGroupUse";
         identity: import("./canonicalGraph.js").Identity;
     }[];
 };
@@ -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;

package/dist/compiler/soapHeaders.js

@@ -0,0 +1,42 @@
+const SOAP = 'http://schemas.xmlsoap.org/soap/envelope/';
+/** 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 function assessComponentSoapHeader(header, check) {
+    check();
+    if (header.name.namespace !== SOAP || header.name.local !== 'Header' || header.attributes.length)
+        return Object.freeze({ kind: 'protocol', rule: 'SOAP Header shape' });
+    const headers = [];
+    for (const child of header.children) {
+        check();
+        if (child.kind === 'text') {
+            if (/[^\t\r\n ]/.test(child.value))
+                return Object.freeze({ kind: 'protocol', rule: 'SOAP Header text' });
+            continue;
+        }
+        if (!child.name.namespace)
+            return Object.freeze({ kind: 'protocol', rule: 'SOAP header block namespace required' });
+        let mandatory = false;
+        for (const attribute of child.attributes) {
+            check();
+            if (attribute.name.namespace !== SOAP)
+                continue;
+            if (attribute.name.local === 'actor')
+                return Object.freeze({ kind: 'unsupported', rule: 'SOAP actor header capability required' });
+            if (attribute.name.local === 'mustUnderstand') {
+                if (attribute.value !== '0' && attribute.value !== '1')
+                    return Object.freeze({ kind: 'protocol', rule: 'SOAP 1.1 mustUnderstand value' });
+                mandatory = attribute.value === '1';
+            }
+            else if (attribute.name.local !== 'encodingStyle')
+                return Object.freeze({ kind: 'unsupported', rule: 'unknown SOAP header attribute' });
+        }
+        if (mandatory)
+            return Object.freeze({ kind: 'unsupported', rule: 'incoming mandatory SOAP header' });
+        headers.push(Object.freeze({ ...child.name }));
+    }
+    return Object.freeze({ kind: 'ignored-optional-headers', headers: Object.freeze(headers) });
+}

package/dist/compiler/sourceSchemaBinding.d.ts

@@ -23,4 +23,3 @@ export declare function prepareBoundSourceGraph(input: SchemaInput, options: Rea
     sourceLimits?: SemanticLimits;
     accountPreparation?: true;
 }>): BoundSourcePreparation;
-//# sourceMappingURL=sourceSchemaBinding.d.ts.map

package/dist/compiler/standardSchemaComponents.d.ts

@@ -0,0 +1,71 @@
+import type { ExpandedName, SyntaxElement } from '../loader/orderedSyntax.js';
+import type { SemanticBudget } from './semanticBudget.js';
+import { assessSchemaElementInstance } from './schemaElementInstance.js';
+export declare const SCHEMA_ELEMENT_LIBRARY: "w3c-xsd10-schema-element-2004-v1";
+export type StandardSchemaLibraryId = typeof SCHEMA_ELEMENT_LIBRARY;
+export interface StandardSchemaTypeReference {
+    readonly kind: 'standard-type';
+    readonly library: StandardSchemaLibraryId;
+    readonly component: 'schema-element-anonymous' | 'openAttrs';
+}
+export interface StandardSchemaLibrary {
+    readonly id: StandardSchemaLibraryId;
+    readonly specification: string;
+}
+export interface StandardSchemaElementDeclaration {
+    readonly kind: 'standard-element';
+    readonly id: string;
+    readonly name: ExpandedName;
+    readonly scope: 'global';
+    readonly type: StandardSchemaTypeReference;
+    readonly abstract: false;
+    readonly nillable: false;
+    readonly block: readonly ['restriction', 'extension', 'substitution'];
+    readonly final: readonly [];
+    readonly instanceGrammar: 'XSD10-S4S-element-instance-2004';
+}
+export interface StandardSchemaComplexType {
+    readonly kind: 'standard-complex-type';
+    readonly reference: StandardSchemaTypeReference;
+    readonly identity: Readonly<{
+        kind: 'anonymous';
+        owner: ExpandedName;
+    }> | Readonly<{
+        kind: 'global';
+        name: ExpandedName;
+    }>;
+    readonly mixed: false;
+    readonly abstract: false;
+    readonly derivation: Readonly<{
+        kind: 'extension';
+        base: StandardSchemaTypeReference;
+    }> | Readonly<{
+        kind: 'restriction';
+        base: Readonly<{
+            kind: 'builtin';
+            name: ExpandedName;
+        }>;
+    }>;
+    readonly grammar: 'schema' | 'openAttrs';
+}
+/** Acquire the implemented fixed standard definitions explicitly, without metadata I/O.
+ * @remarks The schema element has an anonymous complex type extending the named openAttrs type;
+ *   neither is a primitive builtin or an alias of anyType. These definition handles issue no source-validity receipt.
+ * @returns A native library handle; copied JSON or similarly shaped objects cannot resolve definitions.
+ * @throws TypeError For unknown library identifiers.
+ * @see https://www.w3.org/TR/2004/REC-xmlschema-1-20041028/structures.html#composition-schemaImport
+ */
+export declare function acquireStandardSchemaLibrary(id: string): StandardSchemaLibrary;
+/** Authenticate an acquired declaration before a resolver uses its identity. */
+export declare function inspectStandardSchemaElement(declaration: StandardSchemaElementDeclaration): StandardSchemaElementDeclaration;
+/** Borrow the exact acquired declaration's fixed complex ancestry; selectors cannot manufacture this ownership. */
+export declare function standardSchemaElementTypes(declaration: StandardSchemaElementDeclaration): readonly StandardSchemaComplexType[];
+/** Resolve only the supplied library's implemented global declaration; namespace names initiate no acquisition. */
+export declare function standardSchemaElement(library: StandardSchemaLibrary, name: ExpandedName): StandardSchemaElementDeclaration | undefined;
+/** Resolve a selector through an acquired library, retaining anonymous and named complex identities. */
+export declare function standardSchemaType(library: StandardSchemaLibrary, reference: StandardSchemaTypeReference): StandardSchemaComplexType | undefined;
+/** Apply the existing fixed instance owner to an exact native declaration handle.
+ * @remarks This does not qualify application schema declarations, WSDL operations, mappings or portable artifacts.
+ * @throws TypeError For copied or unowned declaration handles.
+ */
+export declare function assessStandardSchemaElement(declaration: StandardSchemaElementDeclaration, root: SyntaxElement, budget: SemanticBudget, options?: Parameters<typeof assessSchemaElementInstance>[2]): import("./schemaElementInstance.js").SchemaElementInstanceResult;

package/dist/compiler/standardSchemaComponents.js

@@ -0,0 +1,74 @@
+/** Explicit native standard-component acquisition; selecting a library never qualifies an application source. */
+import { globalId } from './canonicalGraph.js';
+import { XSD_NAMESPACE } from '../loader/orderedSyntax.js';
+import { assessSchemaElementInstance } from './schemaElementInstance.js';
+export const SCHEMA_ELEMENT_LIBRARY = 'w3c-xsd10-schema-element-2004-v1';
+const libraries = new WeakMap();
+const elements = new WeakMap();
+/** Acquire the implemented fixed standard definitions explicitly, without metadata I/O.
+ * @remarks The schema element has an anonymous complex type extending the named openAttrs type;
+ *   neither is a primitive builtin or an alias of anyType. These definition handles issue no source-validity receipt.
+ * @returns A native library handle; copied JSON or similarly shaped objects cannot resolve definitions.
+ * @throws TypeError For unknown library identifiers.
+ * @see https://www.w3.org/TR/2004/REC-xmlschema-1-20041028/structures.html#composition-schemaImport
+ */
+export function acquireStandardSchemaLibrary(id) {
+    if (id !== SCHEMA_ELEMENT_LIBRARY)
+        throw new TypeError('Unsupported standard schema component library');
+    const library = Object.freeze({ id, specification: 'https://www.w3.org/TR/2004/REC-xmlschema-1-20041028/structures.html#element-schema' });
+    const name = Object.freeze({ namespace: XSD_NAMESPACE, local: 'schema' });
+    const reference = (component) => Object.freeze({ kind: 'standard-type', library: id, component });
+    const schema = reference('schema-element-anonymous'), openAttrs = reference('openAttrs');
+    const element = Object.freeze({ kind: 'standard-element', id: globalId('element', name), name,
+        scope: 'global', type: schema, abstract: false, nillable: false,
+        block: Object.freeze(['restriction', 'extension', 'substitution']), final: Object.freeze([]),
+        instanceGrammar: 'XSD10-S4S-element-instance-2004' });
+    const types = Object.freeze({
+        'schema-element-anonymous': Object.freeze({ kind: 'standard-complex-type', reference: schema,
+            identity: Object.freeze({ kind: 'anonymous', owner: name }), mixed: false, abstract: false,
+            derivation: Object.freeze({ kind: 'extension', base: openAttrs }), grammar: 'schema' }),
+        openAttrs: Object.freeze({ kind: 'standard-complex-type', reference: openAttrs,
+            identity: Object.freeze({ kind: 'global', name: Object.freeze({ namespace: XSD_NAMESPACE, local: 'openAttrs' }) }), mixed: false, abstract: false,
+            derivation: Object.freeze({ kind: 'restriction', base: Object.freeze({ kind: 'builtin', name: Object.freeze({ namespace: XSD_NAMESPACE, local: 'anyType' }) }) }), grammar: 'openAttrs' }),
+    });
+    libraries.set(library, Object.freeze({ element, types }));
+    elements.set(element, library);
+    return library;
+}
+function definition(library) {
+    const owned = libraries.get(library);
+    if (!owned)
+        throw new TypeError('Native acquired standard schema library required');
+    return owned;
+}
+/** Authenticate an acquired declaration before a resolver uses its identity. */
+export function inspectStandardSchemaElement(declaration) {
+    if (!elements.has(declaration))
+        throw new TypeError('Native standard schema declaration required');
+    return declaration;
+}
+/** Borrow the exact acquired declaration's fixed complex ancestry; selectors cannot manufacture this ownership. */
+export function standardSchemaElementTypes(declaration) {
+    inspectStandardSchemaElement(declaration);
+    const owned = definition(elements.get(declaration));
+    return Object.freeze([owned.types['schema-element-anonymous'], owned.types.openAttrs]);
+}
+/** Resolve only the supplied library's implemented global declaration; namespace names initiate no acquisition. */
+export function standardSchemaElement(library, name) {
+    const owned = definition(library);
+    return name.namespace === XSD_NAMESPACE && name.local === 'schema' ? owned.element : undefined;
+}
+/** Resolve a selector through an acquired library, retaining anonymous and named complex identities. */
+export function standardSchemaType(library, reference) {
+    const owned = definition(library);
+    return reference.kind === 'standard-type' && reference.library === library.id && Object.hasOwn(owned.types, reference.component)
+        ? owned.types[reference.component] : undefined;
+}
+/** Apply the existing fixed instance owner to an exact native declaration handle.
+ * @remarks This does not qualify application schema declarations, WSDL operations, mappings or portable artifacts.
+ * @throws TypeError For copied or unowned declaration handles.
+ */
+export function assessStandardSchemaElement(declaration, root, budget, options = {}) {
+    inspectStandardSchemaElement(declaration);
+    return assessSchemaElementInstance(root, budget, options);
+}

package/dist/compiler/standardSchemaConstruction.d.ts

@@ -0,0 +1,20 @@
+import type { SemanticContext } from './semanticContext.js';
+import type { StandardSchemaElementDeclaration, StandardSchemaComplexType } from './standardSchemaComponents.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+export interface StandardElementConstruction {
+    readonly kind: 'checked-standard-element';
+    readonly authority: 'XSD10-fixed-standard-component-v1';
+    readonly scope: 'fixed-standard-element-and-complex-ancestry';
+    readonly contextId: string;
+    readonly declaration: StandardSchemaElementDeclaration;
+    readonly types: readonly StandardSchemaComplexType[];
+}
+/** Consume a native acquired definition in this exact context.
+ * @remarks The fixed dated definitions and S4S instance clauses are implementation-owned, like the builtin
+ *   datatype universe. This establishes their component dependency only, never application source validity,
+ *   opaque payload interpretation, value assessment or portable artifact authority.
+ * @throws TypeError For copied declarations or a declaration not acquired in the selected context.
+ */
+export declare function checkStandardElementConstruction(context: SemanticContext, declaration: StandardSchemaElementDeclaration): StandardElementConstruction | ResourceLimitFailure;
+/** Authenticate both native construction and the selected acquired universe before aggregate closure. */
+export declare function assertStandardElementConstruction(context: SemanticContext, receipt: StandardElementConstruction): void;

package/dist/compiler/standardSchemaConstruction.js

@@ -0,0 +1,34 @@
+/** Native fixed-standard dependencies, separate from application graph construction and mapping authority. */
+import { assertSemanticContext } from './semanticContext.js';
+import { inspectStandardSchemaElement, standardSchemaElementTypes } from './standardSchemaComponents.js';
+const issued = new WeakMap();
+/** Consume a native acquired definition in this exact context.
+ * @remarks The fixed dated definitions and S4S instance clauses are implementation-owned, like the builtin
+ *   datatype universe. This establishes their component dependency only, never application source validity,
+ *   opaque payload interpretation, value assessment or portable artifact authority.
+ * @throws TypeError For copied declarations or a declaration not acquired in the selected context.
+ */
+export function checkStandardElementConstruction(context, declaration) {
+    assertSemanticContext(context);
+    inspectStandardSchemaElement(declaration);
+    return context.budget.guard(() => {
+        context.budget.chargeWork(32 + declaration.id.length);
+        if (context.standardElement(declaration.id) !== declaration)
+            throw new TypeError('Standard declaration is not acquired in this context');
+        const types = standardSchemaElementTypes(declaration);
+        const receipt = Object.freeze({ kind: 'checked-standard-element',
+            authority: 'XSD10-fixed-standard-component-v1', scope: 'fixed-standard-element-and-complex-ancestry',
+            contextId: context.contextId, declaration, types });
+        issued.set(receipt, context);
+        return receipt;
+    });
+}
+/** Authenticate both native construction and the selected acquired universe before aggregate closure. */
+export function assertStandardElementConstruction(context, receipt) {
+    assertSemanticContext(context);
+    if (issued.get(receipt) !== context)
+        throw new TypeError('Native matching standard-element construction required');
+    context.budget.chargeWork(8);
+    if (context.standardElement(receipt.declaration.id) !== receipt.declaration)
+        throw new TypeError('Standard construction scope changed');
+}

package/dist/compiler/structuralCompanions.d.ts

@@ -13,4 +13,3 @@ export type StructuralMerge = Readonly<{
     }>;
 }>;
 export declare function mergeStructuralCompanions(primary: CanonicalGraph, companions: readonly StructuralCompanion[], limits?: SemanticLimits): StructuralMerge;
-//# sourceMappingURL=structuralCompanions.d.ts.map

package/dist/compiler/validateSemanticGraph.d.ts

@@ -2,4 +2,3 @@ import type { CanonicalGraph } from "./canonicalGraph.js";
 export declare function validateSemanticGraph(input: unknown, options?: {
     maxNodes?: number;
 }): asserts input is CanonicalGraph;
-//# sourceMappingURL=validateSemanticGraph.d.ts.map

package/dist/compiler/wildcardAlgebra.d.ts

@@ -23,4 +23,3 @@ export declare function namespaceIntersection(a: NamespaceConstraint, b: Namespa
 export declare function namespaceExpressible(value: NamespaceConstraint, charge?: WildcardCharge): boolean;
 /** The ur-type identity exception belongs to the invoking rule, never spelling. */
 export declare function processContentsRestricts(derived: WildcardProcess, base: WildcardProcess, charge?: WildcardCharge): boolean;
-//# sourceMappingURL=wildcardAlgebra.d.ts.map

package/dist/compiler/wsdlPolicyRequirements.d.ts

@@ -0,0 +1,43 @@
+import type { SchemaInput } from '../loader/schemaInput.js';
+import type { SyntaxElement, SyntaxSource } from '../loader/orderedSyntax.js';
+import type { SemanticBudget, ResourceLimitFailure } from './semanticBudget.js';
+export declare const POLICY_12 = "http://schemas.xmlsoap.org/ws/2004/09/policy";
+export declare const SECURITY_POLICY_11 = "http://schemas.xmlsoap.org/ws/2005/07/securitypolicy";
+declare const suites: readonly ["Basic256", "Basic192", "Basic128", "TripleDes", "Basic256Rsa15", "Basic192Rsa15", "Basic128Rsa15", "TripleDesRsa15", "Basic256Sha256", "Basic192Sha256", "Basic128Sha256", "TripleDesSha256", "Basic256Sha256Rsa15", "Basic192Sha256Rsa15", "Basic128Sha256Rsa15", "TripleDesSha256Rsa15"];
+declare const layouts: readonly ["Strict", "Lax", "LaxTsFirst", "LaxTsLast"];
+export type TransportPolicyRequirements = Readonly<{
+    kind: 'https-transport';
+    requireClientCertificate: boolean;
+    algorithmSuite: typeof suites[number];
+    layout: typeof layouts[number];
+    includeTimestamp: boolean;
+    source: SyntaxSource;
+    enforced: false;
+}>;
+export type BindingPolicyRequirements = Readonly<{
+    kind: 'none';
+}> | TransportPolicyRequirements;
+export interface WsdlPolicyRequirements {
+    readonly kind: 'wsdl-policy-requirements';
+    readonly admitted: false;
+    isPolicyMetadata(node: SyntaxElement): boolean;
+    forBinding(binding: SyntaxElement): BindingPolicyRequirements;
+}
+export type PolicyRequirementsFailure = Readonly<{
+    kind: 'unsupported' | 'invalid-schema';
+    rule: string;
+    source: SyntaxSource;
+}>;
+/** Authenticate the exact loaded snapshot; copied reports or source-shaped records confer no policy authority. */
+export declare function assertWsdlPolicyRequirements(input: SchemaInput, value: WsdlPolicyRequirements): void;
+/** Interpret a closed single-alternative HTTPS transport-policy fragment and same-document binding references.
+ * @remarks Unknown assertions, external/nested references, multiple alternatives/attachments and digest references
+ *   remain explicit refusals. No policy fetch, endpoint permission, algorithm execution or security-header emission occurs.
+ *   The July 2005 defaults are Lax layout and no timestamp. Client-certificate omission is outside this qualified fragment.
+ * @returns Source-owned requirements or an explicit unsupported/invalid/resource result; enforcement remains false.
+ * @throws TypeError For unauthenticated source or foreign binding inspection. Caller cancellation propagates unchanged.
+ * @see https://www.w3.org/submissions/WS-Policy/
+ * @see https://specs.xmlsoap.org/ws/2005/07/securitypolicy/ws-securitypolicy.pdf
+ */
+export declare function prepareWsdlPolicyRequirements(input: SchemaInput, budget: SemanticBudget, check: () => void): WsdlPolicyRequirements | PolicyRequirementsFailure | ResourceLimitFailure;
+export {};