@techspokes/typescript-wsdl-client 1.1.3 → 1.1.5

package/dist/compiler/schemaDocumentSyntax.js

@@ -0,0 +1,294 @@
+import { XSD_NAMESPACE, XML_NAMESPACE } from '../loader/orderedSyntax.js';
+import { assertSemanticContext, prepareSemanticRequest } from './semanticContext.js';
+import { createSemanticBudget } from './semanticBudget.js';
+import { normalizeWhitespace } from './schemaDatatypeValues.js';
+import { schemaUri } from './schemaUri.js';
+import { assessSchemaSourceWildcards, validSchemaXmlLanguage } from './schemaSourceWildcards.js';
+import { checkNotationProperties, equalNotationProperties, notationNameKey, readSourceNotationProperties, sourceNotationNamespace } from './schemaNotationProperties.js';
+import { prepareBoundSourceGraph, sourceSchemasForResolvedGraph } from './sourceSchemaBinding.js';
+const sourceDocuments = new WeakMap();
+/**
+ * One issued input snapshot owns both graph construction and retained source syntax.
+ * Loading happened before entry. Canonical construction/reference resolution retain
+ * their named legacy limits; the snapshot/context/syntax share the supplied budget.
+ */
+export function prepareSourceSchemaRequest(input, options = {}) {
+    const budget = options.budget ?? createSemanticBudget();
+    const source = prepareBoundSourceGraph(input, { budget, sourceLimits: options.sourceLimits, accountPreparation: options.accountPreparation });
+    if (source.kind !== 'prepared')
+        return source;
+    return budget.guard(() => {
+        const prepared = prepareSemanticRequest(source.resolved, { budget });
+        if (prepared.kind === 'prepared') {
+            budget.chargeWork(2);
+            sourceDocuments.set(prepared.request.actual, sourceSchemasForResolvedGraph(source.resolved));
+        }
+        return prepared;
+    });
+}
+class DocumentProblem extends Error {
+    kind;
+    rule;
+    source;
+    constructor(kind, rule, message, source) {
+        super(message);
+        this.kind = kind;
+        this.rule = rule;
+        this.source = source;
+    }
+}
+const globals = new Set(['simpleType', 'complexType', 'element', 'attribute', 'group', 'attributeGroup', 'notation']);
+const unsupported = new Set(['redefine', 'override', 'assert', 'assertion', 'alternative', 'openContent', 'defaultOpenContent', 'explicitTimezone']);
+const rootAttributes = ['id', 'attributeFormDefault', 'elementFormDefault', 'blockDefault', 'finalDefault', 'targetNamespace', 'version'];
+/** Checks source document representation only; component grammar/semantics remain owned elsewhere. */
+export function checkSchemaDocumentSyntax(context) {
+    assertSemanticContext(context);
+    const budget = context.budget;
+    return budget.guard(() => {
+        budget.chargeWork(100);
+        if (context.kind !== 'actual')
+            return Object.freeze({ kind: 'unresolved', rule: 'actual-source-only' });
+        const schemas = sourceDocuments.get(context);
+        if (!schemas)
+            return Object.freeze({ kind: 'unresolved', rule: 'missing-source-syntax' });
+        budget.chargeWork(16);
+        const checkedRoots = new Set();
+        const sources = [];
+        const wildcardObligations = [];
+        const step = (_owner, count = 1) => budget.chargeWork(count);
+        const text = (value) => budget.chargeWork(2 + value.length * 4);
+        const fail = (node, rule, message) => {
+            budget.chargeWork(8 + rule.length + message.length);
+            throw new DocumentProblem('invalid-schema', rule, message, node.source);
+        };
+        const rejectUnsupported = (node) => {
+            text(node.name.local);
+            budget.chargeWork(150);
+            throw new DocumentProblem('unsupported-capability', `xsd:${node.name.local}`, 'Source feature is outside the approved XSD 1.0 profile', node.source);
+        };
+        const value = (node, name) => {
+            for (const attr of node.attributes) {
+                budget.chargeWork(4);
+                text(attr.name.local);
+                if (attr.name.namespace === '' && attr.name.local === name) {
+                    text(attr.value);
+                    return normalizeWhitespace(attr.value, 'collapse');
+                }
+            }
+            return undefined;
+        };
+        const uri = (node, lexical) => {
+            if (!schemaUri(lexical, node, { step }))
+                fail(node, 'schema-for-schemas', 'Invalid schema anyURI value');
+        };
+        const notationProperties = (node, namespace) => {
+            const mapped = readSourceNotationProperties(node, namespace, budget);
+            if (mapped.kind === 'invalid-schema')
+                return fail(node, mapped.rule, mapped.message);
+            return mapped.properties;
+        };
+        const attrs = (node, allowed, language = false) => {
+            for (const attr of node.attributes) {
+                budget.chargeWork(10 + allowed.length);
+                text(attr.name.local);
+                text(attr.name.namespace);
+                text(attr.value);
+                if (language && attr.name.namespace === XML_NAMESPACE && attr.name.local === 'lang') {
+                    if (!validSchemaXmlLanguage(attr.value, budget))
+                        fail(node, 'schema-for-schemas', 'Invalid language value');
+                }
+                else if (attr.name.namespace === XSD_NAMESPACE || attr.name.namespace === '' && !allowed.includes(attr.name.local)) {
+                    fail(node, 'schema-for-schemas', 'Attribute is not permitted in this schema document syntax');
+                }
+            }
+        };
+        const children = (node) => {
+            budget.chargeWork(2);
+            const result = [];
+            for (const child of node.children) {
+                budget.chargeWork(3);
+                if (child.kind === 'element') {
+                    budget.chargeWork();
+                    result.push(child);
+                }
+                else {
+                    text(child.value);
+                    if (/[^\t\r\n ]/.test(child.value))
+                        fail(node, 'schema-for-schemas', 'Schema syntax requires element-only content');
+                }
+            }
+            return result;
+        };
+        try {
+            for (const schema of schemas) {
+                budget.chargeWork(8);
+                text(schema.key);
+                text(schema.digest);
+                sources.push(Object.freeze({ key: schema.key, digest: schema.digest, source: schema.syntax.source }));
+                const root = schema.syntax;
+                if (checkedRoots.has(root))
+                    continue;
+                budget.chargeWork(5);
+                checkedRoots.add(root);
+                // Preserve source-profile classification before evaluating the separate
+                // S4S instance episode. Inert annotation descendants are not components.
+                budget.chargeWork(2);
+                const sourceStack = [root];
+                while (sourceStack.length) {
+                    budget.chargeWork(3);
+                    const node = sourceStack.pop();
+                    if (node.name.namespace !== XSD_NAMESPACE)
+                        continue;
+                    text(node.name.local);
+                    if (unsupported.has(node.name.local))
+                        rejectUnsupported(node);
+                    if (node.name.local === 'annotation')
+                        continue;
+                    for (const child of node.children) {
+                        budget.chargeWork(2);
+                        if (child.kind === 'element') {
+                            budget.chargeWork();
+                            sourceStack.push(child);
+                        }
+                    }
+                }
+                const wildcardResult = assessSchemaSourceWildcards(root, budget);
+                if (wildcardResult.kind !== 'checked')
+                    return wildcardResult;
+                budget.chargeWork(wildcardResult.remaining.length + 1);
+                wildcardObligations.push(...wildcardResult.remaining);
+                attrs(root, rootAttributes, true);
+                const namespace = value(root, 'targetNamespace');
+                if (namespace !== undefined) {
+                    if (namespace === '')
+                        fail(root, 'declare-schema', 'An explicit target namespace cannot be empty');
+                    uri(root, namespace);
+                }
+                for (const name of ['attributeFormDefault', 'elementFormDefault']) {
+                    const form = value(root, name);
+                    if (form !== undefined && form !== 'qualified' && form !== 'unqualified')
+                        fail(root, 'schema-for-schemas', 'Invalid schema form default');
+                }
+                for (const name of ['blockDefault', 'finalDefault']) {
+                    const lexical = value(root, name);
+                    if (lexical === undefined || lexical === '' || lexical === '#all')
+                        continue;
+                    text(lexical);
+                    budget.chargeWork(10);
+                    const allowed = name === 'blockDefault' ? ['extension', 'restriction', 'substitution'] : ['extension', 'restriction', 'list', 'union'];
+                    if (lexical.split(' ').some(token => !allowed.includes(token)))
+                        fail(root, 'schema-for-schemas', 'Invalid schema default derivation set');
+                }
+                budget.chargeWork();
+                const notationNames = new Set();
+                let declarations = false;
+                for (const child of children(root)) {
+                    budget.chargeWork(4);
+                    text(child.name.local);
+                    text(child.name.namespace);
+                    if (child.name.namespace !== XSD_NAMESPACE)
+                        fail(child, 'schema-for-schemas', 'Schema root child must be an XSD declaration');
+                    const role = child.name.local;
+                    if (unsupported.has(role))
+                        rejectUnsupported(child);
+                    if (role === 'annotation')
+                        continue;
+                    if (role === 'include' || role === 'import') {
+                        if (declarations)
+                            fail(child, 'schema-for-schemas', 'Schema directives must precede declarations');
+                        attrs(child, role === 'include' ? ['id', 'schemaLocation'] : ['id', 'namespace', 'schemaLocation']);
+                        const location = value(child, 'schemaLocation');
+                        if (location !== undefined)
+                            uri(child, location);
+                        else if (role === 'include')
+                            fail(child, 'schema-for-schemas', 'Include requires schemaLocation');
+                        if (role === 'import') {
+                            const imported = value(child, 'namespace');
+                            if (imported !== undefined) {
+                                uri(child, imported);
+                                if (imported === namespace)
+                                    fail(child, 'src-import', 'Import namespace must differ from the enclosing target namespace');
+                            }
+                            else if (namespace === undefined)
+                                fail(child, 'src-import', 'Import without namespace requires an enclosing target namespace');
+                        }
+                        continue;
+                    }
+                    if (!globals.has(role))
+                        fail(child, 'schema-for-schemas', 'Unexpected schema root child');
+                    declarations = true;
+                    if (role === 'notation') {
+                        attrs(child, ['id', 'name', 'public', 'system']);
+                        const properties = notationProperties(child, namespace ?? '');
+                        const valid = checkNotationProperties(properties, budget);
+                        if (valid.kind === 'invalid-schema')
+                            fail(child, valid.rule, valid.message);
+                        const name = properties.name.local;
+                        // S4S schema/notation key is scoped to this physical schema root.
+                        // Equal cross-document representations are reconciled separately.
+                        text(name);
+                        budget.chargeWork(2);
+                        if (notationNames.has(name))
+                            fail(child, 'schema-notation-key', 'Notation names must be unique within their schema validation root');
+                        notationNames.add(name);
+                    }
+                }
+                // Contextual S4S owns typed ID/IDREF scope across source and payload;
+                // the source profile walk above does not type them a second time.
+            }
+            // no-identity fixes top-level notation identity by component kind and
+            // expanded name. Equal complete property records describe that one
+            // component even when represented by distinct original XML declarations.
+            // Absence is a property state, not unknown information to fill from peers.
+            // All original annotations and document obligations were checked above.
+            budget.chargeWork(3);
+            const notations = new Map();
+            let namespaceInterpretation = false;
+            for (const schema of schemas) {
+                budget.chargeWork(5);
+                text(schema.targetNamespace);
+                text(schema.context.namespace);
+                const effectiveNamespace = sourceNotationNamespace(schema, budget);
+                // The legacy loader preserves raw namespace spellings. Source anyURI
+                // normalization must not silently certify that legacy symbol mapping.
+                if (schema.targetNamespace !== effectiveNamespace)
+                    namespaceInterpretation = true;
+                for (const child of schema.syntax.children) {
+                    budget.chargeWork(5);
+                    if (child.kind !== 'element' || child.name.namespace !== XSD_NAMESPACE || child.name.local !== 'notation')
+                        continue;
+                    const properties = notationProperties(child, effectiveNamespace);
+                    const key = notationNameKey(properties.name, budget);
+                    const previous = notations.get(key);
+                    if (previous !== undefined) {
+                        if (!equalNotationProperties(previous, properties, budget)) {
+                            fail(child, 'notation-component-properties', 'Same-name notation representations must have equal public and system identifier properties');
+                        }
+                    }
+                    else {
+                        budget.chargeWork();
+                        notations.set(key, properties);
+                    }
+                }
+            }
+            budget.chargeWork(500 + context.contextId.length);
+            const remaining = ['child-component-syntax', 'semantic-construction'];
+            for (const category of ['foreign-attribute-assessment', 'annotation-payload-assessment']) {
+                budget.chargeWork(wildcardObligations.length + 1);
+                if (wildcardObligations.some(obligation => obligation.category === category))
+                    remaining.push(category);
+            }
+            if (namespaceInterpretation)
+                remaining.push('namespace-interpretation');
+            return Object.freeze({ kind: 'checked', authority: 'XSD10-schema-document-syntax-v1', scope: 'schema-document-source-syntax',
+                contextId: context.contextId, sources: Object.freeze(sources), remaining: Object.freeze(remaining),
+                wildcardObligations: Object.freeze(wildcardObligations) });
+        }
+        catch (error) {
+            if (!(error instanceof DocumentProblem))
+                throw error;
+            budget.chargeWork(180 + error.rule.length + error.message.length);
+            return Object.freeze({ kind: error.kind, rule: error.rule, message: error.message, source: error.source });
+        }
+    });
+}

