@hviana/sema 0.1.4 → 0.1.5

package/dist/src/derive/test/derive.test.js

@@ -3,120 +3,124 @@
 // and the optimal cover. Uses node:test; no dependency on sema.
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { coverSequence, lightestDerivation, Trie, } from "../src/index.js";
+import { coverSequence, lightestDerivation, Trie } from "../src/index.js";
 // ── trie: on-demand matching, no length bound ──────────────────────────────
 test("trie matchesAt reports forms beginning exactly at a position", () => {
-    const t = new Trie();
-    t.insert([1, 2], "ab");
-    t.insert([1, 2, 3], "abc");
-    t.insert([2, 3], "bc");
-    const at0 = t.matchesAt([1, 2, 3, 4], 0).map((m) => m.payload);
-    assert.deepEqual(at0, ["ab", "abc"]); // both forms starting at 0, shortest first
-    const at1 = t.matchesAt([1, 2, 3, 4], 1).map((m) => m.payload);
-    assert.deepEqual(at1, ["bc"]);
-    const at3 = t.matchesAt([1, 2, 3, 4], 3).map((m) => m.payload);
-    assert.deepEqual(at3, []); // nothing learned here → dead-ends immediately
+  const t = new Trie();
+  t.insert([1, 2], "ab");
+  t.insert([1, 2, 3], "abc");
+  t.insert([2, 3], "bc");
+  const at0 = t.matchesAt([1, 2, 3, 4], 0).map((m) => m.payload);
+  assert.deepEqual(at0, ["ab", "abc"]); // both forms starting at 0, shortest first
+  const at1 = t.matchesAt([1, 2, 3, 4], 1).map((m) => m.payload);
+  assert.deepEqual(at1, ["bc"]);
+  const at3 = t.matchesAt([1, 2, 3, 4], 3).map((m) => m.payload);
+  assert.deepEqual(at3, []); // nothing learned here → dead-ends immediately
 });
 test("trie scan finds every occurrence; duplicate inserts share an id", () => {
-    const t = new Trie();
-    const id1 = t.insert([7, 7], 1);
-    const id2 = t.insert([7, 7], 2); // same content
-    assert.equal(id1, id2);
-    assert.equal(t.size, 1);
-    const hits = t.scan([7, 7, 7]);
-    assert.equal(hits.length, 2); // [0,2) and [1,3)
+  const t = new Trie();
+  const id1 = t.insert([7, 7], 1);
+  const id2 = t.insert([7, 7], 2); // same content
+  assert.equal(id1, id2);
+  assert.equal(t.size, 1);
+  const hits = t.scan([7, 7, 7]);
+  assert.equal(hits.length, 2); // [0,2) and [1,3)
 });
 // ── engine: Dijkstra/Knuth core with a bridge (multi-premise) rule ─────────
 test("lightestDerivation solves a hypergraph with a bridge premise", () => {
-    // Items: "A", "B", "AB". Axioms A (3) and B (4). A binary bridge A ∧ B → AB
-    // at cost 1. The only derivation of AB costs 3 + 4 + 1 = 8.
-    const A = "A", B = "B", AB = "AB";
-    const system = {
-        key: (s) => s,
-        axioms: () => [{ item: A, cost: 3 }, { item: B, cost: 4 }],
-        isGoal: (s) => s === AB,
-        *rules(item) {
-            // Bridge fires from either premise; the engine waits until both are known.
-            if (item === A)
-                yield { premises: [A, B], conclusion: AB, cost: 1 };
-            if (item === B)
-                yield { premises: [A, B], conclusion: AB, cost: 1 };
-        },
-    };
-    const d = lightestDerivation(system);
-    assert.ok(d);
-    assert.equal(d.item, AB);
-    assert.equal(d.cost, 8);
-    assert.equal(d.premises.length, 2); // it really used the bridge
+  // Items: "A", "B", "AB". Axioms A (3) and B (4). A binary bridge A ∧ B → AB
+  // at cost 1. The only derivation of AB costs 3 + 4 + 1 = 8.
+  const A = "A", B = "B", AB = "AB";
+  const system = {
+    key: (s) => s,
+    axioms: () => [{ item: A, cost: 3 }, { item: B, cost: 4 }],
+    isGoal: (s) => s === AB,
+    *rules(item) {
+      // Bridge fires from either premise; the engine waits until both are known.
+      if (item === A) {
+        yield { premises: [A, B], conclusion: AB, cost: 1 };
+      }
+      if (item === B) {
+        yield { premises: [A, B], conclusion: AB, cost: 1 };
+      }
+    },
+  };
+  const d = lightestDerivation(system);
+  assert.ok(d);
+  assert.equal(d.item, AB);
+  assert.equal(d.cost, 8);
+  assert.equal(d.premises.length, 2); // it really used the bridge
 });
 test("lightestDerivation picks the cheaper of competing derivations", () => {
-    // Two ways to reach the goal G from axiom S: S→G cost 10, or S→M→G cost 3+3.
-    const system = {
-        key: (s) => s,
-        axioms: () => [{ item: "S", cost: 0 }],
-        isGoal: (s) => s === "G",
-        *rules(item) {
-            if (item === "S") {
-                yield { premises: ["S"], conclusion: "G", cost: 10 };
-                yield { premises: ["S"], conclusion: "M", cost: 3 };
-            }
-            if (item === "M")
-                yield { premises: ["M"], conclusion: "G", cost: 3 };
-        },
-    };
-    const d = lightestDerivation(system);
-    assert.ok(d);
-    assert.equal(d.cost, 6); // via M, not the direct 10
-    assert.equal(d.rule?.premises[0], "M");
+  // Two ways to reach the goal G from axiom S: S→G cost 10, or S→M→G cost 3+3.
+  const system = {
+    key: (s) => s,
+    axioms: () => [{ item: "S", cost: 0 }],
+    isGoal: (s) => s === "G",
+    *rules(item) {
+      if (item === "S") {
+        yield { premises: ["S"], conclusion: "G", cost: 10 };
+        yield { premises: ["S"], conclusion: "M", cost: 3 };
+      }
+      if (item === "M") {
+        yield { premises: ["M"], conclusion: "G", cost: 3 };
+      }
+    },
+  };
+  const d = lightestDerivation(system);
+  assert.ok(d);
+  assert.equal(d.cost, 6); // via M, not the direct 10
+  assert.equal(d.rule?.premises[0], "M");
 });
 test("lightestDerivation returns null when the goal is unreachable", () => {
-    const system = {
-        key: (n) => "" + n,
-        axioms: () => [{ item: 0, cost: 0 }],
-        isGoal: (n) => n === 99,
-        *rules(n) {
-            if (n < 3)
-                yield { premises: [n], conclusion: n + 1, cost: 1 };
-        },
-    };
-    assert.equal(lightestDerivation(system), null);
+  const system = {
+    key: (n) => "" + n,
+    axioms: () => [{ item: 0, cost: 0 }],
+    isGoal: (n) => n === 99,
+    *rules(n) {
+      if (n < 3) {
+        yield { premises: [n], conclusion: n + 1, cost: 1 };
+      }
+    },
+  };
+  assert.equal(lightestDerivation(system), null);
 });
 // ── cover: optimal, not greedy ─────────────────────────────────────────────
 test("coverSequence maximises coverage, beating greedy longest-match", () => {
-    // Over [0,4): one long span [1,4) (len 3) vs two short [0,2),[2,4) (cover 4).
-    // Greedy-longest takes [1,4) and covers 3; the optimal cover takes the pair.
-    const cover = coverSequence(4, [
-        { start: 1, end: 4, payload: "long" },
-        { start: 0, end: 2, payload: "left" },
-        { start: 2, end: 4, payload: "right" },
-    ]);
-    assert.equal(cover.covered, 4);
-    assert.equal(cover.uncovered, 0);
-    assert.deepEqual(cover.spans.map((s) => s.payload), ["left", "right"]);
+  // Over [0,4): one long span [1,4) (len 3) vs two short [0,2),[2,4) (cover 4).
+  // Greedy-longest takes [1,4) and covers 3; the optimal cover takes the pair.
+  const cover = coverSequence(4, [
+    { start: 1, end: 4, payload: "long" },
+    { start: 0, end: 2, payload: "left" },
+    { start: 2, end: 4, payload: "right" },
+  ]);
+  assert.equal(cover.covered, 4);
+  assert.equal(cover.uncovered, 0);
+  assert.deepEqual(cover.spans.map((s) => s.payload), ["left", "right"]);
 });
 test("coverSequence prefers fewer, longer spans on ties (unit weight)", () => {
-    // [0,3) covers the same as [0,1)+[1,3) but in one span → preferred.
-    const cover = coverSequence(3, [
-        { start: 0, end: 3, payload: "whole" },
-        { start: 0, end: 1, payload: "a" },
-        { start: 1, end: 3, payload: "b" },
-    ]);
-    assert.deepEqual(cover.spans.map((s) => s.payload), ["whole"]);
+  // [0,3) covers the same as [0,1)+[1,3) but in one span → preferred.
+  const cover = coverSequence(3, [
+    { start: 0, end: 3, payload: "whole" },
+    { start: 0, end: 1, payload: "a" },
+    { start: 1, end: 3, payload: "b" },
+  ]);
+  assert.deepEqual(cover.spans.map((s) => s.payload), ["whole"]);
 });
 test("coverSequence leaves genuinely uncovered gaps uncovered", () => {
-    const cover = coverSequence(10, [
-        { start: 0, end: 3, payload: "x" },
-        { start: 6, end: 9, payload: "y" },
-    ]);
-    assert.equal(cover.covered, 6);
-    assert.equal(cover.uncovered, 4);
-    assert.deepEqual(cover.spans.map((s) => s.payload), ["x", "y"]);
+  const cover = coverSequence(10, [
+    { start: 0, end: 3, payload: "x" },
+    { start: 6, end: 9, payload: "y" },
+  ]);
+  assert.equal(cover.covered, 6);
+  assert.equal(cover.uncovered, 4);
+  assert.deepEqual(cover.spans.map((s) => s.payload), ["x", "y"]);
 });
 test("coverSequence honours weights when coverage ties", () => {
-    // Both single-span covers cover all 2 symbols; the lighter weight wins.
-    const cover = coverSequence(2, [
-        { start: 0, end: 2, weight: 5, payload: "heavy" },
-        { start: 0, end: 2, weight: 1, payload: "light" },
-    ]);
-    assert.deepEqual(cover.spans.map((s) => s.payload), ["light"]);
+  // Both single-span covers cover all 2 symbols; the lighter weight wins.
+  const cover = coverSequence(2, [
+    { start: 0, end: 2, weight: 5, payload: "heavy" },
+    { start: 0, end: 2, weight: 1, payload: "light" },
+  ]);
+  assert.deepEqual(cover.spans.map((s) => s.payload), ["light"]);
 });

