@astrale-os/kernel-dsl 0.2.0-beta.2 → 0.2.0-beta.20

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

@@ -0,0 +1,326 @@
+const CATEGORY = /^(?:L[lmotu]?|M[cen]?|N[dlo]?|P[cdfios]?|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],
+    [14, 0xd7ff],
+    [0xe000, 0x10ffff],
+];
+/** Parse the complete RFC 9485 I-Regexp grammar into the one compiler AST. */
+export function parseIRegexp(source) {
+    if (!isUnicodeScalarString(source) || source === '[^]')
+        return undefined;
+    const characters = Array.from(source);
+    if (characters.length > MAX_CODE_POINTS)
+        return undefined;
+    const parser = new Parser(characters);
+    const expression = parser.expression(undefined, 0);
+    return expression !== undefined && parser.done ? expression : undefined;
+}
+class Parser {
+    characters;
+    index = 0;
+    constructor(characters) {
+        this.characters = characters;
+    }
+    get done() {
+        return this.index === this.characters.length;
+    }
+    expression(stop, depth) {
+        if (depth > MAX_NESTING)
+            return undefined;
+        const alternatives = [];
+        const first = this.sequence(stop, depth);
+        if (first === undefined)
+            return undefined;
+        alternatives.push(first);
+        while (this.peek() === '|') {
+            this.index++;
+            const next = this.sequence(stop, depth);
+            if (next === undefined)
+                return undefined;
+            alternatives.push(next);
+        }
+        return { alternatives };
+    }
+    sequence(stop, depth) {
+        const pieces = [];
+        while (this.index < this.characters.length) {
+            const next = this.peek();
+            if (next === '|' || next === stop)
+                return { pieces };
+            const piece = this.piece(depth);
+            if (piece === undefined)
+                return undefined;
+            pieces.push(piece);
+        }
+        return stop === undefined ? { pieces } : undefined;
+    }
+    piece(depth) {
+        const atom = this.atom(depth);
+        if (atom === undefined)
+            return undefined;
+        const next = this.peek();
+        if (next === '*') {
+            this.index++;
+            return { atom, minimum: 0 };
+        }
+        if (next === '+') {
+            this.index++;
+            return { atom, minimum: 1 };
+        }
+        if (next === '?') {
+            this.index++;
+            return { atom, minimum: 0, maximum: 1 };
+        }
+        if (next === '{') {
+            const range = this.quantifier();
+            return range === undefined ? undefined : { atom, ...range };
+        }
+        return { atom, minimum: 1, maximum: 1 };
+    }
+    atom(depth) {
+        const next = this.peek();
+        if (next === undefined)
+            return undefined;
+        if (next === '(') {
+            this.index++;
+            const expression = this.expression(')', depth + 1);
+            if (expression === undefined || this.peek() !== ')')
+                return undefined;
+            this.index++;
+            return { kind: 'expression', expression };
+        }
+        if (next === '.') {
+            this.index++;
+            return { kind: 'ranges', ranges: DOT_RANGES };
+        }
+        if (next === '[')
+            return this.characterClass();
+        if (next === '\\') {
+            const ranges = this.escape(true);
+            return ranges === undefined ? undefined : { kind: 'ranges', ranges };
+        }
+        if (!isNormalCharacter(next))
+            return undefined;
+        this.index++;
+        return { kind: 'ranges', ranges: singleton(next) };
+    }
+    quantifier() {
+        this.index++;
+        const minimum = this.integer();
+        if (minimum === undefined || minimum > MAX_REPEAT)
+            return undefined;
+        let maximum = minimum;
+        if (this.peek() === ',') {
+            this.index++;
+            maximum = this.integer();
+        }
+        if ((maximum !== undefined && (maximum > MAX_REPEAT || maximum < minimum)) ||
+            this.peek() !== '}') {
+            return undefined;
+        }
+        this.index++;
+        return maximum === undefined ? { minimum } : { minimum, maximum };
+    }
+    characterClass() {
+        this.index++;
+        const negated = this.peek() === '^';
+        if (negated)
+            this.index++;
+        if (this.peek() === undefined || this.peek() === ']')
+            return undefined;
+        const ranges = [];
+        if (this.peek() === '-') {
+            ranges.push(...singleton('-'));
+            this.index++;
+        }
+        else if (!this.classEntry(ranges))
+            return undefined;
+        while (this.peek() !== ']') {
+            if (this.peek() === undefined)
+                return undefined;
+            if (this.peek() === '-' && this.peek(1) === ']') {
+                ranges.push(...singleton('-'));
+                this.index++;
+                break;
+            }
+            if (!this.classEntry(ranges))
+                return undefined;
+        }
+        if (this.peek() !== ']')
+            return undefined;
+        this.index++;
+        const merged = mergeRanges(ranges);
+        return { kind: 'ranges', ranges: negated ? complement(merged) : merged };
+    }
+    classEntry(output) {
+        if (this.peek() === '\\' && (this.peek(1) === 'p' || this.peek(1) === 'P')) {
+            const ranges = this.categoryEscape();
+            if (ranges === undefined)
+                return false;
+            output.push(...ranges);
+            return true;
+        }
+        const start = this.classCharacter();
+        if (start === undefined)
+            return false;
+        if (this.peek() !== '-' || this.peek(1) === ']') {
+            output.push([start, start]);
+            return true;
+        }
+        this.index++;
+        const end = this.classCharacter();
+        if (end === undefined || end < start)
+            return false;
+        output.push([start, end]);
+        return true;
+    }
+    classCharacter() {
+        if (this.peek() === '\\') {
+            const ranges = this.escape(false);
+            return ranges?.length === 1 && ranges[0][0] === ranges[0][1] ? ranges[0][0] : undefined;
+        }
+        const next = this.peek();
+        if (next === undefined || next === '-' || next === '[' || next === ']' || next === '\\')
+            return undefined;
+        this.index++;
+        return next.codePointAt(0);
+    }
+    escape(allowCategory) {
+        if (allowCategory && (this.peek(1) === 'p' || this.peek(1) === 'P')) {
+            return this.categoryEscape();
+        }
+        if (this.peek() !== '\\')
+            return undefined;
+        const escaped = this.peek(1);
+        if (escaped === undefined || !'()*+-.?[\\]^nrt{}'.includes(escaped))
+            return undefined;
+        this.index += 2;
+        const value = escaped === 'n' ? '\n' : escaped === 'r' ? '\r' : escaped === 't' ? '\t' : escaped;
+        return singleton(value);
+    }
+    categoryEscape() {
+        if (this.peek() !== '\\' ||
+            (this.peek(1) !== 'p' && this.peek(1) !== 'P') ||
+            this.peek(2) !== '{')
+            return undefined;
+        const negated = this.peek(1) === 'P';
+        this.index += 3;
+        let category = '';
+        while (this.peek() !== '}' && this.peek() !== undefined) {
+            category += this.peek();
+            this.index++;
+        }
+        if (this.peek() !== '}' || !CATEGORY.test(category))
+            return undefined;
+        this.index++;
+        const ranges = categoryRanges(category);
+        return negated ? complement(ranges) : ranges;
+    }
+    integer() {
+        const start = this.index;
+        while (/^[0-9]$/u.test(this.peek() ?? ''))
+            this.index++;
+        if (this.index === start)
+            return undefined;
+        const value = Number(this.characters.slice(start, this.index).join(''));
+        return Number.isSafeInteger(value) ? value : undefined;
+    }
+    peek(offset = 0) {
+        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 &&
+        ((code >= 0 && code <= 0x27) ||
+            code === 0x2c ||
+            code === 0x2d ||
+            (code >= 0x2f && code <= 0x3e) ||
+            (code >= 0x40 && code <= 0x5a) ||
+            (code >= 0x5e && code <= 0x7a) ||
+            (code >= 0x7e && code <= 0xd7ff) ||
+            (code >= 0xe000 && code <= 0x10ffff)));
+}
+function isUnicodeScalarString(value) {
+    for (let index = 0; index < value.length; index++) {
+        const unit = value.charCodeAt(index);
+        if (unit < 0xd800 || unit > 0xdfff)
+            continue;
+        if (unit > 0xdbff || index + 1 >= value.length)
+            return false;
+        const next = value.charCodeAt(++index);
+        if (next < 0xdc00 || next > 0xdfff)
+            return false;
+    }
+    return true;
+}

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

