@techspokes/typescript-wsdl-client 1.1.5 → 1.1.8

package/dist/compiler/resolveCanonicalGraph.js

@@ -3,6 +3,8 @@ import { deepFreeze, DEFAULT_GRAPH_NODES, globalId, isBuiltinType } from "./cano
 import { positiveLimit } from "./catalogErrors.js";
 import { referenceSlots, containedNodes } from "./graphTraversal.js";
 import { syntaxAttribute, XSD_NAMESPACE } from "../loader/orderedSyntax.js";
+import { normalizeWhitespace } from '../util/xmlWhitespace.js';
+import { standardSchemaElement, inspectStandardSchemaElement } from './standardSchemaComponents.js';
 export class SemanticError extends Error {
     category;
     component;
@@ -17,6 +19,12 @@ export class SemanticError extends Error {
         this.name = "SemanticError";
     }
 }
+/** Internal missing-symbol detail; source resolution must distinguish absent import resources from disproved declarations. */
+class MissingReferenceError extends SemanticError {
+    constructor(reference, owner, id) {
+        super('invalid-schema', `Missing reference target ${id}`, owner.id, reference.kind === 'symbol' ? reference.lexical.context.source : owner.context.source);
+    }
+}
 export function semanticBudget(limits = {}) {
     const maxNodes = positiveLimit(limits.maxNodes, DEFAULT_GRAPH_NODES, "maxNodes");
     const maxSteps = positiveLimit(limits.maxSteps, 1_000_000, "maxSteps");
@@ -47,8 +55,13 @@ export function countSemanticData(value, budget, node) {
             }
     }
 }
+const resolvedStandards = new WeakMap();
+/** Native acquired dependencies only; copied graph reports cannot recreate this association. */
+export function standardSchemaLibrariesForResolved(resolved) {
+    return resolvedStandards.get(resolved);
+}
 /** Resolve against a node index, never against generated names or an asserted stored target. */
