@hviana/sema 0.1.5 → 0.1.7

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

@@ -3,124 +3,120 @@
 // 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,17 +24,14 @@ 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,11 +21,7 @@ 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
@@ -95,30 +91,31 @@ 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;
+ *  computes the stable prefix internally.
+ *
+ *  `boundaries` is the CALLER-computed stable-prefix boundary set (§10.3):
+ *  strictly-increasing proper byte offsets, each the length of a prefix that
+ *  is already a stored whole-stream form.  When given, the fold splits into
+ *  the segments between consecutive boundaries — each folded independently,
+ *  exactly as it folded when it was learned — and the segment roots join
+ *  LEFT-NESTED (((s₀·s₁)·s₂)…), so every learnt cumulative-context root
+ *  reappears as an identical subtree (and, by hash-consing, the very same
+ *  node) inside the grown stream.  This is what lets a conversation's next
+ *  turn extend perception instead of refolding it: identical prefixes
+ *  produce identical subtrees regardless of what follows them. */
+export declare function bytesToTree(space: Space, alphabet: Alphabet, bytes: Uint8Array, leafAt?: (i: number) => number | null, lookup?: (leafIds: number[]) => number | null, boundaries?: readonly number[]): 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
@@ -132,31 +129,20 @@ export declare function bytesToTree(
  *  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;