@astrale-os/kernel-dsl 0.2.0-beta.9 → 1.0.0-beta.1

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

@@ -1,50 +1,207 @@
-/** Load portable NFA data without a regex engine or dynamic compilation. */
+/**
+ * Load the portable counted-run or Thompson NFA executor for search and whole-string matching.
+ * Scratch belongs to one invocation: no match-result cache, shared mutable cursor or DFA expansion.
+ */
 export function loadPattern(pattern) {
-    const start = closure(pattern.states, new Set([pattern.start]));
+    if ('runs' in pattern)
+        return loadRuns(pattern);
+    const states = pattern.states;
+    const start = initialFrontier(pattern);
     const run = (input, search) => {
-        let active = new Set(start);
-        if ((search || input.length === 0) && accepts(pattern.states, active))
+        if (input.length === 0)
+            return start.accepting;
+        if (search && start.accepting)
             return true;
+        const resolve = executionStates(states);
+        // Initial frontier entries consume characters, so none can be a dead conduit cycle.
+        const initial = start.frontier.map((index) => resolve(index));
+        let active = [...initial];
+        let next = [];
+        const pending = [];
+        let activeCount = start.frontier.length;
+        let nextCount = 0;
+        let epoch = 0;
+        let accepting = false;
+        function add(destination) {
+            const seed = resolve(destination);
+            if (seed === null || seed.epoch === epoch)
+                return;
+            let count = 1;
+            pending[0] = seed;
+            seed.epoch = epoch;
+            while (count > 0) {
+                const entry = pending[--count];
+                const state = entry.state;
+                if (state.accepting === true)
+                    accepting = true;
+                if (state.transitions.length > 0)
+                    next[nextCount++] = entry;
+                for (const destination of state.epsilon) {
+                    const target = resolve(destination);
+                    if (target === null || target.epoch === epoch)
+                        continue;
+                    target.epoch = epoch;
+                    pending[count++] = target;
+                }
+            }
+        }
         for (const character of input) {
+            if (!search && activeCount === 0)
+                return false;
+            epoch++;
+            nextCount = 0;
+            accepting = false;
             const scalar = character.codePointAt(0);
-            const next = new Set();
-            for (const index of active) {
-                for (const transition of pattern.states[index].transitions) {
-                    if (transition.ranges.some(([minimum, maximum]) => scalar >= minimum && scalar <= maximum)) {
-                        next.add(transition.to);
+            for (let index = 0; index < activeCount; index++) {
+                for (const transition of active[index].state.transitions) {
+                    for (const range of transition.ranges) {
+                        if (scalar < range[0] || scalar > range[1])
+                            continue;
+                        add(transition.to);
+                        break;
                     }
                 }
             }
-            active = closure(pattern.states, next);
-            if (search)
-                for (const index of start)
-                    active.add(index);
-            if (search && accepts(pattern.states, active))
+            if (search) {
+                if (accepting)
+                    return true;
+                // The complete initial epsilon closure is already known; do not traverse it again.
+                for (const entry of initial) {
+                    if (entry.epoch === epoch)
+                        continue;
+                    entry.epoch = epoch;
+                    next[nextCount++] = entry;
+                }
+            }
+            const previous = active;
+            active = next;
+            next = previous;
+            activeCount = nextCount;
+        }
+        return accepting;
+    };
+    return Object.freeze({
+        test: (input) => run(input, true),
+        matches: (input) => run(input, false),
+    });
+}
+function loadRuns(pattern) {
+    const runs = pattern.runs;
+    const run = (input, search) => {
+        if (search && runs.length === 1) {
+            const scalarRun = runs[0];
+            if (scalarRun.minimum === 0)
                 return true;
+            let count = 0;
+            for (const character of input) {
+                count = includesScalar(scalarRun.ranges, character.codePointAt(0)) ? count + 1 : 0;
+                if (count >= scalarRun.minimum)
+                    return true;
+            }
+            return false;
         }
-        return accepts(pattern.states, active);
+        let start = 0;
+        do {
+            let offset = start;
+            let accepted = true;
+            for (let index = 0; index < runs.length; index++) {
+                const scalarRun = runs[index];
+                const maximum = search && index === runs.length - 1 ? scalarRun.minimum : (scalarRun.maximum ?? Infinity);
+                let count = 0;
+                while (count < maximum && offset < input.length) {
+                    const scalar = input.codePointAt(offset);
+                    if (!includesScalar(scalarRun.ranges, scalar))
+                        break;
+                    offset += scalar > 0xffff ? 2 : 1;
+                    count++;
+                }
+                if (count < scalarRun.minimum) {
+                    accepted = false;
+                    break;
+                }
+            }
+            if (accepted && (search || offset === input.length))
+                return true;
+            if (!search || start === input.length)
+                return false;
+            start += input.codePointAt(start) > 0xffff ? 2 : 1;
+        } while (start <= input.length);
+        return false;
     };
     return Object.freeze({
         test: (input) => run(input, true),
         matches: (input) => run(input, false),
     });
 }
-function closure(states, seed) {
-    const output = new Set(seed);
-    const pending = [...seed];
+function includesScalar(ranges, scalar) {
+    if (ranges.length < 8) {
+        for (const range of ranges) {
+            if (scalar >= range[0] && scalar <= range[1])
+                return true;
+        }
+        return false;
+    }
+    let low = 0;
+    let high = ranges.length - 1;
+    while (low <= high) {
+        const middle = (low + high) >>> 1;
+        const range = ranges[middle];
+        if (scalar < range[0])
+            high = middle - 1;
+        else if (scalar > range[1])
+            low = middle + 1;
+        else
+            return true;
+    }
+    return false;
+}
+function initialFrontier(pattern) {
+    const start = pattern.start;
+    const seen = new Set([start]);
+    const pending = [start];
+    const frontier = [];
+    let accepting = false;
     while (pending.length > 0) {
-        for (const next of states[pending.pop()].epsilon) {
-            if (output.has(next))
+        const index = pending.pop();
+        const state = pattern.states[index];
+        if (state.accepting === true)
+            accepting = true;
+        if (state.transitions.length > 0)
+            frontier.push(index);
+        for (const target of state.epsilon) {
+            if (seen.has(target))
                 continue;
-            output.add(next);
-            pending.push(next);
+            seen.add(target);
+            pending.push(target);
         }
     }
-    return output;
+    return { frontier: Object.freeze(frontier), accepting };
 }
-function accepts(states, active) {
-    for (const index of active)
-        if (states[index]?.accepting === true)
-            return true;
-    return false;
+/** Resolve only visited conduits, once within this invocation; never retain cross-call state. */
+function executionStates(states) {
+    const destinations = new Map();
+    return (index) => {
+        const known = destinations.get(index);
+        if (known !== undefined)
+            return known;
+        const path = [];
+        let current = index;
+        let destination = destinations.get(current);
+        while (destination === undefined) {
+            const state = states[current];
+            if (state.accepting === true || state.transitions.length > 0 || state.epsilon.length !== 1) {
+                destination = { state, epoch: 0 };
+                destinations.set(current, destination);
+                break;
+            }
+            // A revisit before resolving the path is a dead, epsilon-only cycle.
+            destinations.set(current, null);
+            path.push(current);
+            current = state.epsilon[0];
+            destination = destinations.get(current);
+        }
+        for (const member of path)
+            destinations.set(member, destination);
+        return destination;
+    };
 }

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

@@ -1,2 +1,13 @@
-/** 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.
+ */
+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;
+export {};

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,14 +1,17 @@
-import { z } from 'zod';
+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 = z.refine((value) => matcher.matches(value), {
+    const check = refine((value) => matcher.matches(value), {
         error: `String must fully match I-Regexp ${JSON.stringify(source)}.`,
     });
     sources.set(check, source);

package/dist/v1/language/value/syntax/node-path/validate.js

@@ -15,15 +15,13 @@ export function validateNodePathExtension(schema, context, pointer, definitionEx
         const tokens = parseJsonPointerFragment(`#${location.pointer}`);
         const fieldName = tokens?.length === 2 && tokens[0] === 'properties' ? tokens[1] : undefined;
         const root = isJsonObject(schema) ? schema : undefined;
-        const directRequiredField = context === 'callable-input' &&
+        const directField = context === 'callable-input' &&
             root?.type === 'object' &&
             location.depth === 1 &&
             location.parentKeyword === 'properties' &&
-            fieldName !== undefined &&
-            Array.isArray(root?.required) &&
-            root.required.includes(fieldName);
-        if (!directRequiredField) {
-            diagnostics.push(diagnostic('VS_PATH_EXTENSION', extensionPointer, 'x-astrale-path is allowed only on a direct required property schema at a callable-input object root.'));
+            fieldName !== undefined;
+        if (!directField) {
+            diagnostics.push(diagnostic('VS_PATH_EXTENSION', extensionPointer, 'x-astrale-path is allowed only on a direct property schema at a callable-input object root.'));
         }
         const schemaKeys = Object.keys(location.schema);
         if (schemaKeys.length !== 2 ||

package/dist/v1/language/view/model/view.d.ts

@@ -1,9 +1,7 @@
-import type { ClassRef, DefinitionBase, ViewRef } from '../../../addressing/index.js';
+import type { DefinitionBase, ViewRef } from '../../../addressing/index.js';
+/** Every View targets its owning Domain. */
 export type ViewTarget = {
     readonly kind: 'domain';
-} | {
-    readonly kind: 'definition';
-    readonly definitions: readonly [ClassRef, ...ClassRef[]];
 };
 export interface ViewDefinition extends DefinitionBase<ViewRef> {
     readonly description?: string;

package/dist/v1/language/view/resolved.d.ts

@@ -1,9 +1,9 @@
 import type { DefinitionKey, ViewRef } from '../../addressing/index.js';
-import type { ViewDefinition, ViewTarget } from './model/view.js';
+import type { ViewDefinition } from './model/view.js';
+/** One resolved View of its owning Domain. A View has no Class or Node target. */
 export interface ResolvedView {
     readonly ref: ViewRef;
     readonly key: DefinitionKey<string, 'view'>;
-    readonly target: ViewTarget;
     readonly description?: ViewDefinition['description'];
     readonly definition: ViewDefinition;
 }

package/dist/v1/schema/analysis/class.d.ts

@@ -2,40 +2,70 @@ import type { ClassRef } from '../../addressing/index.js';
 import type { MethodDefinition } from '../../language/callable/model/callable.js';
 import type { ClassDefinition } from '../../language/class/model/class.js';
 import type { DataDefinition } from '../../language/class/model/data.js';
-import type { PropertyAuto } from '../../language/class/model/property.js';
+import type { PropertyAuto, PropertyImmutability } from '../../language/class/model/property.js';
+import type { StateTopology } from '../../language/state/index.js';
 import type { JsonSchema } from '../../language/value/model/schema.js';
 import type { SchemaDiagnostic } from '../diagnostic.js';
 import type { DomainResolutionContext } from '../resolution/context.js';
 import { PropertyKey } from '../../addressing/index.js';
+import { type MethodComposition } from '../../language/callable/composition.js';
 export interface EffectiveField {
     readonly identity: PropertyKey;
     readonly owner: ClassRef;
     readonly name: string;
     readonly schema: JsonSchema;
     readonly required: boolean;
-    readonly visibility: 'public' | 'private';
     readonly auto?: PropertyAuto;
+    readonly immutable?: PropertyImmutability;
+    readonly state?: StateTopology;
 }
 export interface EffectiveMethod {
-    readonly identity: string;
+    readonly key: string;
     readonly owner: ClassRef;
     readonly name: string;
     readonly declaration: MethodDefinition;
 }
-export interface EffectiveData {
+interface EffectiveData {
     readonly identity: string;
     readonly owner: ClassRef;
     readonly declaration: DataDefinition;
 }
-export interface DefinitionAnalysis {
+export interface DefinitionAnalysis extends MethodComposition<EffectiveMethod> {
     readonly ref: ClassRef;
     readonly declaration: ClassDefinition;
     readonly properties: ReadonlyMap<PropertyKey, EffectiveField>;
     readonly data?: EffectiveData;
-    readonly methods: ReadonlyMap<string, EffectiveMethod>;
 }
 export interface DefinitionAnalysisResult {
     readonly definitions: ReadonlyMap<string, DefinitionAnalysis>;
     readonly diagnostics: readonly SchemaDiagnostic[];
 }
 export declare function analyzeDefinitions(environment: DomainResolutionContext): DefinitionAnalysisResult;
+/** The exact signature required by abstract Method composition. */
+export declare function sameMethodSignature(left: MethodDefinition, right: MethodDefinition): boolean;
+/**
+ * Shared canonical signature used by admission and compatibility explanations. The execution
+ * modifier appears only when durable, so absent and `durable: false` are the same signature.
+ */
+export declare function methodSignature(value: MethodDefinition): {
+    input: JsonSchema;
+    output: {
+        mode: string;
+        schema: JsonSchema;
+        item?: undefined;
+    } | {
+        schema?: undefined;
+        mode: string;
+        item: JsonSchema;
+    } | {
+        schema?: undefined;
+        item?: undefined;
+        mode: string;
+    };
+    auth: "anonymous" | "authenticated" | "authorized";
+    static: boolean;
+    execution?: {
+        durable: boolean;
+    } | undefined;
+};
+export {};