@techspokes/typescript-wsdl-client 1.1.4 → 1.1.5

package/dist/compiler/schemaDatatypeValues.d.ts

@@ -0,0 +1,4 @@
+/** 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/schemaDatatypeValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaDatatypeValues.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaDatatypeValues.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,OAAO,EAAC,cAAc,IAAI,oBAAoB,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,EAAE,gBAAgB,EAAE,aAAa,EAAE,mBAAmB,EAAC,MAAM,qBAAqB,CAAC;AACjL,YAAY,EAAC,cAAc,EAAE,eAAe,IAAI,aAAa,EAAE,kBAAkB,IAAI,gBAAgB,EAAC,MAAM,qBAAqB,CAAC"}

package/dist/compiler/schemaDatatypeValues.js

@@ -0,0 +1,2 @@
+/** Schema-only facade; the neutral calculations confer no receipt authority. */
+export { datatypeValues as schemaDatatypeValues, builtinListItem, builtinParents, integerBounds, builtinPrimitive, whitespaceFor, normalizeWhitespace } from './datatypeValues.js';

package/dist/compiler/schemaDecimalLanguage.d.ts

@@ -0,0 +1,7 @@
+/** Exact regular preimages of decimal value bounds and precision facets. */
+import type { SchemaPatternContext } from './schemaValueContext.js';
+export declare function schemaDecimalLanguages<Owner>(c: SchemaPatternContext<Owner>): {
+    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/schemaDecimalLanguage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaDecimalLanguage.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaDecimalLanguage.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,yBAAyB,CAAC;AAElE,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,CAAC,EAAE,oBAAoB,CAAC,KAAK,CAAC;0BA+C7C,MAAM,WAAW,OAAO,SAAS,KAAK,KAAG,MAAM,GAAG,SAAS;sBAc/D,aAAa,GAAG,gBAAgB,SAAS,MAAM,SAAS,KAAK,KAAG,MAAM;EAahG"}

package/dist/compiler/schemaDecimalLanguage.js

@@ -0,0 +1,102 @@
+export function schemaDecimalLanguages(c) {
+    const join = (branches, owner) => {
+        c.step(owner, branches.length * 3 + 4);
+        for (const branch of branches)
+            c.text(branch, owner);
+        c.step(owner, branches.reduce((length, branch) => length + branch.length + 1, 2));
+        if (!branches.length)
+            throw new TypeError('Decimal branch union requires a nonempty private inventory');
+        return '(' + branches.join('|') + ')';
+    };
+    const emit = (text, owner) => { c.text(text, owner); return text; };
+    const fractional = (digits, greater, owner) => {
+        c.step(owner, digits.length * 4 + 4);
+        const branches = [];
+        for (let index = 0; index < digits.length; index++) {
+            c.step(owner, index * 2 + 30);
+            const digit = Number(digits[index]);
+            if (greater ? digit < 9 : digit > 0)
+                branches.push(emit(digits.slice(0, index)
+                    + (greater ? `[${digit + 1}-9]` : `[0-${digit - 1}]`) + '[0-9]*', owner));
+            // Omitted digits are padded with zeros for value comparison.
+            if (!greater)
+                branches.push(emit(digits.slice(0, index), owner));
+        }
+        if (greater)
+            branches.push(emit(digits + '0*[1-9][0-9]*', owner));
+        return branches;
+    };
+    const magnitude = (canonical, greater, owner) => {
+        c.text(canonical, owner);
+        const [integer, fraction = ''] = canonical.split('.'), branches = [];
+        if (integer !== '0') {
+            const length = integer.length;
+            c.step(owner, length * 4 + 8);
+            if (greater)
+                branches.push(emit(`0*[1-9][0-9]{${length},}([.][0-9]*)?`, owner));
+            else {
+                branches.push('0+([.][0-9]*)?|[.][0-9]+');
+                if (length > 1)
+                    branches.push(emit(`0*[1-9][0-9]{0,${length - 2}}([.][0-9]*)?`, owner));
+            }
+            for (let index = 0; index < length; index++) {
+                c.step(owner, index * 2 + 32);
+                const digit = Number(integer[index]), minimum = index === 0 ? 1 : 0;
+                if (greater ? digit < 9 : digit > minimum)
+                    branches.push(emit('0*' + integer.slice(0, index)
+                        + (greater ? `[${digit + 1}-9]` : `[${minimum}-${digit - 1}]`)
+                        + `[0-9]{${length - index - 1}}([.][0-9]*)?`, owner));
+            }
+        }
+        else if (greater)
+            branches.push('0*[1-9][0-9]*([.][0-9]*)?');
+        const fractions = fractional(fraction, greater, owner);
+        const prefix = integer === '0' ? '0*' : '0*' + integer;
+        if (fractions.length) {
+            const suffix = join(fractions, owner);
+            c.step(owner, prefix.length + suffix.length + 8);
+            branches.push(prefix + '[.]' + suffix);
+        }
+        if (!greater && fraction.length)
+            branches.push(emit(integer === '0' ? '0+' : prefix, owner));
+        return branches;
+    };
+    const relation = (canonical, greater, owner) => {
+        c.text(canonical, owner);
+        const negative = canonical.startsWith('-'), unsigned = negative ? canonical.slice(1) : canonical;
+        if (unsigned === '0')
+            return greater
+                ? '[+]?(0*[1-9][0-9]*([.][0-9]*)?|0*[.]0*[1-9][0-9]*)'
+                : '\\-(0*[1-9][0-9]*([.][0-9]*)?|0*[.]0*[1-9][0-9]*)';
+        const positive = magnitude(unsigned, negative ? !greater : greater, owner);
+        const own = positive.length ? join(positive, owner) : undefined;
+        const branches = [];
+        if (own) {
+            c.step(owner, own.length + 8);
+            branches.push((negative ? '\\-' : '[+]?') + own);
+        }
+        // Opposite signs (including either spelling of zero) need no rounding.
+        if (negative && greater)
+            branches.push('[+]?([0-9]+([.][0-9]*)?|[.][0-9]+)', '\\-(0+([.]0*)?|[.]0+)');
+        if (!negative && !greater)
+            branches.push('\\-([0-9]+([.][0-9]*)?|[.][0-9]+)');
+        return branches.length ? join(branches, owner) : undefined;
+    };
+    const precision = (name, bound, owner) => {
+        c.text(bound, owner);
+        c.step(owner, bound.length ** 2 + 4);
+        if (name === 'fractionDigits')
+            return emit(`[+\\-]?([0-9]+([.][0-9]{0,${bound}}0*)?|[.][0-9]{0,${bound}}0*)`, owner);
+        const maximum = BigInt(bound), branches = ['0+([.]0*)?'];
+        c.step(owner, 32 + bound.length * 2);
+        branches.push(emit(`0*[.][0-9]{0,${bound}}0*`, owner));
+        for (let count = 1n; count <= maximum; count++) {
+            c.step(owner, bound.length * 8 + 40);
+            branches.push(emit(`0*[1-9][0-9]{${count - 1n}}([.][0-9]{0,${maximum - count}}0*)?`, owner));
+        }
+        const expression = join(branches, owner);
+        c.step(owner, expression.length + 10);
+        return '[+\\-]?' + expression;
+    };
+    return { relation, precision };
+}

package/dist/compiler/schemaDeclarationPrimitives.d.ts

@@ -0,0 +1,34 @@
+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 { SemanticContext } from './semanticContext.js';
+import type { AssessedSchemaOperand, ScalarFailure } from './schemaScalarKernel.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+import type { ScalarObligation } from './scalarSchemaAssessment.js';
+import type { IdentityConstraintDependency } from './schemaIdentityConstraints.js';
+export type DeclarationReceipt = Readonly<{
+    kind: 'checked';
+    component: NodeId;
+    contextId: string;
+    authority: 'XSD10-declaration-properties-v1';
+    constraint?: AssessedSchemaOperand;
+    obligations: readonly string[];
+    scalarObligations: readonly ScalarObligation[];
+    typeDependencies: readonly SemanticTypeDependency[];
+    identityConstraintDependencies: readonly IdentityConstraintDependency[];
+}>;
+export type DeclarationResult = DeclarationReceipt | ScalarFailure | ResourceLimitFailure;
+export type DeclarationValuePropertyResult = DeclarationResult | Readonly<{
+    kind: 'checked';
+    component: NodeId;
+    contextId: string;
+    authority: 'XSD10-mixed-value-property-v1' | 'XSD10-source-simple-value-property-v1' | 'XSD10-raw-simple-value-property-v1';
+    constraint: AssessedSchemaOperand;
+    obligations: readonly string[];
+    scalarObligations: readonly ScalarObligation[];
+    typeDependencies: readonly SemanticTypeDependency[];
+}>;
+/** 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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaDeclarationPrimitives.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaDeclarationPrimitives.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAqC,sBAAsB,EAAmC,MAAM,4BAA4B,CAAC;AAC7I,wFAAwF;AACxF,OAAO,KAAK,EAAwC,MAAM,EAAC,MAAM,qBAAqB,CAAC;AAEvF,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AAG1D,OAAO,KAAK,EAAC,qBAAqB,EAAE,aAAa,EAAC,MAAM,yBAAyB,CAAC;AAElF,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,qBAAqB,CAAC;AAG9D,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,6BAA6B,CAAC;AAElE,OAAO,KAAK,EAAC,4BAA4B,EAAC,MAAM,gCAAgC,CAAC;AAEjF,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAC/F,SAAS,EAAE,iCAAiC,CAAC;IAAC,UAAU,CAAC,EAAE,qBAAqB,CAAC;IACjF,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,iBAAiB,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAAC,gBAAgB,EAAC,SAAS,sBAAsB,EAAE,CAAC;IACnI,8BAA8B,EAAE,SAAS,4BAA4B,EAAE,CAAA;CAAC,CAAC,CAAC;AAC5E,MAAM,MAAM,iBAAiB,GAAG,kBAAkB,GAAG,aAAa,GAAG,oBAAoB,CAAC;AAG1F,MAAM,MAAM,8BAA8B,GAAG,iBAAiB,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAC/H,SAAS,EAAE,+BAA+B,GAAG,uCAAuC,GAAG,oCAAoC,CAAC;IAAC,UAAU,EAAE,qBAAqB,CAAC;IAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/L,iBAAiB,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAAC,gBAAgB,EAAE,SAAS,sBAAsB,EAAE,CAAA;CAAC,CAAC,CAAC;AAkBxG,uGAAuG;AACvG,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,8BAA8B,CA+BlH;AACD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,iBAAiB,CA0FxF"}

package/dist/compiler/schemaDeclarationPrimitives.js

@@ -0,0 +1,194 @@
+import { assertSemanticContext } from './semanticContext.js';
+import { isXmlNCName, XSD_NAMESPACE } from '../loader/orderedSyntax.js';
+import { createSchemaScalarKernel } from './schemaScalarKernel.js';
+import { checkSubstitution, declarationMethods, RelationProblem } from './schemaTypeRelations.js';
+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;
+/** 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;
+    if (constraint.kind !== 'default' && constraint.kind !== 'fixed')
+        return context.budget.freeze(context.budget.snapshot({ kind: 'invalid-schema',
+            rule: 'declaration-value', component: node.id, message: 'Value constraint must be default or fixed', source: node.context.source }));
+    const scalar = createSchemaScalarKernel(context), checked = scalar.checkValue(reference, constraint, node.id);
+    if (checked.kind !== 'checked')
+        return checked;
+    const assessed = scalar.assess(reference, constraint.lexical, node.id);
+    if (assessed.kind !== 'checked')
+        return assessed;
+    const typed = collectSemanticTypeDependencies(context);
+    typed.add(checked.typeDependencies);
+    typed.add(assessed.typeDependencies);
+    context.budget.chargeWork(4 + checked.obligations.length + assessed.obligations.length);
+    return Object.freeze({ kind: 'checked', constraint: assessed.value,
+        scalarObligations: Object.freeze([...checked.obligations, ...assessed.obligations]), typeDependencies: typed.snapshot() });
+}
+/** VALUE properties select actual scalar/fact support; full declaration validity has its own owner. */
+export function checkDeclarationValueProperty(context, id) {
+    assertSemanticContext(context);
+    return context.budget.guard(() => {
+        context.budget.chargeWork(8 + id.length);
+        const found = context.lookup(id);
+        if (found.kind !== 'found' || found.node.kind !== 'element' || !found.node.value)
+            return checkDeclaration(context, id);
+        const node = found.node, declared = declaredType(context, node), type = resolveSemanticType(context, declared);
+        if (type.kind !== 'component' || type.node.kind !== 'complexType')
+            return checkDeclaration(context, id);
+        const raw = context.rawTypeProperties(type.node.id), source = context.sourceNode(type.node.id);
+        const sourceSimple = !raw && source?.kind === 'complexType' && source.derivation?.contentKind === 'simple'
+            && (context.originalComplexContentSource(type.node.id) !== undefined || context.originalComplexPropertySource(type.node.id) !== undefined);
+        const rawSimple = raw?.content.kind === 'simple' ? raw.content : undefined;
+        if (rawSimple) {
+            const selected = resolveSemanticType(context, rawSimple.type);
+            if (selected.kind === 'missing' || selected.kind === 'outside-context')
+                return context.budget.freeze(context.budget.snapshot({ kind: 'unresolved', rule: 'src-resolve', component: type.node.id,
+                    message: 'Simple content datatype is unavailable', source: type.node.context.source }));
+            if (!(selected.kind === 'builtin' && selected.name.local !== 'anyType' || selected.kind === 'original-generated'
+                || selected.kind === 'component' && selected.node.kind === 'simpleType'))
+                return context.budget.freeze(context.budget.snapshot({ kind: 'invalid-schema', rule: 'raw-type-content-role', component: type.node.id,
+                    message: 'Simple content requires an actual simple datatype', source: type.node.context.source }));
+        }
+        const mixed = raw ? raw.content.kind === 'mixed' : source?.kind === 'complexType' && source.mixed && source.derivation?.contentKind !== 'simple';
+        if (!sourceSimple && !rawSimple && !mixed)
+            return checkDeclaration(context, id);
+        const value = constraintValue(context, node, rawSimple?.type ?? (sourceSimple ? declared : { kind: 'builtin', name: { namespace: XSD_NAMESPACE, local: 'string' } }));
+        if (value.kind !== 'checked')
+            return value;
+        return context.budget.freeze(context.budget.snapshot({ kind: 'checked', component: id, contextId: context.contextId,
+            authority: rawSimple ? 'XSD10-raw-simple-value-property-v1' : sourceSimple ? 'XSD10-source-simple-value-property-v1' : 'XSD10-mixed-value-property-v1',
+            constraint: value.constraint, obligations: sourceSimple || rawSimple ? [] : ['element-default-mixed-emptiable:' + type.node.id],
+            scalarObligations: value.scalarObligations, typeDependencies: value.typeDependencies }));
+    });
+}
+export function checkDeclaration(context, id) {
+    assertSemanticContext(context);
+    return context.budget.guard(() => {
+        const lookup = context.lookup(id);
+        if (lookup.kind !== 'found')
+            return context.budget.freeze(context.budget.snapshot({ kind: 'unresolved', rule: 'declaration-operand', component: id, message: 'Declaration is outside the authenticated context' }));
+        const node = lookup.node;
+        const fail = (rule, message, kind = 'invalid-schema') => context.budget.freeze(context.budget.snapshot({ kind, rule, message, component: id, source: node.context.source }));
+        if (node.kind !== 'attribute' && node.kind !== 'element')
+            return fail('declaration-kind', 'Expected an element or attribute declaration');
+        context.budget.chargeWork(32 + node.name.local.length + node.name.namespace.length + node.declaredAttributes.length * 8);
+        if (!isXmlNCName(node.name.local))
+            return fail('declaration-name', 'Declaration name must be an XML NCName');
+        if (node.kind === 'element' && (typeof node.abstract !== 'boolean' || typeof node.nillable !== 'boolean'))
+            return fail('e-props-correct', 'Abstract and nillable properties must be booleans');
+        if (node.value && node.value.kind !== 'default' && node.value.kind !== 'fixed')
+            return fail('declaration-value', 'Value constraint must be default or fixed');
+        if (node.kind === 'attribute' && node.name.namespace === 'http://www.w3.org/2001/XMLSchema-instance')
+            return fail('a-props-correct', 'Attribute declarations cannot target the XML Schema instance namespace');
+        if (node.name.namespace === 'http://www.w3.org/2000/xmlns/' || node.kind === 'attribute' && node.name.local === 'xmlns')
+            return fail('a-props-correct', 'The namespace declaration name is forbidden');
+        if (context.sourceNode(node.id)) {
+            if (nameAttribute(node, 'default') !== undefined && nameAttribute(node, 'fixed') !== undefined)
+                return fail('src-declaration', 'Default and fixed are mutually exclusive');
+            if (nameAttribute(node, 'ref') !== undefined && nameAttribute(node, 'name') !== undefined)
+                return fail('src-declaration', 'Name and ref are mutually exclusive');
+            if (nameAttribute(node, 'type') !== undefined && node.type.kind === 'local')
+                return fail('src-declaration', 'Type and anonymous type are mutually exclusive');
+            for (const property of node.kind === 'element' ? ['abstract', 'nillable'] : []) {
+                const value = nameAttribute(node, property);
+                if (value !== undefined && !['true', 'false', '0', '1'].includes(value.replace(/[\t\r\n ]+/g, ' ').replace(/^ | $/g, '')))
+                    return fail('boolean-lexical', `Invalid ${property} boolean`);
+            }
+            if (node.identity.kind !== 'global') {
+                if (nameAttribute(node, 'substitutionGroup') !== undefined || nameAttribute(node, 'abstract') !== undefined || nameAttribute(node, 'final') !== undefined)
+                    return fail('src-element', 'Local declaration has a global-only property');
+            }
+        }
+        let identityConstraintDependencies = [];
+        if (node.kind === 'element') {
+            const constraints = readElementIdentityConstraints(context, id);
+            if (constraints.kind !== 'checked')
+                return constraints;
+            identityConstraintDependencies = constraints.identityConstraintDependencies;
+        }
+        const type = declaredType(context, node), selected = resolveSemanticType(context, type);
+        const typed = collectSemanticTypeDependencies(context);
+        if (selected.kind === 'component' || selected.kind === 'builtin' || selected.kind === 'original-generated')
+            typed.add([{ contextId: context.contextId, type: selected.identity }]);
+        if (selected.kind !== 'component' && selected.kind !== 'builtin' && selected.kind !== 'original-generated')
+            return fail('src-resolve', 'Declared type is unavailable', 'unresolved');
+        if (selected.kind === 'component' && selected.node.kind !== 'simpleType' && selected.node.kind !== 'complexType')
+            return fail('declared-type', 'Reference does not name a type');
+        if (node.kind === 'attribute' && (selected.kind === 'builtin' && selected.name.local === 'anyType' || selected.kind === 'component' && selected.node.kind === 'complexType'))
+            return fail('a-props-correct.2', 'Attribute declarations require a simple type');
+        if (node.kind === 'element') {
+            try {
+                declarationMethods(context, node, 'final');
+                declarationMethods(context, node, 'block');
+            }
+            catch (error) {
+                if (error instanceof RelationProblem)
+                    return fail(error.result.rule, error.message, error.result.kind === 'unresolved' ? 'unresolved' : 'invalid-schema');
+                throw error;
+            }
+            if (node.substitutionGroup) {
+                const head = context.resolve(node.substitutionGroup);
+                if (head.kind !== 'found' || head.node.kind !== 'element')
+                    return fail('e-props-correct.4', 'Affiliation head is unavailable', 'unresolved');
+                if (node.identity.kind !== 'global' || head.node.identity.kind !== 'global')
+                    return fail('e-props-correct.4', 'Affiliation requires global element declarations');
+                const relation = checkSubstitution(context, node.id, head.node.id, { mode: 'affiliation' });
+                if (relation.kind === 'resource-limit')
+                    return relation;
+                if (relation.kind !== 'checked')
+                    return fail(relation.rule, relation.message, 'unresolved');
+                typed.add(relation.typeDependencies);
+                if (!relation.value)
+                    return fail('e-props-correct.4', 'Immediate affiliation type relation is not satisfied');
+            }
+        }
+        const scalar = createSchemaScalarKernel(context), obligations = ['declared-type-component-validity'], scalarObligations = [];
+        const remember = (required) => {
+            context.budget.chargeWork(required.length * 8 + 1);
+            for (const obligation of required) {
+                context.budget.chargeWork(scalarObligations.length + 1);
+                if (!scalarObligations.some(prior => prior.rule === obligation.rule && prior.component === obligation.component && (prior.contextId ?? context.contextId) === (obligation.contextId ?? context.contextId)))
+                    scalarObligations.push(obligation);
+            }
+        };
+        if (selected.kind === 'original-generated' || selected.kind === 'builtin' && selected.name.local !== 'anyType' || selected.kind === 'component' && selected.node.kind === 'simpleType') {
+            const description = scalar.describe(type, node.id);
+            if (description.kind !== 'checked')
+                return description;
+            if (description.value.primitive === 'NOTATION' && !description.value.layers.some(layer => layer.facets.some(facet => facet.name === 'enumeration')))
+                return fail('enumeration-required-notation', 'NOTATION cannot be used directly as a declared datatype');
+            remember(description.obligations);
+            typed.add(description.typeDependencies);
+        }
+        let constraint;
+        if (node.value) {
+            let reference = type;
+            if (selected.kind === 'builtin' && selected.name.local === 'anyType')
+                reference = { kind: 'builtin', name: { namespace: XSD_NAMESPACE, local: 'anySimpleType' } };
+            else if (selected.kind === 'component' && selected.node.kind === 'complexType') {
+                const raw = context.rawTypeProperties(selected.node.id);
+                if (!raw && !context.sourceNode(selected.node.id))
+                    return fail('missing-type-component-properties', 'Abstract helper type requires explicit component properties', 'unresolved');
+                const simple = raw ? raw.content.kind === 'simple' : selected.node.derivation?.contentKind === 'simple';
+                if (!simple) {
+                    if (!(raw ? raw.content.kind === 'mixed' : selected.node.mixed))
+                        return fail('e-props-correct.2', 'Element value constraints require simple or mixed content');
+                    obligations.push('element-default-mixed-emptiable:' + selected.node.id);
+                    reference = { kind: 'builtin', name: { namespace: XSD_NAMESPACE, local: 'string' } };
+                }
+            }
+            const value = constraintValue(context, node, reference);
+            if (value.kind !== 'checked')
+                return value;
+            constraint = value.constraint;
+            remember(value.scalarObligations);
+            typed.add(value.typeDependencies);
+        }
+        const owned = context.budget.freeze(context.budget.snapshot({ kind: 'checked', component: id, contextId: context.contextId,
+            authority: 'XSD10-declaration-properties-v1', constraint, obligations, scalarObligations }));
+        const typeDependencies = typed.snapshot();
+        context.budget.chargeWork(24);
+        return Object.freeze({ ...owned, typeDependencies, identityConstraintDependencies });
+    });
+}

package/dist/compiler/schemaDocumentSyntax.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Original parsed schema documents; never a hypothetical-schema validity receipt.
+ * Checked means document representation plus the fixed S4S instance episode;
+ * explicit imported-XML prerequisites and component construction remain separate.
+ * Primary 2004 Structures: declare-schema, src-import, declare-notation,
+ * Notation_Declaration_details, no-identity, declare-annotation and sch-props-correct/c-nmd.
+ * S4S grammar corroboration: dgis/xsddiagram@9aedeb7dedfdd2fcd6bf916345499468dd4aa931,
+ * XSD/XMLSchema.xsd (e767a159c179bd6e4dc2bac2a63a62f50cbd027ec19d6b5cc9eb1c2f33e0cb2e).
+ * The complete grammar was independently compared to the dated REC Appendix A
+ * Structures/Datatypes text. Imported XML version prerequisites stay explicit.
+ */
+import type { SchemaInput } from '../loader/schemaInput.js';
+import type { SyntaxSource } from '../loader/orderedSyntax.js';
+import type { SemanticLimits } from './resolveCanonicalGraph.js';
+import type { SemanticContext, SemanticPreparation } from './semanticContext.js';
+import type { SemanticBudget, ResourceLimitFailure } from './semanticBudget.js';
+import type { SourceWildcardObligation } from './schemaSourceWildcards.js';
+import type { SourcePreparationFailure } from './sourceSchemaBinding.js';
+export type { SourcePreparationFailure } from './sourceSchemaBinding.js';
+export type SourceSchemaPreparation = SemanticPreparation | SourcePreparationFailure;
+type RemainingDocumentObligation = 'child-component-syntax' | 'semantic-construction' | 'foreign-attribute-assessment' | 'annotation-payload-assessment' | 'namespace-interpretation';
+export type SchemaDocumentResult = Readonly<{
+    kind: 'checked';
+    authority: 'XSD10-schema-document-syntax-v1';
+    scope: 'schema-document-source-syntax';
+    contextId: string;
+    sources: readonly Readonly<{
+        key: string;
+        digest: string;
+        source: SyntaxSource;
+    }>[];
+    remaining: readonly RemainingDocumentObligation[];
+    wildcardObligations: readonly SourceWildcardObligation[];
+}> | Readonly<{
+    kind: 'invalid-schema' | 'unsupported-capability';
+    rule: string;
+    message: string;
+    source: SyntaxSource;
+}> | Readonly<{
+    kind: 'unresolved';
+    rule: 'actual-source-only' | 'missing-source-syntax';
+}> | ResourceLimitFailure;
+/**
+ * One issued input snapshot owns both graph construction and retained source syntax.
+ * Loading happened before entry. Canonical construction/reference resolution retain
+ * their named legacy limits; the snapshot/context/syntax share the supplied budget.
+ */
+export declare function prepareSourceSchemaRequest(input: SchemaInput, options?: Readonly<{
+    budget?: SemanticBudget;
+    sourceLimits?: SemanticLimits;
+    accountPreparation?: true;
+}>): 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/schemaDocumentSyntax.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaDocumentSyntax.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaDocumentSyntax.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAC,WAAW,EAAuB,MAAM,0BAA0B,CAAC;AAEhF,OAAO,KAAK,EAAgB,YAAY,EAAC,MAAM,4BAA4B,CAAC;AAC5E,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,4BAA4B,CAAC;AAE/D,OAAO,KAAK,EAAC,eAAe,EAAE,mBAAmB,EAAC,MAAM,sBAAsB,CAAC;AAE/E,OAAO,KAAK,EAAC,cAAc,EAAE,oBAAoB,EAAC,MAAM,qBAAqB,CAAC;AAI9E,OAAO,KAAK,EAAC,wBAAwB,EAAC,MAAM,4BAA4B,CAAC;AAIzE,OAAO,KAAK,EAAC,wBAAwB,EAAC,MAAM,0BAA0B,CAAC;AAEvE,YAAY,EAAC,wBAAwB,EAAC,MAAM,0BAA0B,CAAC;AACvE,MAAM,MAAM,uBAAuB,GAAG,mBAAmB,GAAG,wBAAwB,CAAC;AACrF,KAAK,2BAA2B,GAAG,wBAAwB,GAAG,uBAAuB,GACnF,8BAA8B,GAAG,+BAA+B,GAAG,0BAA0B,CAAC;AAChG,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C,IAAI,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,iCAAiC,CAAC;IAAC,KAAK,EAAE,+BAA+B,CAAC;IACtG,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,SAAS,QAAQ,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,YAAY,CAAA;KAAC,CAAC,EAAE,CAAC;IACrG,SAAS,EAAE,SAAS,2BAA2B,EAAE,CAAC;IAClD,mBAAmB,EAAE,SAAS,wBAAwB,EAAE,CAAC;CAC1D,CAAC,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,gBAAgB,GAAG,wBAAwB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAC,CAAC,GACnH,QAAQ,CAAC;IAAC,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,oBAAoB,GAAG,uBAAuB,CAAA;CAAC,CAAC,GAAG,oBAAoB,CAAC;AAIhH;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,GAAE,QAAQ,CAAC;IAC/E,MAAM,CAAC,EAAE,cAAc,CAAC;IAAC,YAAY,CAAC,EAAE,cAAc,CAAC;IAAC,kBAAkB,CAAC,EAAE,IAAI,CAAC;CACnF,CAAM,GAAG,uBAAuB,CAYhC;AAUD,sGAAsG;AACtG,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,eAAe,GAAG,oBAAoB,CAkLxF"}