@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/semanticTypeDependencies.d.ts

@@ -0,0 +1,7 @@
+import type { SemanticContext } from './semanticContext.js';
+import type { SemanticTypeDependency } from './semanticTypeReference.js';
+/** Call inside the request guard; inputs are borrowed internal receipt data. */
+export declare function collectSemanticTypeDependencies(context: SemanticContext): Readonly<{
+    add(required: readonly SemanticTypeDependency[]): void;
+    snapshot(): readonly SemanticTypeDependency[];
+}>;

package/dist/compiler/semanticTypeDependencies.js

@@ -0,0 +1,64 @@
+/** Charged accumulation of already-owned type dependency facts; no validity authority. */
+import { assertSemanticContext } from './semanticContext.js';
+import { semanticTypeKey } from './schemaTypeIdentity.js';
+const ownedByContext = new WeakMap();
+/** Call inside the request guard; inputs are borrowed internal receipt data. */
+export function collectSemanticTypeDependencies(context) {
+    assertSemanticContext(context);
+    const budget = context.budget;
+    budget.chargeWork(7);
+    let owned = ownedByContext.get(context);
+    if (!owned) {
+        budget.chargeWork(7);
+        owned = { facts: new Map(), keys: new WeakMap() };
+        ownedByContext.set(context, owned);
+    }
+    const facts = new Map();
+    let published;
+    return Object.freeze({
+        add(required) {
+            budget.chargeWork();
+            for (const dependency of required) {
+                budget.chargeWork(4);
+                if (!dependency || typeof dependency !== 'object')
+                    throw new TypeError('Expected a semantic type dependency');
+                let key = owned.keys.get(dependency);
+                if (key === undefined) {
+                    // No accessor execution and no lasting trust in a borrowed input's
+                    // identity. Its current primitive values are checked on every visit.
+                    budget.chargeWork(48);
+                    const origin = Object.getOwnPropertyDescriptor(dependency, 'contextId');
+                    const type = Object.getOwnPropertyDescriptor(dependency, 'type');
+                    if (!origin || !('value' in origin) || typeof origin.value !== 'string' || !type || !('value' in type))
+                        throw new TypeError('Expected own-data semantic type dependency fields');
+                    const identity = semanticTypeKey(context, type.value);
+                    budget.chargeWork(40 + origin.value.length * 2 + identity.length);
+                    key = `${origin.value.length}:${origin.value}:${identity}`;
+                }
+                budget.chargeWork(2);
+                let fact = owned.facts.get(key);
+                if (!fact) {
+                    fact = budget.freeze(budget.snapshot(dependency));
+                    budget.chargeWork(4);
+                    owned.facts.set(key, fact);
+                    owned.keys.set(fact, key);
+                }
+                if (!facts.has(key)) {
+                    budget.chargeWork(3);
+                    facts.set(key, fact);
+                    published = undefined;
+                }
+            }
+        },
+        snapshot() {
+            budget.chargeWork(2);
+            if (published)
+                return published;
+            // Every member is a private owned immutable result. Only this array is
+            // newly copied/frozen; traversing those member graphs again adds no safety.
+            budget.chargeWork(3 + facts.size * 3);
+            published = Object.freeze([...facts.values()]);
+            return published;
+        },
+    });
+}

package/dist/compiler/semanticTypeReference.d.ts

@@ -0,0 +1,23 @@
+/** Internal semantic references. Canonical/public/persisted Reference is unchanged. */
+import type { NodeId, Reference } from './canonicalGraph.js';
+import type { ExpandedName } from '../loader/orderedSyntax.js';
+import type { SemanticBudget } from './semanticBudget.js';
+/** Plain selector data, not an issued component or validity receipt. */
+export type OriginalGeneratedScalarReference = Readonly<{
+    kind: 'original-generated';
+    owner: NodeId;
+}>;
+export type SemanticTypeReference = Reference | OriginalGeneratedScalarReference;
+export type SemanticTypeIdentity = Readonly<{
+    kind: 'component';
+    id: NodeId;
+} | {
+    kind: 'builtin';
+    name: ExpandedName;
+}> | OriginalGeneratedScalarReference;
+export type SemanticTypeDependency = Readonly<{
+    contextId: string;
+    type: SemanticTypeIdentity;
+}>;
+/** Checks only reference shape; authenticated context resolution owns membership. */
+export declare function assertSemanticTypeReferenceShape(value: unknown, budget: SemanticBudget): asserts value is SemanticTypeReference;