@@ -0,0 +1,3 @@
+import type { Pattern } from '../compile/model.js';
+/** Compile one admitted I-Regexp AST to portable Thompson-NFA data. */
+export declare function compilePattern(source: string): Pattern;

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

@@ -0,0 +1,96 @@
+import { parseIRegexp } from './ast.js';
+/** Compile one admitted I-Regexp AST to portable Thompson-NFA data. */
+export function compilePattern(source) {
+    const expression = parseIRegexp(source);
+    if (expression === undefined)
+        throw new TypeError('Cannot compile an invalid I-Regexp source.');
+    const builder = new Builder();
+    const fragment = builder.expression(expression);
+    builder.states[fragment.end].accepting = true;
+    return Object.freeze({
+        source,
+        start: fragment.start,
+        states: Object.freeze(builder.states.map(freezeState)),
+    });
+}
+class Builder {
+    states = [];
+    expression(expression) {
+        const start = this.state();
+        const end = this.state();
+        for (const alternative of expression.alternatives) {
+            const branch = this.sequence(alternative);
+            this.epsilon(start, branch.start);
+            this.epsilon(branch.end, end);
+        }
+        return { start, end };
+    }
+    sequence(sequence) {
+        let output = this.empty();
+        for (const piece of sequence.pieces)
+            output = this.concat(output, this.piece(piece));
+        return output;
+    }
+    piece(piece) {
+        let output = this.empty();
+        for (let index = 0; index < piece.minimum; index++) {
+            output = this.concat(output, this.atom(piece.atom));
+        }
+        if (piece.maximum === undefined)
+            return this.concat(output, this.star(piece.atom));
+        for (let index = piece.minimum; index < piece.maximum; index++) {
+            output = this.concat(output, this.optional(piece.atom));
+        }
+        return output;
+    }
+    atom(atom) {
+        if (atom.kind === 'expression')
+            return this.expression(atom.expression);
+        const start = this.state();
+        const end = this.state();
+        this.states[start].transitions.push({ to: end, ranges: atom.ranges });
+        return { start, end };
+    }
+    optional(atom) {
+        const start = this.state();
+        const end = this.state();
+        const child = this.atom(atom);
+        this.epsilon(start, end);
+        this.epsilon(start, child.start);
+        this.epsilon(child.end, end);
+        return { start, end };
+    }
+    star(atom) {
+        const start = this.state();
+        const end = this.state();
+        const child = this.atom(atom);
+        this.epsilon(start, end);
+        this.epsilon(start, child.start);
+        this.epsilon(child.end, child.start);
+        this.epsilon(child.end, end);
+        return { start, end };
+    }
+    empty() {
+        const start = this.state();
+        const end = this.state();
+        this.epsilon(start, end);
+        return { start, end };
+    }
+    concat(left, right) {
+        this.epsilon(left.end, right.start);
+        return { start: left.start, end: right.end };
+    }
+    state() {
+        return this.states.push({ epsilon: [], transitions: [] }) - 1;
+    }
+    epsilon(from, to) {
+        this.states[from].epsilon.push(to);
+    }
+}
+function freezeState(state) {
+    return Object.freeze({
+        epsilon: Object.freeze(state.epsilon),
+        transitions: Object.freeze(state.transitions.map((transition) => Object.freeze({ to: transition.to, ranges: Object.freeze(transition.ranges) }))),
+        ...(state.accepting === true ? { accepting: true } : {}),
+    });
+}

