@techspokes/typescript-wsdl-client 1.1.3 → 1.1.5

package/dist/compiler/schemaSourceValues.js

@@ -0,0 +1,225 @@
+/** Fixed S4S datatype values. No application components, lookup callbacks or hints. */
+import { XSD_NAMESPACE } from '../loader/orderedSyntax.js';
+import { builtinParents, schemaDatatypeValues } from './schemaDatatypeValues.js';
+import { schemaValueSequences } from './schemaValueSequences.js';
+import { fixedS4SPatterns } from './schemaPattern.js';
+import { occurrenceAlgebra } from './occurrenceAnalysis.js';
+const builtins = ['anySimpleType', 'string', 'boolean', 'decimal', 'float', 'double', 'duration', 'dateTime',
+    'time', 'date', 'gYearMonth', 'gYear', 'gMonthDay', 'gDay', 'gMonth', 'hexBinary', 'base64Binary',
+    'anyURI', 'QName', 'NOTATION', 'NMTOKENS', 'IDREFS', 'ENTITIES', ...Object.keys(builtinParents)];
+const utility = ['formChoice', 'reducedDerivationControl', 'derivationSet', 'typeDerivationControl',
+    'fullDerivationSet', 'allNNI', 'blockSet', 'namespaceList', 'public', 'derivationControl', 'simpleDerivationSet'];
+// Exact fixed restrictions from the dated REC S4S. These are instance datatype
+// grammars, not the stronger XPath/component representation rules.
+const selectorPattern = String.raw `(\.//)?(((child::)?((\i\c*:)?(\i\c*|\*)))|\.)(/(((child::)?((\i\c*:)?(\i\c*|\*)))|\.))*(\|(\.//)?(((child::)?((\i\c*:)?(\i\c*|\*)))|\.)(/(((child::)?((\i\c*:)?(\i\c*|\*)))|\.))*)*`;
+const fieldPattern = String.raw `(\.//)?((((child::)?((\i\c*:)?(\i\c*|\*)))|\.)/)*((((child::)?((\i\c*:)?(\i\c*|\*)))|\.)|((attribute::|@)((\i\c*:)?(\i\c*|\*))))(\|(\.//)?((((child::)?((\i\c*:)?(\i\c*|\*)))|\.)/)*((((child::)?((\i\c*:)?(\i\c*|\*)))|\.)|((attribute::|@)((\i\c*:)?(\i\c*|\*)))))*`;
+const definitions = Object.freeze({
+    ...Object.fromEntries(builtins.map(name => [name, { kind: 'builtin', name }])),
+    formChoice: { kind: 'enum', base: 'NMTOKEN', values: ['qualified', 'unqualified'] },
+    derivationControl: { kind: 'enum', base: 'NMTOKEN', values: ['substitution', 'extension', 'restriction', 'list', 'union'] },
+    reducedDerivationControl: { kind: 'enum', base: 'derivationControl', values: ['extension', 'restriction'] },
+    typeDerivationControl: { kind: 'enum', base: 'derivationControl', values: ['extension', 'restriction', 'list', 'union'] },
+    '#simpleDerivation': { kind: 'enum', base: 'derivationControl', values: ['list', 'union', 'restriction'] },
+    '#block': { kind: 'enum', base: 'derivationControl', values: ['extension', 'restriction', 'substitution'] },
+    '#all': { kind: 'enum', base: 'token', values: ['#all'] },
+    '#reducedList': { kind: 'list', item: 'reducedDerivationControl' },
+    '#typeList': { kind: 'list', item: 'typeDerivationControl' },
+    '#simpleList': { kind: 'list', item: '#simpleDerivation' },
+    '#blockList': { kind: 'list', item: '#block' },
+    derivationSet: { kind: 'union', members: ['#all', '#reducedList'] },
+    fullDerivationSet: { kind: 'union', members: ['#all', '#typeList'] },
+    simpleDerivationSet: { kind: 'union', members: ['#all', '#simpleList'] },
+    blockSet: { kind: 'union', members: ['#all', '#blockList'] },
+    '#unbounded': { kind: 'enum', base: 'NMTOKEN', values: ['unbounded'] },
+    allNNI: { kind: 'union', members: ['nonNegativeInteger', '#unbounded'] },
+    '#namespaceSpecial': { kind: 'enum', base: 'token', values: ['##any', '##other'] },
+    '#namespaceItemSpecial': { kind: 'enum', base: 'token', values: ['##targetNamespace', '##local'] },
+    '#namespaceItem': { kind: 'union', members: ['anyURI', '#namespaceItemSpecial'] },
+    '#namespaceList': { kind: 'list', item: '#namespaceItem' },
+    namespaceList: { kind: 'union', members: ['#namespaceSpecial', '#namespaceList'] },
+    public: { kind: 'enum', base: 'token', values: [] }, // no additional facet
+    '#use': { kind: 'enum', base: 'NMTOKEN', values: ['prohibited', 'optional', 'required'] },
+    '#process': { kind: 'enum', base: 'NMTOKEN', values: ['skip', 'lax', 'strict'] },
+    '#whiteSpace': { kind: 'enum', base: 'NMTOKEN', values: ['preserve', 'replace', 'collapse'] },
+    '#xmlSpace': { kind: 'enum', base: 'NCName', values: ['default', 'preserve'] },
+    '#zeroOne': { kind: 'enum', base: 'nonNegativeInteger', values: ['0', '1'] },
+    '#one': { kind: 'enum', base: 'nonNegativeInteger', values: ['1'] },
+    '#maxZeroOne': { kind: 'enum', base: 'allNNI', values: ['0', '1'] },
+    '#maxOne': { kind: 'enum', base: 'allNNI', values: ['1'] },
+    '#qnames': { kind: 'list', item: 'QName' },
+    '#schemaLocations': { kind: 'list', item: 'anyURI' },
+    '#selector': { kind: 'pattern', base: 'token', value: selectorPattern },
+    '#field': { kind: 'pattern', base: 'token', value: fieldPattern },
+});
+const named = new Set([...builtins, ...utility]);
+class SourceValueProblem extends Error {
+    kind;
+    rule;
+    source;
+    constructor(kind, rule, message, source) {
+        super(message);
+        this.kind = kind;
+        this.rule = rule;
+        this.source = source;
+    }
+}
+/**
+ * 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 function createSchemaSourceValues(budget) {
+    const handles = new WeakMap();
+    const issued = new Map();
+    const context = {
+        step: (_owner, count = 1) => budget.chargeWork(count),
+        text: (value, _owner) => { budget.chargeWork(2 + value.length * 4); return value; },
+        fail: (owner, rule, message, source) => { throw new SourceValueProblem('invalid-schema', rule, message, source ?? owner.source); },
+        unsupported: (owner, rule, message, source) => { throw new SourceValueProblem('unsupported-capability', rule, message, source ?? owner.source); },
+        unresolved: (owner, rule, message, source) => { throw new SourceValueProblem('unresolved', rule, message, source ?? owner.source); },
+        notation: (namespace, local, owner) => {
+            budget.chargeWork(4 + namespace.length + local.length);
+            if (namespace !== XSD_NAMESPACE || !['XMLSchemaStructures', 'XML'].includes(local)) {
+                context.fail(owner, 'notation-declaration', 'NOTATION QName is absent from the fixed S4S assessment schema');
+            }
+        },
+    };
+    const values = schemaDatatypeValues(context);
+    const sequence = schemaValueSequences({ step: context.step,
+        isInvalidSchema: (error) => error instanceof SourceValueProblem && error.kind === 'invalid-schema' });
+    const patterns = fixedS4SPatterns({ ...context, algebra: occurrenceAlgebra(() => budget.chargeWork()) });
+    const fixed = (name) => {
+        budget.chargeWork(4 + name.length);
+        if (!Object.hasOwn(definitions, name))
+            throw new TypeError('Unknown fixed source value descriptor');
+        const existing = issued.get(name);
+        if (existing)
+            return existing;
+        budget.chargeWork(5);
+        const type = Object.freeze({});
+        issued.set(name, type);
+        handles.set(type, name);
+        return type;
+    };
+    const evaluate = (name, lexical, owner) => {
+        budget.chargeWork(8 + name.length);
+        const descriptor = definitions[name];
+        const result = (value) => ({ value, members: [], facts: [] });
+        if (descriptor.kind === 'builtin') {
+            // Declared use is separate from the primitive facet-formation entry.
+            if (name === 'NOTATION')
+                context.fail(owner, 'enumeration-required-notation', 'NOTATION requires an enumeration-derived declared datatype', lexical.context.source);
+            // cvc-simple-type / key-vde: the authentic loader rejects every DOCTYPE,
+            // so this source infoset's unparsedEntities set is known empty. This is
+            // a concrete source failure, not application-component ENTITY authority.
+            if (name === 'ENTITY') {
+                values.atomic('NCName', lexical, owner);
+                context.fail(owner, 'cvc-simple-type', 'ENTITY has no declared unparsed entity in this DTD-free source document', lexical.context.source);
+            }
+            if (name === 'ENTITIES') {
+                const tokens = values.listTokens(lexical, owner);
+                if (tokens.tokens.length === 0)
+                    values.listOperand(tokens, [], owner, 'ENTITIES');
+                context.fail(owner, 'cvc-simple-type', 'ENTITIES has no declared unparsed entities in this DTD-free source document', lexical.context.source);
+            }
+            const value = values.builtin(name, lexical, owner), out = result(value);
+            if (name === 'ID' || name === 'IDREF') {
+                budget.chargeWork(4);
+                out.facts.push({ kind: name, value: value.canonical, source: lexical.context.source });
+            }
+            else if (name === 'IDREFS') {
+                for (const item of value.items ?? []) {
+                    budget.chargeWork(4);
+                    out.facts.push({ kind: 'IDREF', value: item.canonical, source: lexical.context.source });
+                }
+            }
+            return out;
+        }
+        if (descriptor.kind === 'enum') {
+            const value = evaluate(descriptor.base, lexical, owner);
+            let accepted = descriptor.values.length === 0;
+            for (const expected of descriptor.values) {
+                budget.chargeWork(4);
+                const assessed = evaluate(descriptor.base, { value: expected, context: lexical.context }, owner);
+                if (values.sameValue(value.value, assessed.value, owner)) {
+                    accepted = true;
+                    break;
+                }
+            }
+            if (!accepted)
+                context.fail(owner, 'cvc-enumeration-valid', 'Value is outside the fixed S4S enumeration', lexical.context.source);
+            return value;
+        }
+        if (descriptor.kind === 'pattern') {
+            const value = evaluate(descriptor.base, lexical, owner);
+            const compiled = patterns.compile({ value: descriptor.value, context: lexical.context }, owner);
+            if (!patterns.acceptsOperand(compiled, value.value.canonical, owner)) {
+                context.fail(owner, 'cvc-pattern-valid', 'Value does not satisfy the fixed S4S pattern', lexical.context.source);
+            }
+            return value;
+        }
+        if (descriptor.kind === 'list') {
+            const tokens = values.listTokens(lexical, owner);
+            budget.chargeWork(tokens.tokens.length * 3 + 3);
+            const items = [], facts = [], members = [];
+            for (const token of tokens.tokens) {
+                budget.chargeWork(4);
+                const item = evaluate(descriptor.item, { value: token, context: lexical.context }, owner);
+                budget.chargeWork(item.facts.length + item.members.length + 2);
+                items.push(item.value);
+                facts.push(...item.facts);
+                members.push(...item.members);
+            }
+            return { value: values.listOperand(tokens, items, owner), facts, members };
+        }
+        budget.chargeWork(descriptor.members.length + 3);
+        const choices = sequence.chooseUnionMember(descriptor.members, owner);
+        let state = choices.next(), chosen;
+        while (!state.done) {
+            budget.chargeWork(2);
+            try {
+                chosen = evaluate(state.value, lexical, owner);
+                state = choices.next(chosen.value);
+            }
+            catch (error) {
+                chosen = undefined;
+                state = choices.throw(error);
+            }
+        }
+        if (!state.value || !chosen)
+            return context.fail(owner, 'cvc-datatype-valid', 'No fixed S4S union member accepts this value', lexical.context.source);
+        budget.chargeWork(chosen.members.length + 3);
+        return { ...chosen, members: [state.value.request, ...chosen.members] };
+    };
+    return Object.freeze({
+        /** Closed internal grammar domain; this never accepts caller descriptors. */
+        fixed,
+        lookup: (name) => budget.guard(() => {
+            budget.chargeWork(5 + name.namespace.length + name.local.length);
+            // The immutable October 2004 XML import has no named types. Its space
+            // restriction is anonymous and cannot be resolved by an XML QName.
+            return name.namespace === XSD_NAMESPACE && named.has(name.local)
+                ? Object.freeze({ kind: 'found', type: fixed(name.local) }) : Object.freeze({ kind: 'missing' });
+        }),
+        assess: (type, lexical, owner) => {
+            const name = handles.get(type);
+            if (name === undefined)
+                throw new TypeError('Source datatype handle was not issued by this factory');
+            return budget.guard(() => {
+                try {
+                    const value = evaluate(name, lexical, owner);
+                    budget.chargeWork(value.members.length + 8);
+                    // Preserve opaque issued handles: a deep snapshot would create copies.
+                    return Object.freeze({ kind: 'checked', type, value: budget.freeze(budget.snapshot(value.value)),
+                        selectedMembers: Object.freeze(value.members.map(fixed)),
+                        identityFacts: budget.freeze(budget.snapshot(value.facts)), obligations: Object.freeze([]) });
+                }
+                catch (error) {
+                    if (!(error instanceof SourceValueProblem))
+                        throw error;
+                    return budget.freeze(budget.snapshot({ kind: error.kind, rule: error.rule, message: error.message, source: error.source }));
+                }
+            });
+        },
+    });
+}