package/dist/compiler/semanticTypeReference.js

@@ -0,0 +1,36 @@
+/** Checks only reference shape; authenticated context resolution owns membership. */
+export function assertSemanticTypeReferenceShape(value, budget) {
+    const field = (input, key) => {
+        budget.chargeWork(44 + key.length);
+        if (!input || typeof input !== 'object' || Array.isArray(input))
+            throw new TypeError('Expected semantic type reference data');
+        const own = Object.getOwnPropertyDescriptor(input, key);
+        if (own && !('value' in own))
+            throw new TypeError('Semantic type references cannot contain accessors');
+        return own?.value;
+    };
+    const id = (input) => { budget.chargeWork(); if (typeof input !== 'string' || !input)
+        throw new TypeError('Expected semantic type identity'); };
+    const kind = field(value, 'kind');
+    if (kind === 'original-generated') {
+        id(field(value, 'owner'));
+        return;
+    }
+    if (kind === 'local') {
+        id(field(value, 'target'));
+        return;
+    }
+    if (kind !== 'symbol' && kind !== 'builtin')
+        throw new TypeError('Unknown semantic type reference kind');
+    const name = field(value, 'name');
+    if (typeof field(name, 'namespace') !== 'string')
+        throw new TypeError('Expected semantic type namespace');
+    id(field(name, 'local'));
+    if (kind === 'symbol') {
+        if (field(value, 'role') !== 'type')
+            throw new TypeError('Expected a type symbol');
+        const target = field(value, 'target');
+        if (target !== undefined)
+            id(target);
+    }
+}

package/dist/compiler/shapeResolver.d.ts

@@ -1,5 +1,6 @@
 import { type CompiledCatalog } from "./schemaCompiler.js";
 import type { StreamConfig } from "../util/streamConfig.js";