package/dist/src/extension.d.ts

@@ -1,9 +1,9 @@
 /** A half-open byte span of a query an extension computed, and the canonical
  *  result bytes it is authoritative for. */
 export interface ComputedSpan {
-    i: number;
-    j: number;
-    bytes: Uint8Array;
+  i: number;
+  j: number;
+  bytes: Uint8Array;
 }
 /** The generic capabilities the mind lends every extension — nothing here
  *  names any particular extension, and every member is machinery the mind
@@ -24,14 +24,17 @@ export interface ComputedSpan {
  *   • reach — the river's grouping capacity (maxGroup), bounding how far apart
  *     two spans may sit and still be read as one construction. */
 export interface ExtensionHost {
-    meaningOf(bytes: Uint8Array, anchors: ReadonlyArray<{
-        name: string;
-        form: Uint8Array;
-    }>): Promise<string | null>;
-    continuation(bytes: Uint8Array): Promise<Uint8Array | null>;
-    segment(bytes: Uint8Array): Array<{
-        i: number;
-        j: number;
-    }>;
-    reach: number;
+  meaningOf(
+    bytes: Uint8Array,
+    anchors: ReadonlyArray<{
+      name: string;
+      form: Uint8Array;
+    }>,
+  ): Promise<string | null>;
+  continuation(bytes: Uint8Array): Promise<Uint8Array | null>;
+  segment(bytes: Uint8Array): Array<{
+    i: number;
+    j: number;
+  }>;
+  reach: number;
 }

