@hviana/sema 0.1.3 → 0.1.5

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

@@ -36,65 +36,73 @@ 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;
-        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);
+  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;
     }
-    // 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];
+    const w = c.weight ?? 1;
+    if (w > maxWeight) {
+      maxWeight = w;
     }
-    spans.reverse();
-    let covered = 0;
-    for (const s of spans)
-        covered += s.end - s.start;
-    return { spans, covered, uncovered: length - covered };
+    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 };
 }

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;
+  /** 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): {
-        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>>;
+  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,189 +29,193 @@
  */
 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;
+  // ── 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;
     }
-    /** The root state, for cursor walks. */
-    get root() {
-        return ROOT;
+    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;
     }
-    /** Number of distinct patterns stored. */
-    get size() {
-        return this._lens.length;
+    if (n === -2) {
+      return this._multi.get(s).get(c) ?? -1;
     }
-    // ── 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;
-        }
-        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
+    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;
     }
-    // ── 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] };
+    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;
+      }
     }
-    /** Length of the pattern with this id. */
-    lengthOf(id) {
-        return this._lens[id];
+    if (this._end[s] !== -1) {
+      return this._end[s]; // already present
     }
-    // ── 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;
-            }
-        }
-        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;
+    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],
+        });
+      }
     }
-    // ── 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;
         }
-        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],
-                    });
-                }
-            }
+        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;
+  }
 }