@techspokes/typescript-wsdl-client 1.1.4 → 1.1.5

package/dist/compiler/schemaUri.js

@@ -0,0 +1,103 @@
+/** Generic RFC2396/2732 syntax for schema anyURI operands, after XLink escaping. */
+import { isIP } from "node:net";
+/** Regular preimage of the RFC2396/2732 assessor below, before XLink escaping.
+ * Every escaped source character contributes one or more percent octets;
+ * these are legal in precisely the generic URI-token positions. Raw percent
+ * signs still require their two hexadecimal digits. IPv6 has eight 16-bit
+ * units, with an embedded IPv4 tail consuming two and :: omitting at least one.
+ */
+export function schemaUriExpression(owner, c) {
+    c.step(owner, 8192);
+    const escaped = "[^A-Za-z0-9\\-_.!~*'();/?:@&=+$,#\\[\\]%]";
+    const octet = '(%[0-9A-Fa-f]{2}|' + escaped + ')';
+    const token = (characters) => '([' + characters + ']|' + octet + ')';
+    const mark = "A-Za-z0-9\\-_.!~*'()";
+    const uric = token(mark + ';/?:@&=+$,\\[\\]');
+    const nonSlash = token(mark + ';?:@&=+$,\\[\\]');
+    const pchar = token(mark + ':@&=+$,;');
+    const first = token(mark + ';@&=+$,');
+    const registry = token(mark + '$,:;@&=+');
+    const userinfo = token(mark + ';:&=+$,');
+    const hex = '[0-9A-Fa-f]{1,4}';
+    const ipv4octet = '([0-9]{1,2}|[01][0-9]{2}|2[0-4][0-9]|25[0-5])';
+    const ipv4 = ipv4octet + '([.]' + ipv4octet + '){3}';
+    const addresses = [hex + '(:' + hex + '){7}', hex + '(:' + hex + '){5}:' + ipv4];
+    for (const tail of [false, true])
+        for (let left = 0; left <= (tail ? 5 : 7); left++)
+            for (let right = 0; right + left < (tail ? 6 : 8); right++) {
+                c.step(owner, 512);
+                const before = left ? hex + (left > 1 ? '(:' + hex + '){' + (left - 1) + '}' : '') : '';
+                const after = right ? hex + (right > 1 ? '(:' + hex + '){' + (right - 1) + '}' : '') : '';
+                addresses.push(before + '::' + after + (tail ? (right ? ':' : '') + ipv4 : ''));
+            }
+    c.step(owner, addresses.reduce((total, value) => total + value.length, 0) * 4 + 4096);
+    const server = '(' + userinfo + '*@)?\\[(' + addresses.join('|') + ')\\](:[0-9]*)?';
+    const authority = '(' + registry + '*|' + server + ')';
+    const path = pchar + '*(/' + pchar + '*)*';
+    const hierarchical = '(//' + authority + '(/' + path + ')?|/' + path + ')';
+    const query = '([?]' + uric + '*)?';
+    const relative = '(//' + authority + '(/' + path + ')?|/' + path + '|' + first + '+(/' + path + ')?)?';
+    const scheme = '[A-Za-z][A-Za-z0-9+.\\-]*:';
+    const result = '(' + scheme + '(' + nonSlash + uric + '*|' + hierarchical + query + ')|' + relative + query + ')(#' + uric + '*)?';
+    c.step(owner, result.length * 2 + 2);
+    return result;
+}
+export function schemaUri(value, owner, c) {
+    c.step(owner, value.length * 12 + 1);
+    let escaped = "";
+    for (const character of value) {
+        c.step(owner);
+        if (/^[A-Za-z0-9\-_.!~*'();/?:@&=+$,#[\]%]$/.test(character))
+            escaped += character;
+        else
+            for (const byte of Buffer.from(character, "utf8"))
+                escaped += `%${byte.toString(16).padStart(2, "0")}`;
+    }
+    if (/%(?![0-9A-Fa-f]{2})/.test(escaped))
+        return false;
+    const uric = /^(?:[A-Za-z0-9\-_.!~*'();/?:@&=+$,[\]]|%[0-9A-Fa-f]{2})*$/;
+    const hash = escaped.indexOf("#"), fragment = hash < 0 ? "" : escaped.slice(hash + 1), resource = hash < 0 ? escaped : escaped.slice(0, hash);
+    if (!uric.test(fragment))
+        return false;
+    const scheme = /^([A-Za-z][A-Za-z0-9+.-]*):/.exec(resource);
+    let rest = scheme ? resource.slice(scheme[0].length) : resource;
+    if (scheme && !rest)
+        return false;
+    // Opaque absolute identifiers use uric, beginning with a non-slash.
+    if (scheme && rest[0] !== "/")
+        return uric.test(rest);
+    const question = rest.indexOf("?"), query = question < 0 ? "" : rest.slice(question + 1);
+    rest = question < 0 ? rest : rest.slice(0, question);
+    if (!uric.test(query))
+        return false;
+    if (rest.startsWith("//")) {
+        const slash = rest.indexOf("/", 2), authority = rest.slice(2, slash < 0 ? undefined : slash);
+        rest = slash < 0 ? "" : rest.slice(slash);
+        // RFC2396 registry authorities are legal, even where a named protocol
+        // would demand a numeric port. Brackets denote the RFC2732 server form.
+        if (/[\[\]]/.test(authority)) {
+            const server = /^(?:((?:[A-Za-z0-9\-_.!~*'();:&=+$,]|%[0-9A-Fa-f]{2})*)@)?\[([^\]]+)\](?::[0-9]*)?$/.exec(authority);
+            if (!server || server[2].includes("%"))
+                return false;
+            let address = server[2];
+            if (address.includes(".")) {
+                const colon = address.lastIndexOf(":"), octets = address.slice(colon + 1).split(".");
+                // RFC2732 imports RFC2373: embedded IPv4 octets are one to three
+                // decimal digits, including leading zeros (not modern URL grammar).
+                if (octets.length !== 4 || octets.some(octet => !/^[0-9]{1,3}$/.test(octet) || Number(octet) > 255))
+                    return false;
+                address = address.slice(0, colon + 1) + octets.map(octet => String(Number(octet))).join(".");
+            }
+            if (isIP(address) !== 6)
+                return false;
+        }
+        else if (!/^(?:[A-Za-z0-9\-_.!~*'()$,:;@&=+]|%[0-9A-Fa-f]{2})*$/.test(authority))
+            return false;
+    }
+    else if (rest && rest[0] !== "/") {
+        const slash = rest.indexOf("/"), segment = slash < 0 ? rest : rest.slice(0, slash);
+        if (!/^(?:[A-Za-z0-9\-_.!~*'();@&=+$,]|%[0-9A-Fa-f]{2})+$/.test(segment))
+            return false;
+    }
+    return /^(?:[A-Za-z0-9\-_.!~*'():@&=+$,;/]|%[0-9A-Fa-f]{2})*$/.test(rest);
+}

package/dist/compiler/schemaValueContext.d.ts

@@ -0,0 +1,26 @@
+/** Internal diagnostic and accounting seam; it confers no component authority. */
+import type { SyntaxSource } from '../loader/orderedSyntax.js';
+export type DatatypeLexicalOperand = Readonly<{
+    value: string;
+    context: Readonly<{
+        namespaces: Readonly<Record<string, string>>;
+        source: SyntaxSource;
+    }>;
+}>;
+export type DatatypeValueContext<Owner> = {
+    step(owner: Owner, count?: number): void;
+    text(value: string, owner: Owner): string;
+    fail(owner: Owner, rule: string, message: string, source?: SyntaxSource): never;
+    unsupported(owner: Owner, rule: string, message: string, source?: SyntaxSource): never;
+    unresolved(owner: Owner, rule: string, message: string, source?: SyntaxSource): never;
+    notation(namespace: string, local: string, owner: Owner): void;
+};
+export type SchemaPatternContext<Owner> = Pick<SchemaValueContext<Owner>, 'step' | 'text' | 'fail' | 'unsupported'> & {
+    algebra: {
+        compare(a: string, b: string): number;
+    };
+};
+/** Schema-facing aliases preserve existing ownership contracts. */
+export type SchemaLexicalOperand = DatatypeLexicalOperand;
+export type SchemaValueContext<Owner> = DatatypeValueContext<Owner>;
+//# sourceMappingURL=schemaValueContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaValueContext.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaValueContext.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,4BAA4B,CAAC;AAE7D,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC5C,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,QAAQ,CAAC;QAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;QAAC,MAAM,EAAE,YAAY,CAAA;KAAC,CAAC,CAAC;CACzF,CAAC,CAAC;AACH,MAAM,MAAM,oBAAoB,CAAC,KAAK,IAAI;IACxC,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC;IAC1C,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,GAAG,KAAK,CAAC;IAChF,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,GAAG,KAAK,CAAC;IACvF,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,GAAG,KAAK,CAAC;IACtF,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CAChE,CAAC;AACF,MAAM,MAAM,oBAAoB,CAAC,KAAK,IAAI,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,aAAa,CAAC,GAAG;IACpH,OAAO,EAAE;QAAC,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAC,CAAC;CAClD,CAAC;AAEF,mEAAmE;AACnE,MAAM,MAAM,oBAAoB,GAAG,sBAAsB,CAAC;AAC1D,MAAM,MAAM,kBAAkB,CAAC,KAAK,IAAI,oBAAoB,CAAC,KAAK,CAAC,CAAC"}

package/dist/compiler/schemaValueContext.js

@@ -0,0 +1 @@
+export {};

package/dist/compiler/schemaValueImages.d.ts

@@ -0,0 +1,10 @@
+/** Regular images of schema-normalized scalar spellings, with typed families. */
+import type { RegularLanguage } from './schemaRegularLanguage.js';
+import { schemaRegularLanguages } from './schemaRegularLanguage.js';
+import type { SchemaPatternContext } from './schemaValueContext.js';
+export declare function schemaValueImages<Owner>(c: SchemaPatternContext<Owner>, regular: ReturnType<typeof schemaRegularLanguages<Owner>>, expression: (text: string, owner: Owner) => RegularLanguage): {
+    decimal: (source: RegularLanguage, owner: Owner) => RegularLanguage;
+    duration: (source: RegularLanguage, owner: Owner) => RegularLanguage;
+    simple: (source: RegularLanguage, family: string, owner: Owner) => RegularLanguage | undefined;
+};
+//# sourceMappingURL=schemaValueImages.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaValueImages.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaValueImages.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAC,sBAAsB,EAAC,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,yBAAyB,CAAC;AAGlE,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,CAAC,EAAE,oBAAoB,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,KAAK,CAAC,CAAC,EAChI,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,eAAe;sBAElC,eAAe,SAAS,KAAK,KAAG,eAAe;uBA0B9C,eAAe,SAAS,KAAK,KAAG,eAAe;qBAuDjD,eAAe,UAAU,MAAM,SAAS,KAAK,KAAG,eAAe,GAAG,SAAS;EAepG"}

package/dist/compiler/schemaValueImages.js

@@ -0,0 +1,142 @@
+import { schemaRegularLanguages } from './schemaRegularLanguage.js';
+import { schemaIntegerImages } from './schemaIntegerImages.js';
+export function schemaValueImages(c, regular, expression) {
+    const integers = schemaIntegerImages(c, regular, expression);
+    const decimal = (source, owner) => {
+        c.step(owner, 4);
+        const choices = [], epsilon = expression('', owner), digits = expression('[0-9]*', owner);
+        const positiveInteger = expression('[1-9][0-9]*', owner), fractional = expression('[0-9]*[1-9]', owner);
+        const zero = expression('0', owner), zeroes = expression('0*', owner);
+        if (regular.witness(regular.intersect([source, expression('[+\\-]?(0+([.]0*)?|[.]0+)', owner)], owner), owner) !== undefined)
+            choices.push(zero);
+        for (const negative of [false, true]) {
+            const unsigned = regular.quotient(source, expression(negative ? '\\-' : '[+]?', owner), epsilon, owner);
+            const integral = regular.intersect([regular.quotient(unsigned, zeroes, expression('([.]0*)?', owner), owner), positiveInteger], owner);
+            choices.push(regular.concatenate([expression(negative ? '\\-' : '', owner), integral], owner));
+            const program = regular.automaton(unsigned, owner);
+            c.step(owner, program.states.length * 4 + 4);
+            const accepting = new Set(program.states.flatMap((state, index) => state.accepting ? [index] : []));
+            for (let before = 0; before < program.states.length; before++)
+                for (const edge of program.states[before].transitions) {
+                    c.step(owner);
+                    if (edge.lo > 46 || edge.hi < 46)
+                        continue;
+                    const whole = regular.intersect([regular.paths(program, [program.start], new Set([before]), owner), digits], owner);
+                    const canonicalWhole = regular.intersect([regular.quotient(whole, zeroes, epsilon, owner), positiveInteger], owner);
+                    const integralChoices = [canonicalWhole];
+                    if (regular.witness(regular.intersect([whole, zeroes], owner), owner) !== undefined)
+                        integralChoices.push(zero);
+                    const tail = regular.intersect([regular.paths(program, [edge.to], accepting, owner), digits], owner);
+                    const canonicalTail = regular.intersect([regular.quotient(tail, epsilon, zeroes, owner), fractional], owner);
+                    choices.push(regular.concatenate([expression(negative ? '\\-' : '', owner), regular.union(integralChoices, owner),
+                        expression('[.]', owner), canonicalTail], owner));
+                }
+        }
+        return regular.union(choices, owner);
+    };
+    const duration = (source, owner) => {
+        c.step(owner, 4);
+        const images = [], epsilon = expression('', owner), zero = expression('0', owner), digits = expression('[0-9]+', owner);
+        const signed = (language, negative) => !negative ? language : regular.union([
+            regular.intersect([language, zero], owner), regular.concatenate([expression('\\-', owner), regular.intersect([language, regular.negate(zero, owner)], owner)], owner)
+        ], owner);
+        for (const negative of [false, true]) {
+            const unsigned = regular.quotient(source, expression(negative ? '\\-P' : 'P', owner), epsilon, owner), program = regular.automaton(unsigned, owner);
+            c.step(owner, program.states.length * 2 + 4);
+            const accepted = new Set(program.states.flatMap((state, index) => state.accepting ? [index] : []));
+            const cache = new Map();
+            const fields = (start, unit) => {
+                c.step(owner, 24);
+                const key = start + ':' + unit, known = cache.get(key);
+                if (known)
+                    return known;
+                c.step(owner, 3);
+                const options = [{ at: start, value: zero }], cp = unit.charCodeAt(0);
+                for (let end = 0; end < program.states.length; end++)
+                    for (const edge of program.states[end].transitions) {
+                        c.step(owner);
+                        if (edge.lo > cp || edge.hi < cp)
+                            continue;
+                        const value = regular.intersect([regular.paths(program, [start], new Set([end]), owner), digits], owner);
+                        if (regular.witness(value, owner) !== undefined) {
+                            c.step(owner, 3);
+                            options.push({ at: edge.to, value });
+                        }
+                    }
+                c.step(owner, 2);
+                cache.set(key, options);
+                return options;
+            };
+            const next = (from, cp) => {
+                c.step(owner, program.states[from].transitions.length + 2);
+                return program.states[from].transitions.flatMap(edge => edge.lo <= cp && edge.hi >= cp ? [edge.to] : []);
+            };
+            const publish = (month, whole, fraction) => {
+                const seconds = fraction ? regular.concatenate([whole, expression('[.]', owner), fraction], owner) : whole;
+                c.step(owner, 2);
+                images.push(regular.concatenate([signed(month, negative), expression('/', owner), signed(seconds, negative)], owner));
+            };
+            for (const year of fields(program.start, 'Y'))
+                for (const month of fields(year.at, 'M')) {
+                    const months = integers.sum([{ language: year.value, weight: 12 }, { language: month.value, weight: 1 }], owner);
+                    for (const day of fields(month.at, 'D')) {
+                        if (accepted.has(day.at))
+                            publish(months, integers.sum([{ language: day.value, weight: 86400 }], owner));
+                        for (const clock of next(day.at, 84))
+                            for (const hour of fields(clock, 'H'))
+                                for (const minute of fields(hour.at, 'M')) {
+                                    const input = [{ language: day.value, weight: 86400 }, { language: hour.value, weight: 3600 }, { language: minute.value, weight: 60 }];
+                                    if (accepted.has(minute.at))
+                                        publish(months, integers.sum(input, owner));
+                                    for (let end = 0; end < program.states.length; end++) {
+                                        c.step(owner);
+                                        if (!next(end, 83).some(state => accepted.has(state)))
+                                            continue;
+                                        const whole = regular.intersect([regular.paths(program, [minute.at], new Set([end]), owner), digits], owner);
+                                        if (regular.witness(whole, owner) !== undefined)
+                                            publish(months, integers.sum([...input, { language: whole, weight: 1 }], owner));
+                                        for (let before = 0; before < program.states.length; before++)
+                                            for (const after of next(before, 46)) {
+                                                const integral = regular.intersect([regular.paths(program, [minute.at], new Set([before]), owner), digits], owner);
+                                                if (regular.witness(integral, owner) === undefined)
+                                                    continue;
+                                                const fractional = regular.intersect([regular.paths(program, [after], new Set([end]), owner), digits], owner);
+                                                if (regular.witness(fractional, owner) === undefined)
+                                                    continue;
+                                                const sum = integers.sum([...input, { language: integral, weight: 1 }], owner);
+                                                if (regular.witness(regular.intersect([fractional, expression('0+', owner)], owner), owner) !== undefined)
+                                                    publish(months, sum);
+                                                const canonical = regular.intersect([regular.quotient(fractional, epsilon, expression('0*', owner), owner), expression('[0-9]*[1-9]', owner)], owner);
+                                                if (regular.witness(canonical, owner) !== undefined)
+                                                    publish(months, sum, canonical);
+                                            }
+                                    }
+                                }
+                    }
+                }
+        }
+        return regular.union(images, owner);
+    };
+    const simple = (source, family, owner) => {
+        if (family === 'string' || family === 'anyURI')
+            return source;
+        if (family === 'decimal')
+            return decimal(source, owner);
+        if (family === 'duration')
+            return duration(source, owner);
+        if (family === 'hexBinary')
+            return regular.characterImage(source, [{ lo: 65, hi: 70, shift: 32 }], owner);
+        if (family === 'base64Binary')
+            return regular.characterImage(source, [{ lo: 32, hi: 32, remove: true }], owner);
+        if (family === 'boolean') {
+            c.step(owner, 3);
+            const choices = [];
+            for (const [syntax, canonical] of [['true|1', 'true'], ['false|0', 'false']])
+                if (regular.witness(regular.intersect([source, expression(syntax, owner)], owner), owner) !== undefined)
+                    choices.push(expression(canonical, owner));
+            return regular.union(choices, owner);
+        }
+        return undefined;
+    };
+    return { decimal, duration, simple };
+}

package/dist/compiler/schemaValueSequences.d.ts

@@ -0,0 +1,15 @@
+/** Shared private ordered-member scheduling, independent of descriptor ownership. */
+import type { SchemaOperand } from './schemaDatatypeValues.js';
+export type SchemaUnionContext<Owner> = {
+    step(owner: Owner, count?: number): void;
+    /** Must recognize the adapter's own error identity and invalid-schema category. */
+    isInvalidSchema(error: unknown): boolean;
+};
+export declare function schemaValueSequences<Owner>(context: SchemaUnionContext<Owner>): {
+    chooseUnionMember: <Request>(requests: readonly Request[], owner: Owner) => Generator<Request, {
+        request: Request;
+        index: number;
+        value: SchemaOperand;
+    } | undefined, SchemaOperand>;
+};
+//# sourceMappingURL=schemaValueSequences.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaValueSequences.d.ts","sourceRoot":"","sources":["../../src/compiler/schemaValueSequences.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,2BAA2B,CAAC;AAE7D,MAAM,MAAM,kBAAkB,CAAC,KAAK,IAAI;IACtC,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC,mFAAmF;IACnF,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;CAC1C,CAAC;AACF,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,kBAAkB,CAAC,KAAK,CAAC;wBAChD,OAAO,YAAY,SAAS,OAAO,EAAE,SAAS,KAAK,KAC7E,SAAS,CAAC,OAAO,EAAE;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,aAAa,CAAA;KAAC,GAAG,SAAS,EAAE,aAAa,CAAC;EAUzG"}

package/dist/compiler/schemaValueSequences.js

@@ -0,0 +1,19 @@
+export function schemaValueSequences(context) {
+    function* chooseUnionMember(requests, owner) {
+        for (let index = 0; index < requests.length; index++) {
+            context.step(owner);
+            const request = requests[index];
+            try {
+                const value = yield request;
+                context.step(owner, 3);
+                return { request, index, value };
+            }
+            catch (error) {
+                if (!context.isInvalidSchema(error))
+                    throw error;
+            }
+        }
+        return undefined;
+    }
+    return { chooseUnionMember };
+}

package/dist/compiler/semanticBudget.d.ts

@@ -0,0 +1,50 @@
+export interface ResolverLimits {
+    readonly maxNodes?: number;
+    readonly maxWork?: number;
+}
+export interface ResolverUsage {
+    readonly nodes: number;
+    readonly work: number;
+}
+export interface ResourceLimitFailure {
+    readonly kind: 'resource-limit';
+    readonly limit: 'nodes' | 'work';
+    readonly usage: ResolverUsage;
+}
+export interface ResolverBudget {
+    chargeWork(amount?: number): void;
+    reserveNodes(amount: number): void;
+    usage(): ResolverUsage;
+    exhausted(): boolean;
+    failure(): ResourceLimitFailure | undefined;
+    guard<T>(operation: () => T): T | ResourceLimitFailure;
+    compareText(left: string, right: string): number;
+    sorted<T>(values: readonly T[], compare: (left: T, right: T) => number): T[];
+    snapshot<T>(value: T): T;
+    freeze<T>(value: T): Readonly<T>;
+}
+export declare const DEFAULT_MAX_NODES = 100000;
+export declare const DEFAULT_MAX_WORK = 125000000;
+/**
+ * The terminal result is reserved once, including its borrowed counter view.
+ * Construction: 2 records + 5 fields + 23 field-name units + 14 kind units +
+ * 5 limit units = 49. Freezing: 2 records + 5 fields + 23 field-name units = 30.
+ * Fixed budget bookkeeping and the private abort signal do not contain input
+ * data and are the constant escape machinery, rather than graph work.
+ */
+export declare const TERMINAL_RESERVATION_WORK = 79;
+export declare class ResolverInvalidLimitsError extends RangeError {
+    constructor();
+}
+export declare function createResolverBudget(limits?: ResolverLimits): ResolverBudget;
+/** Shared production owner; historical research names remain source-compatible. */
+export type SemanticBudget = ResolverBudget;
+export type SemanticBudgetLimits = ResolverLimits;
+export declare const createSemanticBudget: typeof createResolverBudget;
+/** Observe sticky failure without charging routine procedural work. */
+export declare function checkSemanticBudget(budget: SemanticBudget): void;
+/** Application execution has no work quota unless the caller explicitly supplies one. */
+export declare function createApplicationBudget(limits?: SemanticBudgetLimits): SemanticBudget;
+/** Internal identity marker, never source/transport authorization. */
+export declare function isApplicationUnmetered(budget: SemanticBudget): boolean;
+//# sourceMappingURL=semanticBudget.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"semanticBudget.d.ts","sourceRoot":"","sources":["../../src/compiler/semanticBudget.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;CAC/B;AAED,MAAM,WAAW,cAAc;IAC7B,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,KAAK,IAAI,aAAa,CAAC;IACvB,SAAS,IAAI,OAAO,CAAC;IACrB,OAAO,IAAI,oBAAoB,GAAG,SAAS,CAAC;IAC5C,KAAK,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,oBAAoB,CAAC;IACvD,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IACjD,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,MAAM,GAAG,CAAC,EAAE,CAAC;IAC7E,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC;IACzB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;CAClC;AAED,eAAO,MAAM,iBAAiB,SAAU,CAAC;AAMzC,eAAO,MAAM,gBAAgB,YAAc,CAAC;AAE5C;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAE5C,qBAAa,0BAA2B,SAAQ,UAAU;;CAKzD;AAoBD,wBAAgB,oBAAoB,CAAC,MAAM,GAAE,cAA0B,GAAG,cAAc,CA8GvF;AAED,mFAAmF;AACnF,MAAM,MAAM,cAAc,GAAG,cAAc,CAAC;AAC5C,MAAM,MAAM,oBAAoB,GAAG,cAAc,CAAC;AAClD,eAAO,MAAM,oBAAoB,6BAAuB,CAAC;AAEzD,uEAAuE;AACvE,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAAwB;AAGzF,yFAAyF;AACzF,wBAAgB,uBAAuB,CAAC,MAAM,CAAC,EAAE,oBAAoB,GAAG,cAAc,CAWrF;AACD,sEAAsE;AACtE,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAgC"}

package/dist/compiler/semanticBudget.js

@@ -0,0 +1,178 @@
+/** Shared request-local semantic accounting; historical resolver names remain compatible. */
+import { createDataOwnership } from './dataOwnership.js';
+export const DEFAULT_MAX_NODES = 100_000;
+// Scalar containment calibration includes a 79-million-work complete URI /
+// IEEE-list query. The 125-million default allows substantial workload
+// variation; earlier 25-million and one-million regression profiles remain.
+// See the resolver implementation's scalar capacity evidence. These remain
+// revisable engineering limits, not semantic or mathematical proof bounds.
+export const DEFAULT_MAX_WORK = 125_000_000;
+/**
+ * The terminal result is reserved once, including its borrowed counter view.
+ * Construction: 2 records + 5 fields + 23 field-name units + 14 kind units +
+ * 5 limit units = 49. Freezing: 2 records + 5 fields + 23 field-name units = 30.
+ * Fixed budget bookkeeping and the private abort signal do not contain input
+ * data and are the constant escape machinery, rather than graph work.
+ */
+export const TERMINAL_RESERVATION_WORK = 79;
+export class ResolverInvalidLimitsError extends RangeError {
+    constructor() {
+        super('RE01 limits must be positive safe integers');
+        this.name = 'ResolverInvalidLimitsError';
+    }
+}
+function validLimit(value) {
+    return Number.isSafeInteger(value) && value > 0;
+}
+const NO_LIMITS = Object.freeze({});
+/** Fixed limit metadata belongs to the bounded request-start machinery. */
+function limit(limits, key, fallback) {
+    if (!limits || typeof limits !== 'object' || Array.isArray(limits))
+        throw new ResolverInvalidLimitsError();
+    const descriptor = Object.getOwnPropertyDescriptor(limits, key);
+    if (descriptor === undefined)
+        return fallback;
+    if (!('value' in descriptor))
+        throw new ResolverInvalidLimitsError();
+    const value = descriptor.value;
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== 'number' || !validLimit(value))
+        throw new ResolverInvalidLimitsError();
+    return value;
+}
+export function createResolverBudget(limits = NO_LIMITS) {
+    const maxNodes = limit(limits, 'maxNodes', DEFAULT_MAX_NODES);
+    const maxWork = limit(limits, 'maxWork', DEFAULT_MAX_WORK);
+    if (!validLimit(maxNodes) || !validLimit(maxWork))
+        throw new ResolverInvalidLimitsError();
+    let nodes = 0;
+    let work = 0;
+    let failed;
+    // These fixed-size objects are the request's reserved terminal machinery.
+    const usage = Object.freeze({ get nodes() { return nodes; }, get work() { return work; } });
+    const failure = Object.freeze({
+        kind: 'resource-limit',
+        get limit() { return failed ?? 'work'; },
+        usage,
+    });
+    const abort = Object.freeze({});
+    function charge(amount, limit) {
+        if (failed !== undefined)
+            throw abort;
+        if (!Number.isSafeInteger(amount) || amount < 0) {
+            throw new RangeError('RE01 charges must be nonnegative safe integers');
+        }
+        const used = limit === 'nodes' ? nodes : work;
+        const maximum = limit === 'nodes' ? maxNodes : maxWork;
+        // Subtraction is checked before adding: no overflow and inclusive limits.
+        if (amount > maximum - used) {
+            failed = limit;
+            throw abort;
+        }
+        if (limit === 'nodes')
+            nodes += amount;
+        else
+            work += amount;
+    }
+    function chargeWork(amount = 1) { charge(amount, 'work'); }
+    function compareText(left, right) {
+        chargeWork(2); // Constant-time length reads.
+        const leftLength = left.length;
+        const rightLength = right.length;
+        const length = Math.min(leftLength, rightLength);
+        for (let index = 0; index < length; index += 1) {
+            chargeWork(2); // Both inspected UTF-16 units, before inspection.
+            const a = left.charCodeAt(index);
+            const b = right.charCodeAt(index);
+            if (a !== b)
+                return a < b ? -1 : 1;
+        }
+        return leftLength < rightLength ? -1 : leftLength > rightLength ? 1 : 0;
+    }
+    function sorted(values, compare) {
+        chargeWork(); // Input length read.
+        const length = values.length;
+        chargeWork(2); // The two containers, before allocation.
+        let source = [];
+        let target = [];
+        for (let index = 0; index < length; index += 1) {
+            chargeWork(2); // Input read and copied output entry.
+            source[index] = values[index];
+        }
+        // A specified merge order avoids engine/version-dependent comparator counts.
+        for (let width = 1; width < length; width *= 2) {
+            for (let start = 0; start < length; start += width * 2) {
+                const middle = Math.min(start + width, length);
+                const end = Math.min(middle + width, length);
+                let left = start;
+                let right = middle;
+                for (let output = start; output < end; output += 1) {
+                    let takeLeft = right >= end;
+                    if (left < middle && right < end) {
+                        chargeWork(3); // Two reads and one comparator visit.
+                        takeLeft = compare(source[left], source[right]) <= 0;
+                    }
+                    if (left >= middle)
+                        takeLeft = false;
+                    chargeWork(2); // Chosen input read and output write.
+                    target[output] = takeLeft ? source[left++] : source[right++];
+                }
+            }
+            const previous = source;
+            source = target;
+            target = previous;
+        }
+        return source;
+    }
+    const { snapshot, freeze } = createDataOwnership(chargeWork);
+    // Budgets smaller than the reservation fail without performing graph work;
+    // their one constant terminal envelope remains the reserved escape path.
+    if (maxWork < TERMINAL_RESERVATION_WORK)
+        failed = 'work';
+    else
+        work = TERMINAL_RESERVATION_WORK;
+    return {
+        chargeWork,
+        reserveNodes: (amount) => charge(amount, 'nodes'),
+        usage: () => usage,
+        exhausted: () => failed !== undefined,
+        failure: () => failed === undefined ? undefined : failure,
+        guard(operation) {
+            if (failed !== undefined)
+                return failure;
+            try {
+                return operation();
+            }
+            catch (error) {
+                if (error === abort)
+                    return failure;
+                throw error;
+            }
+        },
+        compareText,
+        sorted,
+        snapshot,
+        freeze,
+    };
+}
+export const createSemanticBudget = createResolverBudget;
+/** Observe sticky failure without charging routine procedural work. */
+export function checkSemanticBudget(budget) { budget.chargeWork(0); }
+const unmetered = new WeakSet();
+/** Application execution has no work quota unless the caller explicitly supplies one. */
+export function createApplicationBudget(limits) {
+    if (limits !== undefined)
+        return createSemanticBudget(limits);
+    const ownership = createDataOwnership(() => { });
+    const budget = {
+        chargeWork() { }, reserveNodes() { }, usage: () => ({ nodes: 0, work: 0 }),
+        exhausted: () => false, failure: () => undefined, guard: operation => operation(),
+        compareText: (a, b) => a < b ? -1 : a > b ? 1 : 0,
+        sorted: (values, compare) => Array.from(values).sort(compare), ...ownership,
+    };
+    unmetered.add(budget);
+    return budget;
+}
+/** Internal identity marker, never source/transport authorization. */
+export function isApplicationUnmetered(budget) { return unmetered.has(budget); }