package/dist/v1/{schema → language}/value/regexp/lower.d.ts

@@ -1,4 +1,3 @@
-import type { JsonSchema } from '../schema.js';
+import type { JsonSchema } from '../model/schema.js';
 /** Creates an Ajv-private schema copy with only checked I-Regexp sources lowered. */
 export declare function lowerIRegexpSchemas(schema: JsonSchema): JsonSchema;
-//# sourceMappingURL=lower.d.ts.map

package/dist/v1/{schema → language}/value/regexp/lower.js

@@ -1,6 +1,6 @@
 import { accept as acceptJsonValue } from '@astrale-os/kernel-dsl/value';
-import { walkSchema } from '../location/walk.js';
-import { isValueObject as isJsonObject } from '../object.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { walkSchema } from '../syntax/walk.js';
 import { lowerIRegexpPattern } from './pattern.js';
 /** Creates an Ajv-private schema copy with only checked I-Regexp sources lowered. */
 export function lowerIRegexpSchemas(schema) {
@@ -24,4 +24,3 @@ export function lowerIRegexpSchemas(schema) {
     });
     return lowered;
 }
-//# sourceMappingURL=lower.js.map

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

@@ -0,0 +1,7 @@
+import type { Pattern } from '../compile/model.js';
+export interface IRegexpMatcher {
+    test(value: string): boolean;
+    matches(value: string): boolean;
+}
+/** Load portable NFA data without a regex engine or dynamic compilation. */
+export declare function loadPattern(pattern: Pattern): IRegexpMatcher;

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

