@techspokes/typescript-wsdl-client 1.1.4 → 1.1.5

package/dist/compiler/schemaExactCalendar.d.ts

@@ -0,0 +1,73 @@
+/** Shared exact schema calendar semantics: accepted DT01 A; no payload policy. */
+export type Decimal = Readonly<{
+    coefficient: bigint;
+    scale: number;
+    digits: number;
+}>;
+export type ReducedFamily = "time" | "gYear" | "gYearMonth" | "gMonthDay" | "gDay" | "gMonth";
+export type CalendarFamily = "date" | "dateTime" | ReducedFamily;
+export type Calendar = Readonly<{
+    family: CalendarFamily;
+    year: bigint;
+    month: number;
+    day: number;
+    seconds: Decimal;
+    zoned: boolean;
+    lexical: string;
+    digits: number;
+}>;
+export type Duration = Readonly<{
+    months: bigint;
+    seconds: Decimal;
+    digits: number;
+    lexical: string;
+}>;
+export type Order = "less" | "equal" | "greater" | "indeterminate";
+export declare class ProbeFailure extends Error {
+    readonly kind: "invalid-schema" | "resource-limit";
+    constructor(kind: "invalid-schema" | "resource-limit", message: string);
+}
+/** Inclusive limits; failures happen before the charged work or allocation. */
+export interface CalendarBudget {
+    charge(work: number): void;
+    arithmetic(digits: number): void;
+    text(value: string): void;
+}
+export declare class Budget implements CalendarBudget {
+    readonly maxWork: number;
+    readonly maxNodes: number;
+    used: number;
+    constructor(maxWork?: number, maxNodes?: number);
+    nodes(count: number): void;
+    charge(work: number): void;
+    arithmetic(digits: number): void;
+    text(value: string): void;
+}
+export declare const isLeap: (year: bigint) => boolean;
+/** Option A removes year zero; digits is a trusted, validated conservative bound. */
+export declare function ordinal(year: bigint, month: number, day: number, budget: CalendarBudget, digits: number): bigint;
+/** Invert by cycles; digits is a trusted, validated conservative operand bound. */
+export declare function fromOrdinal(dayNumber: bigint, budget: CalendarBudget, digits: number): Readonly<{
+    year: bigint;
+    month: number;
+    day: number;
+}>;
+export declare function parseCalendar(family: "date" | "dateTime", lexical: string, budget: CalendarBudget): Calendar;
+/** Exact schema comparison representatives; omitted fields remain type context. */
+export declare function parseReduced(family: ReducedFamily, lexical: string, budget: CalendarBudget): Calendar;
+/** Internal coordinate display, with the value timeline explicit and no zone suffix. */
+export declare function showRepresentative(value: Calendar, budget: CalendarBudget): Readonly<{
+    family: CalendarFamily;
+    timeline: "zoned" | "local";
+    coordinate: string;
+}>;
+export declare function parseDuration(lexical: string, budget: CalendarBudget): Duration;
+export declare function sameDuration(a: Duration, b: Duration, budget: CalendarBudget): boolean;
+/** Calendar ordering and equality are distinct; different timelines never equal. */
+export declare function sameCalendar(a: Calendar, b: Calendar, budget: CalendarBudget): boolean;
+export declare function compareCalendar(a: Calendar, b: Calendar, budget: CalendarBudget): Order;
+export declare function addDuration(start: Calendar, duration: Duration, budget: CalendarBudget): Decimal;
+export declare function compareDuration(a: Duration, b: Duration, budget: CalendarBudget): Order;
+/** Exact output for tests only; canonical strings never replace retained lexicals. */
+export declare function showInstant(value: Decimal, budget: CalendarBudget): string;
+//# sourceMappingURL=schemaExactCalendar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaExactCalendar.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaExactCalendar.ts"],"names":[],"mappings":"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"}

package/dist/compiler/schemaExactCalendar.js

