@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/schemaSymbolicValueSets.js

@@ -0,0 +1,149 @@
+import { schemaRegularLanguages } from './schemaRegularLanguage.js';
+import { schemaNumericImageConditions } from './schemaNumericImageConditions.js';
+import { schemaIeeeLanguages } from './schemaIeeeLanguage.js';
+export function schemaSymbolicValueSets(c, regular, numeric, ieee, expression, parseIeee, encode) {
+    const quote = (text, owner) => { c.text(text, owner); c.step(owner, text.length * 2 + 1); return expression(text.replace(/[\\.\-^?*+{}()\[\]|]/g, '\\$&').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t'), owner); };
+    const inverse = (value, owner) => ({ intervals: ieee.inverseIntervals(value, owner),
+        literals: value.canonical === 'NaN' ? ['NaN'] : value.canonical === 'Infinity' ? ['INF'] : value.canonical === '-Infinity' ? ['-INF'] : [], nonNumeric: false });
+    const includes = (set, value, owner) => {
+        c.step(owner);
+        if (set.family !== value.family)
+            return false;
+        if (set.kind === 'singleton') {
+            c.text(set.value.canonical, owner);
+            c.text(value.canonical, owner);
+            return set.value.canonical === value.canonical;
+        }
+        if (set.kind === 'regular')
+            return numeric.exists(regular.intersect([set.language, quote(encode(value, owner), owner)], owner), set.numeric, owner);
+        const cell = inverse(value, owner);
+        for (const input of set.inputs)
+            if (numeric.exists(input.language, numeric.intersection(input.numeric, cell, owner), owner))
+                return true;
+        return false;
+    };
+    const singleton = (set, owner) => {
+        let value;
+        for (const branch of set.inputs) {
+            const word = numeric.numericWitness(branch.language, branch.numeric, owner);
+            if (word !== undefined) {
+                value = parseIeee(set.family, word, owner);
+                break;
+            }
+        }
+        if (!value)
+            return undefined;
+        const cell = inverse(value, owner);
+        for (const branch of set.inputs)
+            if (numeric.exists(branch.language, numeric.difference(branch.numeric, cell, owner), owner))
+                return undefined;
+        return value;
+    };
+    const satisfiable = (positive, negative, owner) => {
+        if (!positive.length)
+            throw new TypeError('A typed token product needs a positive value-domain label');
+        c.step(owner, positive.length + negative.length + 3);
+        const family = positive[0].family;
+        if (positive.some(set => set.family !== family))
+            return false;
+        const excluded = negative.filter(set => set.family === family);
+        if (positive.some(set => excluded.includes(set)))
+            return false;
+        if (family === 'float' || family === 'double') {
+            for (const supplied of positive)
+                if (supplied.kind === 'ieee')
+                    for (const inherited of excluded)
+                        if (inherited.kind === 'ieee') {
+                            let covered = true;
+                            for (const input of supplied.inputs) {
+                                c.step(owner, 3);
+                                let residual = [input];
+                                for (const prior of inherited.inputs) {
+                                    c.step(owner, residual.length * 2 + 4);
+                                    const next = [];
+                                    for (const branch of residual) {
+                                        next.push({ language: regular.intersect([branch.language, regular.negate(prior.language, owner)], owner), numeric: branch.numeric });
+                                        next.push({ language: regular.intersect([branch.language, prior.language], owner), numeric: numeric.difference(branch.numeric, prior.numeric, owner) });
+                                    }
+                                    residual = next;
+                                }
+                                if (residual.some(branch => numeric.exists(branch.language, branch.numeric, owner))) {
+                                    for (const branch of residual) {
+                                        const word = numeric.numericWitness(branch.language, branch.numeric, owner);
+                                        if (word !== undefined) {
+                                            const value = parseIeee(supplied.family, word, owner);
+                                            if (positive.every(set => includes(set, value, owner)) && excluded.every(set => !includes(set, value, owner)))
+                                                return true;
+                                        }
+                                    }
+                                    covered = false;
+                                    break;
+                                }
+                            }
+                            if (covered)
+                                return false;
+                        }
+        }
+        const exact = positive.find(set => set.kind === 'singleton');
+        const test = (value) => positive.every(set => includes(set, value, owner)) && excluded.every(set => !includes(set, value, owner));
+        if (exact?.kind === 'singleton')
+            return test(exact.value);
+        if (family === 'float' || family === 'double') {
+            for (const set of positive)
+                if (set.kind === 'ieee')
+                    for (const branch of set.inputs) {
+                        const word = numeric.numericWitness(branch.language, branch.numeric, owner);
+                        if (word !== undefined && test(parseIeee(set.family, word, owner)))
+                            return true;
+                    }
+            for (const set of positive)
+                if (set.kind === 'ieee') {
+                    const point = singleton(set, owner);
+                    if (point)
+                        return test(point);
+                }
+            const domain = positive.find(set => set.kind === 'ieee');
+            if (domain?.kind !== 'ieee')
+                throw new TypeError('An infinite IEEE image requires an IEEE input authority');
+            for (const branch of domain.inputs) {
+                let remaining = branch.numeric;
+                for (;;) {
+                    const word = numeric.numericWitness(branch.language, remaining, owner);
+                    if (word === undefined)
+                        break;
+                    const value = parseIeee(domain.family, word, owner);
+                    if (test(value))
+                        return true;
+                    // A failed exact membership test excludes this whole rounding cell,
+                    // rather than only this spelling. Each step removes one actual IEEE
+                    // value; the finite format bounds termination. Only the complete
+                    // numeric witness authority can prove that no cells remain.
+                    remaining = numeric.difference(remaining, inverse(value, owner), owner);
+                }
+            }
+            return false;
+        }
+        c.step(owner, 3);
+        let candidates = [{ language: regular.intersect([], owner), numeric: numeric.all() }];
+        for (const set of positive) {
+            if (set.kind !== 'regular')
+                throw new TypeError('A non-IEEE infinite image requires a regular canonical value authority');
+            candidates = candidates.map(branch => ({ language: regular.intersect([branch.language, set.language], owner), numeric: numeric.intersection(branch.numeric, set.numeric, owner) }));
+        }
+        for (const set of excluded) {
+            c.step(owner, candidates.length * 2 + 3);
+            const next = [];
+            for (const branch of candidates) {
+                const language = set.kind === 'singleton' ? quote(set.encoded, owner) : set.kind === 'regular' ? set.language : undefined;
+                if (!language)
+                    throw new TypeError('A non-IEEE image label has an incompatible authority');
+                next.push({ language: regular.intersect([branch.language, regular.negate(language, owner)], owner), numeric: branch.numeric });
+                if (set.kind === 'regular')
+                    next.push({ language: regular.intersect([branch.language, language], owner), numeric: numeric.difference(branch.numeric, set.numeric, owner) });
+            }
+            candidates = next;
+        }
+        return candidates.some(branch => numeric.exists(branch.language, branch.numeric, owner));
+    };
+    return { includes, singleton, satisfiable };
+}

package/dist/compiler/schemaSyntaxAssessment.d.ts

@@ -0,0 +1,24 @@
+/** Original component XML syntax only; aggregate schema/candidate checking is separate. */
+import type { NodeId } from "./canonicalGraph.js";
+import type { SemanticContext } from "./semanticContext.js";
+import type { ResourceLimitFailure } from "./semanticBudget.js";
+import type { SyntaxSource } from "../loader/orderedSyntax.js";
+export type ActualSyntaxResult = Readonly<{
+    kind: 'checked';
+    contextId: string;
+    component: NodeId;
+    authority: 'XSD10-original-component-syntax-v1';
+    scope: 'original-component-source-syntax';
+    remaining: readonly ['schema-document-syntax', 'child-component-syntax', 'semantic-construction'];
+}> | Readonly<{
+    kind: 'invalid-schema' | 'unsupported-capability' | 'unresolved';
+    rule: string;
+    component: NodeId;
+    message: string;
+    source?: SyntaxSource;
+}> | ResourceLimitFailure;
+/**
+ * Checks the source slice retained by the canonical node. This is not a complete
+ * schema-for-schemas validator, and has no hypothetical-construction authority.
+ */
+export declare function checkActualSchemaSyntax(context: SemanticContext, nodeId: NodeId): ActualSyntaxResult;

package/dist/compiler/schemaSyntaxAssessment.js

@@ -0,0 +1,361 @@
+import { schemaScalarContext, SchemaAssessmentError } from "./schemaScalarContext.js";
+import { assertSemanticContext } from "./semanticContext.js";
+import { isXmlNCName, XSD_NAMESPACE } from "../loader/orderedSyntax.js";
+import { normalizeWhitespace } from "./schemaDatatypeValues.js";
+import { declarationMethods, RelationProblem } from "./schemaTypeRelations.js";
+import { schemaBooleanLexical, schemaNonNegativeIntegerLexical } from './schemaSourceLexical.js';
+const facetNames = new Set(["length", "minLength", "maxLength", "pattern", "enumeration", "whiteSpace", "minInclusive", "maxInclusive", "minExclusive", "maxExclusive", "totalDigits", "fractionDigits"]);
+const particleNames = new Set(["sequence", "choice", "all", "group"]);
+const excluded = new Set(["key", "keyref", "unique", "assert", "assertion", "alternative", "openContent", "defaultOpenContent", "explicitTimezone", "redefine"]);
+function sameSource(c, node, left, right) {
+    c.step(node, 12);
+    return c.budget.compareText(left.uri, right.uri) === 0 && c.budget.compareText(left.digest, right.digest) === 0
+        && c.budget.compareText(left.path, right.path) === 0
+        && left.start.offset === right.start.offset && left.end.offset === right.end.offset
+        && left.start.line === right.start.line && left.start.column === right.start.column
+        && left.end.line === right.end.line && left.end.column === right.end.column;
+}
+/** The builder represents one local element source as declaration and use.
+ * Its retained inline child belongs to the exact declaration's anonymous type.
+ */
+function particleInlineType(c, node) {
+    c.step(node, 12);
+    if (node.kind !== "particle" || node.term.kind !== "element" || node.term.declaration.kind !== "local"
+        || node.identity.kind !== "scoped")
+        return;
+    const declaration = c.get(node.term.declaration.target);
+    if (declaration.kind !== "element" || declaration.identity.kind !== "scoped" || declaration.type.kind !== "local"
+        || c.budget.compareText(declaration.identity.owner, node.identity.owner) !== 0
+        || !sameSource(c, node, declaration.context.source, node.context.source))
+        return;
+    const type = c.get(declaration.type.target);
+    if ((type.kind !== "simpleType" && type.kind !== "complexType") || type.identity.kind !== "scoped"
+        || c.budget.compareText(type.identity.owner, declaration.id) !== 0)
+        return;
+    const source = type.context.source, owner = declaration.context.source;
+    c.text(source.path, node);
+    c.text(owner.path, node);
+    c.step(node, 6);
+    const prefix = owner.path + "/";
+    if (c.budget.compareText(source.uri, owner.uri) !== 0 || c.budget.compareText(source.digest, owner.digest) !== 0
+        || !source.path.startsWith(prefix) || source.path.slice(prefix.length).includes("/")
+        || source.start.offset < owner.start.offset || source.end.offset > owner.end.offset)
+        return;
+    return type;
+}
+function checkSchemaSyntax(c, node) {
+    if (node.kind === "wsdl")
+        return;
+    // Fixed grammar tables/closures below are bounded per component; reserve them
+    // before allocation. Input-sized traversal and output are charged separately.
+    c.step(node, 300);
+    const fail = (message, source = node.context.source) => c.fail(node, "schema-for-schemas", message, source);
+    const attrs = (attributes, allowed, source, facet = false) => {
+        for (const a of attributes) {
+            c.step(node);
+            c.text(a.name.local, node);
+            c.text(a.value, node);
+            if (a.name.namespace === XSD_NAMESPACE || !a.name.namespace && !allowed.includes(a.name.local))
+                fail("Attribute is not permitted in this XSD syntax context", source);
+            if (!a.name.namespace && a.name.local === "id" && !isXmlNCName(normalizeWhitespace(a.value, "collapse")))
+                fail("Schema id must be an XML NCName", source);
+            if (!a.name.namespace && (["abstract", "nillable", "mixed"].includes(a.name.local) || facet && a.name.local === "fixed") && !schemaBooleanLexical(a.value))
+                fail("Invalid XML Schema boolean spelling", source);
+            if (!a.name.namespace && ["minOccurs", "maxOccurs"].includes(a.name.local)) {
+                const value = normalizeWhitespace(a.value, "collapse");
+                if (!(a.name.local === "maxOccurs" && value === "unbounded") && !schemaNonNegativeIntegerLexical(value))
+                    fail("Occurrence requires an exact nonnegative integer", source);
+            }
+        }
+    };
+    const global = node.identity.kind === "global", common = ["id"];
+    let allowed;
+    switch (node.kind) {
+        case "element":
+            allowed = [...common, "name", "type", "default", "fixed", "nillable", "block", ...(global ? ["abstract", "final", "substitutionGroup"] : ["form", "minOccurs", "maxOccurs"])];
+            break;
+        case "attribute":
+            allowed = [...common, "name", "type", "default", "fixed", ...(global ? [] : ["form", "use"])];
+            break;
+        case "complexType":
+            allowed = [...common, "mixed", ...(global ? ["name", "abstract", "final", "block"] : [])];
+            break;
+        case "simpleType":
+            allowed = [...common, ...(global ? ["name", "final"] : [])];
+            break;
+        case "group":
+        case "attributeGroup":
+            allowed = [...common, "name"];
+            break;
+        case "attributeGroupUse":
+            allowed = [...common, "ref"];
+            break;
+        case "attributeWildcard":
+            allowed = [...common, "namespace", "processContents"];
+            break;
+        case "attributeUse":
+            allowed = [...common, "name", "ref", "type", "default", "fixed", "form", "use"];
+            break;
+        case "particle": {
+            const bounds = [...common, "minOccurs", "maxOccurs"];
+            allowed = node.term.kind === "any" ? [...bounds, "namespace", "processContents"] : node.term.kind === "group" ? [...bounds, "ref"]
+                : node.term.kind !== "element" ? bounds : node.term.declaration.kind === "symbol" ? [...bounds, "ref"] : [...bounds, "name", "type", "default", "fixed", "nillable", "block", "form"];
+            break;
+        }
+    }
+    c.step(node, allowed.length + common.length + 16);
+    attrs(node.declaredAttributes, allowed, node.context.source);
+    attrs(node.context.schemaAttributes, ["id", "attributeFormDefault", "elementFormDefault", "blockDefault", "finalDefault", "targetNamespace", "version"], node.context.source);
+    for (const a of node.context.schemaAttributes) {
+        c.step(node, 12);
+        c.text(a.value, node);
+        if (!a.name.namespace && ["attributeFormDefault", "elementFormDefault"].includes(a.name.local)
+            && !["qualified", "unqualified"].includes(normalizeWhitespace(a.value, "collapse")))
+            fail("Invalid schema form default");
+    }
+    for (const a of node.declaredAttributes) {
+        c.step(node, 30);
+        c.text(a.value, node);
+        if (!a.name.namespace && ["form", "processContents", "use", "whiteSpace"].includes(a.name.local)) {
+            const domains = { form: ["qualified", "unqualified"], processContents: ["strict", "lax", "skip"], use: ["optional", "required", "prohibited"] };
+            if (domains[a.name.local] && !domains[a.name.local].includes(normalizeWhitespace(a.value, "collapse")))
+                fail("Invalid XSD token spelling");
+        }
+    }
+    // Graph construction retains roles and source positions rather than a
+    // second syntax tree. Reconstruct direct-child ordering from those original
+    // positions; do not infer it from composed/flattened properties.
+    c.step(node);
+    const children = [];
+    const child = (role, source) => {
+        c.step(node);
+        c.text(source.path, node);
+        c.text(node.context.source.path, node);
+        c.text(source.uri, node);
+        c.text(node.context.source.uri, node);
+        const prefix = node.context.source.path + "/";
+        if (source.uri === node.context.source.uri && source.path.startsWith(prefix) && !source.path.slice(prefix.length).includes("/")) {
+            c.step(node, 4);
+            children.push({ role, source });
+        }
+    };
+    for (const annotation of node.annotations)
+        child("annotation", annotation.source);
+    for (const syntax of node.syntaxDetails)
+        child("content", syntax.source);
+    if (node.kind === "complexType") {
+        if (node.content)
+            child("content", c.get(node.content).context.source);
+        for (const id of node.attributes) {
+            const n = c.get(id);
+            child(n.kind === "attributeWildcard" ? "wildcard" : "attribute", n.context.source);
+        }
+    }
+    else if (node.kind === "attributeGroup") {
+        for (const id of node.attributes) {
+            const n = c.get(id);
+            child(n.kind === "attributeWildcard" ? "wildcard" : "attribute", n.context.source);
+        }
+    }
+    else if (node.kind === "group")
+        child("content", c.get(node.content).context.source);
+    else if (node.kind === "particle" && "children" in node.term)
+        for (const id of node.term.children)
+            child("member", c.get(id).context.source);
+    else if (node.kind === "particle") {
+        const type = particleInlineType(c, node);
+        if (type)
+            child("content", type.context.source);
+    }
+    else if ((node.kind === "element" || node.kind === "attribute") && node.type.kind === "local")
+        child("content", c.get(node.type.target).context.source);
+    const ordered = c.budget.sorted(children, (a, b) => { c.step(node); return a.source.start.offset - b.source.start.offset; });
+    let seenAnnotation = false, seenContent = false, stage = 0;
+    for (const item of ordered) {
+        c.step(node);
+        if (item.role === "annotation") {
+            if (stage || seenAnnotation)
+                fail("Annotation must occur once before declaration content", item.source);
+            seenAnnotation = true;
+            continue;
+        }
+        const next = item.role === "content" || item.role === "member" ? 1 : item.role === "attribute" ? 2 : 3;
+        if (item.role === "content") {
+            if (seenContent)
+                fail("Declaration permits at most one content child", item.source);
+            seenContent = true;
+        }
+        if (next < stage || stage === 3)
+            fail("Declaration child violates the XSD source ordering", item.source);
+        stage = next;
+    }
+    c.step(node, node.declaredAttributes.length * 4);
+    if (node.kind === "attributeUse" && node.declaredAttributes.some(a => !a.name.namespace && a.name.local === "default")
+        && node.use !== "optional")
+        c.fail(node, "src-attribute", "Attribute source default requires an optional use");
+    for (const attribute of node.context.schemaAttributes) {
+        c.step(node);
+        if (attribute.name.namespace || !["finalDefault", "blockDefault"].includes(attribute.name.local))
+            continue;
+        c.text(attribute.value, node);
+        const tokens = normalizeWhitespace(attribute.value, "collapse").split(" ").filter(Boolean);
+        const allowed = attribute.name.local === "finalDefault" ? ["extension", "restriction", "list", "union"] : ["extension", "restriction", "substitution"];
+        if (!(tokens.length === 1 && tokens[0] === "#all") && tokens.some(t => !allowed.includes(t)))
+            fail("Invalid schema default derivation set");
+    }
+    if (node.kind === "attribute" && (node.name.local === "xmlns" || node.name.namespace === "http://www.w3.org/2001/XMLSchema-instance"))
+        c.fail(node, "no-xmlns/no-xsi", "User attribute declaration uses a reserved XML Schema name");
+    if (node.kind === "simpleType" || node.kind === "complexType") {
+        for (const syntax of node.syntaxDetails) {
+            c.step(node, 40);
+            if (node.kind === "simpleType")
+                checkBody(syntax, "scalar");
+            else {
+                attrs(syntax.attributes, ["id", ...(syntax.name.local === "complexContent" ? ["mixed"] : [])], syntax.source);
+                const children = elements(syntax);
+                let body, annotation = false;
+                for (const child of children) {
+                    c.step(node);
+                    if (child.name.local === "annotation" && child.name.namespace === XSD_NAMESPACE && !body && !annotation) {
+                        annotation = true;
+                        continue;
+                    }
+                    if (body || child.name.namespace !== XSD_NAMESPACE || !["restriction", "extension"].includes(child.name.local))
+                        fail("Content wrapper requires one restriction or extension after annotation", child.source);
+                    body = child;
+                }
+                if (!body)
+                    fail("Missing content derivation", syntax.source);
+                checkBody(body, syntax.name.local === "complexContent" ? "complex" : "simple");
+            }
+        }
+    }
+    function elements(syntax) {
+        c.step(node);
+        const result = [];
+        for (const child of syntax.children) {
+            c.step(node, 2);
+            if (child.kind === "element")
+                result.push(child);
+            else {
+                c.text(child.value, node);
+                if (/[^\t\r\n ]/.test(child.value))
+                    fail("XSD declaration requires element-only syntax", child.source);
+            }
+        }
+        return result;
+    }
+    function checkBody(body, context) {
+        c.step(node, 50);
+        attrs(body.attributes, ["id", body.name.local === "list" ? "itemType" : body.name.local === "union" ? "memberTypes" : "base"], body.source);
+        let stage = 0, annotation = false, scalarType = false, particle = false, wildcard = false;
+        for (const child of elements(body)) {
+            c.step(node, 40);
+            const name = child.name.local;
+            if (child.name.namespace !== XSD_NAMESPACE)
+                fail("Foreign child belongs in annotation/appinfo", child.source);
+            if (excluded.has(name))
+                c.unsupported(node, `xsd:${name}`, "Excluded schema feature is retained for capability diagnosis", child.source);
+            if (name === "annotation") {
+                if (stage || annotation)
+                    fail("Annotation must occur once before the content", child.source);
+                annotation = true;
+                continue;
+            }
+            if (name === "simpleType" && (context === "scalar" || context === "simple" && body.name.local === "restriction")
+                && stage <= 1 && (body.name.local === "union" || !scalarType)) {
+                scalarType = true;
+                stage = 1;
+                continue;
+            }
+            if (facetNames.has(name) && body.name.local === "restriction" && context !== "complex" && stage <= 2) {
+                stage = 2;
+                attrs(child.attributes, ["id", "value", ...(["enumeration", "pattern"].includes(name) ? [] : ["fixed"])], child.source, true);
+                const contents = elements(child);
+                if (contents.length > 1 || contents.some(n => n.name.namespace !== XSD_NAMESPACE || n.name.local !== "annotation"))
+                    fail("Facet permits only an optional annotation", child.source);
+                continue;
+            }
+            if (context === "complex" && particleNames.has(name) && stage < 3 && !particle) {
+                particle = true;
+                stage = 3;
+                continue;
+            }
+            if (context !== "scalar" && ["attribute", "attributeGroup"].includes(name) && !wildcard) {
+                stage = 4;
+                continue;
+            }
+            if (context !== "scalar" && name === "anyAttribute" && !wildcard) {
+                stage = 5;
+                wildcard = true;
+                continue;
+            }
+            fail("Child is not permitted at this position in the XSD content grammar", child.source);
+        }
+    }
+}
+/**
+ * Checks the source slice retained by the canonical node. This is not a complete
+ * schema-for-schemas validator, and has no hypothetical-construction authority.
+ */
+export function checkActualSchemaSyntax(context, nodeId) {
+    assertSemanticContext(context);
+    return context.budget.guard(() => {
+        const b = context.budget;
+        b.chargeWork(200 + nodeId.length);
+        const publish = (result) => b.freeze(b.snapshot(result));
+        if (context.kind !== 'actual')
+            return publish({ kind: 'unresolved', rule: 'actual-source-only',
+                component: nodeId, message: 'Hypothetical components do not acquire XML source representation obligations' });
+        const found = context.lookup(nodeId);
+        if (found.kind !== 'found')
+            return publish({ kind: 'unresolved', rule: 'src-resolve',
+                component: nodeId, message: `Original component is ${found.kind}` });
+        const node = found.node;
+        if (node.kind === 'wsdl')
+            return publish({ kind: 'unresolved', rule: 'xsd-source-only',
+                component: node.id, source: node.context.source, message: 'WSDL representation is outside the XSD source owner' });
+        const c = schemaScalarContext(context);
+        c.setCurrent(node);
+        try {
+            checkSchemaSyntax(c, node);
+            declarationMethods(context, node, 'final');
+            declarationMethods(context, node, 'block');
+            const inline = node.retained.length ? particleInlineType(c, node) : undefined;
+            let inlineSeen = false;
+            for (const retained of node.retained) {
+                c.step(node);
+                c.text(retained.name.local, node);
+                if (!inlineSeen && inline && retained.name.namespace === XSD_NAMESPACE && retained.name.local === inline.kind
+                    && sameSource(c, node, retained.source, inline.context.source)) {
+                    inlineSeen = true;
+                    continue;
+                }
+                if (retained.name.namespace === XSD_NAMESPACE && ['key', 'unique', 'keyref'].includes(retained.name.local)
+                    && context.originalIdentityConstraints().ownsSyntax(node, retained))
+                    continue;
+                if (retained.name.namespace === XSD_NAMESPACE && excluded.has(retained.name.local))
+                    c.unsupported(node, `xsd:${retained.name.local}`, 'Retained feature needs its separate capability authority', retained.source);
+                c.fail(node, 'schema-for-schemas', 'Unexpected child in the declaration content grammar', retained.source);
+            }
+            if (node.kind === 'group') {
+                const content = c.get(node.content);
+                c.step(node, content.declaredAttributes.length);
+                if (content.kind !== 'particle' || content.declaredAttributes.some(a => !a.name.namespace && ['minOccurs', 'maxOccurs'].includes(a.name.local)))
+                    c.fail(node, 'src-group', 'Named group compositors cannot declare occurrence attributes');
+            }
+            return publish({ kind: 'checked', contextId: context.contextId, component: node.id,
+                authority: 'XSD10-original-component-syntax-v1', scope: 'original-component-source-syntax',
+                remaining: ['schema-document-syntax', 'child-component-syntax', 'semantic-construction'] });
+        }
+        catch (error) {
+            if (error instanceof RelationProblem)
+                return publish({ kind: error.result.kind === 'invalid-input' ? 'invalid-schema' : 'unresolved',
+                    rule: error.result.rule, component: node.id, message: error.result.message, source: node.context.source });
+            if (!(error instanceof SchemaAssessmentError))
+                throw error;
+            return publish({ kind: error.category === 'missing-prerequisite' || error.category === 'scalar-indeterminate'
+                    ? 'unresolved' : error.category, rule: error.rule, component: node.id, message: error.message, source: error.source });
+        }
+    });
+}

package/dist/compiler/schemaTemporalAliases.d.ts

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