@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/schemaSimpleTypeProperties.js

@@ -0,0 +1,103 @@
+import { assertSemanticTypeReferenceShape } from './semanticTypeReference.js';
+import { validateFacetAnnotation } from './schemaFacetAnnotation.js';
+const object = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const facetNames = ['length', 'minLength', 'maxLength', 'pattern', 'enumeration', 'whiteSpace', 'maxInclusive', 'maxExclusive', 'minInclusive', 'minExclusive', 'totalDigits', 'fractionDigits'];
+export function validateRawSimpleTypeShape(value, budget) {
+    budget.chargeWork(16);
+    if (!object(value) || typeof value.type !== 'string' || !object(value.base) || !Array.isArray(value.final) || !object(value.variety))
+        return false;
+    assertSemanticTypeReferenceShape(value.base, budget);
+    const binding = value.facetBinding;
+    const exact = value.facetComponentSet;
+    if (binding !== undefined) {
+        if (value.facetLayers !== undefined || exact !== undefined || !object(binding) || binding.kind !== 'original')
+            return false;
+        assertSemanticTypeReferenceShape(binding.type, budget);
+    }
+    else if (exact !== undefined ? value.facetLayers !== undefined || !Array.isArray(exact) : !Array.isArray(value.facetLayers))
+        return false;
+    const layers = binding !== undefined ? [] : (exact ?? value.facetLayers);
+    if (value.targetNamespace !== undefined && typeof value.targetNamespace !== 'string')
+        return false;
+    budget.chargeWork(value.type.length + value.final.length * 4 + layers.length * 4);
+    if (value.final.some(method => !['restriction', 'list', 'union'].includes(method)))
+        return false;
+    if (!['atomic', 'list', 'union'].includes(value.variety.kind))
+        return false;
+    if (value.variety.kind === 'list' && !object(value.variety.item) || value.variety.kind === 'union' && !Array.isArray(value.variety.members))
+        return false;
+    if (value.variety.kind === 'list')
+        assertSemanticTypeReferenceShape(value.variety.item, budget);
+    if (value.variety.kind === 'union')
+        for (const member of value.variety.members)
+            assertSemanticTypeReferenceShape(member, budget);
+    for (const layer of layers) {
+        budget.chargeWork(4);
+        if (!object(layer))
+            return false;
+        if (exact !== undefined && !('facets' in layer)) {
+            const pattern = Object.getOwnPropertyDescriptor(layer, 'builtinPattern');
+            if (pattern) {
+                if ('baseComponent' in layer || 'annotation' in layer || !('value' in pattern) || !object(pattern.value))
+                    return false;
+                const name = Object.getOwnPropertyDescriptor(pattern.value, 'name'), index = Object.getOwnPropertyDescriptor(pattern.value, 'index');
+                if (!name || !('value' in name) || typeof name.value !== 'string' || !name.value
+                    || !index || !('value' in index) || !Number.isSafeInteger(index.value) || index.value < 0)
+                    return false;
+                budget.chargeWork(name.value.length + 32);
+                continue;
+            }
+            const selected = Object.getOwnPropertyDescriptor(layer, 'baseComponent');
+            if ('annotation' in layer || !selected || !('value' in selected)
+                || !Number.isSafeInteger(selected.value) || selected.value < 0)
+                return false;
+            continue;
+        }
+        if (!Array.isArray(layer.facets) || exact !== undefined && !layer.facets.length)
+            return false;
+        if (exact !== undefined && 'builtinPattern' in layer)
+            return false;
+        budget.chargeWork(layer.facets.length * 4);
+        if (exact !== undefined) {
+            const first = layer.facets[0];
+            if (!object(first) || typeof first.name !== 'string'
+                || layer.facets.some((facet) => !object(facet) || facet.name !== first.name)
+                || layer.facets.length > 1 && !['pattern', 'enumeration'].includes(first.name))
+                return false;
+            const annotation = Object.getOwnPropertyDescriptor(layer, 'annotation');
+            if (annotation && (!('value' in annotation) || annotation.value !== undefined
+                && !validateFacetAnnotation(annotation.value, budget)))
+                return false;
+        }
+        for (const facet of layer.facets) {
+            budget.chargeWork(8);
+            if (!object(facet) || !facetNames.includes(facet.name) || typeof facet.fixed !== 'boolean' || !object(facet.lexical) || typeof facet.lexical.value !== 'string' || !object(facet.lexical.context) || !object(facet.lexical.context.namespaces) || !object(facet.lexical.context.source))
+                return false;
+            budget.chargeWork(56);
+            const annotation = Object.getOwnPropertyDescriptor(facet, 'annotation');
+            if (annotation && (!('value' in annotation) || annotation.value !== undefined &&
+                (exact !== undefined || annotation.value !== 'absent')))
+                return false;
+            if (facet.operand !== undefined && (!object(facet.operand) || !object(facet.operand.type) || typeof facet.operand.owner !== 'string' || !['original', 'active'].includes(facet.operand.context)))
+                return false;
+            if (facet.operand !== undefined && !['enumeration', 'minInclusive', 'minExclusive', 'maxInclusive', 'maxExclusive'].includes(facet.name))
+                return false;
+            if (facet.operand !== undefined)
+                assertSemanticTypeReferenceShape(facet.operand.type, budget);
+            budget.chargeWork(facet.lexical.value.length + 4);
+            for (const namespace in facet.lexical.context.namespaces) {
+                budget.chargeWork(namespace.length + 1);
+                if (typeof facet.lexical.context.namespaces[namespace] !== 'string')
+                    return false;
+            }
+        }
+    }
+    if (!object(value.provenance))
+        return false;
+    if (value.provenance.kind === 'actual-mapped')
+        return typeof value.provenance.original === 'string';
+    if (value.provenance.kind !== 'hypothetical-abstract' || !Array.isArray(value.provenance.originals))
+        return false;
+    budget.chargeWork(value.provenance.originals.length + 1);
+    return value.provenance.originals.every(id => typeof id === 'string');
+}