@@ -0,0 +1,264 @@
+export class ProbeFailure extends Error {
+    kind;
+    constructor(kind, message) {
+        super(message);
+        this.kind = kind;
+    }
+}
+export class Budget {
+    maxWork;
+    maxNodes;
+    used = 0;
+    constructor(maxWork = 1_000_000, maxNodes = 100_000) {
+        this.maxWork = maxWork;
+        this.maxNodes = maxNodes;
+        if (!Number.isSafeInteger(maxWork) || maxWork < 1 || !Number.isSafeInteger(maxNodes) || maxNodes < 1) {
+            throw new Error("Budget limits must be positive exact safe integers");
+        }
+    }
+    nodes(count) {
+        if (!Number.isSafeInteger(count) || count < 0 || count > this.maxNodes) {
+            throw new ProbeFailure("resource-limit", "Input graph node budget exhausted");
+        }
+        this.charge(count);
+    }
+    charge(work) {
+        if (!Number.isSafeInteger(work) || work < 0 || work > this.maxWork - this.used) {
+            throw new ProbeFailure("resource-limit", "Exact calendar work budget exhausted");
+        }
+        this.used += work;
+    }
+    arithmetic(digits) { this.charge((digits + 2) ** 2); }
+    text(value) { this.charge(value.length * 4 + 8); }
+}
+const invalid = (message) => { throw new ProbeFailure("invalid-schema", message); };
+const floor = (a, b) => a >= 0n ? a / b : (a - b + 1n) / b;
+const mod = (a, b) => a - floor(a, b) * b;
+export const isLeap = (year) => year % 4n === 0n && (year % 100n !== 0n || year % 400n === 0n);
+const monthLengths = (year) => [31, isLeap(year) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+/** Option A removes year zero; digits is a trusted, validated conservative bound. */
+export function ordinal(year, month, day, budget, digits) {
+    if (year === 0n)
+        return invalid("Option A has no year zero");
+    budget.arithmetic(digits + 8);
+    const y = year - 1n;
+    const prior = 365n * y + floor(y, 4n) - floor(y, 100n) + floor(y, 400n) + (year < 0n ? 366n : 0n);
+    const lengths = monthLengths(year);
+    let before = 0;
+    for (let m = 1; m < month; m++) {
+        budget.charge(1);
+        before += lengths[m - 1];
+    }
+    return prior + BigInt(before + day - 1);
+}
+/** Invert by cycles; digits is a trusted, validated conservative operand bound. */
+export function fromOrdinal(dayNumber, budget, digits) {
+    budget.arithmetic(digits + 8);
+    const astronomical = dayNumber < 0n ? dayNumber - 366n : dayNumber;
+    const cycle = floor(astronomical, 146097n);
+    let rest = astronomical - cycle * 146097n;
+    const century = rest / 36524n > 3n ? 3n : rest / 36524n;
+    rest -= century * 36524n;
+    const quad = rest / 1461n;
+    rest -= quad * 1461n;
+    const single = rest / 365n > 3n ? 3n : rest / 365n;
+    rest -= single * 365n;
+    const year = cycle * 400n + century * 100n + quad * 4n + single + 1n;
+    let month = 1;
+    for (const length of monthLengths(year)) {
+        budget.charge(1);
+        if (rest < BigInt(length))
+            break;
+        rest -= BigInt(length);
+        month++;
+    }
+    return { year, month, day: Number(rest) + 1 };
+}
+function decimal(value, budget) {
+    budget.text(value);
+    if (!/^[0-9]+(?:\.[0-9]+)?$/.test(value))
+        return invalid("Invalid decimal seconds");
+    const dot = value.indexOf(".");
+    let scale = dot < 0 ? 0 : value.length - dot - 1;
+    budget.arithmetic(value.length);
+    let coefficient = BigInt(value.replace(".", ""));
+    while (scale && coefficient % 10n === 0n) {
+        budget.charge(value.length);
+        coefficient /= 10n;
+        scale--;
+    }
+    return { coefficient, scale, digits: value.length };
+}
+function scaled(value, target, budget) {
+    budget.arithmetic(value.digits + target - value.scale);
+    return value.coefficient * 10n ** BigInt(target - value.scale);
+}
+function sum(a, b, budget) {
+    const scale = Math.max(a.scale, b.scale);
+    return { coefficient: scaled(a, scale, budget) + scaled(b, scale, budget), scale,
+        digits: Math.max(a.digits + scale - a.scale, b.digits + scale - b.scale) + 1 };
+}
+function integer(value, digits) { return { coefficient: value, scale: 0, digits }; }
+function compareDecimal(a, b, budget) {
+    const scale = Math.max(a.scale, b.scale);
+    const x = scaled(a, scale, budget), y = scaled(b, scale, budget);
+    return x < y ? "less" : x > y ? "greater" : "equal";
+}
+export function parseCalendar(family, lexical, budget) {
+    budget.text(lexical);
+    const value = lexical.replace(/[\t\r\n ]+/g, " ").replace(/^ | $/g, "");
+    const match = (family === "date" ? /^(-?[0-9]{4,})-([0-9]{2})-([0-9]{2})(Z|[+-][0-9]{2}:[0-9]{2})?$/
+        : /^(-?[0-9]{4,})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2}(?:\.[0-9]+)?)(Z|[+-][0-9]{2}:[0-9]{2})?$/).exec(value);
+    if (!match)
+        return invalid("Calendar lexical form is invalid");
+    const rawYear = match[1], unsigned = rawYear.replace(/^-/, "");
+    if (unsigned.length > 4 && unsigned[0] === "0")
+        return invalid("Extended years cannot have leading zeroes");
+    budget.arithmetic(rawYear.length);
+    const year = BigInt(rawYear), month = Number(match[2]), day = Number(match[3]);
+    if (!year || month < 1 || month > 12 || day < 1 || day > monthLengths(year)[month - 1])
+        return invalid("Calendar date is invalid");
+    const hour = family === "date" ? 0 : Number(match[4]), minute = family === "date" ? 0 : Number(match[5]);
+    const second = decimal(family === "date" ? "0" : match[6], budget);
+    // XSD 1.0 D.1 admits second 60; Appendix E treats it as overflow.
+    if (hour > 24 || minute > 59 || compareDecimal(second, integer(61n, 2), budget) !== "less"
+        || hour === 24 && (minute !== 0 || second.coefficient !== 0n))
+        return invalid("Calendar clock is invalid");
+    const zone = match[family === "date" ? 4 : 7];
+    let offset = 0;
+    if (zone && zone !== "Z") {
+        const hours = Number(zone.slice(1, 3)), minutes = Number(zone.slice(4));
+        if (hours > 14 || minutes > 59 || hours === 14 && minutes !== 0)
+            return invalid("Timezone is invalid");
+        offset = (zone[0] === "-" ? -1 : 1) * (hours * 60 + minutes);
+    }
+    const seconds = sum(integer(ordinal(year, month, day, budget, lexical.length) * 86400n + BigInt(hour * 3600 + minute * 60 - offset * 60), lexical.length + 8), second, budget);
+    budget.arithmetic(seconds.digits + seconds.scale);
+    // This API stores assessed value objects: section 3.2.7 places zoned values
+    // in UTC. Appendix E's raw field-tuple timezone conversion is a separate use.
+    const normalized = fromOrdinal(floor(seconds.coefficient, 86400n * 10n ** BigInt(seconds.scale)), budget, seconds.digits);
+    return { family, ...normalized, seconds, zoned: zone !== undefined, lexical, digits: lexical.length + 8 };
+}
+/** Exact schema comparison representatives; omitted fields remain type context. */
+export function parseReduced(family, lexical, budget) {
+    budget.text(lexical);
+    const value = lexical.replace(/[\t\r\n ]+/g, " ").replace(/^ | $/g, "");
+    // Six fixed regex objects and their lookup record, before creation.
+    budget.charge(7);
+    const patterns = {
+        time: /^([0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]+)?)(Z|[+-][0-9]{2}:[0-9]{2})?$/,
+        gYear: /^(-?[0-9]{4,})(Z|[+-][0-9]{2}:[0-9]{2})?$/,
+        gYearMonth: /^(-?[0-9]{4,})-([0-9]{2})(Z|[+-][0-9]{2}:[0-9]{2})?$/,
+        gMonthDay: /^--([0-9]{2})-([0-9]{2})(Z|[+-][0-9]{2}:[0-9]{2})?$/,
+        gDay: /^---([0-9]{2})(Z|[+-][0-9]{2}:[0-9]{2})?$/,
+        gMonth: /^--([0-9]{2})(Z|[+-][0-9]{2}:[0-9]{2})?$/,
+    };
+    const match = patterns[family].exec(value);
+    if (!match)
+        return invalid("Reduced calendar lexical form is invalid");
+    const zone = match.at(-1) ?? "";
+    // Pay for constructing the fixed reference tuple before its allocation.
+    budget.charge(value.length + 32);
+    const reference = family === "time" ? `2000-01-01T${match[1]}${zone}`
+        : family === "gYear" ? `${match[1]}-01-01T00:00:00${zone}`
+            : family === "gYearMonth" ? `${match[1]}-${match[2]}-01T00:00:00${zone}`
+                : family === "gMonthDay" ? `2000-${match[1]}-${match[2]}T00:00:00${zone}`
+                    : family === "gDay" ? `2000-01-${match[1]}T00:00:00${zone}`
+                        : `2000-${match[1]}-01T00:00:00${zone}`;
+    const assessed = parseCalendar("dateTime", reference, budget);
+    if (family !== "time") {
+        budget.charge(10); // Returned record and its copied fixed-width fields.
+        return { ...assessed, family, lexical };
+    }
+    // Selected time law: normalize zoned clocks modulo one day and rebase on
+    // the common date. Unknown clocks retain their unshifted clock on that date;
+    // legal 24:00 and second-60 overflow use the selected midnight alias.
+    budget.arithmetic(assessed.seconds.digits + assessed.seconds.scale + 8);
+    const day = 86400n * 10n ** BigInt(assessed.seconds.scale);
+    budget.charge(3); // Decimal record copied before modulo-clock allocation.
+    const clock = { ...assessed.seconds, coefficient: mod(assessed.seconds.coefficient, day) };
+    const seconds = sum(integer(ordinal(2000n, 1, 1, budget, 4) * 86400n, 12), clock, budget);
+    budget.charge(10); // Returned reference record and copied fixed-width fields.
+    return { ...assessed, family, year: 2000n, month: 1, day: 1, seconds, lexical };
+}
+/** Internal coordinate display, with the value timeline explicit and no zone suffix. */
+export function showRepresentative(value, budget) {
+    budget.charge(value.digits + value.seconds.scale + 32);
+    budget.charge(3); // Display record container, before allocation.
+    return { family: value.family, timeline: value.zoned ? "zoned" : "local",
+        coordinate: showInstant(value.seconds, budget).slice(0, -1) };
+}
+export function parseDuration(lexical, budget) {
+    budget.text(lexical);
+    const value = lexical.replace(/[\t\r\n ]+/g, " ").replace(/^ | $/g, "");
+    const match = /^(-)?P(?:([0-9]+)Y)?(?:([0-9]+)M)?(?:([0-9]+)D)?(?:T(?:([0-9]+)H)?(?:([0-9]+)M)?(?:([0-9]+(?:\.[0-9]+)?)S)?)?$/.exec(value);
+    if (!match || !match.slice(2).some(x => x !== undefined) || value.endsWith("T"))
+        return invalid("Duration lexical form is invalid");
+    budget.arithmetic(lexical.length + 8);
+    const sign = match[1] ? -1n : 1n;
+    const months = sign * (BigInt(match[2] ?? "0") * 12n + BigInt(match[3] ?? "0"));
+    const whole = BigInt(match[4] ?? "0") * 86400n + BigInt(match[5] ?? "0") * 3600n + BigInt(match[6] ?? "0") * 60n;
+    const seconds = sum(integer(whole, lexical.length + 8), decimal(match[7] ?? "0", budget), budget);
+    return { months, seconds: { ...seconds, coefficient: seconds.coefficient * sign }, digits: lexical.length + 8, lexical };
+}
+export function sameDuration(a, b, budget) {
+    budget.arithmetic(Math.max(a.digits, b.digits));
+    return a.months === b.months && compareDecimal(a.seconds, b.seconds, budget) === "equal";
+}
+/** Calendar ordering and equality are distinct; different timelines never equal. */
+export function sameCalendar(a, b, budget) {
+    return a.family === b.family && a.zoned === b.zoned && compareDecimal(a.seconds, b.seconds, budget) === "equal";
+}
+export function compareCalendar(a, b, budget) {
+    if (a.family !== b.family)
+        return "indeterminate";
+    if (a.zoned === b.zoned)
+        return compareDecimal(a.seconds, b.seconds, budget);
+    const uncertain = a.zoned ? b : a, certain = a.zoned ? a : b;
+    const lower = sum(uncertain.seconds, integer(-50400n, 5), budget);
+    const upper = sum(uncertain.seconds, integer(50400n, 5), budget);
+    if (compareDecimal(certain.seconds, lower, budget) === "less")
+        return a.zoned ? "less" : "greater";
+    if (compareDecimal(certain.seconds, upper, budget) === "greater")
+        return a.zoned ? "greater" : "less";
+    return "indeterminate";
+}
+export function addDuration(start, duration, budget) {
+    if (start.family !== "dateTime")
+        return invalid("The narrow addition probe takes dateTime operands");
+    budget.arithmetic(duration.digits + start.digits + 8);
+    const continuousYear = start.year > 0n ? start.year - 1n : start.year;
+    const index = continuousYear * 12n + BigInt(start.month - 1) + duration.months;
+    const coordinate = floor(index, 12n), month = Number(mod(index, 12n)) + 1;
+    const year = coordinate >= 0n ? coordinate + 1n : coordinate;
+    const day = Math.min(start.day, monthLengths(year)[month - 1]);
+    const sourceDay = ordinal(start.year, start.month, start.day, budget, start.digits);
+    const targetDay = ordinal(year, month, day, budget, duration.digits + start.digits);
+    const shifted = sum(start.seconds, integer((targetDay - sourceDay) * 86400n, duration.digits + start.digits + 16), budget);
+    return sum(shifted, duration.seconds, budget);
+}
+const anchors = ["1696-09-01T00:00:00Z", "1697-02-01T00:00:00Z", "1903-03-01T00:00:00Z", "1903-07-01T00:00:00Z"];
+export function compareDuration(a, b, budget) {
+    if (sameDuration(a, b, budget))
+        return "equal";
+    let order;
+    for (const anchor of anchors) {
+        const start = parseCalendar("dateTime", anchor, budget);
+        const current = compareDecimal(addDuration(start, a, budget), addDuration(start, b, budget), budget);
+        if (current === "equal" || order !== undefined && current !== order)
+            return "indeterminate";
+        order = current;
+    }
+    return order ?? "indeterminate";
+}
+/** Exact output for tests only; canonical strings never replace retained lexicals. */
+export function showInstant(value, budget) {
+    budget.arithmetic(value.digits + value.scale + 24);
+    const power = 10n ** BigInt(value.scale);
+    const whole = floor(value.coefficient, power), fraction = mod(value.coefficient, power);
+    const date = fromOrdinal(floor(whole, 86400n), budget, value.digits), clock = Number(mod(whole, 86400n));
+    const year = (date.year < 0n ? "-" : "") + (date.year < 0n ? -date.year : date.year).toString().padStart(4, "0");
+    const two = (n) => n.toString().padStart(2, "0");
+    const suffix = value.scale && fraction ? "." + fraction.toString().padStart(value.scale, "0").replace(/0+$/, "") : "";
+    return `${year}-${two(date.month)}-${two(date.day)}T${two(Math.floor(clock / 3600))}:${two(Math.floor(clock / 60) % 60)}:${two(clock % 60)}${suffix}Z`;
+}