package/dist/compiler/schemaDurationLanguage.d.ts

@@ -0,0 +1,11 @@
+import type { Duration } from './schemaExactCalendar.js';
+import type { RegularLanguage } from './schemaRegularLanguage.js';
+import { schemaRegularLanguages } from './schemaRegularLanguage.js';
+import type { SchemaPatternContext } from './schemaValueContext.js';
+export declare function schemaDurationLanguages<Owner>(c: SchemaPatternContext<Owner>, regular: ReturnType<typeof schemaRegularLanguages<Owner>>, expression: (text: string, owner: Owner) => RegularLanguage): {
+    bound: (input: RegularLanguage, endpoint: Duration, name: "minInclusive" | "minExclusive" | "maxInclusive" | "maxExclusive", owner: Owner) => RegularLanguage;
+    valid: (owner: Owner) => Readonly<{
+        kind: "private-regular-language";
+    }>;
+};
+//# sourceMappingURL=schemaDurationLanguage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaDurationLanguage.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaDurationLanguage.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAA0B,QAAQ,EAAC,MAAM,0BAA0B,CAAC;AAChF,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAC,sBAAsB,EAAC,MAAM,4BAA4B,CAAC;AAGlE,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,yBAAyB,CAAC;AAGlE,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,CAAC,EAAE,oBAAoB,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,KAAK,CAAC,CAAC,EACtI,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,eAAe;mBAyCrC,eAAe,YAAY,QAAQ,QAAQ,cAAc,GAAG,cAAc,GAAG,cAAc,GAAG,cAAc,SAAS,KAAK,KAAG,eAAe;mBAF5I,KAAK;;;EA0F5B"}