package/dist/compiler/schemaSourceGrammar.d.ts

@@ -0,0 +1,26 @@
+import type { ExpandedName, SyntaxElement, SyntaxSource } from '../loader/orderedSyntax.js';
+import type { SemanticBudget } from './semanticBudget.js';
+export type SourceGrammarRole = 'schema' | 'include' | 'import' | 'redefine' | 'annotation' | 'appinfo' | 'documentation' | 'openAttrs' | 'annotated' | 'anyType' | 'complexType' | 'topLevelComplexType' | 'localComplexType' | 'complexContent' | 'simpleContent' | 'restrictionType' | 'complexRestrictionType' | 'extensionType' | 'simpleRestrictionType' | 'simpleExtensionType' | 'simpleType' | 'topLevelSimpleType' | 'localSimpleType' | 'restriction' | 'list' | 'union' | 'element' | 'topLevelElement' | 'localElement' | 'narrowMaxMin' | 'attribute' | 'topLevelAttribute' | 'attributeGroup' | 'namedAttributeGroup' | 'attributeGroupRef' | 'group' | 'realGroup' | 'namedGroup' | 'groupRef' | 'explicitGroup' | 'simpleExplicitGroup' | 'all' | 'localAll' | 'wildcard' | 'any' | 'selector' | 'field' | 'keybase' | 'keyref' | 'notation' | 'facet' | 'noFixedFacet' | 'numFacet' | 'totalDigits' | 'whiteSpace' | 'pattern';
+export declare function globalSourceRole(name: ExpandedName): SourceGrammarRole | undefined;
+export declare function namedSourceRole(name: ExpandedName): SourceGrammarRole | undefined;
+export declare function sourceRoleTypeName(role: SourceGrammarRole): string | undefined;
+export declare function abstractSourceRole(role: SourceGrammarRole): boolean;
+export type SourceGrammarResult = Readonly<{
+    kind: 'checked';
+    hasIdAttributeUse: boolean;
+    attributes: readonly Readonly<{
+        index: number;
+        type: string;
+    }>[];
+    children: readonly Readonly<{
+        index: number;
+        role?: SourceGrammarRole;
+    }>[];
+}> | Readonly<{
+    kind: 'invalid-schema';
+    rule: 'schema-for-schemas';
+    message: string;
+    source: SyntaxSource;
+}>;
+/** Immediate clauses only. The owned walk preserves roles, values and all scopes. */
+export declare function assessSourceGrammar(role: SourceGrammarRole, node: SyntaxElement, budget: SemanticBudget): SourceGrammarResult;

package/dist/compiler/schemaSourceGrammar.js

