@techspokes/typescript-wsdl-client 1.1.5 → 1.1.8

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;

package/dist/compiler/schemaElementInstance.js

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

package/dist/compiler/schemaElementProperties.d.ts

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

package/dist/compiler/schemaEndpointWordCapacity.d.ts

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

package/dist/compiler/schemaExactCalendar.d.ts

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

package/dist/compiler/schemaFacetAnnotation.d.ts

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

package/dist/compiler/schemaGeneratedScalarShape.d.ts

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

package/dist/compiler/schemaGeneratedScalarShape.js

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

package/dist/compiler/schemaIdentityConstraints.d.ts

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

package/dist/compiler/schemaIeeeLanguage.d.ts

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

package/dist/compiler/schemaIntegerImages.d.ts

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

package/dist/compiler/schemaLexicalPredicates.d.ts

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

package/dist/compiler/schemaNotationProperties.d.ts

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

package/dist/compiler/schemaNumericImageConditions.d.ts

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

package/dist/compiler/schemaParticleWildcardProperties.d.ts

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

package/dist/compiler/schemaPattern.d.ts

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

package/dist/compiler/schemaRegularLanguage.d.ts

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

package/dist/compiler/schemaScalarContext.d.ts

@@ -34,9 +34,14 @@ export declare function schemaScalarContext(context: SemanticContext): {
         lookupNotation(name: import("../loader/orderedSyntax.js").ExpandedName): import("./semanticContext.js").ContextNotationLookup;
         originalIdentityConstraints(): import("./schemaIdentityConstraints.js").OriginalIdentityConstraintRegistry;
         lookup(id: NodeId): import("./semanticContext.js").ContextLookup;
+        standardElement(id: NodeId): import("./standardSchemaComponents.js").StandardSchemaElementDeclaration | undefined;
+        standardLibraryIds(): readonly string[];
         ownTypeReference(reference: import("./semanticTypeReference.js").SemanticTypeReference): import("./semanticTypeReference.js").SemanticTypeReference;
         resolve(reference: Reference): import("./semanticContext.js").ContextResolution;
         sourceNode(id: NodeId): GraphNode | undefined;
+        originalDeclarationSource(id: NodeId): Extract<GraphNode, {
+            kind: "element" | "attribute";
+        }> | undefined;
         originalSourceComponentAbsent(id: NodeId): boolean;
         originalComplexPropertySource(id: NodeId): import("./canonicalGraph.js").ComplexTypeNode | undefined;
         originalComplexContentSource(id: NodeId): import("./canonicalGraph.js").ComplexTypeNode | undefined;
@@ -78,4 +83,3 @@ export declare function schemaScalarContext(context: SemanticContext): {
     };
 };
 export type AssessmentContext = ReturnType<typeof schemaScalarContext>;
-//# sourceMappingURL=schemaScalarContext.d.ts.map

package/dist/compiler/schemaScalarKernel.d.ts

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

package/dist/compiler/schemaScalarWitnesses.d.ts

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

package/dist/compiler/schemaSimpleTypeProperties.d.ts

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

package/dist/compiler/schemaSourceGrammar.d.ts

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

package/dist/compiler/schemaSourceLexical.d.ts

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

package/dist/compiler/schemaSourceValues.d.ts

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

package/dist/compiler/schemaSourceWildcards.d.ts

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

package/dist/compiler/schemaSourceWildcards.js

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

package/dist/compiler/schemaSymbolicSequences.d.ts

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

package/dist/compiler/schemaSymbolicValueSets.d.ts

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

package/dist/compiler/schemaSyntaxAssessment.d.ts

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

package/dist/compiler/schemaTemporalAliases.d.ts

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

package/dist/compiler/schemaTokenImages.d.ts

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

package/dist/compiler/schemaTypeIdentity.d.ts

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

package/dist/compiler/schemaTypeIdentity.js

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

package/dist/compiler/schemaTypeRelations.d.ts

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

package/dist/compiler/schemaUri.d.ts

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

package/dist/compiler/schemaValueContext.d.ts

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

package/dist/compiler/schemaValueImages.d.ts

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

package/dist/compiler/schemaValueSequences.d.ts

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