@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/schemaBinaryWordReconstruction.d.ts

@@ -0,0 +1,9 @@
+/** Shared-core reconstruction after all complete native WORD predicates are compiled. */
+import type { RegularLanguage } from './schemaRegularLanguage.js';
+import { schemaRegularLanguages } from './schemaRegularLanguage.js';
+import type { SchemaPatternContext } from './schemaValueContext.js';
+/** No semantic authority is issued here: callers supply exact masks from native owners. */
+export declare function reconstructBinaryWords<Owner>(c: SchemaPatternContext<Owner>, regular: ReturnType<typeof schemaRegularLanguages<Owner>>, masks: readonly RegularLanguage[], binaryMask: RegularLanguage, literal: (word: string) => RegularLanguage, owner: Owner): Readonly<{
+    core: string;
+    words: readonly string[];
+}> | undefined;

package/dist/compiler/schemaBinaryWordReconstruction.js

@@ -0,0 +1,33 @@
+import { schemaRegularLanguages } from './schemaRegularLanguage.js';
+/** No semantic authority is issued here: callers supply exact masks from native owners. */
+export function reconstructBinaryWords(c, regular, masks, binaryMask, literal, owner) {
+    const erased = [{ lo: 9, hi: 10, remove: true }, { lo: 13, hi: 13, remove: true }, { lo: 32, hi: 32, remove: true }];
+    c.step(owner, masks.length * 2 + 8);
+    const projected = masks.map(mask => regular.characterImage(mask, erased, owner));
+    projected.push(regular.characterImage(binaryMask, erased, owner));
+    const core = regular.witness(regular.intersect(projected, owner), owner);
+    if (core === undefined)
+        return undefined;
+    // The complete erasure inverse has arbitrary XML whitespace at every cut.
+    // literal() quotes complete words; whitespace alternatives stay private to
+    // this regular factory, so no externally fabricated language handle enters.
+    const whitespace = regular.union([literal(' '), literal('\t'), literal('\r'), literal('\n')], owner);
+    const gaps = regular.repeat(whitespace, 0, 'unbounded', owner);
+    c.step(owner, core.length * 3 + 4);
+    const pieces = [gaps];
+    for (const character of core) {
+        c.step(owner, 3 + character.length);
+        pieces.push(literal(character), gaps);
+    }
+    const inverse = regular.concatenate(pieces, owner);
+    c.step(owner, masks.length * 2 + 2);
+    const words = [];
+    for (const mask of masks) {
+        const word = regular.witness(regular.intersect([mask, inverse], owner), owner);
+        if (word === undefined)
+            throw new TypeError('A projected binary core must have an actual WORD preimage');
+        c.step(owner, word.length + 2);
+        words.push(word);
+    }
+    return { core, words };
+}

package/dist/compiler/schemaBuiltinFacets.d.ts

@@ -0,0 +1,13 @@
+import type { SchemaValueContext } from './schemaValueContext.js';
+export type IntrinsicScalarFacet = Readonly<{
+    name: string;
+    kind: 'integer' | 'bound' | 'whiteSpace';
+    value: string;
+    fixed: boolean;
+}>;
+export type IntrinsicFacetProperties = Readonly<{
+    scalars: readonly IntrinsicScalarFacet[];
+    patterns: readonly string[];
+}>;
+export declare const LIST_CONSTRUCTOR_FACETS: IntrinsicFacetProperties;
+export declare function schemaBuiltinFacetProperties<Owner>(name: string, owner: Owner, c: Pick<SchemaValueContext<Owner>, 'step' | 'text'>): IntrinsicFacetProperties;

package/dist/compiler/schemaBuiltinFacets.js

