@hviana/sema 0.1.8 → 0.2.0

package/dist/src/geometry.js

@@ -157,8 +157,13 @@ export function coverageBar(_maxGroup, D) {
 /** Fold `items[start .. start+count)` in groups of `mg` into `out`.
  *
  *  With `force`, the trailing incomplete group (2..mg-1 items) is folded as
- *  well — only a lone singleton passes through — guaranteeing progress when
- *  the caller detected a stall. */
+ *  well — only a lone singleton passes through.  The river always folds with
+ *  force: every level contracts by ~mg, so the tree's DEPTH is a function of
+ *  ceil(log_mg(n)) alone.  Letting leftovers pass through unfolded made depth
+ *  depend on the exact byte count (39 bytes folded in 3 levels, 41 in 4), and
+ *  each extra level applies another seat permutation to the whole gist —
+ *  near-identical inputs straddling such a cliff read as orthogonal
+ *  (measured: 33-byte-identical prefixes at cos ≈ 0). */
 function foldSlice(space, items, start, count, out, force) {
     const mg = space.maxGroup;
     const D = space.D;
@@ -213,21 +218,13 @@ function riverFold(space, row, stableBytes) {
         const next = [];
         if (boundary < level.length) {
             // Prefix folds independently of the suffix — structural stability.
-            foldSlice(space, level, 0, boundary, next, false);
-            foldSlice(space, level, boundary, level.length - boundary, next, false);
+            foldSlice(space, level, 0, boundary, next, true);
+            foldSlice(space, level, boundary, level.length - boundary, next, true);
         }
         else {
-            foldSlice(space, level, 0, level.length, next, false);
-        }
-        if (next.length === level.length) {
-            // Stuck — every group was incomplete.  Force-fold to break the stall.
-            const forced = [];
-            foldSlice(space, next, 0, next.length, forced, true);
-            level = forced;
-        }
-        else {
-            level = next;
+            foldSlice(space, level, 0, level.length, next, true);
         }
+        level = next;
     }
     // LINEAR fold — this root normalize is the ONLY normalize of the entire
     // fold; every intermediate gist stays unnormalized (see the folding
@@ -353,15 +350,8 @@ function riverFoldRaw(space, row) {
     let level = row;
     while (level.length > 1) {
         const next = [];
-        foldSlice(space, level, 0, level.length, next, false);
-        if (next.length === level.length) {
-            const forced = [];
-            foldSlice(space, next, 0, next.length, forced, true);
-            level = forced;
-        }
-        else {
-            level = next;
-        }
+        foldSlice(space, level, 0, level.length, next, true);
+        level = next;
     }
     return level[0];
 }
@@ -420,15 +410,7 @@ export function bytesToTreePyramid(space, alphabet, bytes, prev) {
             for (let i = 0; i < reused; i++)
                 next.push(cand[i]);
         }
-        foldSlice(space, level, reused * mg, level.length - reused * mg, next, false);
-        if (next.length === level.length) {
-            // Stuck — same force-fold as riverFold (reuse cannot cause it: any
-            // reused block replaces a whole folded group, so reused > 0 implies
-            // progress).
-            const forced = [];
-            foldSlice(space, next, 0, next.length, forced, true);
-            next = forced;
-        }
+        foldSlice(space, level, reused * mg, level.length - reused * mg, next, true);
         levels.push(next);
         level = next;
         L++;

package/dist/src/mind/mechanisms/cast.js

@@ -288,7 +288,7 @@ export async function counterfactualTransfer(ctx, query, pre) {
             indexOf(dominant.ctx, p.ctx, 0) < 0 &&
             indexOf(p.ctx, dominant.ctx, 0) < 0 &&
             indexOf(query, p.ctx, 0) < 0) {
-            analogs.push({ anchor: p.anchor, point: p });
+            analogs.push({ anchor: p.anchor, point: p, src: p });
         }
         // Reach through to the point's continuation targets regardless
         // of the point's own context length: when the point is a leaf
@@ -306,7 +306,7 @@ export async function counterfactualTransfer(ctx, query, pre) {
                 indexOf(nctx, dominant.ctx, 0) >= 0 ||
                 indexOf(query, nctx, 0) >= 0)
                 continue;
-            analogs.push({ anchor: nid, point: null });
+            analogs.push({ anchor: nid, point: null, src: p });
         }
     }
     let bestAnalog = null;