package/dist/compiler/schemaDurationLanguage.js

@@ -0,0 +1,170 @@
+/** Complete duration-bound preimages for the four strict Appendix E anchors. */
+import { addDuration, parseCalendar } from './schemaExactCalendar.js';
+import { schemaRegularLanguages } from './schemaRegularLanguage.js';
+import { schemaDecimalLanguages } from './schemaDecimalLanguage.js';
+import { durationAliasExpressions } from './schemaTemporalAliases.js';
+const ANCHORS = ['1696-09-01T00:00:00Z', '1697-02-01T00:00:00Z', '1903-03-01T00:00:00Z', '1903-07-01T00:00:00Z'];
+export function schemaDurationLanguages(c, regular, expression) {
+    const decimals = schemaDecimalLanguages(c);
+    const integer = '[0-9]+', seconds = '[0-9]+([.][0-9]+)?';
+    const rest = '([0-9]+D)?(T([0-9]+H)?([0-9]+M)?(' + seconds + 'S)?)?';
+    const time = '(T([0-9]+H)?([0-9]+M)?(' + seconds + 'S)?)?';
+    const budget = (owner) => ({ charge: count => c.step(owner, count),
+        arithmetic: digits => c.step(owner, (digits + 4) ** 2), text: value => { c.text(value, owner); } });
+    const text = (value, owner) => {
+        c.step(owner, (value.digits + value.scale + 4) ** 2);
+        c.step(owner, value.digits + value.scale + 4);
+        const negative = value.coefficient < 0n, digits = (negative ? -value.coefficient : value.coefficient).toString().padStart(value.scale + 1, '0');
+        return (negative ? '-' : '') + (value.scale ? digits.slice(0, -value.scale) + '.' + digits.slice(-value.scale) : digits);
+    };
+    const field = (value, unit, owner, digits) => {
+        c.step(owner, (digits + 4) ** 2 + digits * 2 + 16);
+        return value ? '0*' + value.toString() + unit : '(0+' + unit + ')?';
+    };
+    const relation = (value, greater, owner) => {
+        const source = decimals.relation(text(value, owner), greater, owner);
+        return source === undefined ? regular.union([], owner) : expression(source, owner);
+    };
+    const integers = (source, prefix, suffix, maximum, owner, digits) => {
+        function* values() {
+            if (maximum < 0n)
+                return;
+            c.step(owner, prefix.length + suffix.length + 8);
+            const p = expression(prefix, owner), s = expression(suffix, owner);
+            const projected = regular.intersect([regular.quotient(source, p, s, owner), expression(integer, owner)], owner);
+            const zero = regular.witness(regular.intersect([projected, expression('0+', owner)], owner), owner) !== undefined
+                || regular.witness(regular.intersect([source, regular.concatenate([p, expression(suffix.slice(1), owner)], owner)], owner), owner) !== undefined;
+            if (zero)
+                yield 0n;
+            // Removing leading zeroes preserves the numeric image, and the finite
+            // upper bound makes the remaining canonical-word graph acyclic.
+            const canonical = regular.intersect([regular.quotient(projected, expression('0*', owner), expression('', owner), owner),
+                expression('[1-9][0-9]*', owner), regular.negate(relation({ coefficient: maximum, scale: 0, digits }, true, owner), owner)], owner);
+            const finite = regular.finiteWords(canonical, owner);
+            if (finite.kind !== 'finite')
+                throw new TypeError('A bounded canonical nonnegative integer language must be finite');
+            for (const word of finite.words) {
+                c.step(owner, (word.length + 4) ** 2);
+                yield BigInt(word);
+            }
+        }
+        return values();
+    };
+    const valid = (owner) => regular.intersect([expression('\\-?P([0-9]+Y)?([0-9]+M)?' + rest, owner),
+        regular.negate(expression('\\-?P|\\-?P([0-9]+Y)?([0-9]+M)?([0-9]+D)?T', owner), owner)], owner);
+    const bound = (input, endpoint, name, owner) => {
+        const source = regular.intersect([input, valid(owner)], owner), greater = name.startsWith('min'), b = budget(owner);
+        b.arithmetic(endpoint.digits + endpoint.seconds.scale + 16);
+        const scale = endpoint.seconds.scale, power = 10n ** BigInt(scale), unit = 28n * 86400n * power;
+        const digits = endpoint.digits + scale + 64;
+        const integerText = (value) => { c.step(owner, (digits + 4) ** 2 + digits + 2); return value.toString(); };
+        c.step(owner, 16);
+        const starts = ANCHORS.map(anchor => parseCalendar('dateTime', anchor, b));
+        const targets = starts.map(start => addDuration(start, endpoint, b));
+        let largest = 0n;
+        for (let index = 0; index < starts.length; index++) {
+            b.arithmetic(endpoint.digits + starts[index].digits + scale + 16);
+            const delta = targets[index].coefficient - starts[index].seconds.coefficient * power;
+            const magnitude = delta < 0n ? -delta : delta;
+            if (magnitude > largest)
+                largest = magnitude;
+        }
+        b.arithmetic(endpoint.digits + scale + 16);
+        const cutoff = largest / unit + 2n;
+        c.step(owner, 4);
+        const choices = [];
+        const possible = (value) => regular.witness(regular.intersect([source, expression(value, owner)], owner), owner) !== undefined;
+        const append = (value) => { c.step(owner, value.length + 2); choices.push(regular.intersect([source, expression(value, owner)], owner)); };
+        const secondsPredicate = (prefix, threshold, more) => {
+            b.arithmetic(threshold.digits + threshold.scale + 16);
+            const p = 10n ** BigInt(threshold.scale), coefficient = threshold.coefficient;
+            if (coefficient < 0n) {
+                if (more)
+                    append(prefix + rest);
+                return;
+            }
+            const floorDay = coefficient / (86400n * p);
+            const large = (limit) => {
+                const language = decimals.relation(integerText(limit), true, owner);
+                c.step(owner, language.length + 8);
+                return '(' + language + ')';
+            };
+            if (more)
+                append(prefix + large(floorDay) + 'D' + time);
+            for (const day of integers(source, prefix, 'D' + time, floorDay, owner, digits)) {
+                b.arithmetic(threshold.digits + threshold.scale + 16);
+                const afterDay = coefficient - day * 86400n * p, dayPrefix = prefix + field(day, 'D', owner, digits);
+                // No T denotes exactly the integral day contribution.
+                if (more ? afterDay < 0n : afterDay > 0n)
+                    append(dayPrefix);
+                const hLimit = afterDay / (3600n * p);
+                if (more)
+                    append(dayPrefix + 'T' + large(hLimit) + 'H([0-9]+M)?(' + seconds + 'S)?');
+                for (const hour of integers(source, dayPrefix + 'T', 'H([0-9]+M)?(' + seconds + 'S)?', hLimit, owner, digits)) {
+                    b.arithmetic(threshold.digits + threshold.scale + 16);
+                    const afterHour = afterDay - hour * 3600n * p, hourPrefix = dayPrefix + 'T' + field(hour, 'H', owner, digits), minuteLimit = afterHour / (60n * p);
+                    if (more)
+                        append(hourPrefix + large(minuteLimit) + 'M(' + seconds + 'S)?');
+                    for (const minute of integers(source, hourPrefix, 'M(' + seconds + 'S)?', minuteLimit, owner, digits)) {
+                        b.arithmetic(threshold.digits + threshold.scale + 16);
+                        const remainder = afterHour - minute * 60n * p, minutePrefix = hourPrefix + field(minute, 'M', owner, digits);
+                        const predicate = relation({ ...threshold, coefficient: remainder }, more, owner);
+                        choices.push(regular.intersect([source, regular.concatenate([expression(minutePrefix, owner),
+                                regular.intersect([expression(seconds, owner), predicate], owner), expression('S', owner)], owner)], owner));
+                        if (!more && remainder > 0n)
+                            append(minutePrefix);
+                    }
+                    // An omitted minute is zero and is already represented above.
+                }
+                // Omitted hours/minutes are represented by the zero projections.
+            }
+        };
+        for (const negative of [false, true]) {
+            const prefix = (negative ? '\\-' : '') + 'P';
+            const automatic = negative ? !greater : greater;
+            const yearLimit = (cutoff - 1n) / 12n;
+            if (automatic) {
+                const y = decimals.relation(integerText(yearLimit), true, owner);
+                append(prefix + '(' + y + ')Y([0-9]+M)?' + rest);
+            }
+            for (const year of integers(source, prefix, 'Y([0-9]+M)?' + rest, yearLimit, owner, digits)) {
+                const yPrefix = prefix + field(year, 'Y', owner, digits), monthLimit = cutoff - 1n - year * 12n;
+                if (automatic) {
+                    const m = decimals.relation(integerText(monthLimit), true, owner);
+                    append(yPrefix + '(' + m + ')M' + rest);
+                }
+                for (const month of integers(source, yPrefix, 'M' + rest, monthLimit, owner, digits)) {
+                    const mPrefix = yPrefix + field(month, 'M', owner, digits);
+                    if (!possible(mPrefix + rest))
+                        continue;
+                    b.arithmetic(endpoint.digits + scale + 32);
+                    const magnitude = year * 12n + month;
+                    c.step(owner, 8);
+                    const duration = { months: negative ? -magnitude : magnitude,
+                        seconds: { coefficient: 0n, scale: 0, digits: 1 }, digits: endpoint.digits + 32, lexical: '' };
+                    const deltas = starts.map((start, index) => {
+                        const at = addDuration(start, duration, b);
+                        b.arithmetic(endpoint.digits + at.digits + scale + 16);
+                        return negative ? at.coefficient * power - targets[index].coefficient : targets[index].coefficient - at.coefficient * power;
+                    });
+                    const more = negative ? !greater : greater;
+                    let threshold = deltas[0];
+                    for (const delta of deltas) {
+                        c.step(owner);
+                        if (more ? delta > threshold : delta < threshold)
+                            threshold = delta;
+                    }
+                    secondsPredicate(mPrefix, { coefficient: threshold, scale, digits: endpoint.digits + scale + 32 }, more);
+                }
+            }
+        }
+        // Appendix E returns equality only for the same (months, seconds) pair.
+        // Equality at all four anchors with a different pair is indeterminate.
+        if (name.endsWith('Inclusive'))
+            for (const alias of durationAliasExpressions(endpoint, owner, c, possible))
+                append(alias);
+        c.step(owner, choices.length + 2);
+        return regular.union(choices, owner);
+    };
+    return { bound, valid };
+}

