@hviana/sema 0.1.5 → 0.1.6

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

@@ -43,85 +43,83 @@
  * 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,118 +44,112 @@ 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;
+    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);
         }
-        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,11 +1,5 @@
 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,69 +9,65 @@
  * of objects) keep the hot path allocation-free.
  */
 export class MinHeap {
-  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;
-      }
+    keys = [];
+    vals = [];
+    get size() {
+        return this.keys.length;
     }
-  }
-  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;
+    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;
         }
-        if (best === i) {
-          break;
+    }
+    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 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;
     }
-    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,7 +53,4 @@ 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>;