@hviana/sema 0.1.4 → 0.1.5

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

@@ -43,83 +43,85 @@
  * derives `conclusion` at an additional `cost`.
  */
 export interface Rule<I> {
-    premises: readonly I[];
-    conclusion: I;
-    /** Local (edge) cost added on top of the premises' costs. Non-negative. */
-    cost: number;
-    /** The combinator this rule's firing uses at its conclusion:
-     *   • `"min"` (default, omitted) — Knuth/A* proper: the conclusion's cost is
-     *     the CHEAPEST of any rule that reaches it, every other route discarded.
-     *     The shortest-path monoid (min, +) that makes the search admissible and
-     *     output-sensitive.
-     *   • `"sum"` — evidence pooling: EVERY firing of a sum rule contributes its
-     *     cost to the SAME conclusion (accumulated in {@link
-     *     DeductionSystem.pool}), instead of competing to be the one cheapest
-     *     route.  The (+, +) monoid a consensus vote needs — several
-     *     independent premises corroborating one conclusion — kept deliberately
-     *     OUT of the min-cost chart: a pooled conclusion is never relaxed into
-     *     `g`, never enters the agenda, and is never itself a premise — it is a
-     *     terminal aggregate the caller reads out of `pool` once the search is
-     *     done. */
-    combine?: "min" | "sum";
+  premises: readonly I[];
+  conclusion: I;
+  /** Local (edge) cost added on top of the premises' costs. Non-negative. */
+  cost: number;
+  /** The combinator this rule's firing uses at its conclusion:
+   *   • `"min"` (default, omitted) — Knuth/A* proper: the conclusion's cost is
+   *     the CHEAPEST of any rule that reaches it, every other route discarded.
+   *     The shortest-path monoid (min, +) that makes the search admissible and
+   *     output-sensitive.
+   *   • `"sum"` — evidence pooling: EVERY firing of a sum rule contributes its
+   *     cost to the SAME conclusion (accumulated in {@link
+   *     DeductionSystem.pool}), instead of competing to be the one cheapest
+   *     route.  The (+, +) monoid a consensus vote needs — several
+   *     independent premises corroborating one conclusion — kept deliberately
+   *     OUT of the min-cost chart: a pooled conclusion is never relaxed into
+   *     `g`, never enters the agenda, and is never itself a premise — it is a
+   *     terminal aggregate the caller reads out of `pool` once the search is
+   *     done. */
+  combine?: "min" | "sum";
 }
 /** One rule's contribution to a pooled (`combine: "sum"`) conclusion — the
  *  firing rule and the already-finalised derivations of its premises, so a
  *  caller can render each contribution exactly as it would a min-cost step. */
 export interface PooledContribution<I> {
-    rule: Rule<I>;
-    premises: Array<Derivation<I>>;
+  rule: Rule<I>;
+  premises: Array<Derivation<I>>;
 }
 /** The running aggregate at one pooled conclusion: every sum-mode rule that
  *  has fired for it, accumulated. */
 export interface PooledConclusion<I> {
-    item: I;
-    cost: number;
-    contributions: Array<PooledContribution<I>>;
+  item: I;
+  cost: number;
+  contributions: Array<PooledContribution<I>>;
 }
 /** The problem the solver is given: items, rules, a goal, and a heuristic. */
 export interface DeductionSystem<I> {
-    /** Canonical key for chart memoization (the item's boundary signature). */
-    key(item: I): string;
-    /** Axioms: the atomic items and their base costs (the search's seeds). */
-    axioms(): Iterable<{
-        item: I;
-        cost: number;
-    }>;
-    /**
-     * Lazily generate the demanded rules that have `item` among their premises.
-     * Called once, when `item` is finalised. `costOf` returns the finalised cost
-     * of any item (Infinity if not yet known) — use it for backward-demand /
-     * boundary filtering, e.g. drop a rule whose other premises are still open or
-     * whose conclusion can no longer beat the best goal.
-     */
-    rules(item: I, costOf: (other: I) => number): Iterable<Rule<I>>;
-    /** Whether `item` satisfies the goal. The first finalised goal wins. */
-    isGoal(item: I): boolean;
-    /** Admissible, consistent lower bound on the cost from `item` to a goal. */
-    heuristic?(item: I): number;
-    /** Present only on a system that fires `combine: "sum"` rules — supplied
-     *  empty, populated in place as the search runs, read back once it returns
-     *  (typically `null`: a pooling system has no goal to reach, it exhausts its
-     *  axioms instead — see {@link lightestDerivation}).  Absent on every
-     *  ordinary min-cost system, which is what keeps pooling a zero-cost opt-in:
-     *  `relax` only takes the pooling branch when a rule declares `combine:
-     *  "sum"` AND this map is present. */
-    pool?: Map<string, PooledConclusion<I>>;
+  /** Canonical key for chart memoization (the item's boundary signature). */
+  key(item: I): string;
+  /** Axioms: the atomic items and their base costs (the search's seeds). */
+  axioms(): Iterable<{
+    item: I;
+    cost: number;
+  }>;
+  /**
+   * Lazily generate the demanded rules that have `item` among their premises.
+   * Called once, when `item` is finalised. `costOf` returns the finalised cost
+   * of any item (Infinity if not yet known) — use it for backward-demand /
+   * boundary filtering, e.g. drop a rule whose other premises are still open or
+   * whose conclusion can no longer beat the best goal.
+   */
+  rules(item: I, costOf: (other: I) => number): Iterable<Rule<I>>;
+  /** Whether `item` satisfies the goal. The first finalised goal wins. */
+  isGoal(item: I): boolean;
+  /** Admissible, consistent lower bound on the cost from `item` to a goal. */
+  heuristic?(item: I): number;
+  /** Present only on a system that fires `combine: "sum"` rules — supplied
+   *  empty, populated in place as the search runs, read back once it returns
+   *  (typically `null`: a pooling system has no goal to reach, it exhausts its
+   *  axioms instead — see {@link lightestDerivation}).  Absent on every
+   *  ordinary min-cost system, which is what keeps pooling a zero-cost opt-in:
+   *  `relax` only takes the pooling branch when a rule declares `combine:
+   *  "sum"` AND this map is present. */
+  pool?: Map<string, PooledConclusion<I>>;
 }
 /** A node of the reconstructed derivation tree. */
 export interface Derivation<I> {
-    /** The derived item. */
-    item: I;
-    /** This item's minimum derivation cost (its g value). */
-    cost: number;
-    /** The rule that produced it, or null if it is an axiom. */
-    rule: Rule<I> | null;
-    /** Derivations of the rule's premises (empty for an axiom). */
-    premises: Array<Derivation<I>>;
+  /** The derived item. */
+  item: I;
+  /** This item's minimum derivation cost (its g value). */
+  cost: number;
+  /** The rule that produced it, or null if it is an axiom. */
+  rule: Rule<I> | null;
+  /** Derivations of the rule's premises (empty for an axiom). */
+  premises: Array<Derivation<I>>;
 }
 /**
  * Find a lightest derivation of a goal item, or `null` if none exists.
  * `cost` on the returned root is the total derivation cost.
  */