package/dist/src/geometry.d.ts

@@ -21,7 +21,11 @@ export declare function mergeThreshold(D: number): number;
  *  fraction, the span's MAGNITUDE (√len, the linear fold's own norm) converts
  *  the tolerated fraction into tolerated bytes.  Derived from W, D and the
  *  span; never tuned. */
-export declare function identityBar(D: number, maxGroup: number, len: number): number;
+export declare function identityBar(
+  D: number,
+  maxGroup: number,
+  len: number,
+): number;
 /** The reach bar: half a river quantum, derived from the fold's own geometry.
  *  A branch folds up to `maxGroup` children, so two forms that differ in ONE
  *  whole child — the smallest distinction perception can mean — sit at cosine
@@ -91,20 +95,30 @@ export declare function consensusFloor(N: number): number;
  *  structurally-isolated entries.  Derived, never tuned. */
 export declare function coverageBar(_maxGroup: number, D: number): number;
 export interface Grid {
-    width: number;
-    height: number;
-    channels: number;
-    data: Uint8Array;
-    dims?: number[];
+  width: number;
+  height: number;
+  channels: number;
+  data: Uint8Array;
+  dims?: number[];
 }
 /** Find the longest prefix of `bytes` whose leaf-id signature matches a
  *  known branch via `lookup`.  Returns the byte-length of that prefix, or 0. */