package/dist/compiler/schemaFacetAnnotation.d.ts

@@ -0,0 +1,32 @@
+/** Complete supplied facet annotation infoset, without source provenance. */
+import type { SemanticBudget } from './semanticBudget.js';
+import type { SyntaxElement } from '../loader/orderedSyntax.js';
+export type FacetAnnotationNode = Readonly<{
+    kind: 'text';
+    value: string;
+} | {
+    kind: 'element';
+    name: Readonly<{
+        namespace: string;
+        local: string;
+    }>;
+    attributes: readonly Readonly<{
+        name: Readonly<{
+            namespace: string;
+            local: string;
+        }>;
+        value: string;
+    }>[];
+    namespaces: Readonly<Record<string, string>>;
+    children: readonly FacetAnnotationNode[];
+}>;
+export type FacetAnnotation = 'absent' | Readonly<{
+    kind: 'present';
+    content: FacetAnnotationNode;
+}>;
+export declare function validateFacetAnnotation(value: unknown, budget: SemanticBudget): value is FacetAnnotation;
+/** Preserve XML infoset content, omitting URI, digest, positions and element-name spelling. */
+export declare function projectFacetAnnotation(node: SyntaxElement, budget: SemanticBudget): FacetAnnotation;
+/** A structural mismatch that may share an abstract annotation is unresolved. */
+export declare function compareFacetAnnotation(left: FacetAnnotation, right: FacetAnnotation, budget: SemanticBudget): 'equal' | 'different' | 'unresolved';
+//# sourceMappingURL=schemaFacetAnnotation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaFacetAnnotation.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaFacetAnnotation.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAExD,OAAO,KAAK,EAAC,aAAa,EAAa,MAAM,4BAA4B,CAAC;AAE1E,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CACxC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,GAC7B;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IACnE,UAAU,EAAE,SAAS,QAAQ,CAAC;QAAC,IAAI,EAAE,QAAQ,CAAC;YAAC,SAAS,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAAC,EAAE,CAAC;IACrG,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAAC,QAAQ,EAAE,SAAS,mBAAmB,EAAE,CAAA;CAAC,CAC1F,CAAC;AACF,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,mBAAmB,CAAA;CAAC,CAAC,CAAC;AAQnG,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,cAAc,GAAG,KAAK,IAAI,eAAe,CAgCxG;AAED,+FAA+F;AAC/F,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,cAAc,GAAG,eAAe,CA+BnG;AAED,iFAAiF;AACjF,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,eAAe,EAClF,MAAM,EAAE,cAAc,GAAG,OAAO,GAAG,WAAW,GAAG,YAAY,CAwD9D"}

