@hviana/sema 0.9.0 → 0.9.2

package/src/meter.ts

@@ -143,6 +143,13 @@ export class Meter {
   perceivedBytes = 0;
   /** `perceive` calls served from the per-response / conversation memo. */
   perceiveHits = 0;
+  /** Bytes walked by the IDENTITY fold (`exactNode` — the fold's shape read
+   *  for its node id, no vectors).  Perception's content-addressed half: what
+   *  used to show up in `perceivedBytes` when every resolve folded vectors. */
+  identityBytes = 0;
+  /** Branches the read side named by their BYTES — the flat node the write
+   *  side reused when the children named none (primitives.ts `branchNaming`). */
+  flatBranchNames = 0;
   /** `recognise` calls that actually ran. */
   recognitions = 0;
   /** Bytes recognised by those calls. */
@@ -201,6 +208,10 @@ export class Meter {
   searchPops = 0;
   /** Chart items pushed by those searches. */
   searchPushes = 0;
+  /** Chart items popped DOMINATED — a span's form or completion that could
+   *  only yield completions of that span costing at least one already yielded
+   *  (graph-search.ts `buildSearch`), so no rule was generated from it. */
+  searchDominated = 0;
 
   // ── Mind: the mechanism market ──────────────────────────────────────────
   /** `floor()` calls that returned a bound (the mechanism could fire). */
@@ -209,6 +220,10 @@ export class Meter {
   mechanismSkips = 0;
   /** `run()` calls — the ones the floor pruning let through. */
   mechanismRuns = 0;
+  /** Mechanisms skipped because a mechanism floored lower, run AHEAD of them
+   *  (pipeline.ts, "a cheaper bound is looked at before a dearer one is paid
+   *  for"), already reached a grade their floor cannot beat. */
+  mechanismsBounded = 0;
   /** Candidates the decider weighed. */
   candidates = 0;
 
@@ -216,7 +231,7 @@ export class Meter {
   //
   // The join's outcome was observable ONLY through the rationale, and the
   // rationale PERTURBS the search (measured: appending text to a refusal note
-  // changed a traced answer).  These four counters are the untraced view — the
+  // changed a traced answer).  These five counters are the untraced view — the
   // same surface every other work counter uses, incremented where the decision
   // is made, never behind a trace guard.
   /** `deriveThrough` yielded — a fact was reached through the subject the query
@@ -229,6 +244,11 @@ export class Meter {
   joinNoKey = 0;
   /** Refused: the fact contains no entity that leads anywhere. */
   joinNoEntity = 0;
+  /** Facts the join was priced for — the facts a lightest derivation stood on
+   *  (graph-search.ts `solve`), each once.  The output-sensitivity of the join
+   *  in one number: it tracks the answer's facts, never how many facts the
+   *  exploration reached (`test/150`). */
+  joinFacts = 0;
   /** `recompleteNode` re-covered a produced form — the descent that decomposes
    *  a completion by ITS OWN kids.  Without this the descent is invisible: a
    *  caller could see the chain's result but not whether the recomposition
@@ -245,6 +265,19 @@ export class Meter {
   /** Times the reasoner pivoted on a span its answer contains and stepped
    *  across that fact. */
   pivotSteps = 0;
+  /** `chooseNext` picks the question NAMED — a continuation one of whose own
+   *  establishing contexts the question (plus the node) wholly witnesses
+   *  (traverse.ts, the exact tier). */
+  askedContinuations = 0;
+  /** Predecessor rows that exact tier read, against its shared √N budget. */
+  askedPredecessorReads = 0;
+  /** Times the tier abstained on a read it could not trust: the continuations
+   *  came back at the √N cap, or its predecessor budget ran out before every
+   *  continuation was asked about — the distributional ladder decided. */
+  askedReadsSaturated = 0;
+  /** Cover sites dropped as FRAGMENTS whose several continuations the question
+   *  names none of (mechanisms/cover.ts). */
+  unaskedFragments = 0;
   /** Canon probes REFUSED because the canon budget ran out — the one thing the
    *  budget does that nothing could see.  The budget itself is derived
    *  (`bytes.length · chainReach(W)²`, recognition.ts), and the cheap exact route

package/src/mind/articulation.ts

@@ -4,12 +4,13 @@
 //                using concept (halo) resonance to match the voices.
 
 import { Vec } from "../vec.js";
+import { indexOf } from "../bytes.js";
 import type { MindContext } from "./types.js";
 import { spliceAll } from "./types.js";
 import { recognise } from "./recognition.js";
 import { answers, contains } from "./traverse.js";
 import { bestHaloMate } from "./match.js";
-import type { Site } from "./graph-search.js";
+import { noLicence } from "./graph-search.js";
 import type { CandidateSpan } from "../derive/src/index.js";
 import { coverSequence } from "../derive/src/index.js";
 import { rItem, rNode, traceDerivation } from "./trace.js";
@@ -75,8 +76,19 @@ export async function articulate(
     const found = bestHaloMate(ctx, h, voices, (v) => v.halo);
     if (!found) continue;
     const voice = found.item;
+    // THE ASKER'S WORDING ALREADY HOLDING THE FORM is not a re-voicing of it:
+    // splicing it in would add the asker's other words to the answer.  That is
+    // what `contains` asks of the DAG, and the DAG can miss it — the fold cuts
+    // `eva director` as `eva d|irector`, so `eva` is no structural child of it
+    // — so the question is also asked of the bytes, the reading that cannot
+    // miss.  Measured (test/106's chain): the answer's `eva`, a halo mate of the
+    // asker's `eva director` because both lead to the same fact, was revoiced
+    // as "The director of eva director is Gustaf Molander."
+    const formBytes = store.bytesPrefix(s.payload, voice.bytes.length + 1);
     if (
       voice.node === s.payload || contains(ctx, voice.node, s.payload) ||
+      (formBytes.length <= voice.bytes.length &&
+        indexOf(voice.bytes, formBytes, 0) >= 0) ||
       answers(ctx, voice.node, s.payload)
     ) {
       continue;
@@ -116,7 +128,7 @@ export async function articulate(
   const solved = ctx.search.cover(
     answer.length,
     voicedSites,
-    new Map(),
+    noLicence(),
     ans.leaves,
     ans.splits,
     substitutions,

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;
+}

package/src/mind/evidence.ts

@@ -0,0 +1,107 @@
+// evidence.ts — what of a stored form the material at hand WITNESSES.
+//
+// A stored form is WITNESSED by some material when every one of its bytes lies
+// inside a W-window that occurs literally in that material — in any order, at
+// any place.  It is the order-free reading of correspondence (`alignRuns` is
+// its run-producing sibling, `junctionContainersFrom(…, unordered)` its
+// container-finding one): a learnt form is evidenced by bytes that hold all of
+// its windows, whichever way the asker happened to arrange them.
+//
+// The material is a LIST of sources because what a derivation has at hand is
+// more than the question: the node it stands on is material too.  A trained
+// question `Edmond T. Gréville place of death` is in neither the asker's
+// `Where was the place of death of the director of film Beat Girl?` nor the
+// fact `The director of Beat Girl is Edmond T. Gréville.` the first hop reached
+// — and both together hold every byte of it.  The witness records which source
+// held each window, so a consumer can tell the question's share (what the asker
+// SAID about the form) from what the derivation itself brought.
+//
+// Exact, deterministic and linear: one window index per source, one probe per
+// window of the form.  Below one window a byte agreement is chance (the floor
+// identityBar, attestedQ and the site test all draw), so a form shorter than W
+// is never witnessed.
+//
+// Layering: bytes only — importable from traverse.ts and everything above it.
+
+import { latin1 } from "../bytes.js";
+
+/** Where each W-window of one source first occurs.  Built once per source and
+ *  reused across every form asked against it. */
+export type WindowIndex = Map<string, number>;
+
+export function windowIndex(bytes: Uint8Array, W: number): WindowIndex {
+  const index: WindowIndex = new Map();
+  for (let o = 0; o + W <= bytes.length; o++) {
+    const key = latin1(bytes.subarray(o, o + W));
+    if (!index.has(key)) index.set(key, o);
+  }
+  return index;
+}
+
+/** The windows of `index` (over `bytes`) that `spoken` does not hold — what
+ *  of the question no product of the derivation has restated yet.  The keys
+ *  keep their positions in `bytes`, so a witnessing span still names the
+ *  asker's bytes. */
+export function unspoken(
+  index: WindowIndex,
+  spoken: ReadonlyArray<WindowIndex>,
+): WindowIndex {
+  const out: WindowIndex = new Map();
+  for (const [key, at] of index) {
+    if (!spoken.some((s) => s.has(key))) out.set(key, at);
+  }
+  return out;
+}
+
+/** How a form is witnessed by a list of sources. */
+export interface Witnessing {
+  /** Every byte of the form lies in a window some source holds. */
+  complete: boolean;
+  /** The windows SOURCE 0 alone supplied — windows no later source holds — as
+   *  merged spans of source 0.  With the question as source 0, this is what the
+   *  asker said about the form that the derivation did not already have. */
+  spans: Array<[number, number]>;
+  /** Bytes of source 0 inside `spans`. */
+  bytes: number;
+}
+
+/** Witness `form` against `sources` (their window indexes, same order).  A
+ *  window is credited to the LAST source holding it — so source 0 is credited
+ *  only with what nothing else at hand supplies. */
+export function witness(
+  form: Uint8Array,
+  indexes: ReadonlyArray<WindowIndex>,
+  W: number,
+): Witnessing {
+  const none: Witnessing = { complete: false, spans: [], bytes: 0 };
+  if (form.length < W || indexes.length === 0) return none;
+  const covered = new Uint8Array(form.length);
+  const own: Array<[number, number]> = [];
+  for (let o = 0; o + W <= form.length; o++) {
+    const key = latin1(form.subarray(o, o + W));
+    let at = -1;
+    let from = -1;
+    for (let s = indexes.length - 1; s >= 0; s--) {
+      const p = indexes[s].get(key);
+      if (p !== undefined) {
+        at = p;
+        from = s;
+        break;
+      }
+    }
+    if (from < 0) continue;
+    covered.fill(1, o, o + W);
+    if (from === 0) own.push([at, at + W]);
+  }
+  for (let i = 0; i < form.length; i++) if (!covered[i]) return none;
+  own.sort((a, b) => a[0] - b[0]);
+  const spans: Array<[number, number]> = [];
+  for (const [s, e] of own) {
+    const last = spans[spans.length - 1];
+    if (last !== undefined && s <= last[1]) last[1] = Math.max(last[1], e);
+    else spans.push([s, e]);
+  }
+  let bytes = 0;
+  for (const [s, e] of spans) bytes += e - s;
+  return { complete: true, spans, bytes };
+}