bireactive 0.3.0 → 0.3.2

package/dist/core/values/reg/ambiguity.d.ts

@@ -0,0 +1,8 @@
+import { type Re } from "./engine.js";
+/** A witness in `L(a) ∩ L(b)` (shortest), or `null` if the languages are
+ *  disjoint. Product BFS over derivative pairs. */
+export declare function intersects(a: Re, b: Re): string | null;
+/** A witness string that `a · b` factors two distinct ways, or `null` if the
+ *  concatenation is unambiguous. Ambiguous iff some nonempty bridge `t` can
+ *  both extend a word of `L(a)` and be absorbed into `L(b)`. */
+export declare function concatAmbiguity(a: Re, b: Re): string | null;

package/dist/core/values/reg/ambiguity.js

@@ -0,0 +1,131 @@
+import { alphabetOf, der, nullable, reKey } from "./engine.js";
+const cp = (c) => String.fromCharCode(c);
+/** Representative code units that distinguish every transition in `a` and `b`
+ *  (the range endpoints of every char class). Sufficient to realize every
+ *  reachable derivative pair. */
+function alphaUnion(a, b) {
+    const set = alphabetOf(a);
+    alphabetOf(b, set);
+    return [...set];
+}
+/** Fold the derivative across a string. */
+function applyStr(r, s) {
+    let cur = r;
+    for (let i = 0; i < s.length && cur.k !== "emp"; i++)
+        cur = der(cur, s.charCodeAt(i));
+    return cur;
+}
+/** A witness in `L(a) ∩ L(b)` (shortest), or `null` if the languages are
+ *  disjoint. Product BFS over derivative pairs. */
+export function intersects(a, b) {
+    const alpha = alphaUnion(a, b);
+    const seen = new Set([`${reKey(a)}|${reKey(b)}`]);
+    const queue = [{ a, b, w: "" }];
+    for (let head = 0; head < queue.length; head++) {
+        const { a: da, b: db, w } = queue[head];
+        if (nullable(da) && nullable(db))
+            return w;
+        for (const c of alpha) {
+            const na = der(da, c);
+            if (na.k === "emp")
+                continue;
+            const nb = der(db, c);
+            if (nb.k === "emp")
+                continue;
+            const key = `${reKey(na)}|${reKey(nb)}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            queue.push({ a: na, b: nb, w: w + cp(c) });
+        }
+    }
+    return null;
+}
+/** All reachable derivative states of `r`, each with a shortest word reaching
+ *  it (BFS over the derivative automaton). */
+function reachableStates(r) {
+    const alpha = [...alphabetOf(r)];
+    const out = new Map([[reKey(r), { re: r, word: "" }]]);
+    const queue = [{ re: r, word: "" }];
+    for (let head = 0; head < queue.length; head++) {
+        const { re, word } = queue[head];
+        for (const c of alpha) {
+            const d = der(re, c);
+            if (d.k === "emp")
+                continue;
+            const k = reKey(d);
+            if (out.has(k))
+                continue;
+            const w = word + cp(c);
+            out.set(k, { re: d, word: w });
+            queue.push({ re: d, word: w });
+        }
+    }
+    return out;
+}
+const SET_KEY = (states) => states.map(reKey).sort().join(",");
+const dedup = (states) => {
+    const seen = new Set();
+    const out = [];
+    for (const s of states) {
+        const k = reKey(s);
+        if (!seen.has(k)) {
+            seen.add(k);
+            out.push(s);
+        }
+    }
+    return out;
+};
+// A generous bound: if the product search explodes past this, refuse to certify
+// (sound — we reject rather than risk admitting an ambiguous grammar).
+const MAX_STATES = 200000;
+/** A witness string that `a · b` factors two distinct ways, or `null` if the
+ *  concatenation is unambiguous. Ambiguous iff some nonempty bridge `t` can
+ *  both extend a word of `L(a)` and be absorbed into `L(b)`. */
+export function concatAmbiguity(a, b) {
+    const statesA = reachableStates(a);
+    const accepting = [];
+    for (const st of statesA.values())
+        if (nullable(st.re))
+            accepting.push(st);
+    if (accepting.length === 0)
+        return null; // L(a) = ∅: nothing to split
+    const alpha = alphaUnion(a, b);
+    // Search for a nonempty bridge `t`: state = (set of A-derivatives reached
+    // from A's accepting states by `t`, der(b, t)).
+    const start = dedup(accepting.map(s => s.re));
+    const seen = new Set([`${SET_KEY(start)}|${reKey(b)}`]);
+    const queue = [{ sa: start, db: b, t: "" }];
+    for (let head = 0; head < queue.length; head++) {
+        if (seen.size > MAX_STATES)
+            throw new Error("reg: grammar too complex to verify");
+        const { sa, db, t } = queue[head];
+        if (t.length > 0 && sa.some(nullable)) {
+            const v = intersects(db, b); // v ∈ L(b) with t·v ∈ L(b)
+            if (v !== null)
+                return witnessFor(accepting, t, v);
+        }
+        for (const c of alpha) {
+            const db2 = der(db, c);
+            if (db2.k === "emp")
+                continue; // t·… can no longer be a prefix of L(b)
+            const sa2 = dedup(sa.map(s => der(s, c)).filter(s => s.k !== "emp"));
+            if (sa2.length === 0)
+                continue; // no accepting continuation on the left
+            const key = `${SET_KEY(sa2)}|${reKey(db2)}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            queue.push({ sa: sa2, db: db2, t: t + cp(c) });
+        }
+    }
+    return null;
+}
+/** Assemble the full doubly-parsing string `u·t·v`: pick an accepting `u ∈ L(a)`
+ *  (shortest known) with `u·t ∈ L(a)`; falls back to `t·v` if none is found. */
+function witnessFor(accepting, t, v) {
+    for (const s of accepting)
+        if (nullable(applyStr(s.re, t)))
+            return s.word + t + v;
+    return t + v;
+}