package/dist/compiler/schemaFacetAnnotation.js

@@ -0,0 +1,199 @@
+import { XSD_NAMESPACE } from '../loader/orderedSyntax.js';
+const record = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const name = (value, budget) => {
+    if (!record(value) || typeof value.namespace !== 'string' || typeof value.local !== 'string')
+        return false;
+    budget.chargeWork(value.namespace.length + value.local.length + 2);
+    return true;
+};
+export function validateFacetAnnotation(value, budget) {
+    if (value === 'absent')
+        return true;
+    if (!record(value) || value.kind !== 'present' || !record(value.content))
+        return false;
+    if (value.content.kind !== 'element' || !record(value.content.name)
+        || value.content.name.namespace !== XSD_NAMESPACE || value.content.name.local !== 'annotation')
+        return false;
+    const stack = [value.content];
+    while (stack.length) {
+        const node = stack.pop();
+        budget.chargeWork(8);
+        if (!record(node))
+            return false;
+        if (node.kind === 'text') {
+            if (typeof node.value !== 'string')
+                return false;
+            budget.chargeWork(node.value.length);
+            continue;
+        }
+        if (node.kind !== 'element' || !name(node.name, budget) || !Array.isArray(node.attributes)
+            || !record(node.namespaces) || !Array.isArray(node.children))
+            return false;
+        budget.chargeWork(node.attributes.length * 4 + node.children.length * 2);
+        for (const attribute of node.attributes) {
+            if (!record(attribute) || !name(attribute.name, budget) || typeof attribute.value !== 'string')
+                return false;
+            budget.chargeWork(attribute.value.length);
+        }
+        for (let i = 0; i < node.attributes.length; i++)
+            for (let j = i + 1; j < node.attributes.length; j++) {
+                budget.chargeWork(2);
+                if (budget.compareText(node.attributes[i].name.namespace, node.attributes[j].name.namespace) === 0
+                    && budget.compareText(node.attributes[i].name.local, node.attributes[j].name.local) === 0)
+                    return false;
+            }
+        for (const prefix in node.namespaces) {
+            const uri = node.namespaces[prefix];
+            if (typeof uri !== 'string')
+                return false;
+            budget.chargeWork(prefix.length + uri.length + 1);
+        }
+        for (const child of node.children) {
+            budget.chargeWork();
+            stack.push(child);
+        }
+    }
+    return true;
+}
+/** Preserve XML infoset content, omitting URI, digest, positions and element-name spelling. */
+export function projectFacetAnnotation(node, budget) {
+    const projectOne = (syntax) => {
+        budget.chargeWork(8);
+        if (syntax.kind === 'text') {
+            budget.chargeWork(syntax.value.length);
+            return { kind: 'text', value: syntax.value };
+        }
+        budget.chargeWork(syntax.name.namespace.length + syntax.name.local.length + syntax.attributes.length * 4 + syntax.children.length * 2);
+        const attributes = syntax.attributes.map(attribute => {
+            budget.chargeWork(attribute.name.namespace.length + attribute.name.local.length + attribute.value.length);
+            return { name: { namespace: attribute.name.namespace, local: attribute.name.local }, value: attribute.value };
+        });
+        const namespaces = Object.create(null);
+        for (const prefix in syntax.namespaces) {
+            const uri = syntax.namespaces[prefix];
+            budget.chargeWork(prefix.length + uri.length + 1);
+            namespaces[prefix] = uri;
+        }
+        budget.chargeWork(2);
+        return { kind: 'element', name: { namespace: syntax.name.namespace, local: syntax.name.local },
+            attributes, namespaces, children: [] };
+    };
+    const content = projectOne(node);
+    const stack = [[node, content]];
+    while (stack.length) {
+        budget.chargeWork(2);
+        const [source, target] = stack.pop();
+        for (const child of source.children) {
+            const copied = projectOne(child);
+            budget.chargeWork(2);
+            target.children.push(copied);
+            if (child.kind === 'element') {
+                budget.chargeWork();
+                stack.push([child, copied]);
+            }
+        }
+    }
+    return { kind: 'present', content };
+}
+/** A structural mismatch that may share an abstract annotation is unresolved. */
+export function compareFacetAnnotation(left, right, budget) {
+    if (left === 'absent' || right === 'absent')
+        return left === right ? 'equal' : 'different';
+    const stack = [[left.content, right.content, false]];
+    let unresolved = false;
+    while (stack.length) {
+        const [a, b, ambiguousSibling] = stack.pop();
+        budget.chargeWork(8);
+        if (a.kind !== b.kind) {
+            unresolved = true;
+            continue;
+        }
+        if (a.kind === 'text' && b.kind === 'text') {
+            budget.chargeWork(a.value.length + b.value.length);
+            if (a.value !== b.value) {
+                if (ambiguousSibling)
+                    unresolved = true;
+                else
+                    return 'different';
+            }
+            continue;
+        }
+        if (a.kind !== 'element' || b.kind !== 'element')
+            return 'unresolved';
+        budget.chargeWork(a.name.namespace.length + a.name.local.length + b.name.namespace.length + b.name.local.length);
+        if (a.name.namespace !== b.name.namespace || a.name.local !== b.name.local) {
+            unresolved = true;
+            continue;
+        }
+        const wrapper = a.name.namespace === XSD_NAMESPACE && a.name.local === 'annotation';
+        if (a.attributes.length !== b.attributes.length) {
+            if (wrapper || ambiguousSibling)
+                unresolved = true;
+            else
+                return 'different';
+        }
+        for (const x of a.attributes) {
+            let found = false;
+            for (const y of b.attributes) {
+                budget.chargeWork(x.name.namespace.length + x.name.local.length + x.value.length
+                    + y.name.namespace.length + y.name.local.length + y.value.length + 4);
+                if (x.name.namespace === y.name.namespace && x.name.local === y.name.local && x.value === y.value) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                if (wrapper || ambiguousSibling)
+                    unresolved = true;
+                else
+                    return 'different';
+            }
+        }
+        let xCount = 0, yCount = 0;
+        for (const prefix in a.namespaces) {
+            xCount++;
+            budget.chargeWork(prefix.length + a.namespaces[prefix].length + 2);
+            if (!Object.hasOwn(b.namespaces, prefix) || a.namespaces[prefix] !== b.namespaces[prefix])
+                unresolved = true;
+        }
+        for (const prefix in b.namespaces) {
+            yCount++;
+            budget.chargeWork(prefix.length + 1);
+        }
+        if (xCount !== yCount)
+            unresolved = true;
+        if (a.children.length !== b.children.length) {
+            if (wrapper || ambiguousSibling)
+                unresolved = true;
+            else
+                return 'different';
+        }
+        budget.chargeWork(a.children.length * 2);
+        const repeated = (children, index) => {
+            const selected = children[index];
+            for (let j = 0; j < children.length; j++) {
+                budget.chargeWork(3);
+                if (j === index)
+                    continue;
+                const other = children[j];
+                if (selected.kind !== other.kind)
+                    continue;
+                if (selected.kind === 'text')
+                    return true;
+                if (other.kind === 'element') {
+                    budget.chargeWork(selected.name.namespace.length + selected.name.local.length
+                        + other.name.namespace.length + other.name.local.length);
+                    if (selected.name.namespace === other.name.namespace && selected.name.local === other.name.local)
+                        return true;
+                }
+            }
+            return false;
+        };
+        for (let i = 0; i < Math.min(a.children.length, b.children.length); i++) {
+            const ambiguous = ambiguousSibling || repeated(a.children, i) || repeated(b.children, i);
+            budget.chargeWork();
+            stack.push([a.children[i], b.children[i], ambiguous]);
+        }
+    }
+    return unresolved ? 'unresolved' : 'equal';
+}