package/dist/compiler/schemaSourceWildcards.d.ts

@@ -0,0 +1,28 @@
+import type { ExpandedName, SyntaxElement, SyntaxSource } from '../loader/orderedSyntax.js';
+import type { SemanticBudget, ResourceLimitFailure } from './semanticBudget.js';
+export type SourceTypedId = Readonly<{
+    value: string;
+    source: SyntaxSource;
+}>;
+export type SourceWildcardObligation = Readonly<{
+    category: 'foreign-attribute-assessment' | 'annotation-payload-assessment';
+    rule: string;
+    source: SyntaxSource;
+    name: ExpandedName;
+    message?: string;
+}>;
+export type SourceWildcardResult = Readonly<{
+    kind: 'checked';
+    remaining: readonly SourceWildcardObligation[];
+    ids: readonly SourceTypedId[];
+}> | Readonly<{
+    kind: 'invalid-schema';
+    rule: string;
+    message: string;
+    source: SyntaxSource;
+}> | ResourceLimitFailure;
+/** 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

package/dist/compiler/schemaSourceWildcards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaSourceWildcards.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaSourceWildcards.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAC,YAAY,EAAE,aAAa,EAAE,YAAY,EAAC,MAAM,4BAA4B,CAAC;AAC1F,OAAO,KAAK,EAAC,cAAc,EAAE,oBAAoB,EAAC,MAAM,qBAAqB,CAAC;AAW9E,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAC,CAAC,CAAC;AAC5E,MAAM,MAAM,wBAAwB,GAAG,QAAQ,CAAC;IAC9C,QAAQ,EAAE,8BAA8B,GAAG,+BAA+B,CAAC;IAC3E,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,YAAY,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC1E,CAAC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,SAAS,wBAAwB,EAAE,CAAC;IAAC,GAAG,EAAE,SAAS,aAAa,EAAE,CAAA;CAAC,CAAC,GACzI,QAAQ,CAAC;IAAC,IAAI,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAC,CAAC,GACvF,oBAAoB,CAAC;AAEzB,sEAAsE;AACtE,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,GAAG,OAAO,CAGrF;AAQD,kGAAkG;AAClG,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,cAAc,GAAG,oBAAoB,CA8J7G"}

package/dist/compiler/schemaSourceWildcards.js

@@ -0,0 +1,247 @@
+/**
+ * Fixed S4S instance assessment: dated 2004 Structures/Datatypes Appendix A,
+ * cvc-assess-elt, cvc-elt/type/complex-type/attribute/wildcard and cvc-id/key.
+ * Parent-selected local declarations outrank global lookup. Application Gamma
+ * and schema-location hints never extend this distinct assessment universe.
+ * Imported XML declarations are fixed by https://www.w3.org/2004/10/xml.xsd.
+ */
+import { XML_NAMESPACE, XSD_NAMESPACE } from '../loader/orderedSyntax.js';
+import { normalizeWhitespace } from './schemaDatatypeValues.js';
+import { createSchemaSourceValues } from './schemaSourceValues.js';
+import { abstractSourceRole, assessSourceGrammar, globalSourceRole, namedSourceRole, sourceRoleTypeName } from './schemaSourceGrammar.js';
+const XSI_NAMESPACE = 'http://www.w3.org/2001/XMLSchema-instance';
+const xsiTypes = Object.freeze({ type: 'QName', nil: 'boolean',
+    schemaLocation: '#schemaLocations', noNamespaceSchemaLocation: 'anyURI' });
+/** The dated October 2004 XML import declares lang as xs:language. */
+export function validSchemaXmlLanguage(value, budget) {
+    budget.chargeWork(4 + value.length * 4);
+    return /^[A-Za-z]{1,8}(?:-[A-Za-z0-9]{1,8})*$/.test(normalizeWhitespace(value, 'collapse'));
+}
+class SourceProblem extends Error {
+    rule;
+    source;
+    constructor(rule, message, source) {
+        super(message);
+        this.rule = rule;
+        this.source = source;
+    }
+}
+/** Pure borrowed-syntax clauses. Only the authentic document owner issues aggregate authority. */
+export function assessSchemaSourceWildcards(root, budget) {
+    return budget.guard(() => {
+        budget.chargeWork(30);
+        const remaining = [], ids = [], references = [];
+        const idValues = new Set(), values = createSchemaSourceValues(budget);
+        const stack = [{ node: root, payload: false }];
+        const fail = (node, message, rule = 'schema-for-schemas') => {
+            budget.chargeWork(6 + message.length + rule.length);
+            throw new SourceProblem(rule, message, node.source);
+        };
+        const pending = (node, name, category, rule, message) => {
+            budget.chargeWork(8);
+            remaining.push({ category, rule, source: node.source, name, ...(message === undefined ? {} : { message }) });
+        };
+        const facts = (node, entries, category) => {
+            for (const entry of entries) {
+                budget.chargeWork(5 + entry.value.length);
+                if (entry.kind === 'ID') {
+                    if (idValues.has(entry.value))
+                        fail(node, 'Schema IDs must be unique within their schema validation root', 'schema-id');
+                    budget.chargeWork(4);
+                    idValues.add(entry.value);
+                    ids.push({ value: entry.value, source: entry.source });
+                }
+                else {
+                    budget.chargeWork(3);
+                    references.push({ ...entry, category });
+                }
+            }
+        };
+        const assess = (node, type, lexical, name, category) => {
+            budget.chargeWork(6);
+            const result = values.assess(type, { value: lexical, context: { namespaces: node.namespaces, source: node.source } }, node);
+            if (result.kind === 'resource-limit') {
+                budget.chargeWork();
+                throw new Error('Unreachable exhausted source budget');
+            }
+            if (result.kind === 'invalid-schema')
+                return fail(node, `${result.rule}: ${result.message}`);
+            if (result.kind !== 'checked') {
+                pending(node, name, category, result.rule, result.message);
+                return undefined;
+            }
+            facts(node, result.identityFacts, category);
+            for (const obligation of result.obligations) {
+                budget.chargeWork();
+                pending(node, obligation.name ?? name, category, obligation.rule);
+            }
+            return result.value;
+        };
+        try {
+            while (stack.length) {
+                budget.chargeWork(12);
+                const frame = stack.pop(), { node, payload } = frame;
+                const category = payload ? 'annotation-payload-assessment' : 'foreign-attribute-assessment';
+                budget.chargeWork(node.name.namespace.length + node.name.local.length);
+                const declaration = frame.role ?? globalSourceRole(node.name);
+                let role = declaration, simpleType, typeName;
+                for (const attr of node.attributes) {
+                    budget.chargeWork(7 + attr.name.namespace.length + attr.name.local.length);
+                    if (attr.name.namespace !== XSI_NAMESPACE || !Object.hasOwn(xsiTypes, attr.name.local))
+                        continue;
+                    const assessed = assess(node, values.fixed(xsiTypes[attr.name.local]), attr.value, attr.name, category);
+                    if (attr.name.local === 'nil' && declaration !== undefined)
+                        fail(node, 'A non-nillable S4S declaration forbids xsi:nil presence');
+                    if (attr.name.local === 'type' && assessed) {
+                        budget.chargeWork(assessed.canonical.length * 3 + 4);
+                        const pair = JSON.parse(assessed.canonical);
+                        typeName = { namespace: pair[0], local: pair[1] };
+                    }
+                }
+                if (typeName) {
+                    budget.chargeWork(8 + typeName.namespace.length + typeName.local.length);
+                    const complex = namedSourceRole(typeName);
+                    if (complex !== undefined) {
+                        if (abstractSourceRole(complex))
+                            fail(node, 'An abstract fixed S4S type cannot assess an element');
+                        if (declaration !== undefined && sourceRoleTypeName(declaration) !== typeName.local) {
+                            fail(node, 'xsi:type does not match the declared S4S type under blockDefault=#all');
+                        }
+                        role = complex;
+                    }
+                    else {
+                        const lookup = values.lookup(typeName);
+                        if (lookup.kind === 'resource-limit') {
+                            budget.chargeWork();
+                            throw new Error('Unreachable exhausted source budget');
+                        }
+                        if (lookup.kind === 'found') {
+                            if (declaration !== undefined)
+                                fail(node, 'A simple xsi:type cannot replace this S4S complex declaration');
+                            role = undefined;
+                            simpleType = lookup.type;
+                        }
+                        else if (declaration !== undefined)
+                            fail(node, 'xsi:type is absent from the fixed S4S assessment type universe');
+                        // Undeclared + genuinely absent type follows lax ur-type fallback.
+                    }
+                }
+                // The fixed imported XML schema has no global element declarations.
+                // Undeclared XML names therefore use the same lax fallback as other
+                // genuinely absent declarations; descendants are still assessed.
+                if (simpleType) {
+                    budget.chargeWork(5);
+                    const chunks = [];
+                    for (const child of node.children) {
+                        budget.chargeWork(3);
+                        if (child.kind === 'element')
+                            fail(node, 'A simple item type forbids element children');
+                        else {
+                            budget.chargeWork(child.value.length + 1);
+                            chunks.push(child.value);
+                        }
+                    }
+                    for (const attr of node.attributes) {
+                        budget.chargeWork(4);
+                        if (attr.name.namespace !== XSI_NAMESPACE || !Object.hasOwn(xsiTypes, attr.name.local)) {
+                            fail(node, 'A simple item type permits only the four builtin schema-instance attributes');
+                        }
+                    }
+                    budget.chargeWork(chunks.length + 1);
+                    assess(node, simpleType, chunks.join(''), typeName, category);
+                    continue;
+                }
+                const grammar = assessSourceGrammar(role ?? 'anyType', node, budget);
+                if (grammar.kind !== 'checked')
+                    return budget.freeze(budget.snapshot(grammar));
+                budget.chargeWork(3);
+                const assessedAttributes = new Map();
+                for (const item of grammar.attributes) {
+                    budget.chargeWork(3);
+                    const attr = node.attributes[item.index], assessed = assess(node, values.fixed(item.type), attr.value, attr.name, category);
+                    if (assessed) {
+                        budget.chargeWork(2);
+                        assessedAttributes.set(attr.name.local, assessed);
+                    }
+                }
+                for (const attr of node.attributes) {
+                    budget.chargeWork(6 + attr.name.namespace.length + attr.name.local.length);
+                    if (attr.name.namespace !== XML_NAMESPACE)
+                        continue;
+                    if (attr.name.local === 'lang') {
+                        assess(node, values.fixed('language'), attr.value, attr.name, category);
+                    }
+                    else if (attr.name.local === 'space')
+                        assess(node, values.fixed('#xmlSpace'), attr.value, attr.name, category);
+                    else if (attr.name.local === 'base')
+                        assess(node, values.fixed('anyURI'), attr.value, attr.name, category);
+                    else if (attr.name.local === 'id') {
+                        // This is the sole wildcard ID declaration in the closed schema;
+                        // XML expanded-name uniqueness already enforces 5.1. Clause 5.2
+                        // forbids it when the selected type has an ID use, even absent.
+                        if (grammar.hasIdAttributeUse)
+                            fail(node, 'A wildcard ID cannot replace an ID attribute use', 'cvc-complex-type.5.2');
+                        assess(node, values.fixed('ID'), attr.value, attr.name, category);
+                    }
+                    // Other XML attribute names are absent from the complete inventory.
+                }
+                // Seven fixed S4S keys belong to each schema declaration; ID/IDREF
+                // duties belong to the outer physical schema validation root.
+                let scope = frame.scope;
+                if (declaration === 'schema') {
+                    budget.chargeWork(7);
+                    scope = { parent: scope, direct: new Map(), identities: new Set() };
+                }
+                const name = assessedAttributes.get('name')?.canonical;
+                if (node.name.namespace === XSD_NAMESPACE && ['key', 'unique', 'keyref'].includes(node.name.local)) {
+                    if (name === undefined)
+                        fail(node, 'S4S identity-constraint key requires an assessed name');
+                    for (let current = frame.scope; current; current = current.parent) {
+                        budget.chargeWork(4 + name.length);
+                        if (current.identities.has(name))
+                            fail(node, 'Duplicate S4S descendant identity-constraint key', 'schema-key');
+                        current.identities.add(name);
+                    }
+                }
+                if (frame.parentSchema && node.name.namespace === XSD_NAMESPACE) {
+                    const local = node.name.local, key = local === 'simpleType' || local === 'complexType' ? 'type'
+                        : ['element', 'attribute', 'group', 'attributeGroup', 'notation'].includes(local) ? local : undefined;
+                    if (key !== undefined) {
+                        if (name === undefined)
+                            fail(node, 'S4S schema key requires an assessed name');
+                        let members = frame.parentSchema.direct.get(key);
+                        if (!members) {
+                            budget.chargeWork(3);
+                            members = new Set();
+                            frame.parentSchema.direct.set(key, members);
+                        }
+                        budget.chargeWork(3 + name.length);
+                        if (members.has(name))
+                            fail(node, 'Duplicate S4S schema declaration key', key === 'notation' ? 'schema-notation-key' : 'schema-key');
+                        members.add(name);
+                    }
+                }
+                const childrenArePayload = payload || declaration === 'appinfo' || declaration === 'documentation';
+                for (let index = grammar.children.length - 1; index >= 0; index--) {
+                    budget.chargeWork(7);
+                    const child = grammar.children[index], syntax = node.children[child.index];
+                    if (syntax.kind !== 'element')
+                        throw new Error('Source grammar selected a non-element child');
+                    stack.push({ node: syntax, payload: childrenArePayload, role: child.role, scope,
+                        ...(declaration === 'schema' ? { parentSchema: scope } : {}) });
+                }
+            }
+            for (const reference of references) {
+                budget.chargeWork(3 + reference.value.length);
+                if (!idValues.has(reference.value))
+                    throw new SourceProblem('cvc-id', 'IDREF has no ID in its physical schema validation root', reference.source);
+            }
+            return budget.freeze(budget.snapshot({ kind: 'checked', remaining, ids }));
+        }
+        catch (error) {
+            if (!(error instanceof SourceProblem))
+                throw error;
+            return budget.freeze(budget.snapshot({ kind: 'invalid-schema', rule: error.rule, message: error.message, source: error.source }));
+        }
+    });
+}

