@astrale-os/kernel-dsl 0.2.0-beta.44 → 0.2.0-beta.46

package/dist/v1/language/value/profile/rules.js

@@ -3,8 +3,7 @@ import { diagnostic } from '../../validation/diagnostic.js';
 import { blob, BLOB_VALUE_KIND } from '../model/blob.js';
 import { isValueObject as isJsonObject } from '../model/object.js';
 import { VALUE_SCHEMA_DIALECT } from '../model/schema.js';
-import { compilePattern, PatternComplexityError } from '../regexp/compile.js';
-import { isIRegexp } from '../regexp/syntax.js';
+import { refuseIRegexp, stateBudgetMessage } from '../regexp/syntax.js';
 import { walkSchema } from '../syntax/walk.js';
 import { FORBIDDEN_DYNAMIC_KEYWORDS, STANDARD_SCHEMA_KEYWORDS } from './vocabulary.js';
 export function validateSchemaProfile(schema, context, pointer) {
@@ -96,43 +95,23 @@ function validateRegexes(schema, pointer, diagnostics) {
     if (Object.hasOwn(schema, 'fullMatch') && typeof schema.fullMatch !== 'string') {
         diagnostics.push(diagnostic('VS_META_SCHEMA', `${pointer}/fullMatch`, 'fullMatch must be an I-Regexp source string.'));
     }
-    if (typeof schema.fullMatch === 'string' && !isIRegexp(schema.fullMatch)) {
-        diagnostics.push(diagnostic('VS_REGEX_PORTABLE', `${pointer}/fullMatch`, 'fullMatch must satisfy the complete RFC 9485 I-Regexp syntax.'));
+    if (typeof schema.fullMatch === 'string') {
+        portableRegex(schema.fullMatch, `${pointer}/fullMatch`, 'fullMatch', 'fullMatch must satisfy the complete RFC 9485 I-Regexp syntax.', diagnostics);
     }
-    else if (typeof schema.fullMatch === 'string') {
-        checkPatternComplexity(schema.fullMatch, `${pointer}/fullMatch`, diagnostics);
-    }
-    if (typeof schema.pattern === 'string' && !isIRegexp(schema.pattern)) {
-        diagnostics.push(diagnostic('VS_REGEX_PORTABLE', `${pointer}/pattern`, 'pattern must satisfy the complete RFC 9485 I-Regexp syntax.'));
-    }
-    else if (typeof schema.pattern === 'string') {
-        checkPatternComplexity(schema.pattern, `${pointer}/pattern`, diagnostics);
+    if (typeof schema.pattern === 'string') {
+        portableRegex(schema.pattern, `${pointer}/pattern`, 'pattern', 'pattern must satisfy the complete RFC 9485 I-Regexp syntax.', diagnostics);
     }
     if (isJsonObject(schema.patternProperties)) {
         for (const pattern of Object.keys(schema.patternProperties)) {
-            if (!isIRegexp(pattern)) {
-                diagnostics.push(diagnostic('VS_REGEX_PORTABLE', `${pointer}/patternProperties/${escapeToken(pattern)}`, 'patternProperties keys must satisfy RFC 9485 I-Regexp syntax.'));
-            }
-            else {
-                checkPatternComplexity(pattern, `${pointer}/patternProperties/${escapeToken(pattern)}`, diagnostics);
-            }
+            portableRegex(pattern, `${pointer}/patternProperties/${escapeToken(pattern)}`, 'A patternProperties key', 'patternProperties keys must satisfy RFC 9485 I-Regexp syntax.', diagnostics);
         }
     }
 }
-/**
- * Reject a syntactically valid I-Regexp that compiles to an unbounded NFA (nested counted
- * repetitions, P1-I-01) at admission, rather than letting it unroll to ~120k states and cost
- * seconds per validated value. Other compile failures are already reported by the syntax checks.
- */
-function checkPatternComplexity(source, pointer, diagnostics) {
-    try {
-        compilePattern(source);
-    }
-    catch (error) {
-        if (error instanceof PatternComplexityError) {
-            diagnostics.push(diagnostic('VS_REGEX_PORTABLE', pointer, `${error.message} Simplify nested counted repetitions to stay within the I-Regexp complexity bound.`));
-        }
-    }
+function portableRegex(source, pointer, subject, syntax, diagnostics) {
+    const refusal = refuseIRegexp(source);
+    if (refusal === undefined)
+        return;
+    diagnostics.push(diagnostic('VS_REGEX_PORTABLE', pointer, refusal === 'syntax' ? syntax : stateBudgetMessage(subject)));
 }
 function rejectPrimitiveDuplicates(values, pointer, name, diagnostics) {
     const seen = new Set();

package/dist/v1/language/value/regexp/ast.js

@@ -1,11 +1,8 @@
-const CATEGORY = /^(?:L[lmotu]?|M[cen]?|N[dlo]?|P[cdfios]?|Z[lps]?|S[ckmo]?|C[cfno]?)$/u;
+import { categoryRanges, complement, mergeRanges } from './unicode.js';
+const CATEGORY = /^(?:L[lmotu]?|M[cen]?|N[dlo]?|P[cdefios]?|Z[lps]?|S[ckmo]?|C[cfno]?)$/u;
 const MAX_CODE_POINTS = 4096;
 const MAX_NESTING = 32;
 const MAX_REPEAT = 1000;
-const SCALAR_RANGES = [
-    [0, 0xd7ff],
-    [0xe000, 0x10ffff],
-];
 const DOT_RANGES = [
     [0, 9],
     [11, 12],
@@ -200,7 +197,7 @@ class Parser {
         if (this.peek() !== '\\')
             return undefined;
         const escaped = this.peek(1);
-        if (escaped === undefined || !'()*+-.?[\\]^nrt{}'.includes(escaped))
+        if (escaped === undefined || !'()*+-.?[\\]^nrt{|}'.includes(escaped))
             return undefined;
         this.index += 2;
         const value = escaped === 'n' ? '\n' : escaped === 'r' ? '\r' : escaped === 't' ? '\t' : escaped;
@@ -237,68 +234,10 @@ class Parser {
         return this.characters[this.index + offset];
     }
 }
-const categories = new Map();
-function categoryRanges(category) {
-    const retained = categories.get(category);
-    if (retained !== undefined)
-        return retained;
-    const expression = new RegExp(`^\\p{${category}}$`, 'u');
-    const output = [];
-    let start;
-    let previous = -2;
-    for (const [minimum, maximum] of SCALAR_RANGES) {
-        for (let scalar = minimum; scalar <= maximum; scalar++) {
-            if (!expression.test(String.fromCodePoint(scalar)))
-                continue;
-            if (start === undefined)
-                start = scalar;
-            else if (scalar !== previous + 1) {
-                output.push([start, previous]);
-                start = scalar;
-            }
-            previous = scalar;
-        }
-    }
-    if (start !== undefined)
-        output.push([start, previous]);
-    const frozen = Object.freeze(output.map((range) => Object.freeze(range)));
-    categories.set(category, frozen);
-    return frozen;
-}
 function singleton(value) {
     const scalar = value.codePointAt(0);
     return scalar === undefined ? [] : [[scalar, scalar]];
 }
-function mergeRanges(input) {
-    const sorted = [...input].sort((left, right) => left[0] - right[0] || left[1] - right[1]);
-    const output = [];
-    for (const range of sorted) {
-        const previous = output.at(-1);
-        if (previous === undefined || range[0] > previous[1] + 1)
-            output.push([range[0], range[1]]);
-        else
-            output[output.length - 1] = [previous[0], Math.max(previous[1], range[1])];
-    }
-    return output;
-}
-function complement(input) {
-    const output = [];
-    for (const [minimum, maximum] of SCALAR_RANGES) {
-        let cursor = minimum;
-        for (const [start, end] of input) {
-            if (end < minimum || start > maximum)
-                continue;
-            if (start > cursor)
-                output.push([cursor, Math.min(start - 1, maximum)]);
-            cursor = Math.max(cursor, end + 1);
-            if (cursor > maximum)
-                break;
-        }
-        if (cursor <= maximum)
-            output.push([cursor, maximum]);
-    }
-    return output;
-}
 function isNormalCharacter(value) {
     const code = value.codePointAt(0);
     return (code !== undefined &&

package/dist/v1/language/value/regexp/compile.d.ts

@@ -1,9 +1,32 @@
 import type { Pattern, RunPattern } from '../compile/model.js';
-export declare const MAX_PATTERN_STATES = 10000;
-/** Thrown when an I-Regexp source compiles past `MAX_PATTERN_STATES` NFA states. */
+import type { Expression } from './ast.js';
+/**
+ * The most states the machine of one I-Regexp may have (`limits.regexp.maxStates`), an
+ * implementation limit as RFC 9485 §8 allows. Counted repetitions are expanded copy by copy, so the
+ * parser's bounds on length, nesting and counts alone admit machines of billions of states. The
+ * counted-run form never expands, so it is not subject to this budget.
+ */
+export declare const MAX_STATES = 10000;
+/**
+ * Thrown when an I-Regexp source compiles to a machine of more than `MAX_STATES` states. A short
+ * branching source such as `(a{0,1000}){0,60}b` would unroll to ~120k states and cost seconds per
+ * validated value (P1-I-01); it is refused before any state is built.
+ */
 export declare class PatternComplexityError extends RangeError {
     readonly limit: number;
     constructor(limit?: number);
 }
 /** Compile scalar sequences as counted runs; preserve the NFA for branching expressions. */
 export declare function compilePattern(source: string): Pattern | RunPattern;
+/**
+ * Whether a parsed I-Regexp compiles within the state budget: as counted runs, which never expand,
+ * or as a machine of at most `MAX_STATES` states, counted from the AST before anything is built.
+ */
+export declare function withinStateBudget(expression: Expression): boolean;
+/**
+ * The number of states `Builder` builds for an expression, computed from the AST alone: `states`
+ * in `proofs/Regexp.lean`, where `compile_size` proves it exact. Nesting and counts are bounded by
+ * the parser, so the count stays finite; it is exact up to `Number.MAX_SAFE_INTEGER`, and above it
+ * every rounding keeps it above the budget.
+ */
+export declare function states(expression: Expression): number;

package/dist/v1/language/value/regexp/compile.js

@@ -1,16 +1,20 @@
 import { parseIRegexp } from './ast.js';
-// A branching I-Regexp compiles to an NFA whose size is the product of its nested counted
-// repetitions, so a short source such as `(a{0,1000}){0,60}b` unrolls to ~120k states and costs
-// seconds per validated value (P1-I-01). Bound the NFA so a pathological source is rejected at
-// schema admission instead. The limit is well above realistic patterns: the RFC 9485 domain-name
-// regex `([a-z0-9-]{1,63}\.){1,32}[a-z]{2,63}` compiles to ~4.3k states. Pure scalar runs
-// (`a{0,1000}`) never reach this path: they compile to counted runs, not NFA states.
-export const MAX_PATTERN_STATES = 10_000;
-/** Thrown when an I-Regexp source compiles past `MAX_PATTERN_STATES` NFA states. */
+/**
+ * The most states the machine of one I-Regexp may have (`limits.regexp.maxStates`), an
+ * implementation limit as RFC 9485 §8 allows. Counted repetitions are expanded copy by copy, so the
+ * parser's bounds on length, nesting and counts alone admit machines of billions of states. The
+ * counted-run form never expands, so it is not subject to this budget.
+ */
+export const MAX_STATES = 10_000;
+/**
+ * Thrown when an I-Regexp source compiles to a machine of more than `MAX_STATES` states. A short
+ * branching source such as `(a{0,1000}){0,60}b` would unroll to ~120k states and cost seconds per
+ * validated value (P1-I-01); it is refused before any state is built.
+ */
 export class PatternComplexityError extends RangeError {
     limit;
-    constructor(limit = MAX_PATTERN_STATES) {
-        super(`I-Regexp compiles to more than ${limit} states.`);
+    constructor(limit = MAX_STATES) {
+        super(`Cannot compile an I-Regexp machine of more than ${limit} states.`);
         this.limit = limit;
         this.name = 'PatternComplexityError';
     }
@@ -23,6 +27,8 @@ export function compilePattern(source) {
     const runs = scalarRuns(expression);
     if (runs !== undefined)
         return Object.freeze({ source, runs });
+    if (states(expression) > MAX_STATES)
+        throw new PatternComplexityError();
     const builder = new Builder();
     const fragment = builder.expression(expression);
     builder.states[fragment.end].accepting = true;
@@ -32,6 +38,38 @@ export function compilePattern(source) {
         states: Object.freeze(builder.states.map(freezeState)),
     });
 }
+/**
+ * Whether a parsed I-Regexp compiles within the state budget: as counted runs, which never expand,
+ * or as a machine of at most `MAX_STATES` states, counted from the AST before anything is built.
+ */
+export function withinStateBudget(expression) {
+    return scalarRuns(expression) !== undefined || states(expression) <= MAX_STATES;
+}
+/**
+ * The number of states `Builder` builds for an expression, computed from the AST alone: `states`
+ * in `proofs/Regexp.lean`, where `compile_size` proves it exact. Nesting and counts are bounded by
+ * the parser, so the count stays finite; it is exact up to `Number.MAX_SAFE_INTEGER`, and above it
+ * every rounding keeps it above the budget.
+ */
+export function states(expression) {
+    const [only, ...others] = expression.alternatives;
+    if (only !== undefined && others.length === 0)
+        return sequenceStates(only);
+    return expression.alternatives.reduce((total, sequence) => total + sequenceStates(sequence), 2);
+}
+function sequenceStates({ pieces }) {
+    if (pieces.length === 0)
+        return 2;
+    return pieces.reduce((total, piece) => total + pieceStates(piece), 0);
+}
+/** `pieceStates`: `minimum` copies, then a star, or a shared end and the optional copies. */
+function pieceStates({ atom, minimum, maximum }) {
+    const copy = atom.kind === 'ranges' ? 2 : states(atom.expression);
+    if (maximum === undefined)
+        return minimum * copy + (copy + 2);
+    return ((minimum === 0 ? 2 : minimum * copy) +
+        (maximum === minimum ? 0 : 1 + (maximum - minimum) * copy));
+}
 function scalarRuns(expression) {
     if (expression.alternatives.length !== 1)
         return undefined;
@@ -139,8 +177,6 @@ class Builder {
         return { start: left.start, end: right.end };
     }
     state() {
-        if (this.states.length >= MAX_PATTERN_STATES)
-            throw new PatternComplexityError();
         return this.states.push({ epsilon: [], transitions: [] }) - 1;
     }
     epsilon(from, to) {

package/dist/v1/language/value/regexp/syntax.d.ts

@@ -1,2 +1,12 @@
-/** Complete RFC 9485 syntax admission through the same AST consumed by compilation. */
+/**
+ * Why a source is not an admitted I-Regexp: `syntax` when it is outside the RFC 9485 grammar or the
+ * parser's bounds on length, nesting and counts; `states` when its machine would exceed the state
+ * budget.
+ */
+export type IRegexpRefusal = 'syntax' | 'states';
+/** The refusal of one source, through the same AST and state count as compilation. */
+export declare function refuseIRegexp(source: string): IRegexpRefusal | undefined;
+/** Complete RFC 9485 syntax admission, within the implementation limits RFC 9485 §8 allows. */
 export declare function isIRegexp(source: string): boolean;
+/** The authoring explanation of a `states` refusal of `subject` (`pattern`, `fullMatch`, ...). */
+export declare function stateBudgetMessage(subject: string): string;

package/dist/v1/language/value/regexp/syntax.js

@@ -1,5 +1,17 @@
 import { parseIRegexp } from './ast.js';
-/** Complete RFC 9485 syntax admission through the same AST consumed by compilation. */
+import { MAX_STATES, withinStateBudget } from './compile.js';
+/** The refusal of one source, through the same AST and state count as compilation. */
+export function refuseIRegexp(source) {
+    const expression = parseIRegexp(source);
+    if (expression === undefined)
+        return 'syntax';
+    return withinStateBudget(expression) ? undefined : 'states';
+}
+/** Complete RFC 9485 syntax admission, within the implementation limits RFC 9485 §8 allows. */
 export function isIRegexp(source) {
-    return parseIRegexp(source) !== undefined;
+    return refuseIRegexp(source) === undefined;
+}
+/** The authoring explanation of a `states` refusal of `subject` (`pattern`, `fullMatch`, ...). */
+export function stateBudgetMessage(subject) {
+    return `${subject} expands its counted repetitions into more than ${MAX_STATES} states, the I-Regexp implementation limit (RFC 9485 §8); nest fewer or smaller counts.`;
 }

package/dist/v1/language/value/regexp/unicode.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Unicode scalar sets for the I-Regexp compiler: the scalar space, unions and complements of ordered
+ * ranges, and the General_Category table that `\p{..}` and `\P{..}` denote.
+ *
+ * The table is pinned to Unicode 17.0, the version of the Node runtime the Kernel pins (26.7.0 in
+ * `.nvmrc`, ICU 78.3), so a category denotes the same scalars on every host whatever Unicode data
+ * its own `RegExp` engine carries (Node, Bun/JavaScriptCore, workerd). It was generated under that
+ * Node by testing every scalar against `new RegExp('^\\p{<name>}$', 'u')` and keeping the maximal
+ * runs. `__tests__/categories.test.ts` holds that generation: on a host whose
+ * `process.versions.unicode` is {@link UNICODE_VERSION} it requires this table to equal the encoding
+ * of the host's runs, and a deliberate Unicode upgrade replaces the table with the value that test
+ * then expects.
+ *
+ * Only the 28 assigned two-letter categories that RFC 9485 `IsCategory` can name are stored. A major
+ * category is the union of its subcategories, `Cn` holds every scalar that no stored category holds,
+ * and `Cs` (the surrogates) holds no scalar. An entry lists its runs in scalar order, each as two
+ * base-32 numbers: the gap from the end of the previous run (from U+0000 for the first), then the run
+ * length minus one. A number is written most significant digit first, and every digit but its last
+ * is taken from the upper half of `DIGITS`. A category is decoded on its first use only.
+ */
+import type { ScalarRange } from './ast.js';
+/** The Unicode version whose General_Category values the table below records. */
+export declare const UNICODE_VERSION = "17.0";
+export declare const SCALAR_RANGES: readonly ScalarRange[];
+/** The encoded runs of each stored General_Category, generated under Unicode 17.0. */
+export declare const GENERAL_CATEGORIES: Readonly<Record<string, string>>;
+/** The maximal runs of the scalars in one General_Category that the I-Regexp grammar admits. */
+export declare function categoryRanges(category: string): readonly ScalarRange[];
+/** Sorted, disjoint and non-adjacent runs covering exactly the scalars of `input`. */
+export declare function mergeRanges(input: readonly ScalarRange[]): readonly ScalarRange[];
+/** The runs of the scalars, surrogates excluded, outside the sorted, disjoint runs of `input`. */
+export declare function complement(input: readonly ScalarRange[]): readonly ScalarRange[];

package/dist/v1/language/value/regexp/unicode.js

@@ -0,0 +1,139 @@
+/**
+ * Unicode scalar sets for the I-Regexp compiler: the scalar space, unions and complements of ordered
+ * ranges, and the General_Category table that `\p{..}` and `\P{..}` denote.
+ *
+ * The table is pinned to Unicode 17.0, the version of the Node runtime the Kernel pins (26.7.0 in
+ * `.nvmrc`, ICU 78.3), so a category denotes the same scalars on every host whatever Unicode data
+ * its own `RegExp` engine carries (Node, Bun/JavaScriptCore, workerd). It was generated under that
+ * Node by testing every scalar against `new RegExp('^\\p{<name>}$', 'u')` and keeping the maximal
+ * runs. `__tests__/categories.test.ts` holds that generation: on a host whose
+ * `process.versions.unicode` is {@link UNICODE_VERSION} it requires this table to equal the encoding
+ * of the host's runs, and a deliberate Unicode upgrade replaces the table with the value that test
+ * then expects.
+ *
+ * Only the 28 assigned two-letter categories that RFC 9485 `IsCategory` can name are stored. A major
+ * category is the union of its subcategories, `Cn` holds every scalar that no stored category holds,
+ * and `Cs` (the surrogates) holds no scalar. An entry lists its runs in scalar order, each as two
+ * base-32 numbers: the gap from the end of the previous run (from U+0000 for the first), then the run
+ * length minus one. A number is written most significant digit first, and every digit but its last
+ * is taken from the upper half of `DIGITS`. A category is decoded on its first use only.
+ */
+/** The Unicode version whose General_Category values the table below records. */
+export const UNICODE_VERSION = '17.0';
+export const SCALAR_RANGES = [
+    [0, 0xd7ff],
+    [0xe000, 0x10ffff],
+];
+const DIGITS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+/** The encoded runs of each stored General_Category, generated under Unicode 17.0. */
+export const GENERAL_CATEGORIES = {
+    Cc: 'AfifhA',
+    Cf: 'lNAhqSFWAmAAhRAsABiQAj5LAh/cEaEhREBJh30PAnZCkmBAPAo7CPhijADlmPH4r0GAeif',
+    Co: 'h4gAmnf8h4Ah//dCh//d',
+    Ll: 'jBZhaAhJXBHBABABABABABABABABABABABABABABABABABABABABABABABABABABABBBABABABABABABABBBABABABABABABABABABABABABABABABABABABABABABABACABABCCABACADBEACADCCACABABACABBBACADABACBCCGACACABABABABABABABABBBABABABABABABABABBCABADABABABABABABABABABABABABABABABABABABABABABABABABABABABABABGCACBBAEABABABABiECZmBABADADCSAbhCBBDCBABABABABABABABABABABABEBACACBhThPBABABABABABABABABABABABABABABABABAJABABABABABABABABABABABABABABABABABABABABABABABABABABACABABABABABABBBABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAhQhIi6HhKCC3YFikCIBAjVhLhfMBhBjGABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABIBABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABIIFKHIHIFKHIHINCHIHIHIEBBGADCBBIDCBIHKCBBoSADBDAbAEAEACBIDEAhVAi1LhPBADBBABABAEABBBFFABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABBHABAEAMhFBAFA+oTABABABABABABABABABABABABABABABABABABABABABABATABABABABABABABABABABABABABAkHABABABABABABCBABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABHBABACABABABABAEABACABCBABABABABABABABABABAFAFABABABABABABABAEABACABABABABABABABAaADA5VhKFIHiPz6AGMEhhJZhmNhHkIhDkbKBOBGBBh4DhSjdVi5af1sAfhbY5qGZaGBRaZaDBABGBKaZaZaZaZaZaZaZaZabcYBFaYBFaYBFaYBFaYBFBAh5UJBTGFivXhB',
+    Lm: '1QRELOEHABAkFAFAueAnGAlEBoNBEAfAJADAlAAlHAhmUAjfAxVAh2aAjLAzDAuQFlOheNAhChE1RANAQMi+fBnRAlfAuVAhLEFAjBBidC74WAhnCFoOAjSAcBjZIiQAXAjIDDBuVAWAkJAjMAVBjHDJA1gGAhNBh/AFBhJBIhsTAhAAqVAj4TAzrGDvcChIBxGMiABBAOBv/cDBGBBshRhdmJG9NAwTAyLA',
+    Lo: 'lKAPAoAAEDmQB5aaEDhNfBJhDBBjCBAYBKCCAQABddiYLAYhAVVhKYHKFXBGQhIhbhVDASAHJQOEHCBCVBGBADDDAQANBBCOBKAIFEBCVBGBBBBBBfDBATCQIBCBVBGBBBEDASAPBXALHCBCVBGBBBEDAeBBCPARABFDCBDDBBABBDBDCDLWAhUHBCBWBPDAaCBBCBeAEHBCBWBJBEDAeCBBPBRIBCBhICAQAFCICYFFRDXBIBACGhahPBBMFhbBBABEBXBABJBBJACEXDhAAhfHBhDbEjThKUAQFEDDADBHCEMMAjRqIBDCGBABDChIBDChABDCGBABDCOBhYBDCiChFPjRzLCQBZFiKGHHRNSOROMBCPhThIAiDhCBhUHEChBBAFiFKehRdCELhLEZhWWJhUlQhORHhWdNBKhLahDhJCKdjRDBFBBDAhhaDi/XhXYWJGBGBGBGBGBGBGBGxHAhVAEiVIABiZEAFhKBidRfhQPwAmtfiA0wUBhjWiDhHIoLEPKBiCAhRiFlJAjHADGBCBDBWdhTOhRheFDABBLbKWZcHhOhNECIKEBhIXCBHUPBFDADhRBADBCECABAYBDKHAOFCFCFJGBGkRhCdq9DMWEhQooErNCjJiDABJBMBEBABBBBBjLhBrKShfChVhILjUEBkGjJJBhMCeDFCFCFCChDLBZBSBBBOCNhCjasFcDhQhPfNTBHGhFKdChDEHkAiNjChHIhTichTMpWJVKHkYFCABhLBBDACWKWJeiBSBBKVKZGZhGhXGBiAAPDBCBchKcDchDHBbbhVKVKSNRjOiIlXhDhGDBApQhJGBQCBBhYcKAIVhKRhOUbWMhUhZBCANhMhAYahDdACAIhCDAMhPODVABAhDRBYTBhfGBABDBOBJHhOhGHCBCVBGBBBEDASAMEeJBACABhFBAZABAhMhUSDUCehPUBBAlYhOhJDhEhPUAhbhKNAiHahFGlZhLmTHCACHBBBXPABAieHChGQABAcAKhHHAVALhNTASiImHhAfIBhERAhRdjQGBBBhFVAZFBBBfOAXhIBBoESPABMBhBjcAiP8ZnGmDiyMjAPhhPRFZj8aFyGm1Zdh3CxYHeRiORdShPhTUFStThHsViKFAlPnmVhJfjBjSowNpCPAdCCAODIsLioEjKFMDIHJozQAvVhMhBAqBdShLvEanFdCAmPeBCBBBGCEJAnBGBDBBBOBmEhpbDBaBBBACABJBDBABAGAEABABABCBBBACABABABABABBBACDBGBDBDBABJBQFCBEBQkqEhp2fhAkodCl0NCnpQPzNitCwdhvCk6KFopJ',
+    Lt: 'uFACACAhGAnsVHIHIHMAPAhPA',
+    Lu: 'iBZjFWBGhBABABABABABABABABABABABABABABABABABABABABABABABABABABABACABABABABABABABACABABABABABABABABABABABABABABABABABABABABABABABBBABADBBABBBCCDBBBCDBBBBABABBBACABBBCBABBDAHACACACABABABABABABABACABABABABABABABABACACABCBABABABABABABABABABABABABABABABABABABABABABABABABABABABABAHBBBCABDBABABABApBABADAIAGABCBABBBQBIhDACCDABABABABABABABABABABABAFACABBChShQABABABABABABABABABABABABABABABABAJABABABABABABABABABABABABABABABABABABABABABABABABABABABBBABABABABABACABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAChFi6JhFBAFA2SiVikTAGhKCCqAABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAJABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAJHIFKHIHIFLABABABAIHiIDMDMDMELDoGAEADCCCCADEGABABABDCDKBFAhdAizchPhQABCCABABABDBACAICBABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAIABAEA+qNABABABABABABABABABABABABABABABABABABABABABABATABABABABABABABABABABABABABAkHABABABABABABADABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAKABABBBABABABAEABACABADABABABABABABABABABABEBEBABABABABABABABDBABBBABABABABABABABAYA15LZhmFhHkIhDkcKBOBGBBh3KhSkdVi5af1sAfiAY5qHZaZaZaABBCACBCDBHaZaBBDCHBGbBBDBEBADGbZaZaZaZaZaZeYhBYhBYhBYhBYhBAkpVhB',
+    Mc: 'ioDAhXACCIDBBhSBhaCGBCBKAhLAhaCiCAhaCIABBhVBhaABAGBCBKAjGBBBDCBCKAhJChdDhdBhaABECBBBJBcAOBhaCFCBCKAhKBiLCGHSBqKBhfAlLBEAGACBZBKCCGVBCFCAKChzYAeAkBAHHBBqaDCCEBBFnABhaABAJABBIFkRAhQAFABEBBhdAeAEBCAhcACCBADBhQHIBlLAVAk5WB9/TBCAiYBhSPkOBhPAhQBEBCCjOBCBYAhNABAjNACBFAnNBBBBBBA5gTABAjfAhNCEBjTAYBhbAhQCJBNAidCDBBAlKCfBhaBBDCBCCJAKBiUCHACABDBBBAjFCIBDAjKCGABDCAnNCGDCAjRCIBBAjNABBGAjHABBEAoFCJAnXFBBEACABAkOCIDEAiUAdBheAmJADABAmHAOAjKAHACAmVEEBBAqeBMAhQBIBBAwvICjxEhWjIB4rTBGF',
+    Me: 'hkIBlxUAhweDBChhsLC',
+    Mn: '4AjPoTEoJhMBABBBBBAiIKhQUQAjFGCFCBBDhDAeaibKhaIJAYDBIBCBEhLChbIhKXBfhXABAEHEADGKBdAhaAEDIAUBaACBhZAEBEBCCDAeBDALBhZAEEBBEAUBWFBAhaACABDIAHBLBeAhdAMAhSADAhXABCFCBDHBLBdAhaACAGAFBUBcBhZBEDIAUBdAiIAHCBAiaACGMHjCACILGiJBbABABAhXNBEBBFKBhDJAjGDBFBBCBZBECQDNACBGAPA1fC9SCdBeBeBiABBGIACKJAhNCBAjVBhCAjWCEBJAGCmbBCAhaABGBABACHGJCAhQNBeCLUDhQABEBAFAhIIMBhADCBBChYABBDABChaHCBkYCBMBGEAGADBmGhf2QMEADLi/eCkNAjAfxKDjLB9uUAEJhABiQBoQADAEAZBFAkXBaRNAhGHZKhOChQACDCBhHAiDFCBCBMAIAhPAhTABCCBFBBAhKBIAnOACAEAz5QA3BPQP+NAnCAkVEh0GCBBFDhICEAlFBxdDiBEpdBiNFiGKhRDjbAhWOhJACBKChRDCBHAhdChEEBHheAMBhUIKDCAifCCABBGACAkdADHVBhZBDAhFGDEiGFNABABAOBiVHCCBAXAiUFBAEBBBnODGBBBbBiVHCABBjKABACFBAjFABACDBEoDIBBoABBAEAkQDCBEAhAJhIFCDIAJFCChOMBBmGABCBAmJGBFBAiSVCGBBBBjaFDABBBGBAiIBDABAqbBLBhUEFABAXAlnFAGOrmILDCiuAEhbGhgYAhfDiRAzlYBkzBhNCWxACRHCGeDkUCh9bhWEhRIAOAWEBOhqQGBQCGBBBEjEAlAGrXAhdDvcDneBnTACAHBFAuaGjNG4l9VnP',
+    Nd: 'hQJhxGJkGJmGJscJjWJjWJjWJjWJjWJjWJjWJjWJjWJjAJjWJiGJoWJiGJh6GJhGJpMJkAJlGJGJlWJiWJkGJGJhiuGJ1GJhGJmGJWJiWJsWJ04WJhsGJikGJGJ4cJkAJhcJkQJoWJqWJjWJrWJjGJGTiMJtGJjGJ0WJiWJnWJiGJhWJrGJwuWJipGJiWJkGJwWJ37WJi2UhRiqAJtGJvWJnXJ6VJk0WJ',
+    Nl: 'l3OCizPhCCDjzeAZIOC91LJ2yQhUuMAIAkGEohKjOy8FC',
+    No: 'lSBFACCipVFrYFjYCkFGmZGRItRJhhVThjTJvAAh0VADFGJmGPhJA2WhbiOVzWdhrJAhkUDkKJeHBOhAJhHO9rQF2mRhMiBDRBqVahEDhpUHZGhHIiLEWFlABCPChNiAIhUBeCiLEjIHYHhJGqKFrAekeJhKDjQGkGTrbThqFBtOI7HS6TUy8GG4eW5hJTMTjMYlqOI9BhaBCBDiMhMBO+CM',
+    Pc: 'ifAn+fBTAh3ueBYCnPA',
+    Pd: 'hNAhqcAhTAjyBAhgFAigJFjwBACAfBEAcAteATAjPAhzsQBhFAKAlJAjzAApeA',
+    Pe: 'hJAhTAfAj1dABAh6eAitJAhXAPAzaABAeAhheABABABABABABAiQAhAABABABABAsUABABABABABABABABABABAiAABAhBAhhFABABABAhMABABABAtMABABABABADABABABACBhzoeAmZAdABABABABABABABADARABABAlKAhTAfACACA',
+    Pf: 'lbAn6dADAcAjuIABAEACAPADA',
+    Pi: 'lLAn7MACBCAZAjuIABAEACAPADA',
+    Po: 'hBCBCCABABBKBDBbAiEAFAOBHA1eAIAuSFhJAhWACACAhMBUBBBNABCiKDjGAhLNnJChWOfAoFBKAkMAjYAjZAsGAMArPAiaAKBlIOBAjQAiKEEBjPFlLAzEI4FAjcCiHBkdCBChFFBDpZBmYBkAGBFlABKGcCjcDhbEheBiAHLA6CBIHIICDCCDKBABJjkaDBBjQAkPBECCACIBBBACBKEBJCDBABMCCtMChZAldA9gCBoNCjDAKAjTFrcDiWBhICBAhRBhPAjBMQBjcDjeBQBnZA0xEGCAWAUBCDDCBDHCGABBkVCBCCABABBKBDBbAhEACBsaC0cAhQAseA3HAmHAfAoQIhGAjQGiCGiZD5TAkEEhMDldGjNBBDjeDhQBiPDEANABCiYFjLApKBBBjSEKBBAjIAnaWjJCcMiMAkCCncAoICkbAicHiTCBEidJmXAifEhKB0FBiKMlPAhjQEi7cBuzbBkFAiBEIAxICpHDqHAzlcAnvHEi7TA6eB',
+    Ps: 'hIAhSAfAj1eABAh6eAireADAhGAhXAPAzaABAeAhheABABABABABABAiQAhAABABABABAsUABABABABABABABABABABAiAABAhBAhhFABABABAZASABABABAtMABABABABADABABABACAhzpBAmXAdABABABABABABABADARABABAlKAhSAfADACA',
+    Sc: 'hEAjdDhnJAjbAvSBvSBHAnVAoHAyFAisbAimEhBhh7WA1uDAjMAkaAmbBDBn/WDhw4eAitQA',
+    Sk: 'ieABAiHAGAEADAwJDMNFGBABQjVAOBhoCAl5UABCLCNCNCNBkkcB9zDWJBjHB+QAOB0iGQ7bABAlCAh9gXE',
+    Sm: 'hLAQChdABAhNAEAhFAfA3eAwPCmxbANAhHCNCkLAhHEGAiEEFBEACACAHAfBCABAfoLhABiaAeYhIFuVAJAhWHjPAqQECeKPoAkCWheEfCoBhQUCFhz+cA5YABClEAQChdABAkDAGDjtBBhwrAAh+QAZAfAZAfAZAfAZAfAZAl5MBiueI',
+    So: 'lGACAEABA+RAoKBjfBmOAKATBnXAwDArVAkCFBAkEAmPAhJAsHCPABCCFUABABAkFHBFBBFDmFB3QJ2TA2SAkdhBrBJJIhsDBBDBBKABBGFBABABAEALBOABBBAhaBJECDBBBBBGBeCBBABeoMHETCGCiQBdZhHGiHWKiRiNWlWBIBhVIjOBnXhMhLiAnfwAhPVBGhGCkJnFFrFBhOZBiYMmVaPEANBMAVBGBqQBEJhAhFJAQeLdIAPfKhGPpfmuAhf10QhW7BDKBBAxdC0qJPrNPiABhWHhNCvEADAEBNBpZIhZQCCBMDAhPhMhzaByPAhgIHijGAikVHEQy6KDFA0qWAj7DnPKCDtTGWPPjAjThcnVKhGChbFCWBHdEhcViBDAlaiWhlJvfhXDhSHBNBBh2IAi6cAkBA2RhLEjDMOCOBOBhEXlAhYcNhLEIHBOFkanaF2YDQDMDmZGLEAPLEhXIJGhHIdCLEBheqXINCMDKDhYBAEPCLEJHkSBibKA',
+    Zl: 'ohIA',
+    Zp: 'ohJA',
+    Zs: 'hAAjfAlufAirfKhEAhPAj9AA',
+};
+const MAJOR_CATEGORIES = {
+    C: ['Cc', 'Cf', 'Cn', 'Co'],
+    L: ['Ll', 'Lm', 'Lo', 'Lt', 'Lu'],
+    M: ['Mc', 'Me', 'Mn'],
+    N: ['Nd', 'Nl', 'No'],
+    P: ['Pc', 'Pd', 'Pe', 'Pf', 'Pi', 'Po', 'Ps'],
+    S: ['Sc', 'Sk', 'Sm', 'So'],
+    Z: ['Zl', 'Zp', 'Zs'],
+};
+const categories = new Map();
+/** The maximal runs of the scalars in one General_Category that the I-Regexp grammar admits. */
+export function categoryRanges(category) {
+    const known = categories.get(category);
+    if (known !== undefined)
+        return known;
+    let ranges;
+    if (Object.hasOwn(GENERAL_CATEGORIES, category))
+        ranges = decode(GENERAL_CATEGORIES[category]);
+    else if (Object.hasOwn(MAJOR_CATEGORIES, category))
+        ranges = mergeRanges(MAJOR_CATEGORIES[category].flatMap(categoryRanges));
+    else if (category === 'Cn')
+        ranges = complement(mergeRanges(Object.keys(GENERAL_CATEGORIES).flatMap(categoryRanges)));
+    else
+        throw new TypeError(`The I-Regexp grammar admits no General_Category ${category}.`);
+    const frozen = Object.freeze(ranges.map((range) => Object.freeze(range)));
+    categories.set(category, frozen);
+    return frozen;
+}
+function decode(encoded) {
+    const output = [];
+    let next = 0;
+    let start;
+    let value = 0;
+    for (const character of encoded) {
+        const digit = DIGITS.indexOf(character);
+        value = value * 32 + (digit % 32);
+        if (digit >= 32)
+            continue;
+        if (start === undefined)
+            start = next + value;
+        else {
+            output.push([start, start + value]);
+            next = start + value + 1;
+            start = undefined;
+        }
+        value = 0;
+    }
+    return output;
+}
+/** Sorted, disjoint and non-adjacent runs covering exactly the scalars of `input`. */
+export function mergeRanges(input) {
+    const sorted = [...input].sort((left, right) => left[0] - right[0] || left[1] - right[1]);
+    const output = [];
+    for (const range of sorted) {
+        const previous = output.at(-1);
+        if (previous === undefined || range[0] > previous[1] + 1)
+            output.push([range[0], range[1]]);
+        else
+            output[output.length - 1] = [previous[0], Math.max(previous[1], range[1])];
+    }
+    return output;
+}
+/** The runs of the scalars, surrogates excluded, outside the sorted, disjoint runs of `input`. */
+export function complement(input) {
+    const output = [];
+    for (const [minimum, maximum] of SCALAR_RANGES) {
+        let cursor = minimum;
+        for (const [start, end] of input) {
+            if (end < minimum || start > maximum)
+                continue;
+            if (start > cursor)
+                output.push([cursor, Math.min(start - 1, maximum)]);
+            cursor = Math.max(cursor, end + 1);
+            if (cursor > maximum)
+                break;
+        }
+        if (cursor <= maximum)
+            output.push([cursor, maximum]);
+    }
+    return output;
+}

package/dist/v1/language/value/syntax/full-match.js

@@ -1,11 +1,14 @@
 import { refine } from 'zod';
 import { compilePattern } from '../regexp/compile.js';
 import { loadPattern } from '../regexp/matcher.js';
-import { isIRegexp } from '../regexp/syntax.js';
+import { refuseIRegexp, stateBudgetMessage } from '../regexp/syntax.js';
 const sources = new WeakMap();
 export function fullMatch(source) {
-    if (!isIRegexp(source)) {
-        throw new TypeError('fullMatch(...) requires a complete RFC 9485 I-Regexp source.');
+    const refusal = refuseIRegexp(source);
+    if (refusal !== undefined) {
+        throw new TypeError(refusal === 'syntax'
+            ? 'fullMatch(...) requires a complete RFC 9485 I-Regexp source.'
+            : stateBudgetMessage('fullMatch(...)'));
     }
     const matcher = loadPattern(compilePattern(source));
     const check = refine((value) => matcher.matches(value), {

package/dist/v1/schema/compatibility/comparators/callables.d.ts

@@ -4,6 +4,13 @@ import type { ResolvedFunction, ResolvedMethod } from '../../../language/callabl
 import type { EffectiveMethod } from '../../analysis/class.js';
 import type { Fingerprint } from '../model.js';
 export declare function methodExistence(method: EffectiveMethod): Value;
+/**
+ * A Method as a Policy object resolves it: its owner's own declaration and whether that Class can
+ * execute it. Dispatch and the signature are the caller's, not the Policy's.
+ */
+export declare function methodObject(method: EffectiveMethod, owner: {
+    readonly abstract: boolean;
+}): Value;
 export declare function methodSignature(method: EffectiveMethod): Value;
 export declare function methodInheritance(method: EffectiveMethod): Value;
 export declare function functionSignature(declaration: FunctionDefinition): Value;

package/dist/v1/schema/compatibility/comparators/callables.js

@@ -1,3 +1,4 @@
+import { isMethodExecutable } from '../../../language/callable/executable.js';
 import { isBinaryInput } from '../../../language/callable/model/callable.js';
 import { methodSignature as inheritedSignature } from '../../analysis/class.js';
 import { deepFreeze } from '../../canonical/freeze.js';
@@ -13,6 +14,18 @@ export function methodExistence(method) {
         abstract: method.declaration.abstract,
     });
 }
+/**
+ * A Method as a Policy object resolves it: its owner's own declaration and whether that Class can
+ * execute it. Dispatch and the signature are the caller's, not the Policy's.
+ */
+export function methodObject(method, owner) {
+    return deepFreeze({
+        coordinate: 'method',
+        owner: keyForDefinitionRef(method.owner),
+        name: method.name,
+        executable: isMethodExecutable(owner, method.declaration),
+    });
+}
 export function methodSignature(method) {
     return deepFreeze({
         coordinate: 'method',

package/dist/v1/schema/compatibility/comparators/classes.d.ts

@@ -19,7 +19,25 @@ export declare function classMeaning(context: Context, coordinate: ClassCoordina
     readonly meaning: JsonValue;
     readonly requirement: ClassRequirement;
 } | undefined;
+/**
+ * What a Policy pattern reads of an Edge it matches: its orientation and the Classes each endpoint
+ * accepts, without cardinalities or roles. Undirected endpoints form an unordered pair.
+ */
+export declare function edgeEndpoints(context: Context, coordinate: ClassCoordinate): JsonValue | undefined;
 export declare function propertyMeaning(field: EffectiveField): JsonValue;
+/**
+ * A Class a dependent references or inherits keeps every effective Property it had, whichever
+ * ancestor declares it. Each Property is compared on its owner, which still declares it when the
+ * Class stops extending that owner, and is not compared at all when another origin owns it: only the
+ * Class's own identity set shows those losses. Every loss is recorded, a Property its owner removed
+ * included, and only a loss is: a comparison that keeps every identity keeps its facts and evidence
+ * bytes, and an added ancestor or Property obliges nothing. The target is projected onto the source
+ * identities, as inherited ancestry is, so the differences name the lost Properties.
+ */
+export declare function compareLostProperties({ pair, report, }: {
+    readonly pair: SubjectPair;
+    readonly report: Report;
+}): void;
 /** Newly required data is an obligation even though it was absent from the source footprint. */
 export declare function compareAddedProperties({ context, pair, report, }: {
     readonly context: ComparisonContext;