@@ -0,0 +1,290 @@
+/** Closed contextual grammar of the dated 2004 Structures/Datatypes S4S. */
+import { XSD_NAMESPACE } from '../loader/orderedSyntax.js';
+const id = { id: 'ID' }, occurs = { minOccurs: 'nonNegativeInteger', maxOccurs: 'allNNI' };
+const complexAttrs = { ...id, name: 'NCName', mixed: 'boolean', abstract: 'boolean', final: 'derivationSet', block: 'derivationSet' };
+const commonElement = { ...id, name: 'NCName', type: 'QName', default: 'string', fixed: 'string', nillable: 'boolean', block: 'blockSet' };
+const localElement = { ...commonElement, ref: 'QName', form: 'formChoice', ...occurs };
+const attribute = { ...id, name: 'NCName', ref: 'QName', type: 'QName', use: '#use', default: 'string', fixed: 'string', form: 'formChoice' };
+const wild = { ...id, namespace: 'namespaceList', processContents: '#process' };
+const facet = { ...id, value: 'anySimpleType', fixed: 'boolean' };
+const roles = Object.freeze({
+    schema: { attrs: { ...id, targetNamespace: 'anyURI', version: 'token', finalDefault: 'fullDerivationSet', blockDefault: 'blockSet',
+            attributeFormDefault: 'formChoice', elementFormDefault: 'formChoice' }, model: 'schema' },
+    include: { attrs: { ...id, schemaLocation: 'anyURI' }, required: ['schemaLocation'], annotation: true, model: 'none' },
+    import: { attrs: { ...id, namespace: 'anyURI', schemaLocation: 'anyURI' }, annotation: true, model: 'none' },
+    redefine: { attrs: { ...id, schemaLocation: 'anyURI' }, required: ['schemaLocation'], model: 'redefine' },
+    annotation: { attrs: id, model: 'annotation' },
+    appinfo: { attrs: { source: 'anyURI' }, model: 'mixed' }, documentation: { attrs: { source: 'anyURI' }, model: 'mixed' },
+    openAttrs: { attrs: {}, model: 'none', empty: true, typeName: 'openAttrs' },
+    annotated: { attrs: id, model: 'none', annotation: true, typeName: 'annotated' },
+    anyType: { attrs: {}, model: 'mixed', typeName: 'anyType' },
+    complexType: { attrs: complexAttrs, annotation: true, model: 'complex', abstract: true, typeName: 'complexType' },
+    topLevelComplexType: { attrs: complexAttrs, required: ['name'], annotation: true, model: 'complex', typeName: 'topLevelComplexType' },
+    localComplexType: { attrs: { ...id, mixed: 'boolean' }, annotation: true, model: 'complex', typeName: 'localComplexType' },
+    complexContent: { attrs: { ...id, mixed: 'boolean' }, annotation: true, model: 'complexContent' },
+    simpleContent: { attrs: id, annotation: true, model: 'simpleContent' },
+    restrictionType: { attrs: { ...id, base: 'QName' }, required: ['base'], annotation: true, model: 'restrictionType', typeName: 'restrictionType' },
+    complexRestrictionType: { attrs: { ...id, base: 'QName' }, required: ['base'], annotation: true, model: 'particleAttrs', typeName: 'complexRestrictionType' },
+    extensionType: { attrs: { ...id, base: 'QName' }, required: ['base'], annotation: true, model: 'particleAttrs', typeName: 'extensionType' },
+    simpleRestrictionType: { attrs: { ...id, base: 'QName' }, required: ['base'], annotation: true, model: 'simpleAttrs', typeName: 'simpleRestrictionType' },
+    simpleExtensionType: { attrs: { ...id, base: 'QName' }, required: ['base'], annotation: true, model: 'attrs', typeName: 'simpleExtensionType' },
+    simpleType: { attrs: { ...id, name: 'NCName', final: 'simpleDerivationSet' }, annotation: true, model: 'simple', abstract: true, typeName: 'simpleType' },
+    topLevelSimpleType: { attrs: { ...id, name: 'NCName', final: 'simpleDerivationSet' }, required: ['name'], annotation: true, model: 'simple', typeName: 'topLevelSimpleType' },
+    localSimpleType: { attrs: id, annotation: true, model: 'simple', typeName: 'localSimpleType' },
+    restriction: { attrs: { ...id, base: 'QName' }, annotation: true, model: 'restriction' },
+    list: { attrs: { ...id, itemType: 'QName' }, annotation: true, model: 'list' },
+    union: { attrs: { ...id, memberTypes: '#qnames' }, annotation: true, model: 'union' },
+    element: { attrs: { ...localElement, substitutionGroup: 'QName', abstract: 'boolean', final: 'derivationSet' }, annotation: true,
+        model: 'element', abstract: true, typeName: 'element' },
+    topLevelElement: { attrs: { ...commonElement, substitutionGroup: 'QName', abstract: 'boolean', final: 'derivationSet' }, required: ['name'],
+        annotation: true, model: 'element', typeName: 'topLevelElement' },
+    localElement: { attrs: localElement, annotation: true, model: 'element', typeName: 'localElement' },
+    narrowMaxMin: { attrs: { ...localElement, minOccurs: '#zeroOne', maxOccurs: '#maxZeroOne' }, annotation: true, model: 'element', typeName: 'narrowMaxMin' },
+    attribute: { attrs: attribute, annotation: true, model: 'attribute', typeName: 'attribute' },
+    topLevelAttribute: { attrs: { ...id, name: 'NCName', type: 'QName', default: 'string', fixed: 'string' }, required: ['name'],
+        annotation: true, model: 'attribute', typeName: 'topLevelAttribute' },
+    attributeGroup: { attrs: { ...id, name: 'NCName', ref: 'QName' }, annotation: true, model: 'attrs', abstract: true, typeName: 'attributeGroup' },
+    namedAttributeGroup: { attrs: { ...id, name: 'NCName' }, required: ['name'], annotation: true, model: 'attrs', typeName: 'namedAttributeGroup' },
+    attributeGroupRef: { attrs: { ...id, ref: 'QName' }, required: ['ref'], annotation: true, model: 'none', typeName: 'attributeGroupRef' },
+    group: { attrs: { ...id, name: 'NCName', ref: 'QName', ...occurs }, annotation: true, model: 'group', abstract: true, typeName: 'group' },
+    realGroup: { attrs: { ...id, name: 'NCName', ref: 'QName', ...occurs }, annotation: true, model: 'realGroup', typeName: 'realGroup' },
+    namedGroup: { attrs: { ...id, name: 'NCName' }, required: ['name'], annotation: true, model: 'namedGroup', typeName: 'namedGroup' },
+    groupRef: { attrs: { ...id, ref: 'QName', ...occurs }, required: ['ref'], annotation: true, model: 'none', typeName: 'groupRef' },
+    explicitGroup: { attrs: { ...id, ...occurs }, annotation: true, model: 'explicitGroup', typeName: 'explicitGroup' },
+    simpleExplicitGroup: { attrs: id, annotation: true, model: 'explicitGroup', typeName: 'simpleExplicitGroup' },
+    all: { attrs: { ...id, minOccurs: '#zeroOne', maxOccurs: '#maxOne' }, annotation: true, model: 'all', typeName: 'all' },
+    localAll: { attrs: id, annotation: true, model: 'all' },
+    wildcard: { attrs: wild, annotation: true, model: 'none', typeName: 'wildcard' },
+    any: { attrs: { ...wild, ...occurs }, annotation: true, model: 'none' },
+    selector: { attrs: { ...id, xpath: '#selector' }, required: ['xpath'], annotation: true, model: 'none' },
+    field: { attrs: { ...id, xpath: '#field' }, required: ['xpath'], annotation: true, model: 'none' },
+    keybase: { attrs: { ...id, name: 'NCName' }, required: ['name'], annotation: true, model: 'keybase', typeName: 'keybase' },
+    keyref: { attrs: { ...id, name: 'NCName', refer: 'QName' }, required: ['name', 'refer'], annotation: true, model: 'keybase' },
+    notation: { attrs: { ...id, name: 'NCName', public: 'public', system: 'anyURI' }, required: ['name'], annotation: true, model: 'none' },
+    facet: { attrs: facet, required: ['value'], annotation: true, model: 'none', typeName: 'facet' },
+    noFixedFacet: { attrs: { ...id, value: 'anySimpleType' }, required: ['value'], annotation: true, model: 'none', typeName: 'noFixedFacet' },
+    numFacet: { attrs: { ...facet, value: 'nonNegativeInteger' }, required: ['value'], annotation: true, model: 'none', typeName: 'numFacet' },
+    totalDigits: { attrs: { ...facet, value: 'positiveInteger' }, required: ['value'], annotation: true, model: 'none' },
+    whiteSpace: { attrs: { ...facet, value: '#whiteSpace' }, required: ['value'], annotation: true, model: 'none' },
+    pattern: { attrs: { ...id, value: 'string' }, required: ['value'], annotation: true, model: 'none' },
+});
+const globals = Object.freeze({
+    schema: 'schema', include: 'include', import: 'import', redefine: 'redefine', annotation: 'annotation', appinfo: 'appinfo', documentation: 'documentation',
+    complexType: 'topLevelComplexType', simpleType: 'topLevelSimpleType', complexContent: 'complexContent', simpleContent: 'simpleContent',
+    restriction: 'restriction', list: 'list', union: 'union', element: 'topLevelElement', attribute: 'topLevelAttribute', group: 'namedGroup',
+    attributeGroup: 'namedAttributeGroup', all: 'all', choice: 'explicitGroup', sequence: 'explicitGroup', any: 'any', anyAttribute: 'wildcard',
+    selector: 'selector', field: 'field', key: 'keybase', unique: 'keybase', keyref: 'keyref', notation: 'notation',
+    minExclusive: 'facet', minInclusive: 'facet', maxExclusive: 'facet', maxInclusive: 'facet', enumeration: 'noFixedFacet',
+    totalDigits: 'totalDigits', fractionDigits: 'numFacet', length: 'numFacet', minLength: 'numFacet', maxLength: 'numFacet',
+    whiteSpace: 'whiteSpace', pattern: 'pattern',
+});
+const named = new Map(Object.entries(roles).flatMap(([role, definition]) => definition.typeName ? [[definition.typeName, role]] : []));
+const facets = new Set(['minExclusive', 'minInclusive', 'maxExclusive', 'maxInclusive', 'totalDigits', 'fractionDigits', 'length', 'minLength', 'maxLength', 'enumeration', 'whiteSpace', 'pattern']);
+const schemaTop = new Set(['simpleType', 'complexType', 'group', 'attributeGroup', 'element', 'attribute', 'notation']);
+const redefinable = new Set(['simpleType', 'complexType', 'group', 'attributeGroup']);
+const nestedParticles = new Set(['element', 'group', 'choice', 'sequence', 'any']);
+const particles = new Set([...nestedParticles, 'all']);
+export function globalSourceRole(name) {
+    return name.namespace === XSD_NAMESPACE && Object.hasOwn(globals, name.local) ? globals[name.local] : undefined;
+}
+export function namedSourceRole(name) {
+    return name.namespace === XSD_NAMESPACE ? named.get(name.local) : undefined;
+}
+export function sourceRoleTypeName(role) { return roles[role].typeName; }
+export function abstractSourceRole(role) { return roles[role].abstract === true; }
+/** Immediate clauses only. The owned walk preserves roles, values and all scopes. */
+export function assessSourceGrammar(role, node, budget) {
+    budget.chargeWork(15);
+    const definition = roles[role];
+    const invalid = (message) => ({ kind: 'invalid-schema', rule: 'schema-for-schemas', message, source: node.source });
+    const attributes = [], children = [];
+    const seen = new Set();
+    for (let index = 0; index < node.attributes.length; index++) {
+        const attr = node.attributes[index];
+        budget.chargeWork(6 + attr.name.local.length + attr.name.namespace.length);
+        if (role === 'anyType')
+            continue;
+        if (attr.name.namespace === XSD_NAMESPACE)
+            return invalid('The S4S attribute wildcard excludes the XSD namespace');
+        if (attr.name.namespace)
+            continue;
+        if (!Object.hasOwn(definition.attrs, attr.name.local))
+            return invalid('Attribute is not permitted by the selected S4S type');
+        budget.chargeWork(3);
+        seen.add(attr.name.local);
+        attributes.push({ index, type: definition.attrs[attr.name.local] });
+    }
+    for (const required of definition.required ?? []) {
+        budget.chargeWork(2);
+        if (!seen.has(required))
+            return invalid(`S4S ${required} attribute is required`);
+    }
+    const elements = [];
+    for (let index = 0; index < node.children.length; index++) {
+        const child = node.children[index];
+        budget.chargeWork(4);
+        if (child.kind === 'text') {
+            budget.chargeWork(child.value.length * 4);
+            if (definition.empty || definition.model !== 'mixed' && /[^\t\r\n ]/.test(child.value))
+                return invalid('Text is not permitted by the selected S4S content type');
+        }
+        else {
+            budget.chargeWork(3);
+            elements.push({ node: child, index });
+        }
+    }
+    let at = 0;
+    const local = () => {
+        budget.chargeWork(3);
+        const item = elements[at]?.node;
+        return item?.name.namespace === XSD_NAMESPACE ? item.name.local : undefined;
+    };
+    const take = (selected) => { budget.chargeWork(3); children.push({ index: elements[at++].index, role: selected }); };
+    const optional = (name, selected) => { if (local() !== name)
+        return false; take(selected); return true; };
+    const global = () => { const name = local(); take(globals[name]); };
+    const particle = () => {
+        const name = local();
+        if (name === 'group') {
+            take('groupRef');
+            return true;
+        }
+        if (name === 'all' || name === 'choice' || name === 'sequence') {
+            global();
+            return true;
+        }
+        return false;
+    };
+    const attrs = () => {
+        while (local() === 'attribute' || local() === 'attributeGroup')
+            take(local() === 'attribute' ? 'attribute' : 'attributeGroupRef');
+        optional('anyAttribute', 'wildcard');
+    };
+    const simpleRestriction = () => {
+        optional('simpleType', 'localSimpleType');
+        while (facets.has(local() ?? ''))
+            global();
+    };
+    if (definition.annotation)
+        optional('annotation', 'annotation');
+    switch (definition.model) {
+        case 'mixed':
+            while (at < elements.length)
+                take();
+            break;
+        case 'annotation':
+            while (local() === 'appinfo' || local() === 'documentation')
+                global();
+            break;
+        case 'schema': {
+            while (['include', 'import', 'redefine', 'annotation'].includes(local() ?? ''))
+                global();
+            while (schemaTop.has(local() ?? '')) {
+                global();
+                while (local() === 'annotation')
+                    global();
+            }
+            break;
+        }
+        case 'redefine':
+            while (local() === 'annotation' || redefinable.has(local() ?? ''))
+                global();
+            break;
+        case 'complex':
+            if (local() === 'simpleContent' || local() === 'complexContent')
+                global();
+            else {
+                particle();
+                attrs();
+            }
+            break;
+        case 'complexContent':
+        case 'simpleContent': {
+            const restriction = local() === 'restriction', extension = local() === 'extension';
+            if (!restriction && !extension)
+                return invalid('Content wrapper requires one derivation child');
+            take(definition.model === 'complexContent' ? restriction ? 'complexRestrictionType' : 'extensionType'
+                : restriction ? 'simpleRestrictionType' : 'simpleExtensionType');
+            break;
+        }
+        case 'restrictionType':
+            if (!particle())
+                simpleRestriction();
+            attrs();
+            break;
+        case 'particleAttrs':
+            particle();
+            attrs();
+            break;
+        case 'simpleAttrs':
+            simpleRestriction();
+            attrs();
+            break;
+        case 'attrs':
+            attrs();
+            break;
+        case 'simple':
+            if (!['restriction', 'list', 'union'].includes(local() ?? ''))
+                return invalid('Simple type requires one derivation child');
+            else
+                global();
+            break;
+        case 'restriction':
+            simpleRestriction();
+            break;
+        case 'list':
+            optional('simpleType', 'localSimpleType');
+            break;
+        case 'union':
+            while (optional('simpleType', 'localSimpleType')) {
+                budget.chargeWork();
+            }
+            break;
+        case 'element':
+            if (local() === 'simpleType' || local() === 'complexType')
+                take(local() === 'simpleType' ? 'localSimpleType' : 'localComplexType');
+            while (['key', 'unique', 'keyref'].includes(local() ?? ''))
+                global();
+            break;
+        case 'attribute':
+            optional('simpleType', 'localSimpleType');
+            break;
+        case 'namedGroup':
+            if (local() === 'all')
+                take('localAll');
+            else if (local() === 'choice' || local() === 'sequence')
+                take('simpleExplicitGroup');
+            else
+                return invalid('Named group requires one compositor');
+            break;
+        case 'realGroup':
+            if (['all', 'choice', 'sequence'].includes(local() ?? ''))
+                global();
+            break;
+        case 'group':
+        case 'explicitGroup':
+            while ((definition.model === 'group' ? particles : nestedParticles).has(local() ?? '')) {
+                const name = local();
+                take(name === 'element' ? 'localElement' : name === 'group' ? 'groupRef' : globals[name]);
+            }
+            break;
+        case 'all':
+            while (optional('element', 'narrowMaxMin')) {
+                budget.chargeWork();
+            }
+            break;
+        case 'keybase':
+            if (!optional('selector', 'selector') || !optional('field', 'field'))
+                return invalid('Identity constraint requires selector and at least one field');
+            while (optional('field', 'field')) {
+                budget.chargeWork();
+            }
+            break;
+        case 'none': break;
+    }
+    if (at !== elements.length)
+        return invalid('Children do not match the selected contextual S4S grammar');
+    // Every ID use in this closed grammar is the unqualified id declaration.
+    // cvc-complex-type 5.2 depends on the use even when the attribute is absent.
+    return { kind: 'checked', hasIdAttributeUse: definition.attrs.id === 'ID', attributes, children };
+}