package/dist/compiler/schemaSymbolicSequences.d.ts

@@ -0,0 +1,16 @@
+/** Finite subset products over source-owned, decidable typed token predicates. */
+import type { SchemaPatternContext } from './schemaValueContext.js';
+export type SymbolicSequence<Label> = Readonly<{
+    start: number;
+    states: readonly Readonly<{
+        accepting: boolean;
+        edges: readonly Readonly<{
+            to: number;
+            label: Label;
+        }>[];
+    }>[];
+}>;
+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/schemaSymbolicSequences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaSymbolicSequences.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaSymbolicSequences.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,yBAAyB,CAAC;AAClE,MAAM,MAAM,gBAAgB,CAAC,KAAK,IAAI,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,SAAS,QAAQ,CAAC;QACvF,SAAS,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,SAAS,QAAQ,CAAC;YAAC,EAAE,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,KAAK,CAAA;SAAC,CAAC,EAAE,CAAC;KAC5E,CAAC,EAAE,CAAA;CAAC,CAAC,CAAC;AACP,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,oBAAoB,CAAC,KAAK,CAAC,EAClF,WAAW,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,EAAE,EAAE,QAAQ,EAAE,SAAS,KAAK,EAAE,EAAE,KAAK,EAAE,KAAK,KAAK,OAAO,EAC9F,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM;0BACJ,gBAAgB,CAAC,KAAK,CAAC,KAAK,gBAAgB,CAAC,KAAK,CAAC,SAAS,KAAK,KAAG,OAAO;EAmDzG"}