@@ -404,13 +404,13 @@ export async function counterfactualTransfer(ctx, query, pre) {
         // A halo-mediated act (the analogy gate) plus two seat projections.
         CONCEPT + STEP + STEP, 
         // What comparison READ: the dominant's own aligned runs, plus the
-        // analog's aligned runs when it was itself an aligned point (a nextOf
-        // descendant was never aligned to the query directly, so it
-        // contributes no accounted span — its seat is graph-reached, not
-        // query-matched).
+        // aligned runs of the point that named the analog — the analog itself
+        // when it was an aligned point, else the source point whose
+        // continuation edge reached it (that alignment IS the query evidence
+        // the hop rests on).
         [
             ...runSpans(dominant),
-            ...(bestAnalog.point !== null ? runSpans(bestAnalog.point) : []),
+            ...runSpans(bestAnalog.point ?? bestAnalog.src),
         ]);
     }
     t?.done(results.map((r) => rItem(r.bytes, "answer")), results.length > 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
   "type": "module",
   "main": "dist/src/index.js",

package/src/geometry.ts

@@ -189,8 +189,13 @@ export interface Grid {
 /** Fold `items[start .. start+count)` in groups of `mg` into `out`.
  *
  *  With `force`, the trailing incomplete group (2..mg-1 items) is folded as
- *  well — only a lone singleton passes through — guaranteeing progress when
- *  the caller detected a stall. */
+ *  well — only a lone singleton passes through.  The river always folds with
+ *  force: every level contracts by ~mg, so the tree's DEPTH is a function of
+ *  ceil(log_mg(n)) alone.  Letting leftovers pass through unfolded made depth
+ *  depend on the exact byte count (39 bytes folded in 3 levels, 41 in 4), and
+ *  each extra level applies another seat permutation to the whole gist —
+ *  near-identical inputs straddling such a cliff read as orthogonal
+ *  (measured: 33-byte-identical prefixes at cos ≈ 0). */
 function foldSlice(
   space: Space,
   items: Folded[],
@@ -251,19 +256,12 @@ function riverFold(space: Space, row: Folded[], stableBytes: number): Folded {
     const next: Folded[] = [];
     if (boundary < level.length) {
       // Prefix folds independently of the suffix — structural stability.
-      foldSlice(space, level, 0, boundary, next, false);
-      foldSlice(space, level, boundary, level.length - boundary, next, false);
+      foldSlice(space, level, 0, boundary, next, true);
+      foldSlice(space, level, boundary, level.length - boundary, next, true);
     } else {
-      foldSlice(space, level, 0, level.length, next, false);
-    }
-    if (next.length === level.length) {
-      // Stuck — every group was incomplete.  Force-fold to break the stall.
-      const forced: Folded[] = [];
-      foldSlice(space, next, 0, next.length, forced, true);
-      level = forced;
-    } else {
-      level = next;
+      foldSlice(space, level, 0, level.length, next, true);
     }
+    level = next;
   }
   // LINEAR fold — this root normalize is the ONLY normalize of the entire
   // fold; every intermediate gist stays unnormalized (see the folding
@@ -413,14 +411,8 @@ function riverFoldRaw(space: Space, row: Folded[]): Folded {
   let level = row;
   while (level.length > 1) {
     const next: Folded[] = [];
-    foldSlice(space, level, 0, level.length, next, false);
-    if (next.length === level.length) {
-      const forced: Folded[] = [];
-      foldSlice(space, next, 0, next.length, forced, true);
-      level = forced;
-    } else {
-      level = next;
-    }
+    foldSlice(space, level, 0, level.length, next, true);
+    level = next;
   }
   return level[0];
 }
@@ -509,16 +501,8 @@ export function bytesToTreePyramid(
       reused * mg,
       level.length - reused * mg,
       next,
-      false,
+      true,
     );
-    if (next.length === level.length) {
-      // Stuck — same force-fold as riverFold (reuse cannot cause it: any
-      // reused block replaces a whole folded group, so reused > 0 implies
-      // progress).
-      const forced: Folded[] = [];
-      foldSlice(space, next, 0, next.length, forced, true);
-      next = forced;
-    }
     levels.push(next);
     level = next;
     L++;

package/src/mind/mechanisms/cast.ts

@@ -368,6 +368,11 @@ export async function counterfactualTransfer(
     /** The point this candidate came from, or null when it is a nextOf
      *  descendant — then seatOfNode supplies the seat. */
     point: Point | null;
+    /** For a nextOf descendant: the aligned point whose continuation edge
+     *  named it.  Its runs ARE the query evidence this analog rests on
+     *  (the hop was reached THROUGH that alignment), so the comparison
+     *  schema accounts them. */
+    src: Point;
   }
   const analogs: AnalogCandidate[] = [];
   for (const p of points) {
@@ -380,7 +385,7 @@ export async function counterfactualTransfer(
       indexOf(p.ctx, dominant.ctx, 0) < 0 &&
       indexOf(query, p.ctx, 0) < 0
     ) {
-      analogs.push({ anchor: p.anchor, point: p });
+      analogs.push({ anchor: p.anchor, point: p, src: p });
     }
     // Reach through to the point's continuation targets regardless
     // of the point's own context length: when the point is a leaf
@@ -399,7 +404,7 @@ export async function counterfactualTransfer(
         indexOf(nctx, dominant.ctx, 0) >= 0 ||
         indexOf(query, nctx, 0) >= 0
       ) continue;
-      analogs.push({ anchor: nid, point: null });
+      analogs.push({ anchor: nid, point: null, src: p });
     }
   }
   let bestAnalog: AnalogCandidate | null = null;
@@ -521,13 +526,13 @@ export async function counterfactualTransfer(
       // A halo-mediated act (the analogy gate) plus two seat projections.
       CONCEPT + STEP + STEP,
       // What comparison READ: the dominant's own aligned runs, plus the
-      // analog's aligned runs when it was itself an aligned point (a nextOf
-      // descendant was never aligned to the query directly, so it
-      // contributes no accounted span — its seat is graph-reached, not
-      // query-matched).
+      // aligned runs of the point that named the analog — the analog itself
+      // when it was an aligned point, else the source point whose
+      // continuation edge reached it (that alignment IS the query evidence
+      // the hop rests on).
       [
         ...runSpans(dominant),
-        ...(bestAnalog.point !== null ? runSpans(bestAnalog.point) : []),
+        ...runSpans(bestAnalog.point ?? bestAnalog.src),
       ],
     );
   }