package/dist/compiler/schemaElementProperties.d.ts

@@ -0,0 +1,16 @@
+/** Abstract declaration flags; GraphNode carries the other canonical declaration properties. */
+import type { NodeId } from './canonicalGraph.js';
+import type { SemanticBudget } from './semanticBudget.js';
+import type { SemanticTypeReference } from './semanticTypeReference.js';
+import type { OriginalIdentityConstraintId } from './schemaIdentityConstraints.js';
+export type RawElementProperties = Readonly<{
+    element: NodeId;
+    /** Explicit semantic type overrides the canonical source contribution. */
+    type?: SemanticTypeReference;
+    /** Original IC identities only, admitted at this ELEMENT's genuine first birth. */
+    identityConstraints?: readonly OriginalIdentityConstraintId[];
+    final: readonly ('restriction' | 'extension')[];
+    block: readonly ('restriction' | 'extension' | 'substitution')[];
+}>;
+export declare function validateRawElementShape(value: unknown, budget: SemanticBudget): value is RawElementProperties;
+//# sourceMappingURL=schemaElementProperties.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaElementProperties.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaElementProperties.ts"],"names":[],"mappings":"AAAA,gGAAgG;AAChG,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAExD,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,4BAA4B,CAAC;AACtE,OAAO,KAAK,EAAC,4BAA4B,EAAC,MAAM,gCAAgC,CAAC;AACjF,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,0EAA0E;IAC1E,IAAI,CAAC,EAAE,qBAAqB,CAAC;IAC7B,mFAAmF;IACnF,mBAAmB,CAAC,EAAE,SAAS,4BAA4B,EAAE,CAAC;IAC9D,KAAK,EAAE,SAAS,CAAC,aAAa,GAAG,WAAW,CAAC,EAAE,CAAC;IAChD,KAAK,EAAE,SAAS,CAAC,aAAa,GAAG,WAAW,GAAG,cAAc,CAAC,EAAE,CAAC;CAClE,CAAC,CAAC;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,cAAc,GAAG,KAAK,IAAI,oBAAoB,CAgB7G"}