-export declare function lightestDerivation<I>(system: DeductionSystem<I>): Derivation<I> | null;
+export declare function lightestDerivation<I>(
+  system: DeductionSystem<I>,
+): Derivation<I> | null;

package/dist/src/derive/src/deduction.js

@@ -44,112 +44,118 @@ import { MinHeap } from "./priority-queue.js";
  * `cost` on the returned root is the total derivation cost.
  */
 export function lightestDerivation(system) {
-    const g = new Map(); // best known cost per item
-    const proof = new Map(); // producing rule per item
-    const items = new Map(); // key → the item it stands for
-    const hCache = new Map();
-    const agenda = new MinHeap();
-    const heuristic = system.heuristic;
-    const h = (item, key) => {
-        if (!heuristic)
-            return 0;
-        let v = hCache.get(key);
-        if (v === undefined) {
-            v = heuristic(item);
-            hCache.set(key, v);
-        }
-        return v;
-    };
-    const costOf = (item) => g.get(system.key(item)) ?? Infinity;
-    const relax = (item, cost, rule) => {
-        const key = system.key(item);
-        if (rule?.combine === "sum" && system.pool) {
-            // Evidence pooling: accumulate this firing rather than compete for the
-            // cheapest — see {@link Rule.combine}.  The premises are already
-            // finalised (the caller only relaxes a rule once every premise's cost
-            // is known), so their derivations can be read back immediately.
-            const premises = rule.premises.map((p) => reconstruct(p, system, g, proof));
-            const prior = system.pool.get(key);
-            system.pool.set(key, {
-                item,
-                cost: (prior?.cost ?? 0) + cost,
-                contributions: [...(prior?.contributions ?? []), { rule, premises }],
-            });
-            return;
-        }
-        const current = g.get(key);
-        if (current === undefined || cost < current) {
-            g.set(key, cost);
-            proof.set(key, rule);
-            items.set(key, item);
-            agenda.push(cost + h(item, key), { key, g: cost });
-        }
-    };
-    for (const { item, cost } of system.axioms())
-        relax(item, cost, null);
-    while (agenda.size > 0) {
-        const { value } = agenda.pop();
-        const key = value.key;
-        // Lazy deletion: an entry is stale if a cheaper derivation has since been
-        // recorded for the same item.
-        if (value.g !== g.get(key))
-            continue;
-        const item = items.get(key);
-        if (system.isGoal(item)) {
-            return reconstruct(item, system, g, proof);
-        }
-        for (const rule of system.rules(item, costOf)) {
-            let sum = rule.cost;
-            let ready = true;
-            for (const p of rule.premises) {
-                const pc = g.get(system.key(p));
-                if (pc === undefined) {
-                    ready = false;
-                    break;
-                }
-                sum += pc;
-            }
-            if (ready)
-                relax(rule.conclusion, sum, rule);
+  const g = new Map(); // best known cost per item
+  const proof = new Map(); // producing rule per item
+  const items = new Map(); // key → the item it stands for
+  const hCache = new Map();
+  const agenda = new MinHeap();
+  const heuristic = system.heuristic;
+  const h = (item, key) => {
+    if (!heuristic) {
+      return 0;
+    }
+    let v = hCache.get(key);
+    if (v === undefined) {
+      v = heuristic(item);
+      hCache.set(key, v);
+    }
+    return v;
+  };
+  const costOf = (item) => g.get(system.key(item)) ?? Infinity;
+  const relax = (item, cost, rule) => {
+    const key = system.key(item);
+    if (rule?.combine === "sum" && system.pool) {
+      // Evidence pooling: accumulate this firing rather than compete for the
+      // cheapest — see {@link Rule.combine}.  The premises are already
+      // finalised (the caller only relaxes a rule once every premise's cost
+      // is known), so their derivations can be read back immediately.
+      const premises = rule.premises.map((p) =>
+        reconstruct(p, system, g, proof)
+      );
+      const prior = system.pool.get(key);
+      system.pool.set(key, {
+        item,
+        cost: (prior?.cost ?? 0) + cost,
+        contributions: [...(prior?.contributions ?? []), { rule, premises }],
+      });
+      return;
+    }
+    const current = g.get(key);
+    if (current === undefined || cost < current) {
+      g.set(key, cost);
+      proof.set(key, rule);
+      items.set(key, item);
+      agenda.push(cost + h(item, key), { key, g: cost });
+    }
+  };
+  for (const { item, cost } of system.axioms()) {
+    relax(item, cost, null);
+  }
+  while (agenda.size > 0) {
+    const { value } = agenda.pop();
+    const key = value.key;
+    // Lazy deletion: an entry is stale if a cheaper derivation has since been
+    // recorded for the same item.
+    if (value.g !== g.get(key)) {
+      continue;
+    }
+    const item = items.get(key);
+    if (system.isGoal(item)) {
+      return reconstruct(item, system, g, proof);
+    }
+    for (const rule of system.rules(item, costOf)) {
+      let sum = rule.cost;
+      let ready = true;
+      for (const p of rule.premises) {
+        const pc = g.get(system.key(p));
+        if (pc === undefined) {
+          ready = false;
+          break;
         }
+        sum += pc;
+      }
+      if (ready) {
+        relax(rule.conclusion, sum, rule);
+      }
     }
-    return null;
+  }
+  return null;
 }
 function reconstruct(item, system, g, proof) {
-    // Iterative post-order over the derivation hypergraph.  In the rewrite
-    // search every rule has one premise, so the derivation is a chain whose
-    // length equals the number of frontier edges — which, with long inputs,
-    // can exceed the call stack.  Multi-premise rules (the test-suite bridge
-    // case) are handled by the same explicit stack.
-    const done = new Map();
-    const stack = [item];
-    while (stack.length > 0) {
-        const cur = stack[stack.length - 1]; // peek
-        const key = system.key(cur);
-        if (done.has(key)) {
-            stack.pop();
-            continue;
-        }
-        const rule = proof.get(key) ?? null;
-        const premises = rule?.premises ?? [];
-        // Push any unresolved premises (rightmost first → leftmost resolves first).
-        let pending = false;
-        for (let i = premises.length - 1; i >= 0; i--) {
-            if (!done.has(system.key(premises[i]))) {
-                stack.push(premises[i]);
-                pending = true;
-            }
-        }
-        if (!pending) {
-            stack.pop(); // this item
-            const kids = premises.map((p) => done.get(system.key(p)));
-            done.set(key, {
-                item: cur,
-                cost: g.get(key),
-                rule,
-                premises: kids,
-            });
-        }
+  // Iterative post-order over the derivation hypergraph.  In the rewrite
+  // search every rule has one premise, so the derivation is a chain whose
+  // length equals the number of frontier edges — which, with long inputs,
+  // can exceed the call stack.  Multi-premise rules (the test-suite bridge
+  // case) are handled by the same explicit stack.
+  const done = new Map();
+  const stack = [item];
+  while (stack.length > 0) {
+    const cur = stack[stack.length - 1]; // peek
+    const key = system.key(cur);
+    if (done.has(key)) {
+      stack.pop();
+      continue;
+    }
+    const rule = proof.get(key) ?? null;
+    const premises = rule?.premises ?? [];
+    // Push any unresolved premises (rightmost first → leftmost resolves first).
+    let pending = false;
+    for (let i = premises.length - 1; i >= 0; i--) {
+      if (!done.has(system.key(premises[i]))) {
+        stack.push(premises[i]);
+        pending = true;
+      }
+    }
+    if (!pending) {
+      stack.pop(); // this item
+      const kids = premises.map((p) => done.get(system.key(p)));
+      done.set(key, {
+        item: cur,
+        cost: g.get(key),
+        rule,
+        premises: kids,
+      });
     }
-    return done.get(system.key(item));
+  }
+  return done.get(system.key(item));
 }

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

@@ -1,5 +1,11 @@
 export { lightestDerivation } from "./deduction.js";
-export type { DeductionSystem, Derivation, PooledConclusion, PooledContribution, Rule, } from "./deduction.js";
+export type {
+  DeductionSystem,
+  Derivation,
+  PooledConclusion,
+  PooledContribution,
+  Rule,
+} from "./deduction.js";
 export { coverSequence } from "./rewrite.js";
 export type { CandidateSpan, Cover } from "./rewrite.js";
 export { Trie } from "./trie.js";

package/dist/src/derive/src/priority-queue.d.ts

@@ -9,12 +9,12 @@
  * of objects) keep the hot path allocation-free.
  */
 export declare class MinHeap<T> {
-    private readonly keys;
-    private readonly vals;
-    get size(): number;
-    push(priority: number, value: T): void;
-    pop(): {
-        priority: number;
-        value: T;
-    } | undefined;
+  private readonly keys;
+  private readonly vals;
+  get size(): number;
+  push(priority: number, value: T): void;
+  pop(): {
+    priority: number;
+    value: T;
+  } | undefined;
 }

package/dist/src/derive/src/priority-queue.js

@@ -9,65 +9,69 @@
  * of objects) keep the hot path allocation-free.
  */
 export class MinHeap {
-    keys = [];
-    vals = [];
-    get size() {
-        return this.keys.length;
+  keys = [];
+  vals = [];
+  get size() {
+    return this.keys.length;
+  }
+  push(priority, value) {
+    const keys = this.keys;
+    const vals = this.vals;
+    let i = keys.length;
+    keys.push(priority);
+    vals.push(value);
+    while (i > 0) {
+      const parent = (i - 1) >> 1;
+      if (keys[i] < keys[parent]) {
+        const tk = keys[i];
+        keys[i] = keys[parent];
+        keys[parent] = tk;
+        const tv = vals[i];
+        vals[i] = vals[parent];
+        vals[parent] = tv;
+        i = parent;
+      } else {
+        break;
+      }
     }
-    push(priority, value) {
-        const keys = this.keys;
-        const vals = this.vals;
-        let i = keys.length;
-        keys.push(priority);
-        vals.push(value);
-        while (i > 0) {
-            const parent = (i - 1) >> 1;
-            if (keys[i] < keys[parent]) {
-                const tk = keys[i];
-                keys[i] = keys[parent];
-                keys[parent] = tk;
-                const tv = vals[i];
-                vals[i] = vals[parent];
-                vals[parent] = tv;
-                i = parent;
-            }
-            else
-                break;
-        }
+  }
+  pop() {
+    const keys = this.keys;
+    const vals = this.vals;
+    const n = keys.length;
+    if (n === 0) {
+      return undefined;
     }
-    pop() {
-        const keys = this.keys;
-        const vals = this.vals;
-        const n = keys.length;
-        if (n === 0)
-            return undefined;
-        const top = { priority: keys[0], value: vals[0] };
-        const lastKey = keys.pop();
-        const lastVal = vals.pop();
-        const m = keys.length;
-        if (m > 0) {
-            keys[0] = lastKey;
-            vals[0] = lastVal;
-            let i = 0;
-            for (;;) {
-                const left = 2 * i + 1;
-                const right = left + 1;
-                let best = i;
-                if (left < m && keys[left] < keys[best])
-                    best = left;
-                if (right < m && keys[right] < keys[best])
-                    best = right;
-                if (best === i)
-                    break;
-                const tk = keys[i];
-                keys[i] = keys[best];
-                keys[best] = tk;
-                const tv = vals[i];
-                vals[i] = vals[best];
-                vals[best] = tv;
-                i = best;
-            }
+    const top = { priority: keys[0], value: vals[0] };
+    const lastKey = keys.pop();
+    const lastVal = vals.pop();
+    const m = keys.length;
+    if (m > 0) {
+      keys[0] = lastKey;
+      vals[0] = lastVal;
+      let i = 0;
+      for (;;) {
+        const left = 2 * i + 1;
+        const right = left + 1;
+        let best = i;
+        if (left < m && keys[left] < keys[best]) {
+          best = left;
+        }
+        if (right < m && keys[right] < keys[best]) {
+          best = right;
+        }
+        if (best === i) {
+          break;
         }
-        return top;
+        const tk = keys[i];
+        keys[i] = keys[best];
+        keys[best] = tk;
+        const tv = vals[i];
+        vals[i] = vals[best];
+        vals[best] = tv;
+        i = best;
+      }
     }
+    return top;
+  }
 }

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

@@ -21,22 +21,22 @@
  */
 /** A candidate span over a sequence, carrying caller payload. */
 export interface CandidateSpan<P> {
-    /** Start offset (inclusive). */
-    start: number;
-    /** End offset (exclusive); must be > start. */
-    end: number;
-    /** Relative cost of using this span (default 1). Lower wins ties. */
-    weight?: number;
-    /** Caller data, returned on the chosen spans. */
-    payload: P;
+  /** Start offset (inclusive). */
+  start: number;
+  /** End offset (exclusive); must be > start. */
+  end: number;
+  /** Relative cost of using this span (default 1). Lower wins ties. */
+  weight?: number;
+  /** Caller data, returned on the chosen spans. */
+  payload: P;
 }
 export interface Cover<P> {
-    /** Chosen non-overlapping spans, left to right. */
-    spans: Array<CandidateSpan<P>>;
-    /** Symbols covered by the chosen spans. */
-    covered: number;
-    /** Symbols left uncovered. */
-    uncovered: number;
+  /** Chosen non-overlapping spans, left to right. */
+  spans: Array<CandidateSpan<P>>;
+  /** Symbols covered by the chosen spans. */
+  covered: number;
+  /** Symbols left uncovered. */
+  uncovered: number;
 }
 /**
  * The lightest non-overlapping cover of `[0, length)` drawn from `candidates`.
@@ -53,4 +53,7 @@ export interface Cover<P> {
  * items, each finalised once, with one "skip" edge plus the candidates that
  * start there. No quadratic span structure.
  */
-export declare function coverSequence<P>(length: number, candidates: ReadonlyArray<CandidateSpan<P>>): Cover<P>;
+export declare function coverSequence<P>(
+  length: number,
+  candidates: ReadonlyArray<CandidateSpan<P>>,
+): Cover<P>;