@techspokes/typescript-wsdl-client 1.1.5 → 1.2.0

package/dist/compiler/schemaCompiler.js

@@ -1,6 +1,7 @@
 import { getChildrenWithLocalName, getFirstWithLocalName, normalizeArray, pascal, resolveQName, } from "../util/tools.js";
 import { xsdToTsPrimitive } from "../xsd/primitives.js";
 import { WsdlCompilationError } from "../util/errors.js";
+import { LegacyDeclarations } from "./legacyDeclarations.js";
 // XML Schema namespace constant
 const XS = "http://www.w3.org/2001/XMLSchema";
 /**
@@ -13,25 +14,6 @@ const XS = "http://www.w3.org/2001/XMLSchema";
 function qkey(q) {
     return `{${q.ns}}${q.local}`;
 }
-/**
- * Generates a name for an inline complex type
- *
- * This function creates appropriate TypeScript names for anonymous types
- * that are defined inline within element declarations.
- *
- * @param {string} parentTypeName - Name of the parent type
- * @param {string} [propName] - Name of the property containing the inline type
- * @param {number|"unbounded"} [_max] - Maximum occurrence (unused but kept for API compatibility)
- * @returns {string} - Generated TypeScript name for the inline type
- */
-function makeInlineTypeName(parentTypeName, propName, _max) {
-    const base = pascal(parentTypeName || "AnonParent");
-    const prop = pascal(propName || "");
-    if (prop) {
-        return prop;
-    }
-    return `${base}Anon`;
-}
 // --- Minimal WS-Policy scanning (inline policies only; PolicyReference not resolved) ---
 /**
  * Extracts security requirements from WS-Policy nodes
@@ -255,9 +237,13 @@ export function compileCatalog(cat, options, streamConfig) {
             }
         }
     }
-    // outputs & state
-    const compiledMap = new Map(); // key: ns|name
-    const aliasMap = new Map(); // key: ns|name
+    const declarations = new LegacyDeclarations([
+        ...Array.from(complexTypes.values(), rec => ({ kind: "complex", name: String(rec.node["@_name"]), ns: rec.tns, node: rec.node, prefixes: rec.prefixes })),
+        ...Array.from(simpleTypes.values(), rec => ({ kind: "simple", name: String(rec.node["@_name"]), ns: rec.tns, node: rec.node, prefixes: rec.prefixes })),
+        ...Array.from(elements.values(), rec => ({ kind: "element", name: String(rec.node["@_name"]), ns: rec.tns, node: rec.node, prefixes: rec.prefixes })),
+    ]);
+    const compiledMap = new Map();
+    const aliasMap = new Map();
     const inProgress = new Set();
     // meta accumulators
     const attrSpec = {};
@@ -314,22 +300,23 @@ export function compileCatalog(cat, options, streamConfig) {
         const list = getFirstWithLocalName(simpleNode, "list");
         if (list?.["@_itemType"]) {
             const q = resolveQName(list["@_itemType"], schemaNS, prefixes);
-            const declared = q.ns === XS ? `xs:${q.local}` : `{${q.ns}}${q.local}`;
-            return { tsType: `${xsdToTsPrimitive(declared, options?.primitive)}[]`, declared };
+            const item = resolveTypeRef(q, schemaNS, prefixes);
+            const itemType = item.tsType.includes("|") ? `(${item.tsType})` : item.tsType;
+            return { tsType: `${itemType}[]`, declared: item.declared };
         }
         // fallback
         return { tsType: "string", declared: "xs:string" };
     }
     /** Compile and cache a named simpleType */
     function getOrCompileAlias(name, sNode, schemaNS, prefixes) {
-        const key = `${schemaNS}|${name}`;
+        const key = declarations.type(schemaNS, name);
         const present = aliasMap.get(key);
         if (present) {
             return present;
         }
         const { tsType, declared, jsdoc } = compileSimpleTypeNode(sNode, schemaNS, prefixes);
         const alias = {
-            name: pascal(name),
+            name: declarations.name(key),
             ns: schemaNS,
             tsType,
             declared,
@@ -373,19 +360,26 @@ export function compileCatalog(cat, options, streamConfig) {
         const k = qkey(q);
         return complexTypes.get(k);
     }
-    function getOrCompileComplex(name, cnode, schemaNS, prefixes) {
-        // Early cycle detection: check if we're already processing this raw name + namespace combo
-        // BEFORE calling pascal() to avoid stack overflow on circular references
-        const rawKey = `${schemaNS}|${name}`;
-        if (inProgress.has(rawKey)) {
-            // Return a minimal stub to break the cycle
-            const stubName = pascal(name);
-            return { name: stubName, ns: schemaNS, attrs: [], elems: [] };
+    function getOrCompileComplex(name, cnode, schemaNS, prefixes, declarationId = declarations.type(schemaNS, name)) {
+        const key = declarationId;
+        const outName = declarations.name(key);
+        const present = compiledMap.get(key);
+        if (present)
+            return present;
+        if (inProgress.has(key))
+            return { name: outName, ns: schemaNS, attrs: [], elems: [] };
+        inProgress.add(key);
+        try {
+            return compileComplexBody(cnode, schemaNS, prefixes, declarationId);
+        }
+        finally {
+            inProgress.delete(key);
         }
-        inProgress.add(rawKey);
-        const outName = pascal(name);
+    }
+    function compileComplexBody(cnode, schemaNS, prefixes, declarationId) {
+        const key = declarationId;
+        const outName = declarations.name(key);
         const typeDoc = extractAnnotationDocumentation(cnode);
-        const key = `${schemaNS}|${outName}`;
         // hoisted helpers for merging and collecting
         const mergeAttrs = (into, list) => {
             const idx = new Map();
@@ -415,40 +409,6 @@ export function compileCatalog(cat, options, streamConfig) {
                 }
             }
         };
-        const mergeChoiceGroups = (into, list) => {
-            if (list.length === 0)
-                return into;
-            const merged = into ? [...into] : [];
-            const idx = new Map();
-            merged.forEach((g, i) => idx.set(g.name, i));
-            for (const g of list) {
-                const pos = idx.get(g.name);
-                if (pos == null) {
-                    idx.set(g.name, merged.length);
-                    merged.push(g);
-                }
-                else {
-                    merged[pos] = g;
-                }
-            }
-            return merged;
-        };
-        const mergeJsonUnique = (into, list) => {
-            if (list.length === 0)
-                return into;
-            const merged = into ? [...into] : [];
-            const seen = new Set(merged.map((w) => JSON.stringify(w)));
-            for (const w of list) {
-                const key = JSON.stringify(w);
-                if (!seen.has(key)) {
-                    seen.add(key);
-                    merged.push(w);
-                }
-            }
-            return merged;
-        };
-        const mergeWildcards = (into, list) => mergeJsonUnique(into, list);
-        const mergeAttributeWildcards = (into, list) => mergeJsonUnique(into, list);
         const collectAttributes = (node) => {
             const out = [];
             const attrs = getChildrenWithLocalName(node, "attribute");
@@ -547,7 +507,7 @@ export function compileCatalog(cat, options, streamConfig) {
             }
             return out;
         };
-        const compileElementParticle = (ownerTypeName, e) => {
+        const compileElementParticle = (e) => {
             const nameOrRef = e["@_name"] || e["@_ref"];
             if (!nameOrRef)
                 return undefined;
@@ -557,8 +517,8 @@ export function compileCatalog(cat, options, streamConfig) {
             const inlineComplex = getFirstWithLocalName(e, "complexType");
             const inlineSimple = getFirstWithLocalName(e, "simpleType");
             if (inlineComplex) {
-                const inlineName = makeInlineTypeName(ownerTypeName, propName || nameOrRef, max);
-                const rec = getOrCompileComplex(inlineName, inlineComplex, schemaNS, prefixes);
+                const inlineId = declarations.inline(declarationId, e);
+                const rec = getOrCompileComplex(String(propName || nameOrRef), inlineComplex, schemaNS, prefixes, inlineId);
                 return {
                     name: propName || nameOrRef,
                     tsType: rec.name,
@@ -603,7 +563,7 @@ export function compileCatalog(cat, options, streamConfig) {
             });
             const recurse = (groupNode, inherited = one, inheritSequenceOccurs = true) => {
                 for (const e of getChildrenWithLocalName(groupNode, "element")) {
-                    const particle = compileElementParticle(ownerTypeName, e);
+                    const particle = compileElementParticle(e);
                     if (!particle)
                         continue;
                     // @constraints Preserve disabled particles until the content model can represent their absence (#145).
@@ -636,7 +596,7 @@ export function compileCatalog(cat, options, streamConfig) {
                         const branches = [];
                         let branchSourceOrder = 0;
                         for (const e of getChildrenWithLocalName(child.node, "element")) {
-                            const particle = compileElementParticle(ownerTypeName, e);
+                            const particle = compileElementParticle(e);
                             if (particle) {
                                 branches.push({
                                     name: particle.name,
@@ -672,29 +632,6 @@ export function compileCatalog(cat, options, streamConfig) {
             recurse(node);
             return out;
         };
-        const present = compiledMap.get(key);
-        if (present) {
-            // On duplicate definitions, merge new attributes and elements
-            const newAttrs = collectAttributes(cnode);
-            const newElems = collectParticles(outName, cnode);
-            const newWildcards = collectWildcards(cnode);
-            const newAttributeWildcards = collectAttributeWildcards(cnode);
-            const newChoiceGroups = collectChoiceGroups(outName, cnode);
-            mergeAttrs(present.attrs, newAttrs);
-            mergeElems(present.elems, newElems);
-            present.wildcards = mergeWildcards(present.wildcards, newWildcards);
-            present.attributeWildcards = mergeAttributeWildcards(present.attributeWildcards, newAttributeWildcards);
-            const mergedChoiceGroups = mergeChoiceGroups(present.choiceGroups, newChoiceGroups);
-            if (mergedChoiceGroups && mergedChoiceGroups.length > 0) {
-                present.choiceGroups = mergedChoiceGroups;
-            }
-            if (!present.doc && typeDoc) {
-                present.doc = typeDoc;
-            }
-            // Remove from inProgress since we're done with this cycle
-            inProgress.delete(rawKey);
-            return present;
-        }
         // result accumulators
         const attrs = [];
         const elems = [];
@@ -749,7 +686,6 @@ export function compileCatalog(cat, options, streamConfig) {
                     ...(localChoiceGroups.length > 0 ? { localChoiceGroups } : {}),
                 };
                 compiledMap.set(key, result);
-                inProgress.delete(key);
                 return result;
             }
         }
@@ -784,7 +720,6 @@ export function compileCatalog(cat, options, streamConfig) {
                     ...(attributeWildcards.length > 0 ? { attributeWildcards } : {}),
                 };
                 compiledMap.set(key, result);
-                inProgress.delete(rawKey);
                 return result;
             };
             if (ext) {
@@ -811,20 +746,19 @@ export function compileCatalog(cat, options, streamConfig) {
             ...(choiceGroups.length > 0 ? { choiceGroups } : {}),
         };
         compiledMap.set(key, result);
-        inProgress.delete(rawKey);
         return result;
     }
     // Helper: compile a global element into a surface type (wrapper)
     function compileElementAsType(name, enode, schemaNS, prefixes) {
-        const outName = pascal(name);
+        const key = declarations.surface(schemaNS, name);
+        const outName = declarations.name(key);
         const elementDoc = extractAnnotationDocumentation(enode);
-        const key = `${schemaNS}|${outName}`;
         const present = compiledMap.get(key);
         if (present)
             return present;
         const inlineComplex = getFirstWithLocalName(enode, "complexType");
         if (inlineComplex) {
-            return getOrCompileComplex(name, inlineComplex, schemaNS, prefixes);
+            return getOrCompileComplex(name, inlineComplex, schemaNS, prefixes, key);
         }
         const inlineSimple = getFirstWithLocalName(enode, "simpleType");
         if (inlineSimple) {
@@ -871,7 +805,7 @@ export function compileCatalog(cat, options, streamConfig) {
                     // record alias: ElementName -> BaseTypeName
                     const aliasKey = key;
                     const existingAlias = aliasMap.get(aliasKey);
-                    const declared = `{${base.ns}}${base.name}`;
+                    const declared = `{${base.ns}}${q.local}`;
                     if (!existingAlias) {
                         aliasMap.set(aliasKey, { name: outName, ns: schemaNS, tsType: base.name, declared, doc: elementDoc });
                     }
@@ -1138,9 +1072,10 @@ export function compileCatalog(cat, options, streamConfig) {
         const inputElement = elementOfMessage(inMsg);
         const outputElement = elementOfMessage(outMsg);
         const doc = extractDirectDocumentation(po);
-        // Derive TypeScript type names from element local names
-        const inputTypeName = inputElement ? pascal(inputElement.local) : undefined;
-        const outputTypeName = outputElement ? pascal(outputElement.local) : undefined;
+        const surfaceName = (element) => elements.has(qkey(element))
+            ? declarations.name(declarations.surface(element.ns, element.local)) : pascal(element.local);
+        const inputTypeName = inputElement ? surfaceName(inputElement) : undefined;
+        const outputTypeName = outputElement ? surfaceName(outputElement) : undefined;
         const op = {
             name,
             soapAction: bOps.get(name) || "",

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;

package/dist/compiler/schemaConstructionAssessment.js

@@ -2,7 +2,7 @@ import { containedNodes } from './graphTraversal.js';
 import { assertSemanticContext } from './semanticContext.js';
 import { checkActualSchemaSyntax } from './schemaSyntaxAssessment.js';
 import { checkDeclaration } from './schemaDeclarationPrimitives.js';
-import { assessAttributeUse, assessRawAttributeUses, assessCandidateAttributeUses, assessSourceAttributeUses } from './schemaAttributeUses.js';
+import { assessAttributeUse, assessRawAttributeUses, assessCandidateAttributeUses, assessSourceAttributeUses, assessAttributeRestrictionPair, assertAttributeRestrictionPair } from './schemaAttributeUses.js';
 import { createSchemaScalarKernel } from './schemaScalarKernel.js';
 import { checkImmediateTypeFinal, immediateTypeBase } from './schemaTypeRelations.js';
 import { deriveActualComplexContent, deriveRawComplexContent, deriveOriginalComplexPropertyContent, deriveOriginalContentSubtree, particleContentNode, deriveBuiltinAnyTypeContent, deriveModelGroupContent, originalUrWildcardSource } from './complexTypeContent.js';
@@ -20,6 +20,7 @@ import { assertCandidateCorrespondence } from './re01CandidateCorrespondence.js'
 import { declaredType, resolveSemanticType, semanticTypeKey } from './schemaTypeIdentity.js';
 import { collectSemanticTypeDependencies } from './semanticTypeDependencies.js';
 import { collectIdentityConstraintDependencies } from './schemaIdentityConstraints.js';
+import { checkStandardElementConstruction } from './standardSchemaConstruction.js';
 const issued = new WeakMap();
 class ConstructionAbort extends Error {
     result;
@@ -67,6 +68,17 @@ export function checkComponentConstruction(context, id, options = {}) {
             if (found.kind !== 'found')
                 return fail('component-membership', 'Component is unavailable in the selected context', 'unresolved');
             const node = found.node, receipts = [], dependencies = new Set(), builtins = new Set();
+            const standards = new Map();
+            const standardDependency = (declaration) => {
+                b.chargeWork(4 + declaration.id.length);
+                if (!standards.has(declaration.id)) {
+                    const result = checkStandardElementConstruction(context, declaration);
+                    if (result.kind === 'resource-limit')
+                        throw new ConstructionAbort(result);
+                    standards.set(declaration.id, result);
+                }
+                return declaration;
+            };
             const typeDependencies = collectSemanticTypeDependencies(context);
             const identityConstraintDependencies = collectIdentityConstraintDependencies(context);
             const obligations = [];
@@ -94,6 +106,8 @@ export function checkComponentConstruction(context, id, options = {}) {
                     builtins.add(lookup.name.local);
                     return undefined;
                 }
+                if (lookup.kind === 'standard-element')
+                    return standardDependency(lookup.declaration);
                 if (lookup.kind !== 'found')
                     return fail('component-dependency', 'A required reference is unavailable', 'unresolved');
                 b.chargeWork(lookup.node.id.length);
@@ -215,6 +229,8 @@ export function checkComponentConstruction(context, id, options = {}) {
                         return fail('source-only-scalar-slot', 'Suppressed original source cannot supply a semantic scalar slot', 'unresolved');
                     b.chargeWork();
                     const target = context.resolve(slot.reference);
+                    if (target.kind === 'standard-element')
+                        standardDependency(target.declaration);
                     if (target.kind === 'found' && target.node.identity.kind === 'global')
                         requireNode(target.node.id);
                 }
@@ -222,6 +238,7 @@ export function checkComponentConstruction(context, id, options = {}) {
                 const receipt = Object.freeze({ kind: 'checked', authority: 'XSD10-component-construction-v1',
                     scope: 'original-source-syntax-only', contextId: context.contextId, component: id, receipts: Object.freeze(receipts),
                     dependencies: Object.freeze([...dependencies]), builtinDependencies: Object.freeze([]), typeDependencies: typeDependencies.snapshot(),
+                    standardDependencies: Object.freeze([...standards.values()]),
                     identityConstraintDependencies: identityConstraintDependencies.snapshot(),
                     obligations: Object.freeze([]), discharged: Object.freeze([]) });
                 b.chargeWork();
@@ -275,9 +292,10 @@ export function checkComponentConstruction(context, id, options = {}) {
             if (sourceContent) {
                 if (originalComplex) {
                     b.chargeWork(100 + context.contextId.length + context.originalContext().contextId.length + id.length);
-                    receipts.push(Object.freeze({ kind: 'checked-original-input', authority: 'XSD10-original-complex-input-v1',
+                    const simpleInput = sourceContent.content.kind === 'simple';
+                    receipts.push(Object.freeze({ kind: 'checked-original-input', authority: simpleInput ? 'XSD10-original-complex-simple-input-v1' : 'XSD10-original-complex-input-v1',
                         contextId: context.contextId, originalContextId: context.originalContext().contextId, component: id,
-                        scope: 'guarded-original-particle-empty-input', remaining: Object.freeze(['actual-source-qualification', 'complete-type-validity']) }));
+                        scope: simpleInput ? 'guarded-original-simple-input' : 'guarded-original-particle-empty-input', remaining: Object.freeze(['actual-source-qualification', 'complete-type-validity']) }));
                     reference(originalComplex.derivation?.base ?? ANY);
                 }
                 else if (rawComplex) {
@@ -339,7 +357,7 @@ export function checkComponentConstruction(context, id, options = {}) {
                     }
                     else if (item.term.kind === 'element') {
                         const declaration = reference(item.term.declaration);
-                        if (declaration?.kind !== 'element')
+                        if (declaration?.kind !== 'element' && declaration?.kind !== 'standard-element')
                             return fail('particle-properties', 'Element use must reference a declaration');
                     }
                 }
@@ -576,9 +594,9 @@ export function checkComponentConstruction(context, id, options = {}) {
                         return fail('p-props-correct', 'A particle component must have a positive maximum occurrence');
                     if (node.term.kind === 'element') {
                         const declaration = reference(node.term.declaration);
-                        if (declaration?.kind !== 'element')
+                        if (declaration?.kind !== 'element' && declaration?.kind !== 'standard-element')
                             return fail('particle-properties', 'Element particle must reference an element declaration');
-                        if (declaration.identity.kind === 'global') {
+                        if (declaration.kind === 'element' && declaration.identity.kind === 'global') {
                             if (context.membership !== 'complete-actual-plus-additions')
                                 obligation('complete-substitution-universe');
                             b.chargeWork(3);
@@ -638,6 +656,7 @@ export function checkComponentConstruction(context, id, options = {}) {
             const receipt = Object.freeze({ kind: 'checked', authority: 'XSD10-component-construction-v1',
                 scope: 'local-component-premises', contextId: context.contextId, component: id, receipts: Object.freeze(receipts),
                 dependencies: Object.freeze([...dependencies]), builtinDependencies: Object.freeze([...builtins]), re01,
+                standardDependencies: Object.freeze([...standards.values()]),
                 typeDependencies: typeDependencies.snapshot(), identityConstraintDependencies: identityConstraintDependencies.snapshot(),
                 obligations: b.freeze(b.snapshot(pending)),
                 discharged: ownRawSimpleContentChecked
@@ -661,3 +680,66 @@ export function checkComponentConstruction(context, id, options = {}) {
         }
     });
 }
+const simpleRestrictionPredicates = new WeakMap();
+/** Authenticate the paired predicate; it never replaces the target's actual derivation. */
+export function assertSimpleRestrictionPredicate(context, receipt) {
+    assertSemanticContext(context);
+    if (simpleRestrictionPredicates.get(receipt) !== context)
+        throw new TypeError('Fresh matching simple restriction predicate required');
+    assertAttributeRestrictionPair(context, receipt.attributes);
+}
+/** 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 function checkSimpleRestrictionPredicate(context, target, base) {
+    assertSemanticContext(context);
+    const b = context.budget;
+    return b.guard(() => {
+        const fail = (rule, details) => {
+            b.chargeWork(64 + rule.length + target.length);
+            return Object.freeze({ kind: 'not-simple-restriction', rule, component: target, contextId: context.contextId, ...(details ? { details } : {}) });
+        };
+        b.chargeWork(64 + target.length + base.length);
+        const targetNode = context.lookup(target), baseNode = context.lookup(base);
+        if (targetNode.kind !== 'found' || targetNode.node.kind !== 'complexType' || baseNode.kind !== 'found' || baseNode.node.kind !== 'complexType')
+            return fail('paired-complex-types');
+        const content = (id) => context.kind === 'actual' ? deriveActualComplexContent(context, id) : deriveOriginalComplexPropertyContent(context, id);
+        const own = content(target), prior = content(base);
+        if (own.kind === 'resource-limit')
+            return own;
+        if (prior.kind === 'resource-limit')
+            return prior;
+        if (own.kind !== 'checked')
+            return fail('paired-target-properties', own);
+        if (prior.kind !== 'checked')
+            return fail('paired-base-properties', prior);
+        if (own.view.content.kind !== 'simple' || prior.view.content.kind !== 'simple')
+            return fail('paired-simple-content');
+        const attributes = assessAttributeRestrictionPair(context, target, base);
+        if (attributes.kind === 'resource-limit')
+            return attributes;
+        if (attributes.kind !== 'checked-attribute-restriction')
+            return fail('paired-attribute-restriction', attributes);
+        assertAttributeRestrictionPair(context, attributes);
+        const scalar = createSchemaScalarKernel(context).contentDerivation(own.view.content.type, prior.view.content.type, target);
+        if (scalar.kind === 'resource-limit')
+            return scalar;
+        if (scalar.kind !== 'checked')
+            return fail('paired-scalar-derivation', scalar);
+        if (!scalar.value)
+            return fail('derivation-ok-restriction.5.2');
+        const typeDependencies = collectSemanticTypeDependencies(context);
+        typeDependencies.add(attributes.assessment.typeDependencies);
+        typeDependencies.add(scalar.typeDependencies);
+        b.chargeWork(128 + attributes.assessment.scalarObligations.length + scalar.obligations.length);
+        const result = Object.freeze({ kind: 'checked-simple-restriction-predicate', contextId: context.contextId,
+            target, base, attributes, scalar, typeDependencies: typeDependencies.snapshot(),
+            scalarObligations: Object.freeze([...attributes.assessment.scalarObligations, ...scalar.obligations]),
+            remaining: Object.freeze(['source-and-base-construction', 'alternative-derivation-interpretation']) });
+        simpleRestrictionPredicates.set(result, context);
+        return result;
+    });
+}

package/dist/compiler/schemaDatatypeValues.d.ts

@@ -1,4 +1,3 @@
 /** Schema-only facade; the neutral calculations confer no receipt authority. */
 export { datatypeValues as schemaDatatypeValues, builtinListItem, builtinParents, integerBounds, builtinPrimitive, whitespaceFor, normalizeWhitespace } from './datatypeValues.js';
 export type { DecimalOperand, DatatypeOperand as SchemaOperand, DatatypeListTokens as SchemaListTokens } from './datatypeValues.js';
-//# sourceMappingURL=schemaDatatypeValues.d.ts.map

package/dist/compiler/schemaDecimalLanguage.d.ts

@@ -4,4 +4,3 @@ export declare function schemaDecimalLanguages<Owner>(c: SchemaPatternContext<Ow
     relation: (canonical: string, greater: boolean, owner: Owner) => string | undefined;
     precision: (name: "totalDigits" | "fractionDigits", bound: string, owner: Owner) => string;
 };
-//# sourceMappingURL=schemaDecimalLanguage.d.ts.map

package/dist/compiler/schemaDeclarationPrimitives.d.ts

@@ -1,6 +1,6 @@
 import type { SemanticTypeDependency } from './semanticTypeReference.js';
 /** Declaration-local properties only. EDC and containing type validity are separate. */
-import type { NodeId } from './canonicalGraph.js';
+import type { ElementNode, AttributeNode, NodeId, ValueConstraint } from './canonicalGraph.js';
 import type { SemanticContext } from './semanticContext.js';
 import type { AssessedSchemaOperand, ScalarFailure } from './schemaScalarKernel.js';
 import type { ResourceLimitFailure } from './semanticBudget.js';
@@ -28,7 +28,12 @@ export type DeclarationValuePropertyResult = DeclarationResult | Readonly<{
     scalarObligations: readonly ScalarObligation[];
     typeDependencies: readonly SemanticTypeDependency[];
 }>;
+/** Map declaration VALUE separately from an attribute use's source default/fixed syntax.
+ * @remarks Under 2004 Structures 3.2.2 a local source attribute declaration has no value constraint;
+ *   the same syntax maps to the attribute use. Global source and explicit raw component values remain declared values.
+ * @throws TypeError For a copied or foreign declaration.
+ */
+export declare function declarationValueConstraint(context: SemanticContext, node: ElementNode | AttributeNode): ValueConstraint | undefined;
 /** VALUE properties select actual scalar/fact support; full declaration validity has its own owner. */
 export declare function checkDeclarationValueProperty(context: SemanticContext, id: NodeId): DeclarationValuePropertyResult;
 export declare function checkDeclaration(context: SemanticContext, id: NodeId): DeclarationResult;
-//# sourceMappingURL=schemaDeclarationPrimitives.d.ts.map

package/dist/compiler/schemaDeclarationPrimitives.js

@@ -6,6 +6,23 @@ import { resolveSemanticType, declaredType } from './schemaTypeIdentity.js';
 import { collectSemanticTypeDependencies } from './semanticTypeDependencies.js';
 import { readElementIdentityConstraints } from './schemaIdentityConstraints.js';
 const nameAttribute = (node, name) => node.declaredAttributes.find(a => a.name.namespace === '' && a.name.local === name)?.value;
+/** Map declaration VALUE separately from an attribute use's source default/fixed syntax.
+ * @remarks Under 2004 Structures 3.2.2 a local source attribute declaration has no value constraint;
+ *   the same syntax maps to the attribute use. Global source and explicit raw component values remain declared values.
+ * @throws TypeError For a copied or foreign declaration.
+ */
+export function declarationValueConstraint(context, node) {
+    assertSemanticContext(context);
+    context.budget.chargeWork(32);
+    const field = node && typeof node === 'object' ? Object.getOwnPropertyDescriptor(node, 'id') : undefined;
+    if (!field || !('value' in field) || typeof field.value !== 'string')
+        throw new TypeError('Authentic declaration required');
+    const found = context.lookup(field.value);
+    if (found.kind !== 'found' || found.node !== node)
+        throw new TypeError('Authentic declaration required');
+    const source = context.originalDeclarationSource(node.id);
+    return node.kind === 'attribute' && source?.kind === 'attribute' && source.identity.kind === 'scoped' ? undefined : node.value;
+}
 /** Shared actual VALUE assessment; selecting a mixed value's STRING is not FULL of its complex owner. */
 function constraintValue(context, node, reference) {
     const constraint = node.value;
@@ -162,7 +179,7 @@ export function checkDeclaration(context, id) {
             typed.add(description.typeDependencies);
         }
         let constraint;
-        if (node.value) {
+        if (declarationValueConstraint(context, node)) {
             let reference = type;
             if (selected.kind === 'builtin' && selected.name.local === 'anyType')
                 reference = { kind: 'builtin', name: { namespace: XSD_NAMESPACE, local: 'anySimpleType' } };

package/dist/compiler/schemaDocumentSyntax.d.ts

@@ -52,4 +52,3 @@ export declare function prepareSourceSchemaRequest(input: SchemaInput, options?:
 }>): SourceSchemaPreparation;
 /** Checks source document representation only; component grammar/semantics remain owned elsewhere. */
 export declare function checkSchemaDocumentSyntax(context: SemanticContext): SchemaDocumentResult;
-//# sourceMappingURL=schemaDocumentSyntax.d.ts.map

package/dist/compiler/schemaDurationLanguage.d.ts

@@ -8,4 +8,3 @@ export declare function schemaDurationLanguages<Owner>(c: SchemaPatternContext<O
         kind: "private-regular-language";
     }>;
 };
-//# sourceMappingURL=schemaDurationLanguage.d.ts.map

package/dist/compiler/schemaElementInstance.d.ts

@@ -0,0 +1,30 @@
+import type { SyntaxElement, SyntaxSource } from '../loader/orderedSyntax.js';
+import type { SourceTypedId, SourceWildcardObligation } from './schemaSourceWildcards.js';
+import type { SemanticBudget, ResourceLimitFailure } from './semanticBudget.js';
+export type SchemaElementInstanceResult = Readonly<{
+    kind: 'schema-element-instance';
+    scope: 'XSD10-S4S-element-instance-2004';
+    ids: readonly SourceTypedId[];
+    remaining: readonly SourceWildcardObligation[];
+}> | Readonly<{
+    kind: 'value-invalid';
+    rule: string;
+    message: string;
+    source: SyntaxSource;
+}> | Readonly<{
+    kind: 'cancelled';
+    rule: 'cooperative-cancellation';
+}> | ResourceLimitFailure;
+/** Assess borrowed, already owned XML syntax as the dated global xs:schema element.
+ * @remarks Reuses the fixed S4S grammar, scalar and identity owners. It does not compile embedded schemas,
+ *   acquire dependencies, qualify a WSDL source or issue a mapping/codec/portable receipt.
+ *   The supplied schema element is the instance validation root. Callers retain responsibility for XML
+ *   parsing/ownership, any enclosing document identity scope and discharging remaining obligations.
+ * @returns Instance clauses only; a well-formed QName can reference an undeclared application type in schema-as-data.
+ * @throws TypeError For a non-native cancellation signal. Other caller-check failures propagate unchanged.
+ * @see https://www.w3.org/TR/2004/REC-xmlschema-1-20041028/structures.html#element-schema
+ */
+export declare function assessSchemaElementInstance(root: SyntaxElement, budget: SemanticBudget, options?: Readonly<{
+    signal?: AbortSignal;
+    check?: () => void;
+}>): SchemaElementInstanceResult;