package/dist/compiler/schemaElementProperties.js

@@ -0,0 +1,23 @@
+import { assertSemanticTypeReferenceShape } from './semanticTypeReference.js';
+export function validateRawElementShape(value, budget) {
+    budget.chargeWork(8);
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const row = value;
+    if (typeof row.element !== 'string' || !Array.isArray(row.final) || !Array.isArray(row.block))
+        return false;
+    if (row.type !== undefined)
+        assertSemanticTypeReferenceShape(row.type, budget);
+    if (row.identityConstraints !== undefined) {
+        if (!Array.isArray(row.identityConstraints))
+            return false;
+        budget.chargeWork(4 + row.identityConstraints.length * 2);
+        for (const identity of row.identityConstraints) {
+            if (typeof identity !== 'string')
+                return false;
+            budget.chargeWork(identity.length);
+        }
+    }
+    budget.chargeWork(row.element.length + row.final.length * 4 + row.block.length * 4);
+    return row.final.every(x => x === 'restriction' || x === 'extension') && row.block.every(x => x === 'restriction' || x === 'extension' || x === 'substitution');
+}

package/dist/compiler/schemaEndpointWordCapacity.d.ts

@@ -0,0 +1,36 @@
+/** Private alias capacity builder; its metrics come from the formed scalar owner. */
+export type EndpointCapacityExpression = Readonly<{
+    kind: 'integer';
+    value: string;
+}> | Readonly<{
+    kind: 'add' | 'multiply';
+    children: readonly EndpointCapacityExpression[];
+}> | Readonly<{
+    kind: 'power';
+    base: EndpointCapacityExpression;
+    exponent: string;
+}>;
+export type EndpointCapacityMetrics = Readonly<{
+    family: string;
+    roles: number;
+    formulaLeaves: number;
+    rawMaskStates: number;
+    constantCount: number;
+    constantTextUnits: number;
+    inputMagnitude: bigint;
+    magnitudeDigits: number;
+}>;
+export declare function endpointCapacity(metrics: EndpointCapacityMetrics, step: (count: number) => void): {
+    kind: "finite-capacity";
+    family: string;
+    roles: number;
+    formulaLeaves: number;
+    maskStates: number;
+    constants: number;
+    equations: number;
+    tracks: number;
+    fieldStates: EndpointCapacityExpression;
+    jointStates: EndpointCapacityExpression;
+    encodedTuple: EndpointCapacityExpression;
+};
+//# sourceMappingURL=schemaEndpointWordCapacity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaEndpointWordCapacity.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaEndpointWordCapacity.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,MAAM,MAAM,0BAA0B,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAAC,GAC/E,QAAQ,CAAC;IAAC,IAAI,EAAE,KAAK,GAAG,UAAU,CAAC;IAAC,QAAQ,EAAE,SAAS,0BAA0B,EAAE,CAAA;CAAC,CAAC,GACrF,QAAQ,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,0BAA0B,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC;AAClF,MAAM,MAAM,uBAAuB,GAAG,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAC1H,aAAa,EAAE,MAAM,CAAC;IAAC,iBAAiB,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC;AACtG,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI;;;;;;;;;;;;EA+B/F"}

