@hviana/sema 0.1.5 → 0.1.6

package/dist/src/derive/src/rewrite.js

@@ -36,73 +36,65 @@ import { lightestDerivation } from "./deduction.js";
  * start there. No quadratic span structure.
  */
 export function coverSequence(length, candidates) {
-  if (length <= 0) {
-    return { spans: [], covered: 0, uncovered: 0 };
-  }
-  // Candidates indexed by where they start, and by their exact (start,end) edge
-  // for reconstruction. Both are O(|candidates|) to build and to read.
-  const byStart = Array.from({ length }, () => []);
-  const byEdge = new Map();
-  let maxWeight = 1;
-  for (const c of candidates) {
-    if (c.end <= c.start || c.start < 0 || c.end > length) {
-      continue;
+    if (length <= 0)
+        return { spans: [], covered: 0, uncovered: 0 };
+    // Candidates indexed by where they start, and by their exact (start,end) edge
+    // for reconstruction. Both are O(|candidates|) to build and to read.
+    const byStart = Array.from({ length }, () => []);
+    const byEdge = new Map();
+    let maxWeight = 1;
+    for (const c of candidates) {
+        if (c.end <= c.start || c.start < 0 || c.end > length)
+            continue;
+        const w = c.weight ?? 1;
+        if (w > maxWeight)
+            maxWeight = w;
+        byStart[c.start].push(c);
+        const edge = c.start * (length + 1) + c.end;
+        const prev = byEdge.get(edge);
+        if (!prev || w < (prev.weight ?? 1))
+            byEdge.set(edge, c);
     }
-    const w = c.weight ?? 1;
-    if (w > maxWeight) {
-      maxWeight = w;
+    // One uncovered symbol must outweigh any sum of span weights, so coverage is
+    // strictly the primary objective and weight only breaks ties.
+    const skipCost = maxWeight * length + 1;
+    const system = {
+        key: (p) => "" + p,
+        axioms: () => [{ item: 0, cost: 0 }],
+        isGoal: (p) => p === length,
+        // No nonzero admissible bound is available here: a single candidate can
+        // cover the whole remainder for unit cost, so any per-symbol estimate would
+        // overestimate. With h = 0 this is exact Knuth/Dijkstra over the frontier —
+        // optimal, and linear in the positions. (The A* outside bound is for systems
+        // whose remaining cost can be genuinely lower-bounded; see the engine.)
+        *rules(p) {
+            if (p >= length)
+                return;
+            yield { premises: [p], conclusion: p + 1, cost: skipCost }; // leave uncovered
+            for (const c of byStart[p]) {
+                yield { premises: [p], conclusion: c.end, cost: c.weight ?? 1 };
+            }
+        },
+    };
+    const best = lightestDerivation(system);
+    if (!best)
+        return { spans: [], covered: 0, uncovered: length };
+    // Walk the frontier chain back to the axiom; an edge p→q is a chosen span iff
+    // a candidate spans exactly [p, q) (a covering edge is always cheaper than the
+    // skips it replaces, so it appears on the optimal path wherever it is used).
+    const spans = [];
+    let node = best;
+    while (node && node.rule) {
+        const to = node.item;
+        const from = node.premises[0].item;
+        const span = byEdge.get(from * (length + 1) + to);
+        if (span)
+            spans.push(span);
+        node = node.premises[0];
     }
-    byStart[c.start].push(c);
-    const edge = c.start * (length + 1) + c.end;
-    const prev = byEdge.get(edge);
-    if (!prev || w < (prev.weight ?? 1)) {
-      byEdge.set(edge, c);
-    }
-  }
-  // One uncovered symbol must outweigh any sum of span weights, so coverage is
-  // strictly the primary objective and weight only breaks ties.
-  const skipCost = maxWeight * length + 1;
-  const system = {
-    key: (p) => "" + p,
-    axioms: () => [{ item: 0, cost: 0 }],
-    isGoal: (p) => p === length,
-    // No nonzero admissible bound is available here: a single candidate can
-    // cover the whole remainder for unit cost, so any per-symbol estimate would
-    // overestimate. With h = 0 this is exact Knuth/Dijkstra over the frontier —
-    // optimal, and linear in the positions. (The A* outside bound is for systems
-    // whose remaining cost can be genuinely lower-bounded; see the engine.)
-    *rules(p) {
-      if (p >= length) {
-        return;
-      }
-      yield { premises: [p], conclusion: p + 1, cost: skipCost }; // leave uncovered
-      for (const c of byStart[p]) {
-        yield { premises: [p], conclusion: c.end, cost: c.weight ?? 1 };
-      }
-    },
-  };
-  const best = lightestDerivation(system);
-  if (!best) {
-    return { spans: [], covered: 0, uncovered: length };
-  }
-  // Walk the frontier chain back to the axiom; an edge p→q is a chosen span iff
-  // a candidate spans exactly [p, q) (a covering edge is always cheaper than the
-  // skips it replaces, so it appears on the optimal path wherever it is used).
-  const spans = [];
-  let node = best;
-  while (node && node.rule) {
-    const to = node.item;
-    const from = node.premises[0].item;
-    const span = byEdge.get(from * (length + 1) + to);
-    if (span) {
-      spans.push(span);
-    }
-    node = node.premises[0];
-  }
-  spans.reverse();
-  let covered = 0;
-  for (const s of spans) {
-    covered += s.end - s.start;
-  }
-  return { spans, covered, uncovered: length - covered };
+    spans.reverse();
+    let covered = 0;
+    for (const s of spans)
+        covered += s.end - s.start;
+    return { spans, covered, uncovered: length - covered };
 }

package/dist/src/derive/src/trie.d.ts

@@ -29,62 +29,62 @@
  */
 /** One pattern occurrence found by the trie. */
 export interface Match<P> {
-  /** Start offset in the searched sequence (inclusive). */
-  start: number;
-  /** End offset (exclusive); `end - start === length`. */
-  end: number;
-  /** Length of the matched pattern. */
-  length: number;
-  /** Pattern id, assigned in insertion order (0-based). */
-  id: number;
-  /** Payload registered with the pattern. */
-  payload: P;
-}
-export declare class Trie<P = undefined> {
-  private _nxt;
-  private _sym;
-  private _multi;
-  private _end;
-  private readonly _lens;
-  private readonly _vals;
-  private _len;
-  constructor();
-  /** The root state, for cursor walks. */
-  get root(): number;
-  /** Number of distinct patterns stored. */
-  get size(): number;
-  /** Allocate a fresh state, growing the typed arrays by a fixed increment
-   *  when full.  No power-of-2 doubling — the transient double-memory spike
-   *  during growth is bounded to the increment. */
-  private _state;
-  /** Follow symbol `c` from state `s`.  Returns the next state, or -1. */
-  private _follow;
-  /** Follow one symbol from `state`; returns the next state or -1 if none. */
-  step(state: number, symbol: number): number;
-  /** The pattern ending exactly at `state`, or null. */
-  terminal(state: number): {
+    /** Start offset in the searched sequence (inclusive). */
+    start: number;
+    /** End offset (exclusive); `end - start === length`. */
+    end: number;
+    /** Length of the matched pattern. */
+    length: number;
+    /** Pattern id, assigned in insertion order (0-based). */
     id: number;
+    /** Payload registered with the pattern. */
     payload: P;
-  } | null;
-  /** Length of the pattern with this id. */
-  lengthOf(id: number): number;
-  /**
-   * Insert a pattern, returning its id. Inserting the same symbol-sequence
-   * twice returns the first id and keeps the first payload (patterns are keyed
-   * by content). Empty patterns are ignored and return -1.
-   */
-  insert(pattern: ArrayLike<number>, payload: P): number;
-  /**
-   * Every stored pattern that begins exactly at `pos` in `seq`, shortest first.
-   * Walks forward from the root in O(longest match); reports nothing about any
-   * other position. This is the on-demand probe the search uses.
-   */
-  matchesAt(seq: ArrayLike<number>, pos: number): Array<Match<P>>;
-  /**
-   * Every occurrence of every pattern anywhere in `seq` (eager form, the union
-   * of {@link matchesAt} over all start positions). O(seq · longest pattern),
-   * independent of how many patterns are stored. Use {@link matchesAt} when the
-   * search only needs the sites at a particular position.
-   */
-  scan(seq: ArrayLike<number>): Array<Match<P>>;
+}
+export declare class Trie<P = undefined> {
+    private _nxt;
+    private _sym;
+    private _multi;
+    private _end;
+    private readonly _lens;
+    private readonly _vals;
+    private _len;
+    constructor();
+    /** The root state, for cursor walks. */
+    get root(): number;
+    /** Number of distinct patterns stored. */
+    get size(): number;
+    /** Allocate a fresh state, growing the typed arrays by a fixed increment
+     *  when full.  No power-of-2 doubling — the transient double-memory spike
+     *  during growth is bounded to the increment. */
+    private _state;
+    /** Follow symbol `c` from state `s`.  Returns the next state, or -1. */
+    private _follow;
+    /** Follow one symbol from `state`; returns the next state or -1 if none. */
+    step(state: number, symbol: number): number;
+    /** The pattern ending exactly at `state`, or null. */
+    terminal(state: number): {
+        id: number;
+        payload: P;
+    } | null;
+    /** Length of the pattern with this id. */
+    lengthOf(id: number): number;
+    /**
+     * Insert a pattern, returning its id. Inserting the same symbol-sequence
+     * twice returns the first id and keeps the first payload (patterns are keyed
+     * by content). Empty patterns are ignored and return -1.
+     */
+    insert(pattern: ArrayLike<number>, payload: P): number;
+    /**
+     * Every stored pattern that begins exactly at `pos` in `seq`, shortest first.
+     * Walks forward from the root in O(longest match); reports nothing about any
+     * other position. This is the on-demand probe the search uses.
+     */
+    matchesAt(seq: ArrayLike<number>, pos: number): Array<Match<P>>;
+    /**
+     * Every occurrence of every pattern anywhere in `seq` (eager form, the union
+     * of {@link matchesAt} over all start positions). O(seq · longest pattern),
+     * independent of how many patterns are stored. Use {@link matchesAt} when the
+     * search only needs the sites at a particular position.
+     */
+    scan(seq: ArrayLike<number>): Array<Match<P>>;
 }

package/dist/src/derive/src/trie.js

@@ -29,193 +29,189 @@
  */
 const ROOT = 0;
 export class Trie {
-  // ── compact transition storage ──────────────────────────────────────────
-  // _nxt[s]  —  -1   terminal (no outgoing transition)
-  //             -2   multi-transition → _multi.get(s)
-  //             >=0  singleton target; the symbol is _sym[s]
-  _nxt;
-  _sym;
-  _multi = null;
-  // _end[s] is the pattern id ending exactly at s, or -1.
-  _end;
-  // Per-pattern data, indexed by pattern id.
-  _lens = [];
-  _vals = [];
-  _len = 1; // next free state (state 0 = root)
-  constructor() {
-    const c = 256;
-    this._nxt = new Int32Array(c);
-    this._sym = new Uint8Array(c);
-    this._end = new Int32Array(c);
-    this._nxt[ROOT] = -1;
-    this._end[ROOT] = -1;
-  }
-  /** The root state, for cursor walks. */
-  get root() {
-    return ROOT;
-  }
-  /** Number of distinct patterns stored. */
-  get size() {
-    return this._lens.length;
-  }
-  // ── internal helpers ────────────────────────────────────────────────────
-  /** Allocate a fresh state, growing the typed arrays by a fixed increment
-   *  when full.  No power-of-2 doubling — the transient double-memory spike
-   *  during growth is bounded to the increment. */
-  _state() {
-    const s = this._len++;
-    if (s >= this._nxt.length) {
-      const c = s + 4096;
-      const nn = new Int32Array(c);
-      nn.set(this._nxt);
-      this._nxt = nn;
-      const ns = new Uint8Array(c);
-      ns.set(this._sym);
-      this._sym = ns;
-      const ne = new Int32Array(c);
-      ne.set(this._end);
-      this._end = ne;
+    // ── compact transition storage ──────────────────────────────────────────
+    // _nxt[s]  —  -1   terminal (no outgoing transition)
+    //             -2   multi-transition → _multi.get(s)
+    //             >=0  singleton target; the symbol is _sym[s]
+    _nxt;
+    _sym;
+    _multi = null;
+    // _end[s] is the pattern id ending exactly at s, or -1.
+    _end;
+    // Per-pattern data, indexed by pattern id.
+    _lens = [];
+    _vals = [];
+    _len = 1; // next free state (state 0 = root)
+    constructor() {
+        const c = 256;
+        this._nxt = new Int32Array(c);
+        this._sym = new Uint8Array(c);
+        this._end = new Int32Array(c);
+        this._nxt[ROOT] = -1;
+        this._end[ROOT] = -1;
     }
-    this._nxt[s] = -1;
-    this._end[s] = -1;
-    return s;
-  }
-  /** Follow symbol `c` from state `s`.  Returns the next state, or -1. */
-  _follow(s, c) {
-    const n = this._nxt[s];
-    if (n >= 0) {
-      return this._sym[s] === c ? n : -1;
+    /** The root state, for cursor walks. */
+    get root() {
+        return ROOT;
     }
-    if (n === -2) {
-      return this._multi.get(s).get(c) ?? -1;
+    /** Number of distinct patterns stored. */
+    get size() {
+        return this._lens.length;
     }
-    return -1; // n === -1
-  }
-  // ── cursor API (allocation-free) ─────────────────────────────────────────
-  /** Follow one symbol from `state`; returns the next state or -1 if none. */
-  step(state, symbol) {
-    return this._follow(state, symbol);
-  }
-  /** The pattern ending exactly at `state`, or null. */
-  terminal(state) {
-    const id = this._end[state];
-    return id === -1 ? null : { id, payload: this._vals[id] };
-  }
-  /** Length of the pattern with this id. */
-  lengthOf(id) {
-    return this._lens[id];
-  }
-  // ── build ───────────────────────────────────────────────────────────────
-  /**
-   * Insert a pattern, returning its id. Inserting the same symbol-sequence
-   * twice returns the first id and keeps the first payload (patterns are keyed
-   * by content). Empty patterns are ignored and return -1.
-   */
-  insert(pattern, payload) {
-    const n = pattern.length;
-    if (n === 0) {
-      return -1;
-    }
-    let s = ROOT;
-    for (let i = 0; i < n; i++) {
-      const c = pattern[i];
-      const t = this._nxt[s];
-      if (t === -1) {
-        // Terminal — place first transition as a singleton.
-        const ns = this._state();
-        this._nxt[s] = ns;
-        this._sym[s] = c;
-        s = ns;
-      } else if (t >= 0) {
-        // Singleton — either advance on match, or expand to multi.
-        if (this._sym[s] === c) {
-          s = t;
-        } else {
-          const map = new Map();
-          map.set(this._sym[s], t);
-          const ns = this._state();
-          map.set(c, ns);
-          if (!this._multi) {
-            this._multi = new Map();
-          }
-          this._multi.set(s, map);
-          this._nxt[s] = -2;
-          s = ns;
-        }
-      } else {
-        // Multi (t === -2) — extend the existing Map.
-        const map = this._multi.get(s);
-        let ns = map.get(c);
-        if (ns === undefined) {
-          ns = this._state();
-          map.set(c, ns);
+    // ── internal helpers ────────────────────────────────────────────────────
+    /** Allocate a fresh state, growing the typed arrays by a fixed increment
+     *  when full.  No power-of-2 doubling — the transient double-memory spike
+     *  during growth is bounded to the increment. */
+    _state() {
+        const s = this._len++;
+        if (s >= this._nxt.length) {
+            const c = s + 4096;
+            const nn = new Int32Array(c);
+            nn.set(this._nxt);
+            this._nxt = nn;
+            const ns = new Uint8Array(c);
+            ns.set(this._sym);
+            this._sym = ns;
+            const ne = new Int32Array(c);
+            ne.set(this._end);
+            this._end = ne;
         }
-        s = ns;
-      }
+        this._nxt[s] = -1;
+        this._end[s] = -1;
+        return s;
+    }
+    /** Follow symbol `c` from state `s`.  Returns the next state, or -1. */
+    _follow(s, c) {
+        const n = this._nxt[s];
+        if (n >= 0)
+            return this._sym[s] === c ? n : -1;
+        if (n === -2)
+            return this._multi.get(s).get(c) ?? -1;
+        return -1; // n === -1
+    }
+    // ── cursor API (allocation-free) ─────────────────────────────────────────
+    /** Follow one symbol from `state`; returns the next state or -1 if none. */
+    step(state, symbol) {
+        return this._follow(state, symbol);
     }
-    if (this._end[s] !== -1) {
-      return this._end[s]; // already present
+    /** The pattern ending exactly at `state`, or null. */
+    terminal(state) {
+        const id = this._end[state];
+        return id === -1 ? null : { id, payload: this._vals[id] };
     }
-    const id = this._lens.length;
-    this._lens.push(n);
-    this._vals.push(payload);
-    this._end[s] = id;
-    return id;
-  }
-  // ── matching ───────────────────────────────────────────────────────────
-  /**
-   * Every stored pattern that begins exactly at `pos` in `seq`, shortest first.
-   * Walks forward from the root in O(longest match); reports nothing about any
-   * other position. This is the on-demand probe the search uses.
-   */
-  matchesAt(seq, pos) {
-    const out = [];
-    let s = ROOT;
-    for (let i = pos, n = seq.length; i < n; i++) {
-      s = this._follow(s, seq[i]);
-      if (s === -1) {
-        break;
-      }
-      const id = this._end[s];
-      if (id !== -1) {
-        out.push({
-          start: pos,
-          end: i + 1,
-          length: this._lens[id],
-          id,
-          payload: this._vals[id],
-        });
-      }
+    /** Length of the pattern with this id. */
+    lengthOf(id) {
+        return this._lens[id];
     }
-    return out;
-  }
-  /**
-   * Every occurrence of every pattern anywhere in `seq` (eager form, the union
-   * of {@link matchesAt} over all start positions). O(seq · longest pattern),
-   * independent of how many patterns are stored. Use {@link matchesAt} when the
-   * search only needs the sites at a particular position.
-   */
-  scan(seq) {
-    const out = [];
-    for (let pos = 0, n = seq.length; pos < n; pos++) {
-      let s = ROOT;
-      for (let i = pos; i < n; i++) {
-        s = this._follow(s, seq[i]);
-        if (s === -1) {
-          break;
+    // ── build ───────────────────────────────────────────────────────────────
+    /**
+     * Insert a pattern, returning its id. Inserting the same symbol-sequence
+     * twice returns the first id and keeps the first payload (patterns are keyed
+     * by content). Empty patterns are ignored and return -1.
+     */
+    insert(pattern, payload) {
+        const n = pattern.length;
+        if (n === 0)
+            return -1;
+        let s = ROOT;
+        for (let i = 0; i < n; i++) {
+            const c = pattern[i];
+            const t = this._nxt[s];
+            if (t === -1) {
+                // Terminal — place first transition as a singleton.
+                const ns = this._state();
+                this._nxt[s] = ns;
+                this._sym[s] = c;
+                s = ns;
+            }
+            else if (t >= 0) {
+                // Singleton — either advance on match, or expand to multi.
+                if (this._sym[s] === c) {
+                    s = t;
+                }
+                else {
+                    const map = new Map();
+                    map.set(this._sym[s], t);
+                    const ns = this._state();
+                    map.set(c, ns);
+                    if (!this._multi)
+                        this._multi = new Map();
+                    this._multi.set(s, map);
+                    this._nxt[s] = -2;
+                    s = ns;
+                }
+            }
+            else {
+                // Multi (t === -2) — extend the existing Map.
+                const map = this._multi.get(s);
+                let ns = map.get(c);
+                if (ns === undefined) {
+                    ns = this._state();
+                    map.set(c, ns);
+                }
+                s = ns;
+            }
         }
-        const id = this._end[s];
-        if (id !== -1) {
-          out.push({
-            start: pos,
-            end: i + 1,
-            length: this._lens[id],
-            id,
-            payload: this._vals[id],
-          });
+        if (this._end[s] !== -1)
+            return this._end[s]; // already present
+        const id = this._lens.length;
+        this._lens.push(n);
+        this._vals.push(payload);
+        this._end[s] = id;
+        return id;
+    }
+    // ── matching ───────────────────────────────────────────────────────────
+    /**
+     * Every stored pattern that begins exactly at `pos` in `seq`, shortest first.
+     * Walks forward from the root in O(longest match); reports nothing about any
+     * other position. This is the on-demand probe the search uses.
+     */
+    matchesAt(seq, pos) {
+        const out = [];
+        let s = ROOT;
+        for (let i = pos, n = seq.length; i < n; i++) {
+            s = this._follow(s, seq[i]);
+            if (s === -1)
+                break;
+            const id = this._end[s];
+            if (id !== -1) {
+                out.push({
+                    start: pos,
+                    end: i + 1,
+                    length: this._lens[id],
+                    id,
+                    payload: this._vals[id],
+                });
+            }
+        }
+        return out;
+    }
+    /**
+     * Every occurrence of every pattern anywhere in `seq` (eager form, the union
+     * of {@link matchesAt} over all start positions). O(seq · longest pattern),
+     * independent of how many patterns are stored. Use {@link matchesAt} when the
+     * search only needs the sites at a particular position.
+     */
+    scan(seq) {
+        const out = [];
+        for (let pos = 0, n = seq.length; pos < n; pos++) {
+            let s = ROOT;
+            for (let i = pos; i < n; i++) {
+                s = this._follow(s, seq[i]);
+                if (s === -1)
+                    break;
+                const id = this._end[s];
+                if (id !== -1) {
+                    out.push({
+                        start: pos,
+                        end: i + 1,
+                        length: this._lens[id],
+                        id,
+                        payload: this._vals[id],
+                    });
+                }
+            }
         }
-      }
+        return out;
     }
-    return out;
-  }
 }