-export function referenceTarget(reference, nodes, owner) {
+export function referenceTarget(reference, nodes, owner, standards) {
     if (reference.kind === "builtin") {
         if (reference.name.namespace !== XSD_NAMESPACE || !isBuiltinType(reference.name.local))
             throw new SemanticError("invalid-schema", "Unknown builtin type", owner.id, owner.context.source);
@@ -56,8 +69,16 @@ export function referenceTarget(reference, nodes, owner) {
     }
     const id = reference.kind === "symbol" ? globalId(reference.role, reference.name) : reference.target;
     const target = nodes.get(id);
-    if (!target)
-        throw new SemanticError("invalid-schema", `Missing reference target ${id}`, owner.id, reference.kind === "symbol" ? reference.lexical.context.source : owner.context.source);
+    if (!target) {
+        const supplied = standards?.get(id);
+        if (!supplied)
+            throw new MissingReferenceError(reference, owner, id);
+        inspectStandardSchemaElement(supplied);
+        if (reference.kind !== 'symbol' || reference.role !== 'element' || supplied.id !== id
+            || reference.target !== undefined && reference.target !== id)
+            throw new SemanticError('invalid-schema', 'Standard declaration reference role/identity mismatch', owner.id, owner.context.source);
+        return id;
+    }
     if (reference.kind === "symbol" && (target.identity.kind !== "global" || target.identity.role !== reference.role || (reference.target !== undefined && reference.target !== id))) {
         throw new SemanticError("invalid-schema", `Reference role/identity mismatch ${id}`, owner.id, reference.lexical.context.source);
     }
@@ -78,9 +99,23 @@ export function resolveCanonicalGraph(graph, limits = {}) {
     const nodes = new Map(graph.nodes.map(n => [n.id, n]));
     if (nodes.size !== graph.nodes.length)
         throw new SemanticError("invalid-schema", "Duplicate graph identities");
+    const standards = new Map(), selectedLibraries = [];
+    for (const library of limits.standardLibraries ?? []) {
+        budget.step();
+        const declaration = standardSchemaElement(library, { namespace: XSD_NAMESPACE, local: 'schema' });
+        if (!declaration)
+            throw new SemanticError('unsupported-capability', 'Standard library supplies no implemented schema element');
+        if (standards.has(declaration.id))
+            throw new SemanticError('unsupported-capability', 'Duplicate standard library selection');
+        if (nodes.has(declaration.id))
+            throw new SemanticError('unsupported-capability', 'Acquired standard declaration conflicts with explicit schema source; select one source authority');
+        standards.set(declaration.id, declaration);
+        selectedLibraries.push(library);
+    }
     // Imports authorize foreign namespaces in the declaring interpretation only.
     // Including/importing documents do not lend their import permissions to a reference.
     const imports = new Map(), unknownImports = new Set();
+    const unlocatedImports = new Map();
     const sourceKey = (source) => JSON.stringify([source.uri, source.digest, source.path]);
     const importSyntax = new Map(graph.schemaRetained.filter(r => r.syntax.name.namespace === XSD_NAMESPACE && r.syntax.name.local === "import")
         .map(r => [sourceKey(r.syntax.source), r.syntax]));
@@ -89,7 +124,7 @@ export function resolveCanonicalGraph(graph, limits = {}) {
         if (edge.kind !== "import")
             continue;
         const syntax = importSyntax.get(sourceKey(edge.source));
-        const ns = syntax ? syntaxAttribute(syntax, "namespace") ?? "" : edge.to ? interpretation(edge.to).namespace : undefined;
+        const ns = syntax ? normalizeWhitespace(syntaxAttribute(syntax, "namespace") ?? "", 'collapse') : edge.to ? interpretation(edge.to).namespace : undefined;
         if (ns === undefined) {
             unknownImports.add(edge.from);
             continue;
@@ -99,13 +134,42 @@ export function resolveCanonicalGraph(graph, limits = {}) {
         const values = imports.get(edge.from) ?? new Set();
         values.add(ns);
         imports.set(edge.from, values);
+        if (!edge.to && syntax && syntaxAttribute(syntax, 'schemaLocation') === undefined) {
+            const pending = unlocatedImports.get(edge.from) ?? new Set();
+            pending.add(ns);
+            unlocatedImports.set(edge.from, pending);
+        }
     }
     const links = [];
+    let unresolvedImport;
     for (const node of graph.nodes) {
         budget.step(node);
         for (const slot of referenceSlots(node)) {
             budget.step(node);
-            const ref = slot.reference, target = referenceTarget(ref, nodes, node);
+            const ref = slot.reference;
+            let target;
+            let unavailable;
+            try {
+                target = referenceTarget(ref, nodes, node, standards);
+            }
+            catch (error) {
+                if (error instanceof MissingReferenceError && ref.kind === 'symbol' && node.kind !== 'wsdl') {
+                    for (const origin of graph.origins[node.id] ?? []) {
+                        budget.step(node);
+                        if (ref.name.namespace !== origin.context.effectiveNamespace && unlocatedImports.get(origin.interpretation)?.has(ref.name.namespace)) {
+                            unavailable = new SemanticError('unsupported-capability', `Missing declaration in namespace ${ref.name.namespace}; supply the locationless import dependency explicitly`, node.id, ref.lexical.context.source);
+                            break;
+                        }
+                    }
+                }
+                if (!unavailable)
+                    throw error;
+            }
+            // @why P1-D01: missing dependency evidence must not mask independent actual reference failures.
+            if (unavailable) {
+                unresolvedImport ??= unavailable;
+                continue;
+            }
             if (ref.kind === "symbol" && node.kind !== "wsdl") {
                 for (const origin of graph.origins[node.id] ?? []) {
                     budget.step(node);
@@ -121,6 +185,8 @@ export function resolveCanonicalGraph(graph, limits = {}) {
             links.push({ owner: node.id, path: slot.path, reference: ref, ...(target ? { target } : {}) });
         }
     }
+    if (unresolvedImport)
+        throw unresolvedImport;
     // Only expansion/base edges enter this DAG. Element -> type and particle -> element
     // are deliberately excluded: crossing an element admits complete recursive values.
     const forbidden = (n) => {
@@ -130,7 +196,9 @@ export function resolveCanonicalGraph(graph, limits = {}) {
             const expansion = n.kind === "simpleType" || n.kind === "complexType" || n.kind === "attributeGroupUse" ||
                 (n.kind === "particle" && n.term.kind === "group") || (n.kind === "element" && slot.path === "substitutionGroup");
             if (expansion) {
-                const target = referenceTarget(slot.reference, nodes, n);
+                const target = referenceTarget(slot.reference, nodes, n, standards);
+                if (target && standards.has(target))
+                    throw new SemanticError('unsupported-capability', 'Substitution affiliation to an acquired standard element is not implemented', n.id, n.context.source);
                 if (target)
                     result.push(target);
             }
@@ -166,5 +234,7 @@ export function resolveCanonicalGraph(graph, limits = {}) {
         }
     }
     const result = { graph, links, metrics: { steps: budget.steps } };
-    return limits.requestBudget ? limits.requestBudget.freeze(result) : deepFreeze(result);
+    const frozen = limits.requestBudget ? limits.requestBudget.freeze(result) : deepFreeze(result);
+    resolvedStandards.set(frozen, Object.freeze(selectedLibraries));
+    return frozen;
 }

package/dist/compiler/scalarSchemaAssessment.d.ts

@@ -422,4 +422,3 @@ export declare function scalarSchemaAssessment(c: AssessmentContext, options?: {
         selectedMembers?: readonly Reference[];
     }>, owner: GraphNode | undefined) => number | undefined;
 };
-//# sourceMappingURL=scalarSchemaAssessment.d.ts.map

package/dist/compiler/schemaAttributeGroupProperties.d.ts

@@ -14,4 +14,3 @@ export type RawAttributeGroupProperties = Readonly<{
 }>;
 /** Data shape only; effective mapping and semantic validity require their owners. */
 export declare function validateRawAttributeGroupShape(value: unknown, budget: SemanticBudget): asserts value is RawAttributeGroupProperties;
-//# sourceMappingURL=schemaAttributeGroupProperties.d.ts.map

package/dist/compiler/schemaAttributeProperties.d.ts

@@ -7,4 +7,3 @@ export type RawAttributeProperties = Readonly<{
     type: SemanticTypeReference;
 }>;
 export declare function validateRawAttributeShape(value: unknown, budget: SemanticBudget): value is RawAttributeProperties;
-//# sourceMappingURL=schemaAttributeProperties.d.ts.map

package/dist/compiler/schemaAttributeUses.d.ts

@@ -62,7 +62,7 @@ export type AttributeFailure = Readonly<{
 export type AttributeResult = Readonly<{
     kind: 'checked';
     contextId: string;
-    authority: 'AU01-C1-source-v1' | 'AU01-C1-raw-v2' | 'AU01-C1-original-construction-v1' | 'AU01-C1-raw-properties-v1' | 'AU01-C1-original-properties-v1';
+    authority: 'AU01-C1-source-v1' | 'AU01-C1-raw-v2' | 'AU01-C1-original-construction-v1' | 'AU01-C1-raw-properties-v1' | 'AU01-C1-original-properties-v1' | 'AU01-C1-restriction-pair-v1';
     value: SourceAttributePlan;
     obligations: readonly string[];
     scalarObligations: readonly ScalarObligation[];
@@ -87,4 +87,24 @@ export declare function readRawAttributeProperties(context: SemanticContext, own
  * qualification, supplied by the whole actual assessment, never an H aggregate receipt.
  */
 export declare function readOriginalAttributeProperties(context: SemanticContext, ownerId: NodeId): AttributeResult;
-//# sourceMappingURL=schemaAttributeUses.d.ts.map
+export type AttributeRestrictionPair = Readonly<{
+    kind: 'checked-attribute-restriction';
+    derived: NodeId;
+    base: NodeId;
+    assessment: Extract<AttributeResult, {
+        kind: 'checked';
+    }>;
+    remaining: readonly ['source-and-base-construction', 'alternative-content-derivation'];
+}>;
+export type AttributeRestrictionPairResult = AttributeRestrictionPair | ResourceLimitFailure | Readonly<{
+    kind: 'not-attribute-restriction';
+    failure: AttributeFailure;
+}>;
+/** Authenticate a paired AU predicate, not the containing type's actual derivation. */
+export declare function assertAttributeRestrictionPair(context: SemanticContext, receipt: AttributeRestrictionPair): void;
+/** Check the existing AU restriction rules against an explicit alternative complex base without changing bindings.
+ * @remarks Only the root predicate's base/method arguments differ; TYPE/SCOPE lookups and every original node remain intact.
+ *   Failed alternative relations never classify the original schema invalid. Construction and content remain separate duties.
+ * @returns An authenticated paired AU predicate, a non-restriction diagnostic or sticky resource failure.
+ */
+export declare function assessAttributeRestrictionPair(context: SemanticContext, derived: NodeId, base: NodeId): AttributeRestrictionPairResult;

package/dist/compiler/schemaAttributeUses.js

@@ -1,12 +1,12 @@
 import { XSD_NAMESPACE } from '../loader/orderedSyntax.js';
 import { assertSemanticContext } from './semanticContext.js';
 import { createSchemaScalarKernel } from './schemaScalarKernel.js';
-import { checkTypeDerivation, checkImmediateTypeFinal } from './schemaTypeRelations.js';
-import { checkDeclaration } from './schemaDeclarationPrimitives.js';
+import { checkTypeDerivation, checkImmediateTypeFinal, declarationMethods } from './schemaTypeRelations.js';
+import { checkDeclaration, declarationValueConstraint } from './schemaDeclarationPrimitives.js';
 import { namespaceAllows, namespaceExpressible, namespaceIntersection, namespaceSubset, namespaceUnion, processContentsRestricts, wildcardNamespaces } from './wildcardAlgebra.js';
 import { declaredType, resolveSemanticType, semanticTypeKey } from './schemaTypeIdentity.js';
 import { collectSemanticTypeDependencies } from './semanticTypeDependencies.js';
-import { deriveOriginalComplexPropertyContent } from './complexTypeContent.js';
+import { deriveOriginalComplexPropertyContent, deriveActualComplexContent } from './complexTypeContent.js';
 // Only immutable, completely evaluated local facts are retained. Context identity
 // captures active membership, raw properties and original/active operand roles;
 // shared source nodes never authorize transfer to another authentic context.
@@ -56,6 +56,45 @@ export function readRawAttributeProperties(context, ownerId) {
 export function readOriginalAttributeProperties(context, ownerId) {
     return rawResult(context, assessAttributeUses(context, ownerId, 'raw', 'original-properties'));
 }
+const restrictionPairs = new WeakMap();
+/** Authenticate a paired AU predicate, not the containing type's actual derivation. */
+export function assertAttributeRestrictionPair(context, receipt) {
+    assertSemanticContext(context);
+    if (restrictionPairs.get(receipt) !== context)
+        throw new TypeError('Fresh matching attribute restriction pair required');
+}
+/** Check the existing AU restriction rules against an explicit alternative complex base without changing bindings.
+ * @remarks Only the root predicate's base/method arguments differ; TYPE/SCOPE lookups and every original node remain intact.
+ *   Failed alternative relations never classify the original schema invalid. Construction and content remain separate duties.
+ * @returns An authenticated paired AU predicate, a non-restriction diagnostic or sticky resource failure.
+ */
+export function assessAttributeRestrictionPair(context, derived, base) {
+    assertSemanticContext(context);
+    return context.budget.guard(() => {
+        context.budget.chargeWork(64 + derived.length + base.length);
+        const baseNode = context.lookup(base), derivedNode = context.lookup(derived);
+        if (baseNode.kind !== 'found' || baseNode.node.kind !== 'complexType' || derivedNode.kind !== 'found' || derivedNode.node.kind !== 'complexType')
+            return Object.freeze({ kind: 'not-attribute-restriction', failure: Object.freeze({ kind: 'unresolved', rule: 'attribute-restriction-types',
+                    component: derived, message: 'Available complex types are required for both relation arguments' }) });
+        // @why The base is evaluated under its actual derivation before applying root-only relation arguments.
+        //   Reusing the proposed root's arguments while reading the base chain would shadow that component indirectly.
+        const baseAssessment = context.kind === 'actual' ? assessSourceAttributeUses(context, base) : assessCandidateAttributeUses(context, base);
+        if (baseAssessment.kind === 'resource-limit')
+            return baseAssessment;
+        if (baseAssessment.kind !== 'checked')
+            return Object.freeze({ kind: 'not-attribute-restriction', failure: baseAssessment });
+        const result = assessAttributeUses(context, derived, 'raw', 'restriction-pair', base, baseAssessment);
+        if (result.kind === 'resource-limit')
+            return result;
+        if (result.kind !== 'checked')
+            return Object.freeze({ kind: 'not-attribute-restriction', failure: result });
+        context.budget.chargeWork(64);
+        const receipt = Object.freeze({ kind: 'checked-attribute-restriction', derived, base, assessment: result,
+            remaining: Object.freeze(['source-and-base-construction', 'alternative-content-derivation']) });
+        restrictionPairs.set(receipt, context);
+        return receipt;
+    });
+}
 function rawResult(context, result) {
     return result.kind === 'invalid-schema' ? context.budget.guard(() => {
         if (result.contextId !== undefined && result.contextId === context.originalContext().contextId)
@@ -64,7 +103,7 @@ function rawResult(context, result) {
         return Object.freeze({ ...result, kind: 'candidate-rejected' });
     }) : result;
 }
-function assessAttributeUses(context, ownerId, role, mode = 'container') {
+function assessAttributeUses(context, ownerId, role, mode = 'container', restrictionBase, restrictionBasePlan) {
     assertSemanticContext(context);
     const budget = context.budget, charge = budget.chargeWork;
     return budget.guard(() => {
@@ -170,7 +209,7 @@ function assessAttributeUses(context, ownerId, role, mode = 'container') {
                 const dependencies = collectSemanticTypeDependencies(context);
                 dependencies.add(checked.typeDependencies);
                 unwrap(scalar.describe(declaredType(context, node), node.id), node, obligations, dependencies);
-                const value = typed(node, node.value, node, 'declaration', obligations, dependencies);
+                const value = typed(node, declarationValueConstraint(context, node), node, 'declaration', obligations, dependencies);
                 charge(10 + obligations.length + node.id.length);
                 const fact = Object.freeze({ receipt: checked, value, scalarObligations: Object.freeze(obligations), typeDependencies: dependencies.snapshot() });
                 cached.declarations.set(node.id, fact);
@@ -415,9 +454,19 @@ function assessAttributeUses(context, ownerId, role, mode = 'container') {
                 let originalInput = false;
                 const input = (node) => {
                     const raw = context.rawTypeProperties(node.id);
-                    if (raw || mode !== 'original-container' || !context.originalComplexPropertySource(node.id))
-                        return raw;
-                    const content = deriveOriginalComplexPropertyContent(context, node.id);
+                    if (raw) {
+                        if (mode !== 'restriction-pair' || node.id !== ownerId)
+                            return raw;
+                        charge(16);
+                        return { attributeUses: raw.attributeUses, wildcard: raw.wildcard,
+                            derivation: { method: 'restriction', base: { kind: 'local', target: restrictionBase } } };
+                    }
+                    if (mode !== 'original-container' && mode !== 'restriction-pair')
+                        return undefined;
+                    const actualInput = mode === 'restriction-pair' && context.kind === 'actual' && context.originalComplexContentSource(node.id) !== undefined;
+                    if (!actualInput && !context.originalComplexPropertySource(node.id))
+                        return undefined;
+                    const content = actualInput ? deriveActualComplexContent(context, node.id) : deriveOriginalComplexPropertyContent(context, node.id);
                     if (content.kind === 'resource-limit')
                         throw new AttributeAbort(content);
                     if (content.kind !== 'checked')
@@ -433,10 +482,27 @@ function assessAttributeUses(context, ownerId, role, mode = 'container') {
                         scalarObligations.push(Object.freeze({ ...item, contextId: item.contextId ?? actual.contextId }));
                     }
                     charge(5 + source.value.uses.length);
-                    return { derivation: { method: node.derivation?.kind ?? 'restriction', base: node.derivation?.base
-                                ?? { kind: 'builtin', name: { namespace: XSD_NAMESPACE, local: 'anyType' } } },
+                    return { derivation: mode === 'restriction-pair' && node.id === ownerId
+                            ? { method: 'restriction', base: { kind: 'local', target: restrictionBase } }
+                            : { method: node.derivation?.kind ?? 'restriction', base: node.derivation?.base
+                                    ?? { kind: 'builtin', name: { namespace: XSD_NAMESPACE, local: 'anyType' } } },
                         attributeUses: source.value.uses.map(use => use.id), wildcard: source.value.wildcard };
                 };
+                if (mode === 'restriction-pair') {
+                    if (!restrictionBasePlan || restrictionBasePlan.contextId !== context.contextId || restrictionBasePlan.value.owner !== restrictionBase)
+                        return problem(root, 'attribute-restriction-base-plan', 'The alternative base needs its own checked attribute plan', 'unresolved');
+                    charge(8 + restrictionBasePlan.scalarObligations.length + restrictionBasePlan.value.declarations.length);
+                    typeDependencies.add(restrictionBasePlan.typeDependencies);
+                    for (const obligation of restrictionBasePlan.scalarObligations) {
+                        charge();
+                        scalarObligations.push(obligation);
+                    }
+                    for (const receipt of restrictionBasePlan.value.declarations) {
+                        charge(2 + receipt.component.length);
+                        declarationEvidence.set(receipt.component, receipt);
+                    }
+                    plans.set(restrictionBase, restrictionBasePlan.value);
+                }
                 charge(3);
                 const stack = [root], active = new Set();
                 while (stack.length) {
@@ -475,14 +541,20 @@ function assessAttributeUses(context, ownerId, role, mode = 'container') {
                         local.push(mapped);
                     }
                     const uses = checkUses(local, node), wildcard = raw.wildcard;
-                    if (mode === 'original-container' && wildcard)
+                    if ((mode === 'original-container' || mode === 'restriction-pair') && wildcard)
                         for (const id of wildcard.sources) {
                             charge();
                             get(id);
                         }
                     if (wildcard && (!['strict', 'lax', 'skip'].includes(wildcard.processContents) || !namespaceExpressible(wildcard.namespace, charge)))
                         return problem(node, 'cos-aw-union/intersect', 'Literal wildcard has invalid component properties');
-                    if (!unwrap(checkImmediateTypeFinal(context, { kind: 'local', target: node.id }), node))
+                    if (mode === 'restriction-pair' && node.id === ownerId) {
+                        if (!baseNode || baseNode.kind !== 'complexType')
+                            return problem(node, 'attribute-restriction-base', 'Alternative base must be complex', 'unresolved');
+                        if (declarationMethods(context, baseNode, 'final').includes('restriction'))
+                            return problem(node, 'derivation-ok-restriction.1', 'Alternative base prohibits restriction');
+                    }
+                    else if (!unwrap(checkImmediateTypeFinal(context, { kind: 'local', target: node.id }), node))
                         return problem(node, 'cos-ct-extends/derivation-ok-restriction', 'Base final excludes derivation');
                     if (raw.derivation.method === 'extension') {
                         for (const original of base?.uses ?? []) {
@@ -574,7 +646,8 @@ function assessAttributeUses(context, ownerId, role, mode = 'container') {
                 }
                 charge(10 + scalarObligations.length);
                 return Object.freeze({ kind: 'checked', contextId: context.contextId,
-                    authority: originalInput ? 'AU01-C1-original-construction-v1' : 'AU01-C1-raw-v2',
+                    authority: mode === 'restriction-pair' ? 'AU01-C1-restriction-pair-v1'
+                        : originalInput ? 'AU01-C1-original-construction-v1' : 'AU01-C1-raw-v2',
                     value: plans.get(root.id), obligations: Object.freeze(['aggregate-type-validity', 'raw-type-property-correspondence']), scalarObligations: Object.freeze(scalarObligations), typeDependencies: typeDependencies.snapshot() });
             }
             const dependencies = (node) => {

package/dist/compiler/schemaBinaryWordReconstruction.d.ts

@@ -7,4 +7,3 @@ export declare function reconstructBinaryWords<Owner>(c: SchemaPatternContext<Ow
     core: string;
     words: readonly string[];
 }> | undefined;
-//# sourceMappingURL=schemaBinaryWordReconstruction.d.ts.map

package/dist/compiler/schemaBuiltinFacets.d.ts

@@ -11,4 +11,3 @@ export type IntrinsicFacetProperties = Readonly<{
 }>;
 export declare const LIST_CONSTRUCTOR_FACETS: IntrinsicFacetProperties;
 export declare function schemaBuiltinFacetProperties<Owner>(name: string, owner: Owner, c: Pick<SchemaValueContext<Owner>, 'step' | 'text'>): IntrinsicFacetProperties;
-//# sourceMappingURL=schemaBuiltinFacets.d.ts.map

package/dist/compiler/schemaCalendarImages.d.ts

@@ -5,4 +5,3 @@ import type { SchemaPatternContext } from './schemaValueContext.js';
 export declare function schemaCalendarImages<Owner>(c: SchemaPatternContext<Owner>, regular: ReturnType<typeof schemaRegularLanguages<Owner>>, expression: (text: string, owner: Owner) => RegularLanguage): {
     image: (source: RegularLanguage, family: CalendarFamily, owner: Owner) => RegularLanguage;
 };
-//# sourceMappingURL=schemaCalendarImages.d.ts.map

package/dist/compiler/schemaCalendarLanguage.d.ts

@@ -8,4 +8,3 @@ export declare function schemaCalendarLanguages<Owner>(c: SchemaPatternContext<O
     valid: (family: CalendarFamily, owner: Owner) => RegularLanguage;
     year: (leap: boolean, owner: Owner) => RegularLanguage;
 };
-//# sourceMappingURL=schemaCalendarLanguage.d.ts.map

package/dist/compiler/schemaCompiler.d.ts

@@ -232,4 +232,3 @@ export type CompiledCatalog = {
  *    portType reference, then enumerate operations and their soapAction URIs.
  */
 export declare function compileCatalog(cat: WsdlCatalog, options: CompilerOptions, streamConfig?: StreamConfig): CompiledCatalog;
-//# sourceMappingURL=schemaCompiler.d.ts.map

package/dist/compiler/schemaComponentEquality.d.ts

@@ -25,4 +25,3 @@ export type ComponentEqualityResult = Readonly<{
 }> | Failure;
 export declare function compareComponentProperties(context: SemanticContext, a: GraphNode, b: GraphNode): ComponentEqualityResult;
 export {};
-//# sourceMappingURL=schemaComponentEquality.d.ts.map

package/dist/compiler/schemaConstructionAssessment.d.ts

@@ -2,9 +2,13 @@
 import type { NodeId } from './canonicalGraph.js';
 import type { SemanticContext } from './semanticContext.js';
 import type { ResourceLimitFailure } from './semanticBudget.js';
+import type { AttributeRestrictionPair } from './schemaAttributeUses.js';
+import type { ScalarResult } from './schemaScalarKernel.js';
+import type { ScalarObligation } from './scalarSchemaAssessment.js';
 import type { CorrespondenceReceipt } from './re01CandidateCorrespondence.js';
 import type { SemanticTypeDependency, SemanticTypeReference } from './semanticTypeReference.js';
 import type { IdentityConstraintDependency } from './schemaIdentityConstraints.js';
+import type { StandardElementConstruction } from './standardSchemaConstruction.js';
 export type ConstructionObligation = Readonly<{
     rule: string;
     component: NodeId;
@@ -19,6 +23,7 @@ export type ComponentConstructionReceipt = Readonly<{
     receipts: readonly object[];
     dependencies: readonly NodeId[];
     builtinDependencies: readonly string[];
+    standardDependencies: readonly StandardElementConstruction[];
     typeDependencies: readonly SemanticTypeDependency[];
     identityConstraintDependencies: readonly IdentityConstraintDependency[];
     re01?: Readonly<{
@@ -43,4 +48,32 @@ export declare function assertComponentConstruction(context: SemanticContext, re
 export declare function checkComponentConstruction(context: SemanticContext, id: NodeId, options?: Readonly<{
     correspondence?: CorrespondenceReceipt;
 }>): ComponentConstructionResult;
-//# sourceMappingURL=schemaConstructionAssessment.d.ts.map
+export type SimpleRestrictionPredicate = Readonly<{
+    kind: 'checked-simple-restriction-predicate';
+    contextId: string;
+    target: NodeId;
+    base: NodeId;
+    attributes: AttributeRestrictionPair;
+    scalar: Extract<ScalarResult<boolean>, {
+        kind: 'checked';
+    }>;
+    typeDependencies: readonly SemanticTypeDependency[];
+    scalarObligations: readonly ScalarObligation[];
+    remaining: readonly ['source-and-base-construction', 'alternative-derivation-interpretation'];
+}>;
+export type SimpleRestrictionPredicateResult = SimpleRestrictionPredicate | ResourceLimitFailure | Readonly<{
+    kind: 'not-simple-restriction';
+    rule: string;
+    component: NodeId;
+    contextId: string;
+    details?: object;
+}>;
+/** Authenticate the paired predicate; it never replaces the target's actual derivation. */
+export declare function assertSimpleRestrictionPredicate(context: SemanticContext, receipt: SimpleRestrictionPredicate): void;
+/** Evaluate simple-content restriction constraints for the actual target properties and an explicit alternative base.
+ * @remarks Reuses the AU derivation owner and scalar content-derivation kernel. No target node, raw property,
+ *   TYPE/SCOPE lookup or stored base edge is replaced. Whole construction and the in-principle derivation interpretation
+ *   remain separate duties; failure of an alternative never declares the source schema invalid.
+ * @returns An authenticated native predicate, an explicit predicate/unavailability diagnostic, or sticky resource failure.
+ */
+export declare function checkSimpleRestrictionPredicate(context: SemanticContext, target: NodeId, base: NodeId): SimpleRestrictionPredicateResult;