package/dist/core/values/reg/engine.d.ts

@@ -0,0 +1,91 @@
+/** A set of UTF-16 code units as sorted, merged, inclusive ranges. Negation is
+ *  resolved at construction, so a set is always a positive union of ranges. */
+export declare class CharSet {
+    readonly ranges: ReadonlyArray<readonly [number, number]>;
+    private constructor();
+    /** Build from arbitrary (possibly overlapping/unsorted) ranges. */
+    static of(ranges: ReadonlyArray<readonly [number, number]>): CharSet;
+    static char(cp: number): CharSet;
+    static range(lo: number, hi: number): CharSet;
+    /** The full code-unit alphabet. */
+    static full(): CharSet;
+    static empty(): CharSet;
+    has(cp: number): boolean;
+    isEmpty(): boolean;
+    union(other: CharSet): CharSet;
+    /** Do the two sets share any code unit? (Both are sorted/normalized.) */
+    overlaps(other: CharSet): boolean;
+    /** Complement against the full code-unit alphabet. */
+    complement(): CharSet;
+    /** Case-fold (ASCII + via `toUpperCase`/`toLowerCase`) for the `i` flag.
+     *  Conservative: adds the upper/lower variant of every unit in range. */
+    ignoreCase(): CharSet;
+}
+/** A regular expression over code units. `emp` = ∅ (matches nothing), `eps` =
+ *  ε (matches the empty string). Built only through the smart constructors
+ *  below so that derivatives stay simplified. */
+export type Re = {
+    readonly k: "emp";
+} | {
+    readonly k: "eps";
+} | {
+    readonly k: "chr";
+    readonly set: CharSet;
+} | {
+    readonly k: "seq";
+    readonly a: Re;
+    readonly b: Re;
+} | {
+    readonly k: "alt";
+    readonly a: Re;
+    readonly b: Re;
+} | {
+    readonly k: "star";
+    readonly r: Re;
+};
+export declare const EMP: Re;
+export declare const EPS: Re;
+export declare function chr(set: CharSet): Re;
+/** Concatenation, simplified: `∅·_ = _·∅ = ∅`, `ε·b = b`, `a·ε = a`. */
+export declare function seq(a: Re, b: Re): Re;
+/** Union, normalized modulo ACI: flatten nested alts and drop duplicate
+ *  branches, preserving first-occurrence order. The derivative-state set is
+ *  finite only modulo ACI, so this keeps `der` bounded. Order is preserved (not
+ *  sorted) to keep greedy/backtracking semantics. */
+export declare function alt(a: Re, b: Re): Re;
+/** Kleene star, simplified: `∅* = ε* = ε`, `(r*)* = r*`. */
+export declare function star(r: Re): Re;
+/** N-ary concatenation (right-nested). */
+export declare function seqAll(parts: readonly Re[]): Re;
+/** N-ary union. */
+export declare function altAll(branches: readonly Re[]): Re;
+/** Bounded repetition `r{lo,hi}` (hi `undefined` = unbounded). */
+export declare function repeat(r: Re, lo: number, hi: number | undefined): Re;
+/** A canonical structural key, used both for ACI dedup in `alt` and for
+ *  derivative-state dedup during language enumeration. */
+export declare function reKey(r: Re): string;
+/** Does `r` match the empty string? */
+export declare function nullable(r: Re): boolean;
+/** Brzozowski derivative of `r` with respect to code unit `cp`. */
+export declare function der(r: Re, cp: number): Re;
+/** Does `r` match exactly `s[from..to)`? */
+export declare function accepts(r: Re, s: string, from?: number, to?: number): boolean;
+/** Every prefix length `k ≥ 0` such that `r` matches `s[pos..pos+k)`, ascending.
+ *  This is the backtracking lexer primitive: a leaf can accept several lengths
+ *  (`\d+` over "123" accepts 1, 2, 3) and the value parser tries them
+ *  greedily (longest first) with proper fallback. */
+export declare function matchLengths(r: Re, s: string, pos: number): number[];
+/** Characters that can begin a word in `L(r)`. */
+export declare function firstSet(r: Re): CharSet;
+/** Characters that can extend an already-complete match of `r` (the union of
+ *  the first-sets of every reachable accepting derivative state). Finite and
+ *  terminating because the derivative-state set is finite modulo ACI. */
+export declare function followLast(r: Re): CharSet;
+/** Representative code units that exercise every char-set boundary in `r`
+ *  (each range's low/high endpoint). Enough to drive structural exploration
+ *  without iterating the whole alphabet. */
+export declare function alphabetOf(r: Re, out?: Set<number>): Set<number>;
+/** Enumerate strings in `L(r)` over `alphabet`, shortest-first, up to `maxLen`
+ *  and `cap` results. Used by the ambiguity oracle to find minimal
+ *  counterexamples; bounded so it always terminates. */
+export declare function language(r: Re, alphabet: readonly number[], maxLen: number, cap: number): Generator<string>;