@@ -0,0 +1,50 @@
+/** Load portable NFA data without a regex engine or dynamic compilation. */
+export function loadPattern(pattern) {
+    const start = closure(pattern.states, new Set([pattern.start]));
+    const run = (input, search) => {
+        let active = new Set(start);
+        if ((search || input.length === 0) && accepts(pattern.states, active))
+            return true;
+        for (const character of input) {
+            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);
+                    }
+                }
+            }
+            active = closure(pattern.states, next);
+            if (search)
+                for (const index of start)
+                    active.add(index);
+            if (search && accepts(pattern.states, active))
+                return true;
+        }
+        return accepts(pattern.states, active);
+    };
+    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];
+    while (pending.length > 0) {
+        for (const next of states[pending.pop()].epsilon) {
+            if (output.has(next))
+                continue;
+            output.add(next);
+            pending.push(next);
+        }
+    }
+    return output;
+}
+function accepts(states, active) {
+    for (const index of active)
+        if (states[index]?.accepting === true)
+            return true;
+    return false;
+}

package/dist/v1/{schema → language}/value/regexp/pattern.d.ts

@@ -1,3 +1,2 @@
 /** Lowers one admitted I-Regexp source into the pattern syntax used by the engine. */
 export declare function lowerIRegexpPattern(pattern: string): string;
-//# sourceMappingURL=pattern.d.ts.map

package/dist/v1/{schema → language}/value/regexp/pattern.js

@@ -36,4 +36,3 @@ export function lowerIRegexpPattern(pattern) {
     }
     return result;
 }
-//# sourceMappingURL=pattern.js.map

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

@@ -0,0 +1,2 @@
+/** Complete RFC 9485 syntax admission through the same AST consumed by compilation. */
+export declare function isIRegexp(source: string): boolean;

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

@@ -0,0 +1,5 @@
+import { parseIRegexp } from './ast.js';
+/** Complete RFC 9485 syntax admission through the same AST consumed by compilation. */
+export function isIRegexp(source) {
+    return parseIRegexp(source) !== undefined;
+}

package/dist/v1/language/value/syntax/full-match.d.ts