@@ -0,0 +1,51 @@
+/** Exact derived-builtin facet components from dated Datatypes Appendix A.
+ * Primitive normalization behavior is separate: primitive {facets} is empty.
+ */
+import { builtinListItem, builtinParents, integerBounds } from './schemaDatatypeValues.js';
+export const LIST_CONSTRUCTOR_FACETS = Object.freeze({
+    scalars: Object.freeze([Object.freeze({ name: 'whiteSpace', kind: 'whiteSpace', value: 'collapse', fixed: true })]),
+    patterns: Object.freeze([]),
+});
+const exactPatterns = Object.freeze({
+    language: '[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*', NMTOKEN: '\\c+', Name: '\\i\\c*',
+    NCName: '[\\i-[:]][\\c-[:]]*', integer: '[\\-+]?[0-9]+',
+});
+export function schemaBuiltinFacetProperties(name, owner, c) {
+    c.step(owner, 5);
+    if (builtinListItem(name)) {
+        c.step(owner, 6);
+        return { scalars: [...LIST_CONSTRUCTOR_FACETS.scalars, { name: 'minLength', kind: 'integer', value: '1', fixed: false }], patterns: [] };
+    }
+    const path = [], scalars = new Map(), patterns = [];
+    for (let current = name; builtinParents[current]; current = builtinParents[current]) {
+        c.step(owner, 2);
+        path.push(current);
+    }
+    for (let index = path.length - 1; index >= 0; index--) {
+        c.step(owner, 6);
+        const current = path[index], pattern = exactPatterns[current];
+        if (pattern !== undefined) {
+            c.text(pattern, owner);
+            patterns.push(pattern);
+        }
+        if (current === 'normalizedString' || current === 'token')
+            scalars.set('whiteSpace', {
+                name: 'whiteSpace', kind: 'whiteSpace', value: current === 'token' ? 'collapse' : 'replace', fixed: false,
+            });
+        if (current === 'integer')
+            scalars.set('fractionDigits', { name: 'fractionDigits', kind: 'integer', value: '0', fixed: true });
+        const bounds = integerBounds[current];
+        if (bounds)
+            for (const position of [0, 1]) {
+                c.step(owner, 4);
+                const value = bounds[position];
+                if (value !== undefined) {
+                    c.text(value, owner);
+                    const boundName = position === 0 ? 'minInclusive' : 'maxInclusive';
+                    scalars.set(boundName, { name: boundName, kind: 'bound', value, fixed: false });
+                }
+            }
+    }
+    c.step(owner, scalars.size + 2);
+    return { scalars: [...scalars.values()], patterns };
+}

package/dist/compiler/schemaCalendarImages.d.ts

@@ -0,0 +1,7 @@
+import type { CalendarFamily } from './schemaExactCalendar.js';
+import type { RegularLanguage } from './schemaRegularLanguage.js';
+import { schemaRegularLanguages } from './schemaRegularLanguage.js';
+import type { SchemaPatternContext } from './schemaValueContext.js';
+export declare function schemaCalendarImages<Owner>(c: SchemaPatternContext<Owner>, regular: ReturnType<typeof schemaRegularLanguages<Owner>>, expression: (text: string, owner: Owner) => RegularLanguage): {
+    image: (source: RegularLanguage, family: CalendarFamily, owner: Owner) => RegularLanguage;
+};

package/dist/compiler/schemaCalendarImages.js