package/dist/core/values/reg/engine.js

@@ -0,0 +1,373 @@
+// Matching is over UTF-16 code units (JS regex without the `/u` flag): `.` is
+// one code unit, an astral char is two. Keeps the whole stack in one index space.
+const UNIT_MAX = 0xffff;
+/** A set of UTF-16 code units as sorted, merged, inclusive ranges. Negation is
+ *  resolved at construction, so a set is always a positive union of ranges. */
+export class CharSet {
+    ranges;
+    constructor(ranges) {
+        this.ranges = ranges;
+    }
+    /** Build from arbitrary (possibly overlapping/unsorted) ranges. */
+    static of(ranges) {
+        return new CharSet(normalize(ranges));
+    }
+    static char(cp) {
+        return new CharSet([[cp, cp]]);
+    }
+    static range(lo, hi) {
+        return new CharSet(lo <= hi ? [[lo, hi]] : [[hi, lo]]);
+    }
+    /** The full code-unit alphabet. */
+    static full() {
+        return new CharSet([[0, UNIT_MAX]]);
+    }
+    static empty() {
+        return new CharSet([]);
+    }
+    has(cp) {
+        for (const [lo, hi] of this.ranges) {
+            if (cp < lo)
+                return false;
+            if (cp <= hi)
+                return true;
+        }
+        return false;
+    }
+    isEmpty() {
+        return this.ranges.length === 0;
+    }
+    union(other) {
+        return CharSet.of([...this.ranges, ...other.ranges]);
+    }
+    /** Do the two sets share any code unit? (Both are sorted/normalized.) */
+    overlaps(other) {
+        let i = 0;
+        let j = 0;
+        while (i < this.ranges.length && j < other.ranges.length) {
+            const a = this.ranges[i];
+            const b = other.ranges[j];
+            if (a[1] < b[0])
+                i++;
+            else if (b[1] < a[0])
+                j++;
+            else
+                return true;
+        }
+        return false;
+    }
+    /** Complement against the full code-unit alphabet. */
+    complement() {
+        const out = [];
+        let at = 0;
+        for (const [lo, hi] of this.ranges) {
+            if (lo > at)
+                out.push([at, lo - 1]);
+            at = hi + 1;
+        }
+        if (at <= UNIT_MAX)
+            out.push([at, UNIT_MAX]);
+        return new CharSet(out);
+    }
+    /** Case-fold (ASCII + via `toUpperCase`/`toLowerCase`) for the `i` flag.
+     *  Conservative: adds the upper/lower variant of every unit in range. */
+    ignoreCase() {
+        const extra = [];
+        for (const [lo, hi] of this.ranges) {
+            for (let cp = lo; cp <= hi; cp++) {
+                const ch = String.fromCharCode(cp);
+                const u = ch.toUpperCase();
+                const l = ch.toLowerCase();
+                if (u.length === 1 && u !== ch)
+                    extra.push([u.charCodeAt(0), u.charCodeAt(0)]);
+                if (l.length === 1 && l !== ch)
+                    extra.push([l.charCodeAt(0), l.charCodeAt(0)]);
+                if (hi - lo > 4096)
+                    break; // don't fold gigantic ranges char-by-char
+            }
+        }
+        return extra.length === 0 ? this : this.union(CharSet.of(extra));
+    }
+}
+function normalize(ranges) {
+    const sorted = ranges
+        .filter(([lo, hi]) => lo <= hi)
+        .map(([lo, hi]) => [Math.max(0, lo), Math.min(UNIT_MAX, hi)])
+        .sort((a, b) => a[0] - b[0]);
+    const out = [];
+    for (const [lo, hi] of sorted) {
+        const last = out[out.length - 1];
+        if (last !== undefined && lo <= last[1] + 1) {
+            if (hi > last[1])
+                last[1] = hi;
+        }
+        else {
+            out.push([lo, hi]);
+        }
+    }
+    return out;
+}
+export const EMP = { k: "emp" };
+export const EPS = { k: "eps" };
+export function chr(set) {
+    return set.isEmpty() ? EMP : { k: "chr", set };
+}
+/** Concatenation, simplified: `∅·_ = _·∅ = ∅`, `ε·b = b`, `a·ε = a`. */
+export function seq(a, b) {
+    if (a.k === "emp" || b.k === "emp")
+        return EMP;
+    if (a.k === "eps")
+        return b;
+    if (b.k === "eps")
+        return a;
+    return { k: "seq", a, b };
+}
+/** Union, normalized modulo ACI: flatten nested alts and drop duplicate
+ *  branches, preserving first-occurrence order. The derivative-state set is
+ *  finite only modulo ACI, so this keeps `der` bounded. Order is preserved (not
+ *  sorted) to keep greedy/backtracking semantics. */
+export function alt(a, b) {
+    if (a.k === "emp")
+        return b;
+    if (b.k === "emp")
+        return a;
+    const branches = [];
+    const seen = new Set();
+    const add = (r) => {
+        if (r.k === "alt") {
+            add(r.a);
+            add(r.b);
+            return;
+        }
+        if (r.k === "emp")
+            return;
+        const key = reKey(r);
+        if (!seen.has(key)) {
+            seen.add(key);
+            branches.push(r);
+        }
+    };
+    add(a);
+    add(b);
+    if (branches.length === 1)
+        return branches[0];
+    let out = branches[branches.length - 1];
+    for (let i = branches.length - 2; i >= 0; i--)
+        out = { k: "alt", a: branches[i], b: out };
+    return out;
+}
+/** Kleene star, simplified: `∅* = ε* = ε`, `(r*)* = r*`. */
+export function star(r) {
+    if (r.k === "emp" || r.k === "eps")
+        return EPS;
+    if (r.k === "star")
+        return r;
+    return { k: "star", r };
+}
+/** N-ary concatenation (right-nested). */
+export function seqAll(parts) {
+    let out = EPS;
+    for (let i = parts.length - 1; i >= 0; i--)
+        out = seq(parts[i], out);
+    return out;
+}
+/** N-ary union. */
+export function altAll(branches) {
+    let out = EMP;
+    for (let i = branches.length - 1; i >= 0; i--)
+        out = alt(branches[i], out);
+    return out;
+}
+/** Bounded repetition `r{lo,hi}` (hi `undefined` = unbounded). */
+export function repeat(r, lo, hi) {
+    const req = [];
+    for (let i = 0; i < lo; i++)
+        req.push(r);
+    if (hi === undefined)
+        return seq(seqAll(req), star(r));
+    let opt = EPS;
+    for (let i = lo; i < hi; i++)
+        opt = alt(EPS, seq(r, opt));
+    return seq(seqAll(req), opt);
+}
+/** A canonical structural key, used both for ACI dedup in `alt` and for
+ *  derivative-state dedup during language enumeration. */
+export function reKey(r) {
+    switch (r.k) {
+        case "emp":
+            return "0";
+        case "eps":
+            return "1";
+        case "chr":
+            return `c${r.set.ranges.map(([a, b]) => `${a}-${b}`).join(",")}`;
+        case "seq":
+            return `.(${reKey(r.a)})(${reKey(r.b)})`;
+        case "alt":
+            return `|(${reKey(r.a)})(${reKey(r.b)})`;
+        case "star":
+            return `*(${reKey(r.r)})`;
+    }
+}
+// ── derivative ─────────────────────────────────────────────────────────
+/** Does `r` match the empty string? */
+export function nullable(r) {
+    switch (r.k) {
+        case "emp":
+        case "chr":
+            return false;
+        case "eps":
+        case "star":
+            return true;
+        case "seq":
+            return nullable(r.a) && nullable(r.b);
+        case "alt":
+            return nullable(r.a) || nullable(r.b);
+    }
+}
+/** Brzozowski derivative of `r` with respect to code unit `cp`. */
+export function der(r, cp) {
+    switch (r.k) {
+        case "emp":
+        case "eps":
+            return EMP;
+        case "chr":
+            return r.set.has(cp) ? EPS : EMP;
+        case "seq": {
+            const d = seq(der(r.a, cp), r.b);
+            return nullable(r.a) ? alt(d, der(r.b, cp)) : d;
+        }
+        case "alt":
+            return alt(der(r.a, cp), der(r.b, cp));
+        case "star":
+            return seq(der(r.r, cp), r);
+    }
+}
+// ── recognition services ───────────────────────────────────────────────
+/** Does `r` match exactly `s[from..to)`? */
+export function accepts(r, s, from = 0, to = s.length) {
+    let cur = r;
+    for (let i = from; i < to; i++) {
+        cur = der(cur, s.charCodeAt(i));
+        if (cur.k === "emp")
+            return false;
+    }
+    return nullable(cur);
+}
+/** Every prefix length `k ≥ 0` such that `r` matches `s[pos..pos+k)`, ascending.
+ *  This is the backtracking lexer primitive: a leaf can accept several lengths
+ *  (`\d+` over "123" accepts 1, 2, 3) and the value parser tries them
+ *  greedily (longest first) with proper fallback. */
+export function matchLengths(r, s, pos) {
+    const out = [];
+    let cur = r;
+    if (nullable(cur))
+        out.push(0);
+    for (let i = pos; i < s.length; i++) {
+        cur = der(cur, s.charCodeAt(i));
+        if (cur.k === "emp")
+            break;
+        if (nullable(cur))
+            out.push(i - pos + 1);
+    }
+    return out;
+}
+// ── determinism analysis (first / followLast) ───────────────────────────
+// `firstSet` is the begin-set, `followLast` the continue-after-a-complete-match
+// set. A grammar is deterministic when, at every split, the left's continue-set
+// is disjoint from the right's begin-set.
+/** Characters that can begin a word in `L(r)`. */
+export function firstSet(r) {
+    switch (r.k) {
+        case "emp":
+        case "eps":
+            return CharSet.empty();
+        case "chr":
+            return r.set;
+        case "seq":
+            return nullable(r.a) ? firstSet(r.a).union(firstSet(r.b)) : firstSet(r.a);
+        case "alt":
+            return firstSet(r.a).union(firstSet(r.b));
+        case "star":
+            return firstSet(r.r);
+    }
+}
+/** Characters that can extend an already-complete match of `r` (the union of
+ *  the first-sets of every reachable accepting derivative state). Finite and
+ *  terminating because the derivative-state set is finite modulo ACI. */
+export function followLast(r) {
+    const reps = [...alphabetOf(r)];
+    let acc = CharSet.empty();
+    const seen = new Set();
+    const stack = [r];
+    while (stack.length > 0) {
+        const st = stack.pop();
+        const key = reKey(st);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        if (nullable(st))
+            acc = acc.union(firstSet(st));
+        for (const c of reps) {
+            const d = der(st, c);
+            if (d.k !== "emp")
+                stack.push(d);
+        }
+    }
+    return acc;
+}
+// ── language enumeration (for the ambiguity oracle) ─────────────────────
+/** Representative code units that exercise every char-set boundary in `r`
+ *  (each range's low/high endpoint). Enough to drive structural exploration
+ *  without iterating the whole alphabet. */
+export function alphabetOf(r, out = new Set()) {
+    switch (r.k) {
+        case "emp":
+        case "eps":
+            return out;
+        case "chr":
+            for (const [lo, hi] of r.set.ranges) {
+                out.add(lo);
+                if (hi !== lo)
+                    out.add(hi);
+            }
+            return out;
+        case "seq":
+        case "alt":
+            alphabetOf(r.a, out);
+            alphabetOf(r.b, out);
+            return out;
+        case "star":
+            return alphabetOf(r.r, out);
+    }
+}
+/** Enumerate strings in `L(r)` over `alphabet`, shortest-first, up to `maxLen`
+ *  and `cap` results. Used by the ambiguity oracle to find minimal
+ *  counterexamples; bounded so it always terminates. */
+export function* language(r, alphabet, maxLen, cap) {
+    let count = 0;
+    const queue = [["", r]];
+    const seen = new Set([`0:${reKey(r)}`]);
+    let head = 0;
+    while (head < queue.length) {
+        const [s, cur] = queue[head++];
+        if (nullable(cur)) {
+            yield s;
+            if (++count >= cap)
+                return;
+        }
+        if (s.length >= maxLen)
+            continue;
+        for (const c of alphabet) {
+            const d = der(cur, c);
+            if (d.k === "emp")
+                continue;
+            const key = `${s.length + 1}:${reKey(d)}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            queue.push([s + String.fromCharCode(c), d]);
+        }
+        if (queue.length > 50000)
+            return; // hard cap on exploration
+    }
+}

package/dist/core/values/reg/nfa.d.ts

@@ -0,0 +1,42 @@
+import type { Node, RegVal, Span } from "../reg.js";
+import { CharSet } from "./engine.js";
+interface EvT {
+    readonly k: number;
+    readonly id: number;
+    readonly i: number;
+}
+type Char = {
+    op: 0;
+    set: CharSet;
+};
+type Split = {
+    op: 1;
+    x: number;
+    y: number;
+};
+type Jmp = {
+    op: 2;
+    x: number;
+};
+type Mark = {
+    op: 3;
+    ev: EvT;
+};
+type MatchI = {
+    op: 4;
+};
+type Instr = Char | Split | Jmp | Mark | MatchI;
+export interface Program {
+    readonly code: readonly Instr[];
+    readonly idOf: WeakMap<Node, number>;
+}
+/** Compile a grammar AST to a tagged Thompson program. */
+export declare function compileProgram(root: Node): Program;
+/** Parse `s` fully; `null` if it doesn't match. Builds the value tree (and, if
+ *  given, the named-capture span map) from the winning marker log. */
+export declare function parseValue(root: Node, prog: Program, s: string, spans?: Map<string, Span>): {
+    val: RegVal;
+} | null;
+/** Does the program match the whole of `s`? Recognition only (no allocation). */
+export declare function recognize(prog: Program, s: string): boolean;
+export {};