@hviana/sema 0.8.9 → 0.9.1

package/src/mind/attention.ts

@@ -34,14 +34,7 @@ import {
   estimatorNoise,
   type StructuralPart,
 } from "../geometry.js";
-import {
-  foldTree,
-  gistOf,
-  latin1Key,
-  perceive,
-  read,
-  resolve,
-} from "./primitives.js";
+import { foldTree, gistOf, perceive, read, resolve } from "./primitives.js";
 import { recognise } from "./recognition.js";
 import { leafIdRun } from "./canonical.js";
 import {
@@ -63,10 +56,10 @@ import {
   walkCache,
 } from "./junction.js";
 import type { Vec } from "../vec.js";
-import { indexOf } from "../bytes.js";
+import { indexOf, latin1 } from "../bytes.js";
 import { restates } from "./derivation.js";
 import type { RationaleItem } from "./rationale.js";
-import { rDeriv, rItem, rNode, traceDerivation } from "./trace.js";
+import { rItem, rNode, traceDerivation } from "./trace.js";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // climbConsensus / inspectRationale instrumentation.
@@ -501,7 +494,7 @@ export async function climbAttentionAll(
   // Content-keyed memo — works for both single-turn respond() and multi-turn
   // respondTurn().
   if (ctx.climbMemo) {
-    const contentKey = latin1Key(query);
+    const contentKey = latin1(query);
     const modeKey = `${k}:${mode}`;
     let byRead = ctx.climbMemo.get(contentKey);
     if (byRead === undefined) {
@@ -1629,7 +1622,10 @@ export function poolVotes(
  *  Strict `<` (not `<=`): verified against gap 3.1's own "gender equality"
  *  root, whose two genuine clusters sit EXACTLY W bytes apart — `<= W`
  *  would wrongly merge them into one and break that pinned requirement. */
-function countClusters(spans: readonly [number, number][], W: number): number {
+export function countClusters(
+  spans: readonly [number, number][],
+  W: number,
+): number {
   if (spans.length === 0) return 0;
   const sorted = [...spans].sort((a, b) => a[0] - b[0]);
   let clusters = 1;
@@ -2103,20 +2099,46 @@ export function canonicalChunkId(
     if (len < 2) return flatId;
 
     // Within one window, the widest reach is still the right CANONICAL
-    // identity — a chunk's anchor should be its most general stable form.
-    let bestId = flatId;
-    let bestReach = edgeAncestors(ctx, flatId, N, reachMemo);
+    // identity — a chunk's anchor should be its most general stable form.  A
+    // SATURATED reach is the widest there is: its count is wherever the climb
+    // happened to stop deciding, so an unsaturated prefix never out-widens it
+    // by comparing against that count.  (It used to: on test/24's gap-3.1
+    // fixture the region `ace and ` had its saturated window replaced by the
+    // unsaturated 2-byte prefix `e `, and that sub-window anchor voted.)
+    //
+    // So a window's anchor is its SHORTEST saturated form when any saturates,
+    // and its widest-reaching form otherwise — and the forms are climbed
+    // shortest first, stopping at the first that saturates: the forms longer
+    // than it cannot change the anchor.  Measured over 8 queries on the
+    // 31.7M-node store: 339 of 347 windows saturate, 312 already at their
+    // 2-byte prefix, while the full window and the 3-byte prefix — climbed
+    // first, to √N contexts each — were 89% of the visits.
+    const forms: number[] = [flatId];
     for (let k2 = 1; k2 < len; k2++) {
-      const shortIds = ids.slice(0, len - k2);
-      const shortId = ctx.store.findBranch(shortIds);
-      if (shortId === null) continue;
-      const shortReach = edgeAncestors(ctx, shortId, N, reachMemo);
-      if (
-        shortReach.saturated ||
-        shortReach.contextsReached > bestReach.contextsReached
-      ) {
-        bestId = shortId;
-        bestReach = shortReach;
+      const shortId = ctx.store.findBranch(ids.slice(0, len - k2));
+      if (shortId !== null) forms.push(shortId);
+    }
+    const reaches: AncestorReach[] = new Array(forms.length);
+    let bestId: number | null = null;
+    let bestReach: AncestorReach | null = null;
+    for (let f = forms.length - 1; f >= 0; f--) {
+      const r = edgeAncestors(ctx, forms[f], N, reachMemo);
+      if (r.saturated) {
+        bestId = forms[f];
+        bestReach = r;
+        break;
+      }
+      reaches[f] = r;
+    }
+    if (bestId === null || bestReach === null) {
+      // None saturates: the widest reach, the longer form on a tie.
+      bestId = forms[0];
+      bestReach = reaches[0];
+      for (let f = 1; f < forms.length; f++) {
+        if (reaches[f].contextsReached > bestReach.contextsReached) {
+          bestId = forms[f];
+          bestReach = reaches[f];
+        }
       }
     }
     if (fallback === null) fallback = bestId;

package/src/mind/bridge.ts

@@ -94,7 +94,7 @@ import { cosine, type Vec } from "../vec.js";
 import { conceptThreshold, dominates, significanceBar } from "../geometry.js";
 import { bytesEqual, indexOf } from "../bytes.js";
 import type { MindContext } from "./types.js";
-import { foldTree, perceive, read } from "./primitives.js";
+import { exactNode, perceive, read } from "./primitives.js";
 import { chainReach, leafIdRun } from "./canonical.js";
 import {
   allWindowsAreScaffolding,
@@ -491,7 +491,7 @@ async function bridgeImpl(
     ) continue;
     let use = sid;
     if (!ctx.store.hasNext(use)) {
-      const folded = foldTree(ctx, perceive(ctx, tb), 0).node;
+      const folded = exactNode(ctx, tb);
       if (folded === null || folded === sid || !ctx.store.hasNext(folded)) {
         continue;
       }
@@ -508,7 +508,7 @@ async function bridgeImpl(
   // be a FLAT content twin whose continuation edge lives on the
   // fold-shaped deposit node with the same bytes — the same twin split
   // canonResolve bridges by re-folding (primitives.ts) — but the re-fold
-  // (a full perceive of the candidate's bytes) is paid only for proposals
+  // (an identity fold of the candidate's bytes) is paid only for proposals
   // that could align at all: alignment can only seed at a picked anchor
   // window occurring literally in the candidate (measured: unconditional
   // re-folds multiplied the refusal-path latency several-fold).

package/src/mind/derivation.ts

@@ -489,3 +489,80 @@ export async function closure(
     d = next;
   }
 }
+
+// ── The engine: one closure over layers ─────────────────────────────────────
+
+/** A LAYER of the closure — a named producer of continuations for one state.
+ *  The layer OFFERS (its {@link Offer} is the whole of what it decides); the
+ *  law admits; the engine sequences.  The hooks are the layer's own
+ *  instrumentation, called by the engine at the moments the law defines. */
+export interface ClosureLayer {
+  /** The layer's name — its rationale scope and its meter phase. */
+  readonly name: string;
+  /** Whether the layer has anything to offer this state at all.  A layer that
+   *  does not engage is not ENTERED: no offer is asked and no work is charged
+   *  to it.  Omitted: it always engages. */
+  readonly engages?: (d: DerivationState) => boolean;
+  /** The layer's continuations, one at a time ({@link Offer}'s contract). */
+  readonly offer: Offer;
+  /** Called for each step the law admits, with the state before and after. */
+  readonly onTaken?: (
+    before: DerivationState,
+    after: DerivationState,
+    witnesses: ReadonlyArray<Witness>,
+  ) => void;
+  /** Called when the law refused the continuation the layer offered. */
+  readonly onRefused?: (at: DerivationState) => void;
+  /** Called once the layer's walk has ended — the layer offered nothing more,
+   *  or the law refused — with the state it began from and the one it reached. */
+  readonly onEnd?: (from: DerivationState, to: DerivationState) => void;
+}
+
+/** THE CLOSURE ENGINE — close a derivation under the law, layer by layer.
+ *
+ *  Each layer is walked to its own end ({@link closure}: the layer offers, the
+ *  law admits or refuses), and the state it reaches is the state the next layer
+ *  is offered against.  Layers are PHASES, in the order given, never revisited:
+ *  a later layer composes what an earlier one produced, and nothing it adds is
+ *  re-offered to the earlier one.
+ *
+ *  THE LAW'S FIRST CLAUSE IS APPLIED HERE, ONCE.  A FIXED state admits no
+ *  transition (`admissible` refuses it before anything else), so no layer is
+ *  entered at all — the decision a caller used to spell as "skip the walk for a
+ *  complete grounding, and skip the fusion too" is the law's, not the caller's,
+ *  and it is taken before any layer pays for an offer it could never have
+ *  taken.
+ *
+ *  `enter` wraps each entered layer's walk — the caller's instrumentation (a
+ *  meter phase), which this module cannot import: it reads nothing but the
+ *  state and the layers. */
+export async function closeOver(
+  d: DerivationState,
+  query: Uint8Array,
+  W: number,
+  layers: ReadonlyArray<ClosureLayer>,
+  enter?: (
+    name: string,
+    walk: () => Promise<DerivationState>,
+  ) => Promise<DerivationState>,
+): Promise<DerivationState> {
+  for (const layer of layers) {
+    if (d.fixed) return d;
+    if (layer.engages !== undefined && !layer.engages(d)) continue;
+    const from = d;
+    const walk = async (): Promise<DerivationState> => {
+      const to = await closure(
+        from,
+        query,
+        W,
+        layer.offer,
+        layer.onTaken,
+        layer.onRefused,
+      );
+      layer.onEnd?.(from, to);
+      return to;
+    };
+    d = enter === undefined ? await walk() : await enter(layer.name, walk);
+  }
+  return d;
+}