+export { prepareResolvedCompilationInput } from "./semanticCatalog.js";
 export interface ApplyShapeCatalogsOptions {
     /** Directory against which relative `catalogFile`/`wsdlSource` paths resolve. Defaults to process.cwd(). */
     baseDir?: string;
@@ -15,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/shapeResolver.js

@@ -14,12 +14,15 @@
  *   - Existing buffered generation stays byte-for-byte identical when no
  *     streamConfig.shapeCatalogs entries are declared.
  */
-import fs from "node:fs";
 import path from "node:path";
 import { compileCatalog } from "./schemaCompiler.js";
 import { loadWsdl } from "../loader/wsdlLoader.js";
 import { resolveCompilerOptions } from "../config.js";
 import { WsdlCompilationError } from "../util/errors.js";
+import { readLegacyCatalogFile, CatalogError } from "./semanticCatalog.js";
+// Internal faithful counterpart consumes namespace/role roots and the typed reader.
+// Public StreamConfig generation continues to call the legacy adapter below.
+export { prepareResolvedCompilationInput } from "./semanticCatalog.js";
 /**
  * Apply a parsed StreamConfig to a compiled catalog:
  *   1. Verify every opted-in operation's record type is resolvable.
@@ -76,19 +79,14 @@ export async function applyShapeCatalogs(compiled, streamConfig, options = {}) {
 async function loadCompanionCatalog(name, ref, baseDir, compiled) {
     if (ref.catalogFile) {
         const abs = path.resolve(baseDir, ref.catalogFile);
-        let text;
         try {
-            text = fs.readFileSync(abs, "utf-8");
+            return readLegacyCatalogFile(abs);
         }
         catch (err) {
+            if (err instanceof CatalogError)
+                throw err;
             throw new WsdlCompilationError(`Failed to read companion catalog "${name}" at ${abs}: ${err.message}`, { suggestion: `Check that shapeCatalogs.${name}.catalogFile points to an existing catalog.json.` });
         }
-        try {
-            return JSON.parse(text);
-        }
-        catch (err) {
-            throw new WsdlCompilationError(`Companion catalog "${name}" at ${abs} is not valid JSON: ${err.message}`);
-        }
     }
     if (ref.wsdlSource) {
         // Relative paths resolve against baseDir; URLs pass through untouched.

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

@@ -0,0 +1,25 @@
+import type { SchemaInput, SchemaInterpretation } from '../loader/schemaInput.js';
+import type { SyntaxSource } from '../loader/orderedSyntax.js';
+import { GraphError } from './canonicalGraph.js';
+import { SemanticError } from './resolveCanonicalGraph.js';
+import type { ResolvedGraph, SemanticLimits } from './resolveCanonicalGraph.js';
+import type { ResourceLimitFailure, SemanticBudget } from './semanticBudget.js';
+export type SourcePreparationFailure = Readonly<{
+    kind: 'source-preparation-failed';
+    stage: 'canonical-build' | 'reference-resolution';
+    category: GraphError['category'] | SemanticError['category'];
+    message: string;
+    source?: SyntaxSource;
+}>;
+export type BoundSourcePreparation = Readonly<{
+    kind: 'prepared';
+    resolved: ResolvedGraph;
+}> | SourcePreparationFailure | ResourceLimitFailure;
+/** Reads only private identity. A copied/forged resolved handle has no binding. */
+export declare function sourceSchemasForResolvedGraph(resolved: ResolvedGraph): readonly SchemaInterpretation[] | undefined;
+/** One issued source snapshot constructs both the immutable graph and its source universe. */
+export declare function prepareBoundSourceGraph(input: SchemaInput, options: Readonly<{
+    budget: SemanticBudget;
+    sourceLimits?: SemanticLimits;
+    accountPreparation?: true;
+}>): BoundSourcePreparation;

package/dist/compiler/sourceSchemaBinding.js

@@ -0,0 +1,39 @@
+/** Exact source-built resolved handles; no caller-issued association or validity receipt. */
+import { assertLoadedSchemaInput } from '../loader/schemaInput.js';
+import { buildCanonicalGraph } from './buildCanonicalGraph.js';
+import { GraphError } from './canonicalGraph.js';
+import { resolveCanonicalGraph, SemanticError } from './resolveCanonicalGraph.js';
+const sourceBindings = new WeakMap();
+/** Reads only private identity. A copied/forged resolved handle has no binding. */
+export function sourceSchemasForResolvedGraph(resolved) {
+    return sourceBindings.get(resolved);
+}
+/** One issued source snapshot constructs both the immutable graph and its source universe. */
+export function prepareBoundSourceGraph(input, options) {
+    assertLoadedSchemaInput(input);
+    const budget = options.budget;
+    return budget.guard(() => {
+        // The loader authenticates this exact input handle. Claim its complete
+        // immutable source tree before any build or caller access can intervene.
+        // The shared budget charges the freeze traversal before each field read.
+        const owned = budget.freeze(input);
+        let stage = 'canonical-build';
+        try {
+            const graph = buildCanonicalGraph(owned, { maxNodes: options.sourceLimits?.maxNodes, requestBudget: options.accountPreparation ? budget : undefined });
+            stage = 'reference-resolution';
+            // The fixed resolver deep-freezes its complete result before returning it.
+            // No caller code receives this exact handle before the private association.
+            const resolved = resolveCanonicalGraph(graph, { ...options.sourceLimits, requestBudget: options.accountPreparation ? budget : undefined });
+            budget.chargeWork(6);
+            sourceBindings.set(resolved, owned.schemas);
+            return Object.freeze({ kind: 'prepared', resolved });
+        }
+        catch (error) {
+            if (!(error instanceof GraphError || error instanceof SemanticError))
+                throw error;
+            budget.chargeWork(200 + error.message.length);
+            return Object.freeze({ kind: 'source-preparation-failed', stage, category: error.category,
+                message: error.message, ...(error.source ? { source: error.source } : {}) });
+        }
+    });
+}

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

@@ -0,0 +1,15 @@
+import type { CanonicalGraph, NodeId } from "./canonicalGraph.js";
+import type { SemanticLimits } from "./resolveCanonicalGraph.js";
+export type StructuralCompanion = Readonly<{
+    graph: CanonicalGraph;
+    roots: readonly NodeId[];
+}>;
+export type StructuralMerge = Readonly<{
+    graph: CanonicalGraph;
+    copied: readonly NodeId[];
+    deduplicated: readonly NodeId[];
+    metrics: Readonly<{
+        steps: number;
+    }>;
+}>;
+export declare function mergeStructuralCompanions(primary: CanonicalGraph, companions: readonly StructuralCompanion[], limits?: SemanticLimits): StructuralMerge;