@@ -0,0 +1,204 @@
+/** Finite field-boundary images of exact DT A calendar values. */
+import { parseCalendar, parseReduced, showInstant } from './schemaExactCalendar.js';
+import { schemaRegularLanguages } from './schemaRegularLanguage.js';
+import { schemaCalendarLanguages } from './schemaCalendarLanguage.js';
+import { schemaIntegerImages } from './schemaIntegerImages.js';
+export function schemaCalendarImages(c, regular, expression) {
+    const calendars = schemaCalendarLanguages(c, regular, expression), integers = schemaIntegerImages(c, regular, expression);
+    const quote = (text, owner) => { c.text(text, owner); c.step(owner, text.length * 2 + 1); return expression(text.replace(/[\\.\-^?*+{}()\[\]|]/g, '\\$&'), owner); };
+    const padded = (language, owner) => {
+        c.step(owner, 3);
+        const choices = [regular.intersect([language, expression('[1-9][0-9]{3,}', owner)], owner)];
+        for (let size = 1; size < 4; size++) {
+            c.step(owner, 16);
+            choices.push(regular.concatenate([expression('0'.repeat(4 - size), owner),
+                regular.intersect([language, expression('[0-9]{' + size + '}', owner)], owner)], owner));
+        }
+        return regular.union(choices, owner);
+    };
+    const image = (source, family, owner) => {
+        const b = { charge: count => c.step(owner, count), arithmetic: digits => c.step(owner, (digits + 4) ** 2), text: value => { c.text(value, owner); } };
+        c.step(owner, 4);
+        const images = [], epsilon = quote('', owner), yearPresent = ['date', 'dateTime', 'gYear', 'gYearMonth'].includes(family);
+        const sourceProgram = regular.automaton(source, owner), suffixCache = new Map();
+        c.step(owner, sourceProgram.states.length * 3 + 2);
+        const finals = sourceProgram.states.flatMap((state, index) => state.accepting ? [index] : []);
+        const prefixFor = (suffix) => {
+            c.text(suffix, owner);
+            let current = finals;
+            for (let offset = suffix.length - 1; offset >= 0; offset--) {
+                c.step(owner, current.length * 16 + 8);
+                const key = suffix.charCodeAt(offset) + ':' + JSON.stringify(current), known = suffixCache.get(key);
+                if (known) {
+                    current = known;
+                    continue;
+                }
+                c.step(owner, current.length * 2 + 3);
+                const accepted = new Set(current), previous = [];
+                for (let state = 0; state < sourceProgram.states.length; state++)
+                    for (const edge of sourceProgram.states[state].transitions) {
+                        c.step(owner);
+                        if (edge.lo <= suffix.charCodeAt(offset) && edge.hi >= suffix.charCodeAt(offset) && accepted.has(edge.to)) {
+                            c.step(owner);
+                            previous.push(state);
+                            break;
+                        }
+                    }
+                c.step(owner, key.length + previous.length + 2);
+                suffixCache.set(key, previous);
+                current = previous;
+                if (!current.length)
+                    return undefined;
+            }
+            if (!current.length)
+                return undefined;
+            return regular.paths(sourceProgram, [sourceProgram.start], new Set(current), owner);
+        };
+        for (let offset = -841; offset <= 840; offset++) {
+            c.step(owner, 16);
+            const zoned = offset !== -841, minutes = zoned ? offset : 0;
+            const zones = !zoned ? [''] : !minutes ? ['Z', '+00:00', '-00:00']
+                : [(minutes < 0 ? '-' : '+') + Math.floor(Math.abs(minutes) / 60).toString().padStart(2, '0') + ':' + (Math.abs(minutes) % 60).toString().padStart(2, '0')];
+            for (const zone of zones) {
+                const prefix = prefixFor(zone);
+                if (!prefix)
+                    continue;
+                for (const negative of yearPresent ? [false, true] : [false]) {
+                    const unsigned = negative ? regular.quotient(prefix, quote('-', owner), epsilon, owner) : prefix, program = regular.automaton(unsigned, owner);
+                    c.step(owner, program.states.length * 3 + 4);
+                    const incoming = program.states.map(() => []), productive = new Set(), pending = [];
+                    for (let from = 0; from < program.states.length; from++) {
+                        if (program.states[from].accepting) {
+                            c.step(owner, 2);
+                            productive.add(from);
+                            pending.push(from);
+                        }
+                        for (const edge of program.states[from].transitions) {
+                            c.step(owner);
+                            incoming[edge.to].push(from);
+                        }
+                    }
+                    while (pending.length) {
+                        c.step(owner);
+                        const state = pending.pop();
+                        for (const from of incoming[state]) {
+                            c.step(owner);
+                            if (!productive.has(from)) {
+                                c.step(owner, 2);
+                                productive.add(from);
+                                pending.push(from);
+                            }
+                        }
+                    }
+                    c.step(owner, 3);
+                    let frames = [];
+                    if (!yearPresent)
+                        frames.push({ at: program.start, year: quote('2000', owner), fields: [] });
+                    else
+                        for (let end = 0; end < program.states.length; end++) {
+                            const year = regular.intersect([regular.paths(program, [program.start], new Set([end]), owner), calendars.year(false, owner)], owner);
+                            if (regular.witness(year, owner) !== undefined)
+                                frames.push({ at: end, year, fields: [] });
+                        }
+                    const walk = (from, text) => {
+                        c.text(text, owner);
+                        let state = from;
+                        for (const character of text) {
+                            c.step(owner, program.states[state].transitions.length + 1);
+                            const cp = character.charCodeAt(0), edge = program.states[state].transitions.find(edge => edge.lo <= cp && edge.hi >= cp);
+                            if (!edge || !productive.has(edge.to))
+                                return undefined;
+                            state = edge.to;
+                        }
+                        return state;
+                    };
+                    const clock = family === 'dateTime' || family === 'time';
+                    const descriptors = [
+                        { present: !['gYear', 'gDay', 'time'].includes(family), separator: family === 'gMonthDay' || family === 'gMonth' ? '--' : '-', min: 1, max: 12, fixed: 1 },
+                        { present: ['date', 'dateTime', 'gMonthDay', 'gDay'].includes(family), separator: family === 'gDay' ? '---' : '-', min: 1, max: 31, fixed: 1 },
+                        { present: clock, separator: family === 'dateTime' ? 'T' : '', min: 0, max: 24, fixed: 0 },
+                        { present: clock, separator: ':', min: 0, max: 59, fixed: 0 },
+                        { present: clock, separator: ':', min: 0, max: 60, fixed: 0 },
+                    ];
+                    for (const descriptor of descriptors) {
+                        c.step(owner, 3);
+                        const next = [];
+                        for (const frame of frames) {
+                            if (!descriptor.present) {
+                                c.step(owner, frame.fields.length + 4);
+                                next.push({ ...frame, fields: [...frame.fields, descriptor.fixed] });
+                                continue;
+                            }
+                            for (let value = descriptor.min; value <= descriptor.max; value++) {
+                                c.step(owner, 12);
+                                const at = walk(frame.at, descriptor.separator + value.toString().padStart(2, '0'));
+                                if (at !== undefined) {
+                                    c.step(owner, frame.fields.length + 4);
+                                    next.push({ ...frame, at, fields: [...frame.fields, value] });
+                                }
+                            }
+                        }
+                        frames = next;
+                    }
+                    c.step(owner, program.states.length * 4 + 3);
+                    const accepted = new Set(program.states.flatMap((state, index) => state.accepting ? [index] : []));
+                    for (const frame of frames) {
+                        c.step(owner, 3);
+                        const fractions = [];
+                        if (accepted.has(frame.at))
+                            fractions.push(undefined);
+                        const dot = clock ? walk(frame.at, '.') : undefined;
+                        if (dot !== undefined) {
+                            const tail = regular.intersect([regular.paths(program, [dot], accepted, owner), expression('[0-9]+', owner)], owner);
+                            if (regular.witness(regular.intersect([tail, expression('0+', owner)], owner), owner) !== undefined)
+                                fractions.push(undefined);
+                            const trimmed = regular.intersect([regular.quotient(tail, epsilon, expression('0*', owner), owner), expression('[0-9]*[1-9]', owner)], owner);
+                            if (regular.witness(trimmed, owner) !== undefined)
+                                fractions.push(trimmed);
+                        }
+                        if (!fractions.length)
+                            continue;
+                        for (const leap of yearPresent ? [false, true] : [true]) {
+                            const rawYear = !yearPresent ? frame.year : regular.intersect([frame.year, leap ? calendars.year(true, owner) : regular.negate(calendars.year(true, owner), owner)], owner);
+                            if (regular.witness(rawYear, owner) === undefined)
+                                continue;
+                            const representative = !yearPresent ? '2000' : negative ? leap ? '-0004' : '-0001' : leap ? '2000' : '2001';
+                            c.step(owner, 96);
+                            const [month, day, hour, minute, second] = frame.fields, two = (n) => n.toString().padStart(2, '0');
+                            const date = representative + '-' + two(month) + '-' + two(day), time = two(hour) + ':' + two(minute) + ':' + two(second);
+                            const lexical = family === 'dateTime' ? date + 'T' + time + zone : family === 'date' ? date + zone : family === 'time' ? time + zone
+                                : family === 'gYear' ? representative + zone : family === 'gYearMonth' ? representative + '-' + two(month) + zone
+                                    : family === 'gMonthDay' ? '--' + two(month) + '-' + two(day) + zone : family === 'gDay' ? '---' + two(day) + zone : '--' + two(month) + zone;
+                            const value = family === 'date' || family === 'dateTime' ? parseCalendar(family, lexical, b) : parseReduced(family, lexical, b), coordinate = showInstant(value.seconds, b);
+                            c.step(owner, coordinate.length * 3 + 8);
+                            const split = /^(-?[0-9]+)(-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2})Z$/.exec(coordinate);
+                            let years;
+                            if (!yearPresent)
+                                years = quote(split[1], owner);
+                            else {
+                                const continuous = (year) => year > 0n ? year - 1n : year;
+                                c.step(owner, 64);
+                                const change = Number(continuous(BigInt(split[1])) - continuous(BigInt(representative))), magnitudeChange = negative ? -change : change;
+                                const absolute = regular.intersect([regular.quotient(rawYear, expression('0*', owner), epsilon, owner), expression('[1-9][0-9]*', owner)], owner);
+                                const one = quote('1', owner), parts = [];
+                                if (magnitudeChange === -1 && regular.witness(regular.intersect([absolute, one], owner), owner) !== undefined)
+                                    parts.push(quote(negative ? '0001' : '-0001', owner));
+                                const remaining = magnitudeChange === -1 ? regular.intersect([absolute, regular.negate(one, owner)], owner) : absolute;
+                                const shifted = integers.sum([{ language: remaining, weight: 1 }], owner, magnitudeChange);
+                                parts.push(regular.concatenate([quote(negative ? '-' : '', owner), padded(shifted, owner)], owner));
+                                years = regular.union(parts, owner);
+                            }
+                            for (const fraction of fractions) {
+                                c.step(owner, 2);
+                                images.push(regular.concatenate([years, quote(split[2], owner),
+                                    fraction ? regular.concatenate([quote('.', owner), fraction], owner) : epsilon, quote(zoned ? 'Z' : '', owner)], owner));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return regular.union(images, owner);
+    };
+    return { image };
+}

package/dist/compiler/schemaCalendarLanguage.d.ts

@@ -0,0 +1,10 @@
+import type { Calendar, CalendarFamily } from './schemaExactCalendar.js';
+import type { RegularLanguage } from './schemaRegularLanguage.js';
+import { schemaRegularLanguages } from './schemaRegularLanguage.js';
+import type { SchemaPatternContext } from './schemaValueContext.js';
+export declare function schemaCalendarLanguages<Owner>(c: SchemaPatternContext<Owner>, regular: ReturnType<typeof schemaRegularLanguages<Owner>>, expression: (text: string, owner: Owner) => RegularLanguage): {
+    bound: (source: RegularLanguage, endpoint: Calendar, name: "minInclusive" | "minExclusive" | "maxInclusive" | "maxExclusive", owner: Owner) => RegularLanguage;
+    validDate: (family: CalendarFamily, owner: Owner) => RegularLanguage;
+    valid: (family: CalendarFamily, owner: Owner) => RegularLanguage;
+    year: (leap: boolean, owner: Owner) => RegularLanguage;
+};

package/dist/compiler/schemaCalendarLanguage.js

@@ -0,0 +1,227 @@
+/** Exact regular preimages of DT A calendar validity and bound predicates. */
+import { showInstant, ordinal } from './schemaExactCalendar.js';
+import { schemaRegularLanguages } from './schemaRegularLanguage.js';
+import { schemaDecimalLanguages } from './schemaDecimalLanguage.js';
+export function schemaCalendarLanguages(c, regular, expression) {
+    const decimals = schemaDecimalLanguages(c), yearLanguages = new Map();
+    const empty = (owner) => regular.union([], owner);
+    const literal = (text, owner) => {
+        c.text(text, owner);
+        c.step(owner, text.length * 2 + 1);
+        return expression(text.replace(/[\\.\-^?*+{}()\[\]|]/g, '\\$&'), owner);
+    };
+    const calendarBudget = (owner) => ({ charge: work => c.step(owner, work),
+        arithmetic: digits => c.step(owner, (digits + 4) ** 2), text: text => { c.text(text, owner); } });
+    const year = (leap, owner) => {
+        const cached = yearLanguages.get(leap);
+        if (cached)
+            return cached;
+        const grammar = regular.intersect([expression('\\-?([0-9]{4}|[1-9][0-9]{4,})', owner), regular.negate(expression('\\-?0000', owner), owner)], owner);
+        if (!leap) {
+            c.step(owner);
+            yearLanguages.set(false, grammar);
+            return grammar;
+        }
+        // 10^4 is divisible by 400. Noncentury leap years have a nonzero
+        // two-digit suffix divisible by four; centuries require their preceding
+        // two digits (the last four digits overall) to be divisible by four.
+        const suffix = '\\-?[0-9]*(([02468][48]|[13579][26]|[2468]0)|([02468][048]|[13579][26])00)';
+        c.step(owner, suffix.length + 2);
+        const language = regular.intersect([grammar, expression(suffix, owner)], owner);
+        c.step(owner);
+        yearLanguages.set(true, language);
+        return language;
+    };
+    const validDate = (family, owner) => {
+        const epsilon = literal('', owner);
+        if (family === 'time')
+            return epsilon;
+        if (family === 'gYear')
+            return year(false, owner);
+        if (family === 'gYearMonth')
+            return regular.concatenate([year(false, owner), expression('\\-(0[1-9]|1[0-2])', owner)], owner);
+        if (family === 'gMonth')
+            return expression('\\-\\-(0[1-9]|1[0-2])', owner);
+        if (family === 'gDay')
+            return expression('\\-\\-\\-(0[1-9]|[12][0-9]|3[01])', owner);
+        const monthDay = '((01|03|05|07|08|10|12)\\-(0[1-9]|[12][0-9]|3[01])|(04|06|09|11)\\-(0[1-9]|[12][0-9]|30)|02\\-(0[1-9]|1[0-9]|2[0-8]))';
+        if (family === 'gMonthDay')
+            return expression('\\-\\-(' + monthDay + '|02\\-29)', owner);
+        return regular.union([regular.concatenate([year(false, owner), literal('-', owner), expression(monthDay, owner)], owner),
+            regular.concatenate([year(true, owner), literal('-02-29', owner)], owner)], owner);
+    };
+    const fields = (family, style, owner) => {
+        c.step(owner, 48);
+        const epsilon = literal('', owner), digits = expression('[0-9]{2}', owner);
+        const y = ['time', 'gMonthDay', 'gDay', 'gMonth'].includes(family)
+            ? { language: epsilon, fixed: 2000, separator: '' } : { language: year(false, owner), separator: '' };
+        const m = family === 'gYear' || family === 'gDay' || family === 'time'
+            ? { language: epsilon, fixed: 1, separator: '' } : { language: digits, separator: family === 'gMonthDay' || family === 'gMonth' ? '--' : '-' };
+        const d = family === 'gYear' || family === 'gYearMonth' || family === 'gMonth' || family === 'time'
+            ? { language: epsilon, fixed: 1, separator: '' } : { language: digits, separator: family === 'gDay' ? '---' : '-' };
+        const clock = family === 'dateTime' || family === 'time';
+        const h = !clock ? { language: epsilon, fixed: 0, separator: '' }
+            : style === '24' ? { language: literal('24', owner), fixed: 0, separator: family === 'dateTime' ? 'T' : '' }
+                : { language: expression('([01][0-9]|2[0-3])', owner), separator: family === 'dateTime' ? 'T' : '' };
+        const minute = !clock ? { language: epsilon, fixed: 0, separator: '' }
+            : style === '24' ? { language: literal('00', owner), fixed: 0, separator: ':' } : { language: expression('[0-5][0-9]', owner), separator: ':' };
+        const second = !clock ? { language: epsilon, fixed: 0, separator: '' }
+            : style === '24' ? { language: expression('00([.]0+)?', owner), fixed: 0, separator: ':' }
+                : { language: expression(style === '60' ? '60([.][0-9]+)?' : '[0-5][0-9]([.][0-9]+)?', owner), shift: style === '60' ? 60 : undefined, separator: ':' };
+        return [y, m, d, h, minute, second];
+    };
+    const joinFields = (parts, descriptor, owner) => {
+        c.step(owner, parts.length * 2 + 2);
+        const result = [];
+        for (let index = 0; index < parts.length; index++) {
+            c.step(owner, 2);
+            result.push(literal(descriptor[index].separator, owner), parts[index]);
+        }
+        return regular.concatenate(result, owner);
+    };
+    const compareFields = (descriptor, threshold, greater, inclusive, owner) => {
+        const budget = calendarBudget(owner), text = showInstant(threshold, budget);
+        c.step(owner, text.length * 3 + 8);
+        const match = /^(-?[0-9]+)-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2}(?:\.[0-9]+)?)Z$/.exec(text);
+        const targets = match.slice(1), equals = [], alternatives = [];
+        for (let index = 0; index < descriptor.length; index++) {
+            c.step(owner, targets[index].length * 2 + 4);
+            const field = descriptor[index], target = targets[index].replace(/^(-?)0+(?=[0-9])/, '$1');
+            let unequal, equal;
+            if (field.fixed !== undefined) {
+                c.step(owner, target.length ** 2 + 4);
+                const order = field.fixed === 0 ? /[1-9]/.test(target) ? -1 : 0
+                    : BigInt(field.fixed) < BigInt(target) ? -1 : BigInt(field.fixed) > BigInt(target) ? 1 : 0;
+                unequal = (greater ? order > 0 : order < 0) ? field.language : empty(owner);
+                equal = order === 0 ? field.language : empty(owner);
+            }
+            else {
+                c.text(target, owner);
+                let compared = target;
+                if (field.shift) {
+                    c.step(owner, target.length + 16);
+                    const [whole, fraction] = target.split('.');
+                    compared = String(Number(whole) + field.shift) + (fraction ? '.' + fraction : '');
+                }
+                const relation = decimals.relation(compared, greater, owner);
+                unequal = relation === undefined ? empty(owner) : regular.intersect([field.language, expression(relation, owner)], owner);
+                const negative = compared.startsWith('-'), unsigned = negative ? compared.slice(1) : compared;
+                const [whole, fraction] = unsigned.split('.');
+                c.step(owner, compared.length * 3 + 32);
+                const inverse = compared.replace(/^[-+]?0+(?=[0-9])/, '') === '0' ? '[+\\-]?(0+([.]0*)?|[.]0+)'
+                    : (negative ? '\\-' : '[+]?') + (fraction ? '0*' + whole + '[.]' + fraction + '0*' : '0*' + whole + '([.]0*)?');
+                equal = regular.intersect([field.language, expression(inverse, owner)], owner);
+            }
+            c.step(owner, descriptor.length * 2 + equals.length + 4);
+            alternatives.push(joinFields([...equals, unequal, ...descriptor.slice(index + 1).map(field => field.language)], descriptor, owner));
+            equals.push(equal);
+        }
+        if (inclusive)
+            alternatives.push(joinFields(equals, descriptor, owner));
+        return regular.union(alternatives, owner);
+    };
+    const suffixChecker = (source, owner) => {
+        const program = regular.automaton(source, owner), cache = new Map();
+        c.step(owner, program.states.length + 4);
+        const final = program.states.flatMap((state, index) => state.accepting ? [index] : []);
+        return (text) => {
+            c.text(text, owner);
+            let current = final;
+            for (let offset = text.length - 1; offset >= 0; offset--) {
+                c.step(owner, current.length * 16 + 8);
+                const identity = text.charCodeAt(offset) + ':' + JSON.stringify(current), known = cache.get(identity);
+                if (known) {
+                    current = known;
+                    continue;
+                }
+                c.step(owner, current.length * 2 + 3);
+                const accepted = new Set(current), previous = [], cp = text.charCodeAt(offset);
+                for (let state = 0; state < program.states.length; state++)
+                    for (const edge of program.states[state].transitions) {
+                        c.step(owner, 2);
+                        if (cp >= edge.lo && cp <= edge.hi && accepted.has(edge.to)) {
+                            c.step(owner);
+                            previous.push(state);
+                            break;
+                        }
+                    }
+                c.step(owner, identity.length + previous.length + 2);
+                cache.set(identity, previous);
+                current = previous;
+                if (!current.length)
+                    return undefined;
+            }
+            if (!current.length)
+                return undefined;
+            c.step(owner, current.length * 2 + program.states.length * 3 + 4);
+            const accepted = new Set(current);
+            return regular.fromAutomaton({ start: program.start, states: program.states.map((state, index) => ({ transitions: state.transitions, accepting: accepted.has(index) })) }, owner);
+        };
+    };
+    const bound = (source, endpoint, name, owner) => {
+        const family = endpoint.family, budget = calendarBudget(owner), possibleSuffix = suffixChecker(source, owner);
+        c.step(owner, 4);
+        const choices = [], greater = name.startsWith('min'), inclusive = name.endsWith('Inclusive');
+        budget.arithmetic(endpoint.seconds.digits + endpoint.seconds.scale + 8);
+        const power = 10n ** BigInt(endpoint.seconds.scale);
+        const shifted = (seconds) => {
+            budget.arithmetic(endpoint.seconds.digits + endpoint.seconds.scale + 8);
+            c.step(owner, 4);
+            return { ...endpoint.seconds, coefficient: endpoint.seconds.coefficient + BigInt(seconds) * power };
+        };
+        c.step(owner, 4);
+        const date = validDate(family, owner);
+        for (let index = -841; index <= 840; index++) {
+            c.step(owner, 16);
+            const zoned = index !== -841, offset = zoned ? index : 0;
+            const suffixes = !zoned ? [''] : !offset ? ['Z', '+00:00', '-00:00']
+                : [(offset < 0 ? '-' : '+') + Math.floor(Math.abs(offset) / 60).toString().padStart(2, '0') + ':' + (Math.abs(offset) % 60).toString().padStart(2, '0')];
+            for (const zone of suffixes) {
+                const prefix = possibleSuffix(zone);
+                if (!prefix)
+                    continue;
+                if (!zone && regular.witness(regular.intersect([source, expression('.*[0-9]', owner)], owner), owner) === undefined)
+                    continue;
+                const crossTimeline = zoned !== endpoint.zoned;
+                const uncertainty = crossTimeline ? (greater ? 50400 : -50400) : 0;
+                for (const style of family === 'dateTime' || family === 'time' ? ['normal', '60', '24'] : ['normal']) {
+                    const descriptor = fields(family, style, owner), rendered = joinFields(descriptor.map(field => field.language), descriptor, owner);
+                    const validity = regular.concatenate([regular.intersect([prefix, rendered,
+                            family === 'dateTime' ? regular.concatenate([date, expression('T.*', owner)], owner)
+                                : family === 'time' ? rendered : date], owner), literal(zone, owner)], owner);
+                    if (regular.witness(regular.intersect([source, validity], owner), owner) === undefined)
+                        continue;
+                    const adjustment = style === '60' ? 60 : style === '24' ? 86400 : 0;
+                    if (family !== 'time') {
+                        const predicate = compareFields(descriptor, shifted(offset * 60 + uncertainty - adjustment), greater, inclusive && !crossTimeline, owner);
+                        choices.push(regular.intersect([validity, regular.concatenate([predicate, literal(zone, owner)], owner)], owner));
+                    }
+                    else {
+                        // Raw clocks occupy one reference day. Four carries cover every
+                        // allowed offset and the two overflow styles under DT A modulo.
+                        const baseDay = ordinal(2000n, 1, 1, budget, 4) * 86400n;
+                        for (let carry = -1; carry <= 2; carry++) {
+                            const main = shifted(offset * 60 + uncertainty - adjustment + carry * 86400);
+                            budget.arithmetic(endpoint.seconds.digits + endpoint.seconds.scale + 16);
+                            c.step(owner, 8);
+                            const begin = { coefficient: (baseDay + BigInt(offset * 60 - adjustment + carry * 86400)) * power, scale: endpoint.seconds.scale, digits: endpoint.seconds.digits + 16 };
+                            const end = { ...begin, coefficient: begin.coefficient + 86400n * power };
+                            const predicate = regular.intersect([compareFields(descriptor, main, greater, inclusive && !crossTimeline, owner),
+                                compareFields(descriptor, begin, true, true, owner), compareFields(descriptor, end, false, false, owner)], owner);
+                            choices.push(regular.intersect([validity, regular.concatenate([predicate, literal(zone, owner)], owner)], owner));
+                        }
+                    }
+                }
+            }
+        }
+        return regular.union(choices, owner);
+    };
+    const valid = (family, owner) => {
+        const zone = expression('(Z|[+\\-]((0[0-9]|1[0-3]):[0-5][0-9]|14:00))?', owner);
+        const clock = expression('(([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)([.][0-9]+)?|24:00:00([.]0+)?)', owner);
+        const value = family === 'time' ? clock : family === 'dateTime'
+            ? regular.concatenate([validDate(family, owner), literal('T', owner), clock], owner) : validDate(family, owner);
+        return regular.concatenate([value, zone], owner);
+    };
+    return { bound, validDate, valid, year };
+}

package/dist/compiler/schemaCompiler.d.ts

@@ -232,4 +232,3 @@ export type CompiledCatalog = {
  *    portType reference, then enumerate operations and their soapAction URIs.
  */
 export declare function compileCatalog(cat: WsdlCatalog, options: CompilerOptions, streamConfig?: StreamConfig): CompiledCatalog;
-//# sourceMappingURL=schemaCompiler.d.ts.map

package/dist/compiler/schemaComponentEquality.d.ts

@@ -0,0 +1,27 @@
+/** Sufficient recursive component-property equality for cos-particle-extend.
+ * Paired recurrence closes equality only; component validity remains a premise.
+ */
+import type { GraphNode, NodeId } from './canonicalGraph.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { ScalarFailure } from './schemaScalarKernel.js';
+import type { ScalarObligation } from './scalarSchemaAssessment.js';
+import type { RelationFailure } from './schemaTypeRelations.js';
+import type { AttributeFailure } from './schemaAttributeUses.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+import type { SemanticTypeDependency } from './semanticTypeReference.js';
+import type { IdentityConstraintDependency } from './schemaIdentityConstraints.js';
+type Failure = RelationFailure | ScalarFailure | AttributeFailure | ResourceLimitFailure;
+export type ComponentEqualityResult = Readonly<{
+    kind: 'checked';
+    value: boolean;
+    contextId: string;
+    authority: 'XSD10-component-properties-v1';
+    obligations: readonly string[];
+    scalarObligations: readonly ScalarObligation[];
+    typeDependencies: readonly SemanticTypeDependency[];
+    identityConstraintDependencies: readonly IdentityConstraintDependency[];
+    /** Concrete component operands whose property facts this comparison consumed. */
+    dependencies: readonly NodeId[];
+}> | Failure;
+export declare function compareComponentProperties(context: SemanticContext, a: GraphNode, b: GraphNode): ComponentEqualityResult;
+export {};