package/dist/compiler/schemaEndpointWordCapacity.js

@@ -0,0 +1,39 @@
+export function endpointCapacity(metrics, step) {
+    // Reserve the entire fixed AST topology, rest arrays, closures and metadata before construction.
+    step(1024 + metrics.magnitudeDigits * 2);
+    const count = (n) => {
+        if (!Number.isSafeInteger(n) || n < 0) {
+            step(Number.MAX_SAFE_INTEGER);
+            throw new Error('Unreachable exhausted capacity count');
+        }
+        return n;
+    };
+    const integer = (value) => {
+        const digits = typeof value === 'number' ? 24 : metrics.magnitudeDigits + 64;
+        step(digits + 8);
+        const text = value.toString();
+        return { kind: 'integer', value: text };
+    };
+    const combine = (kind, children) => {
+        step(children.length + 4);
+        return { kind, children };
+    };
+    const power = (base, exponent) => {
+        count(exponent);
+        step(32);
+        return { kind: 'power', base, exponent: String(exponent) };
+    };
+    const add = (...parts) => combine('add', parts);
+    const multiply = (...parts) => combine('multiply', parts);
+    const nStates = count(1 + metrics.rawMaskStates + 16 * metrics.constantTextUnits + 512);
+    const equations = count(16 * metrics.formulaLeaves + 4 * metrics.roles + 4);
+    const tracks = count(7 * metrics.roles + 6 * metrics.constantCount + equations + 1);
+    step((metrics.magnitudeDigits + 64) ** 2 + 16);
+    const carry = BigInt(tracks + 1) * 1000000000000000n * (1n + metrics.inputMagnitude);
+    const fieldStates = power(integer(2), count(64 * (nStates + 1)));
+    const jointStates = multiply(add(power(multiply(integer(2), fieldStates), tracks), power(add(fieldStates, integer(1)), tracks)), power(integer(2n * carry + 1n), equations), power(integer(2), tracks));
+    const encodedTuple = multiply(integer(count(2 * metrics.roles)), add(multiply(integer(8), add(jointStates, integer(1))), integer(count(2 * nStates + 64))));
+    step(16);
+    return { kind: 'finite-capacity', family: metrics.family, roles: metrics.roles, formulaLeaves: metrics.formulaLeaves,
+        maskStates: metrics.rawMaskStates, constants: metrics.constantCount, equations, tracks, fieldStates, jointStates, encodedTuple };
+}