-export declare function knownPrefixLength(bytes: Uint8Array, leafAt: (i: number) => number | null, lookup: (leafIds: number[]) => number | null): number;
+export declare function knownPrefixLength(
+  bytes: Uint8Array,
+  leafAt: (i: number) => number | null,
+  lookup: (leafIds: number[]) => number | null,
+): number;
 /** Bytes → Sema tree.  `leafAt` and `lookup` are store capabilities for
  *  detecting previously-stored prefixes so the river can split at the
  *  correct boundary.  Pass them through from `perceive`; the geometry
  *  computes the stable prefix internally. */
-export declare function bytesToTree(space: Space, alphabet: Alphabet, bytes: Uint8Array, leafAt?: (i: number) => number | null, lookup?: (leafIds: number[]) => number | null): Sema;
+export declare function bytesToTree(
+  space: Space,
+  alphabet: Alphabet,
+  bytes: Uint8Array,
+  leafAt?: (i: number) => number | null,
+  lookup?: (leafIds: number[]) => number | null,
+): Sema;
 /** The PLAIN fold's full level pyramid — every level's item list, bottom
  *  (leaves) to top (root).  Left-grouped folding is RADIX-ALIGNED: the item
  *  at level L, index i, covers exactly bytes [i·mg^L, (i+1)·mg^L) whenever
@@ -118,20 +132,31 @@ export declare function bytesToTree(space: Space, alphabet: Alphabet, bytes: Uin
  *  never mutated).  Purely an implementation cache: structure and numerics
  *  never depend on whether a pyramid was available. */
 export interface FoldPyramid {
-    levels: Array<Array<{
-        tree: Sema;
-        len: number;
-    }>>;
-    bytes: number;
+  levels: Array<
+    Array<{
+      tree: Sema;
+      len: number;
+    }>
+  >;
+  bytes: number;
 }
 /** Plain bytes→tree (identical to capability-less {@link bytesToTree}) that
  *  also RETURNS its pyramid, reusing `prev` — the pyramid of a PROPER
  *  prefix of `bytes` (caller guarantees content match and
  *  prev.bytes < bytes.length). */
-export declare function bytesToTreePyramid(space: Space, alphabet: Alphabet, bytes: Uint8Array, prev?: FoldPyramid): {
-    tree: Sema;
-    pyramid: FoldPyramid;
+export declare function bytesToTreePyramid(
+  space: Space,
+  alphabet: Alphabet,
+  bytes: Uint8Array,
+  prev?: FoldPyramid,
+): {
+  tree: Sema;
+  pyramid: FoldPyramid;
 };
 export declare function hilbertBytes(grid: Grid): Uint8Array;
-export declare function gridToTree(space: Space, alphabet: Alphabet, grid: Grid): Sema;
+export declare function gridToTree(
+  space: Space,
+  alphabet: Alphabet,
+  grid: Grid,
+): Sema;
 export declare function stackGrids(frames: Grid[]): Grid;