package/dist/compiler/schemaSourceLexical.d.ts

@@ -0,0 +1,3 @@
+export declare function schemaBooleanLexical(value: string): boolean;
+export declare function schemaNonNegativeIntegerLexical(value: string): boolean;
+export declare function schemaPositiveIntegerLexical(value: string): boolean;

package/dist/compiler/schemaSourceLexical.js

@@ -0,0 +1,12 @@
+/** Exact source datatype spellings; callers charge the original lexical length. */
+import { normalizeWhitespace } from '../util/xmlWhitespace.js';
+export function schemaBooleanLexical(value) {
+    return ['true', 'false', '1', '0'].includes(normalizeWhitespace(value, 'collapse'));
+}
+export function schemaNonNegativeIntegerLexical(value) {
+    return /^(?:\+?[0-9]+|-0+)$/.test(normalizeWhitespace(value, 'collapse'));
+}
+export function schemaPositiveIntegerLexical(value) {
+    const normalized = normalizeWhitespace(value, 'collapse');
+    return schemaNonNegativeIntegerLexical(normalized) && /[1-9]/.test(normalized);
+}

package/dist/compiler/schemaSourceValues.d.ts

@@ -0,0 +1,50 @@
+import type { ExpandedName, SyntaxElement, SyntaxSource } from '../loader/orderedSyntax.js';
+import type { SchemaOperand } from './schemaDatatypeValues.js';
+import type { SchemaLexicalOperand } from './schemaValueContext.js';
+import type { ResourceLimitFailure, SemanticBudget } from './semanticBudget.js';
+declare const fixedType: unique symbol;
+export type FixedSimpleTypeHandle = Readonly<{
+    [fixedType]: true;
+}>;
+export type SourceIdentityFact = Readonly<{
+    kind: 'ID' | 'IDREF';
+    value: string;
+    source: SyntaxSource;
+}>;
+export type SourceValueObligation = Readonly<{
+    rule: string;
+    source: SyntaxSource;
+    name?: ExpandedName;
+}>;
+export type SourceValueFailure = Readonly<{
+    kind: 'invalid-schema' | 'unsupported-capability' | 'unresolved';
+    rule: string;
+    message: string;
+    source: SyntaxSource;
+}>;
+export type SourceValueResult = Readonly<{
+    kind: 'checked';
+    value: SchemaOperand;
+    type: FixedSimpleTypeHandle;
+    selectedMembers: readonly FixedSimpleTypeHandle[];
+    identityFacts: readonly SourceIdentityFact[];
+    obligations: readonly SourceValueObligation[];
+}> | SourceValueFailure | ResourceLimitFailure;
+export type FixedSimpleTypeLookup = Readonly<{
+    kind: 'found';
+    type: FixedSimpleTypeHandle;
+}> | Readonly<{
+    kind: 'missing';
+}> | ResourceLimitFailure;
+/**
+ * Internal fixed descriptor factory. Handles are authentic only in this factory.
+ * Name/lexical/diagnostic records are borrowed immutable data from the authentic
+ * DTD-free ordered source traversal; this leaf does not establish membership.
+ */
+export declare function createSchemaSourceValues(budget: SemanticBudget): Readonly<{
+    /** Closed internal grammar domain; this never accepts caller descriptors. */
+    fixed: (name: string) => FixedSimpleTypeHandle;
+    lookup: (name: ExpandedName) => FixedSimpleTypeLookup;
+    assess: (type: FixedSimpleTypeHandle, lexical: SchemaLexicalOperand, owner: SyntaxElement) => SourceValueResult;
+}>;
+export {};