@@ -0,0 +1,6 @@
+import type { $ZodCheck } from 'zod/v4/core';
+/** Zod check whose exact whole-string I-Regexp meaning is serialized by the V1 compiler. */
+export type FullMatch = $ZodCheck<string>;
+export declare function fullMatch(source: string): FullMatch;
+/** Compiler-private recognition of checks created by the Schema-owned fullMatch operation. */
+export declare function fullMatchSource(check: unknown): string | undefined;

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

@@ -0,0 +1,20 @@
+import { refine } from 'zod';
+import { compilePattern } from '../regexp/compile.js';
+import { loadPattern } from '../regexp/matcher.js';
+import { isIRegexp } 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 matcher = loadPattern(compilePattern(source));
+    const check = refine((value) => matcher.matches(value), {
+        error: `String must fully match I-Regexp ${JSON.stringify(source)}.`,
+    });
+    sources.set(check, source);
+    return check;
+}
+/** Compiler-private recognition of checks created by the Schema-owned fullMatch operation. */
+export function fullMatchSource(check) {
+    return check !== null && typeof check === 'object' ? sources.get(check) : undefined;
+}

package/dist/v1/{schema/value/location → language/value/syntax}/keywords.d.ts

@@ -1,4 +1,3 @@
 export declare const SCHEMA_ARRAY_KEYWORDS: Set<string>;
 export declare const SCHEMA_MAP_KEYWORDS: Set<string>;
 export declare const SCHEMA_SINGLE_KEYWORDS: Set<string>;
-//# sourceMappingURL=keywords.d.ts.map

package/dist/v1/{schema/value/location → language/value/syntax}/keywords.js

@@ -18,4 +18,3 @@ export const SCHEMA_SINGLE_KEYWORDS = new Set([
     'unevaluatedItems',
     'unevaluatedProperties',
 ]);
-//# sourceMappingURL=keywords.js.map

package/dist/v1/{schema/value/extensions → language/value/syntax}/node-path/schema.d.ts

@@ -1,6 +1,5 @@
-import type { JsonSchema, JsonSchemaObject } from '../../schema.js';
+import type { JsonSchema, JsonSchemaObject } from '../../model/schema.js';
 export declare const GRAPH_NODE_PATH_SCHEMA_ID: 'https://schemas.astrale.ai/graph/1/node-path';
 /** Exact locally bundled artifact owned by graph/path/language's governed JSON Schema. */
 export declare const graphNodePathSchema: JsonSchemaObject;
 export declare function hasNodePathAnnotation(schema: JsonSchema): boolean;
-//# sourceMappingURL=schema.d.ts.map

package/dist/v1/{schema/value/extensions → language/value/syntax}/node-path/schema.js

@@ -1,5 +1,5 @@
-import { isValueObject as isJsonObject } from '../../object.js';
-import { JSON_SCHEMA_DIALECT } from '../../schema.js';
+import { isValueObject as isJsonObject } from '../../model/object.js';
+import { JSON_SCHEMA_DIALECT } from '../../model/schema.js';
 export const GRAPH_NODE_PATH_SCHEMA_ID = 'https://schemas.astrale.ai/graph/1/node-path';
 /** Exact locally bundled artifact owned by graph/path/language's governed JSON Schema. */
 export const graphNodePathSchema = Object.freeze({
@@ -16,4 +16,3 @@ export function hasNodePathAnnotation(schema) {
         schema.$ref === GRAPH_NODE_PATH_SCHEMA_ID &&
         Object.hasOwn(schema, 'x-astrale-path'));
 }
-//# sourceMappingURL=schema.js.map

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

@@ -0,0 +1,4 @@
+import type { ClassRef } from '../../../../addressing/index.js';
+import type { Diagnostic } from '../../../validation/diagnostic.js';
+import type { JsonSchema, ValueSchemaContext } from '../../model/schema.js';
+export declare function validateNodePathExtension(schema: JsonSchema, context: ValueSchemaContext, pointer: string, definitionExists: (ref: ClassRef) => boolean): readonly Diagnostic[];