package/dist/compiler/schemaGeneratedScalarShape.d.ts

@@ -0,0 +1,35 @@
+/** Original-source scalar identity/shape mapping. No facet or validity engine. */
+import type { NodeId } from './canonicalGraph.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+import type { OriginalGeneratedScalarReference, SemanticTypeIdentity, SemanticTypeReference } from './semanticTypeReference.js';
+export type OriginalScalarShapeFailure = Readonly<{
+    kind: 'unresolved';
+    rule: string;
+    message: string;
+    contextId: string;
+    component?: NodeId;
+}>;
+export type OriginalScalarShapeResult<T> = Readonly<{
+    kind: 'checked';
+    value: T;
+    contextId: string;
+    authority: 'XSD10-original-scalar-shape-v1';
+    acceptance: 'structural-only';
+    sourceDependencies: readonly NodeId[];
+}> | OriginalScalarShapeFailure | ResourceLimitFailure;
+export type OriginalGeneratedScalarShape = Readonly<{
+    slot: OriginalGeneratedScalarReference;
+    name: undefined;
+    targetNamespace: string;
+    final: readonly [];
+    annotation: 'absent';
+    base: SemanticTypeReference;
+    variety: 'atomic' | 'list' | 'union';
+    primitive?: string;
+    item?: SemanticTypeReference;
+    members?: readonly SemanticTypeReference[];
+}>;
+export declare function resolveOriginalScalarIdentity(context: SemanticContext, reference: SemanticTypeReference): OriginalScalarShapeResult<SemanticTypeIdentity>;
+export declare function originalGeneratedShape(context: SemanticContext, slot: OriginalGeneratedScalarReference): OriginalScalarShapeResult<OriginalGeneratedScalarShape>;
+//# sourceMappingURL=schemaGeneratedScalarShape.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaGeneratedScalarShape.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaGeneratedScalarShape.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,OAAO,KAAK,EAA6B,MAAM,EAAY,MAAM,qBAAqB,CAAC;AAKvF,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,qBAAqB,CAAC;AAC9D,OAAO,KAAK,EAAC,gCAAgC,EAAE,oBAAoB,EAAE,qBAAqB,EAAC,MAAM,4BAA4B,CAAC;AAE9H,MAAM,MAAM,0BAA0B,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC;AAC9I,MAAM,MAAM,yBAAyB,CAAC,CAAC,IAAI,QAAQ,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,CAAC,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAChG,SAAS,EAAE,gCAAgC,CAAC;IAAC,UAAU,EAAE,iBAAiB,CAAC;IAAC,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAA;CAAC,CAAC,GACjH,0BAA0B,GAAG,oBAAoB,CAAC;AACtD,MAAM,MAAM,4BAA4B,GAAG,QAAQ,CAAC;IAClD,IAAI,EAAE,gCAAgC,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,eAAe,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,EAAE,CAAC;IACrG,UAAU,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,qBAAqB,CAAC;IAAC,OAAO,EAAE,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;IACxF,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,qBAAqB,CAAC;IAAC,OAAO,CAAC,EAAE,SAAS,qBAAqB,EAAE,CAAC;CAC9F,CAAC,CAAC;AAsHH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,qBAAqB,GAAG,yBAAyB,CAAC,oBAAoB,CAAC,CAKzJ;AACD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,gCAAgC,GAAG,yBAAyB,CAAC,4BAA4B,CAAC,CAWhK"}