package/dist/compiler/schemaSymbolicSequences.js

@@ -0,0 +1,99 @@
+export function schemaSymbolicSequences(c, satisfiable, family) {
+    const differenceExists = (a, b, owner) => {
+        const key = (pair) => { c.step(owner, (pair.a.length + pair.b.length) * 16 + 4); return JSON.stringify(pair); };
+        c.step(owner, 6);
+        const initial = { a: [a.start], b: [b.start] }, pending = [initial], seen = new Set([key(initial)]);
+        for (let cursor = 0; cursor < pending.length; cursor++) {
+            const pair = pending[cursor];
+            c.step(owner, pair.a.length + pair.b.length + 2);
+            if (pair.a.some(state => a.states[state].accepting) && !pair.b.some(state => b.states[state].accepting))
+                return true;
+            c.step(owner, 4);
+            const labels = [], indices = new Map();
+            const index = (label) => {
+                c.step(owner);
+                let value = indices.get(label);
+                if (value === undefined) {
+                    c.step(owner, 3);
+                    value = labels.length;
+                    indices.set(label, value);
+                    labels.push(label);
+                }
+                return value;
+            };
+            c.step(owner, pair.a.length + pair.b.length + 3);
+            const ae = [], be = [];
+            for (const state of pair.a)
+                for (const edge of a.states[state].edges) {
+                    c.step(owner, 3);
+                    ae.push({ to: edge.to, index: index(edge.label) });
+                }
+            for (const state of pair.b)
+                for (const edge of b.states[state].edges) {
+                    c.step(owner, 3);
+                    be.push({ to: edge.to, index: index(edge.label) });
+                }
+            c.step(owner, ae.length + labels.length + 8);
+            const anchors = [...new Set(ae.map(edge => edge.index))];
+            const maskCost = Math.min(Number.MAX_SAFE_INTEGER, (labels.length + 4) ** 2);
+            const masks = (operations = 1) => c.step(owner, Math.min(Number.MAX_SAFE_INTEGER, maskCost * operations));
+            for (let anchorAt = 0; anchorAt < anchors.length; anchorAt++) {
+                const anchor = anchors[anchorAt], tag = family?.(labels[anchor]);
+                c.step(owner, labels.length * 3 + anchors.length + 8);
+                const forced = new Set(anchors.slice(0, anchorAt));
+                if (family)
+                    for (let bit = 0; bit < labels.length; bit++)
+                        if (family(labels[bit]) !== tag)
+                            forced.add(bit);
+                const remaining = labels.flatMap((_label, bit) => bit === anchor || forced.has(bit) ? [] : [bit]);
+                const positive = [labels[anchor]], negative = [...forced].map(bit => labels[bit]);
+                if (!satisfiable(positive, negative, owner))
+                    continue;
+                c.step(owner, 5);
+                masks();
+                const cells = [{ positive, negative, mask: 1n << BigInt(anchor), at: 0 }];
+                while (cells.length) {
+                    c.step(owner);
+                    const cell = cells.pop();
+                    if (cell.at < remaining.length) {
+                        const bit = remaining[cell.at], label = labels[bit];
+                        c.step(owner, cell.positive.length + cell.negative.length + 8);
+                        const admitted = [...cell.positive, label], rejected = [...cell.negative, label];
+                        if (satisfiable(admitted, cell.negative, owner)) {
+                            c.step(owner, 5);
+                            masks(2);
+                            cells.push({ ...cell, positive: admitted, mask: cell.mask | (1n << BigInt(bit)), at: cell.at + 1 });
+                        }
+                        if (satisfiable(cell.positive, rejected, owner)) {
+                            c.step(owner, 5);
+                            cells.push({ ...cell, negative: rejected, at: cell.at + 1 });
+                        }
+                        continue;
+                    }
+                    const mask = cell.mask;
+                    c.step(owner, ae.length + be.length + 4);
+                    const aa = new Set(), bb = new Set();
+                    for (const edge of ae) {
+                        masks(2);
+                        if (mask & (1n << BigInt(edge.index)))
+                            aa.add(edge.to);
+                    }
+                    for (const edge of be) {
+                        masks(2);
+                        if (mask & (1n << BigInt(edge.index)))
+                            bb.add(edge.to);
+                    }
+                    c.step(owner, aa.size ** 2 + bb.size ** 2 + aa.size + bb.size + 5);
+                    const next = { a: [...aa].sort((x, y) => x - y), b: [...bb].sort((x, y) => x - y) }, identity = key(next);
+                    if (!seen.has(identity)) {
+                        c.step(owner, identity.length + 4);
+                        seen.add(identity);
+                        pending.push(next);
+                    }
+                }
+            }
+        }
+        return false;
+    };
+    return { differenceExists };
+}