@hviana/sema 0.9.0 → 0.9.2

package/dist/src/mind/attention.js

@@ -9,12 +9,12 @@
 import { isChunk } from "../sema.js";
 import { lightestDerivation, } from "../derive/src/index.js";
 import { composeStructuralGist, consensusFloor, dominates, estimatorNoise, } 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 { atomIsHub, corpusN, edgeAncestors, hubBound, sharedReachMemo, } from "./traverse.js";
 import { cachedRead, junctionContainersFrom, junctionSeeds, junctionSynonyms, loadJunctionSynonymSides, walkCache, } from "./junction.js";
-import { indexOf } from "../bytes.js";
+import { indexOf, latin1 } from "../bytes.js";
 import { restates } from "./derivation.js";
 import { rItem, rNode, traceDerivation } from "./trace.js";
 function newTraceDraft(perceivedCount) {
@@ -74,7 +74,7 @@ export async function climbAttentionAll(ctx, query, k, mode = "inverse") {
     // 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) {
@@ -1125,7 +1125,7 @@ export function poolVotes(ctx, regionVotes, sat, N, td) {
  *  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, W) {
+export function countClusters(spans, W) {
     if (spans.length === 0)
         return 0;
     const sorted = [...spans].sort((a, b) => a[0] - b[0]);
@@ -1521,19 +1521,47 @@ export function canonicalChunkId(ctx, regionBytes, N, reachMemo) {
         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 = [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 = new Array(forms.length);
+        let bestId = null;
+        let bestReach = 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)

package/dist/src/mind/bridge.js

@@ -92,7 +92,7 @@
 import { cosine } from "../vec.js";
 import { conceptThreshold, dominates, significanceBar } from "../geometry.js";
 import { bytesEqual, indexOf } from "../bytes.js";
-import { foldTree, perceive, read } from "./primitives.js";
+import { exactNode, perceive, read } from "./primitives.js";
 import { chainReach, leafIdRun } from "./canonical.js";
 import { allWindowsAreScaffolding, corpusN, edgeAncestors, hubBound, sharedReachMemo, } from "./traverse.js";
 import { rItem, rNode } from "./trace.js";
@@ -438,7 +438,7 @@ async function bridgeImpl(ctx, query, proposed) {
             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;
             }
@@ -457,7 +457,7 @@ async function bridgeImpl(ctx, query, proposed) {
     // 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/dist/src/mind/derivation.d.ts

@@ -204,3 +204,43 @@ export declare function closure(d: DerivationState, query: Uint8Array, W: number
 onTaken?: (before: DerivationState, after: DerivationState, witnesses: ReadonlyArray<Witness>) => void, 
 /** Called when the law refused the continuation the layer offered. */
 onRefused?: (at: DerivationState) => void): Promise<DerivationState>;
+/** 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 declare function closeOver(d: DerivationState, query: Uint8Array, W: number, layers: ReadonlyArray<ClosureLayer>, enter?: (name: string, walk: () => Promise<DerivationState>) => Promise<DerivationState>): Promise<DerivationState>;

package/dist/src/mind/derivation.js

@@ -334,3 +334,37 @@ onRefused) {
         d = next;
     }
 }
+/** 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, query, W, layers, enter) {
+    for (const layer of layers) {
+        if (d.fixed)
+            return d;
+        if (layer.engages !== undefined && !layer.engages(d))
+            continue;
+        const from = d;
+        const walk = async () => {
+            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/dist/src/mind/evidence.d.ts

@@ -0,0 +1,24 @@
+/** 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 declare function windowIndex(bytes: Uint8Array, W: number): WindowIndex;
+/** 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 declare function unspoken(index: WindowIndex, spoken: ReadonlyArray<WindowIndex>): WindowIndex;
+/** 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 declare function witness(form: Uint8Array, indexes: ReadonlyArray<WindowIndex>, W: number): Witnessing;

package/dist/src/mind/evidence.js

@@ -0,0 +1,90 @@
+// 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";
+export function windowIndex(bytes, W) {
+    const index = 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, spoken) {
+    const out = new Map();
+    for (const [key, at] of index) {
+        if (!spoken.some((s) => s.has(key)))
+            out.set(key, at);
+    }
+    return out;
+}
+/** 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, indexes, W) {
+    const none = { complete: false, spans: [], bytes: 0 };
+    if (form.length < W || indexes.length === 0)
+        return none;
+    const covered = new Uint8Array(form.length);
+    const own = [];
+    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 = [];
+    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 };
+}

package/dist/src/mind/graph-search.d.ts

@@ -46,6 +46,11 @@ export type GItem = {
      *  consolidated, more-explanatory reading wins over leaving the parts split.
      *  See {@link GraphSearch.fuse} and {@link GraphSearch.formRules}. */
     rcmp?: boolean;
+    /** Set on a concept hop's ASKING form: the edge-less form `node` whose halo
+     *  target the caller has not granted yet, held at the hop's own cost and
+     *  span.  Popping it asks for the target; it leads nowhere itself, so it
+     *  is never part of a final derivation (see {@link Licence}). */
+    ask?: boolean;
 } | {
     kind: "out";
     i: number;
@@ -145,6 +150,45 @@ export interface DerivationItem {
  *  conclusion shape (the rules carry no label, so this classifies by structure,
  *  the single place that maps rule geometry to a name). */
 export type DerivationMove = "axiom" | "follow-edge" | "concept-hop" | "voice" | "ground" | "splice-connector" | "split" | "fuse" | "recompose" | "derive-through" | "bridge" | "pool-vote" | "step";
+/** THE ASYNC PREMISES A COVER USES, RESOLVED ONLY WHERE THE SEARCH REACHES THEM.
+ *
+ *  Two of the cover's rules need data the synchronous search cannot fetch — a
+ *  connector splice (a bridge between two answers) and a concept hop (an
+ *  edge-less form's halo sibling) — and both used to be resolved for EVERY
+ *  candidate before the search ran.  A rule fires only from popped premises,
+ *  and the agenda pops in cost order up to the goal, so most of that work fed
+ *  rules the search never reached: measured on the 31.7M-node store, a 262-byte
+ *  query recognised whole paid 23 bridges (143,520 junction pops, 7.3 s of its
+ *  7.9 s) for sub-forms whose rewrites cost a STEP each and so never left the
+ *  agenda before the one-STEP goal — and then 1.2 s of halo reads for concept
+ *  hops priced at CONCEPT, ten times that goal.
+ *
+ *  So the caller OFFERS what it can resolve; where the search reaches an offered
+ *  key it uses a GRANTED value and ASKS for an ungranted one — a connector when
+ *  its splice's premises meet, a concept target when the hop's conclusion, held
+ *  as an asking form at the hop's own cost, is popped.  A run that asked
+ *  nothing is the run every key resolved in advance would have made: the pops
+ *  are decided only by the rules fired from popped items, a granted key fires
+ *  the very rule it fired before, and an asking form that was never popped fired
+ *  none.  So its cover is final.  A run that asked is PROVISIONAL: the caller
+ *  grants the asked keys (the async reads the search cannot run) and covers
+ *  again; every round grants at least one offered key, so the rounds end. */
+export interface Licence<K, V> {
+    /** Every key the caller can resolve. */
+    readonly offered: ReadonlySet<K>;
+    /** The keys resolved so far: their value, or null (nothing learnt). */
+    readonly granted: ReadonlyMap<K, V | null>;
+    /** Filled by the search: the offered keys it reached ungranted. */
+    readonly asked: Set<K>;
+}
+/** Connectors, keyed `L,R` by answer-node ids, valued by the learnt glue. */
+export type ConnectorLicence = Licence<string, Uint8Array>;
+/** Concept hops, keyed by an edge-less form's node, valued by the node its
+ *  halo sibling's edge leads to. */
+export type ConceptLicence = Licence<number, number>;
+/** Nothing offered: a cover with no async premises (a nested completion,
+ *  articulation's revoicing). */
+export declare function noLicence<K, V>(): Licence<K, V>;
 /** The lightest-derivation search over the Sema graph.  One instance binds the
  *  store, `maxGroup` (the fusible span ceiling), and the canonical
  *  {@link resolve} callback; {@link cover} then solves one query. */
@@ -162,13 +206,14 @@ export declare class GraphSearch {
      *  recursive completion), and chooseNext (distributional-evidence edge
      *  disambiguation when a recognised form has multiple continuations). */
     host: GraphSearchHost);
-    /** The nodes the QUERY canonically names — the same identity the store's keys
-     *  were written through.  A byte-exact test is not enough: the query writes
-     *  `Eiffel Tower country` and the deposited node is `eiffel tower country`, so
-     *  a join that filters the query's own subject by RAW bytes re-admits it —
-     *  measured: that is the trap's wrong answer (`The capital of Eiffel Tower
-     *  country is Berlin.`).  Cached by query identity, because the search is
-     *  reused across responses. */
+    /** The hub bound √N (bounded-reads.md) — the ONE fan-out cap, stated here
+     *  rather than imported from `traverse.ts` because this module is
+     *  deliberately host-based (it holds a bare Store, never a MindContext).
+     *  That is the same write/read-side duplication convention canonical.ts's
+     *  header documents: if the formula changes it must change in BOTH places.
+     *  It is stated ONCE per side, though — the expression used to be spelled
+     *  out at three call sites here, one of them inside a per-item rules
+     *  generator, and they had already drifted on the `Math.max(2, …)` floor. */
     private hubBound;
     /** Explore the Sema graph for the lightest cover of the query and return its
      *  chosen spans left-to-right — WITH the derivation's total weight (the g
@@ -185,8 +230,10 @@ export declare class GraphSearch {
      *
      *  Any learnt connector between two rewrites is spliced IN by the in-search
      *  connector rule (see {@link outRules}), so the returned spans already carry
-     *  it — there is no post-pass. */
-    cover(queryLen: number, sites: ReadonlyArray<Site>, conceptTarget: ReadonlyMap<number, number>, leaves: ReadonlyArray<Leaf>, splits: ReadonlySet<number>, substitutions?: ReadonlyMap<number, Uint8Array>, connectors?: ReadonlyMap<string, Uint8Array>, computedResults?: ReadonlyArray<ComputedResult>, 
+     *  it — there is no post-pass.  With a {@link ConnectorLicence}, a cover
+     *  returned while `connectors.asked` is non-empty is PROVISIONAL: grant the
+     *  asked pairs and cover again. */
+    cover(queryLen: number, sites: ReadonlyArray<Site>, concepts: ConceptLicence, leaves: ReadonlyArray<Leaf>, splits: ReadonlySet<number>, substitutions?: ReadonlyMap<number, Uint8Array>, connectors?: ConnectorLicence, computedResults?: ReadonlyArray<ComputedResult>, 
     /** When given, receives each solved span's lightest derivation — the full
      *  adapted A*LD proof tree as classified {@link DerivationStep}s — for the
      *  TOP cover AND every nested completion the sink is threaded into (see
@@ -262,11 +309,12 @@ export declare class GraphSearch {
     private bridgeRule;
     /** The connector-SPLICE rule for an oriented (l, r) pair, or null when the
      *  pair does not qualify — the ONE body behind {@link outRules}' two
-     *  mirror loops (this-as-left over resolved right partners, this-as-right
-     *  over resolved left partners).  Fires only when both sides are
+     *  mirror loops (this-as-left over offered right partners, this-as-right
+     *  over offered left partners).  Fires only when both sides are
      *  recognised, r starts at or after l ends, and the gap between them is
      *  empty or wholly recognised — never across the asker's own literal
-     *  separator. */
+     *  separator — and the pair's connector is granted and learnt.  A qualifying
+     *  pair not yet granted is ASKED for (see {@link ConnectorLicence}). */
     private trySplice;
     /** form(i,j,node,via): follow the graph out of `node`, or (in articulation)
      *  emit its substitute voice directly. */
@@ -307,6 +355,14 @@ export declare class GraphSearch {
      *  outs of a long query re-cover each distinct node at most once); reset at the
      *  top of {@link cover}. */
     private recompleteMemo;
+    /** {@link entityProposals}, per fact BYTES — a pure function of them while
+     *  the store is read-only (one response), so a fact the chart reaches as
+     *  several items (cover/fix variants, nested completions) is scanned once.
+     *  Reset at the top of {@link cover}, like {@link recompleteMemo}. */
+    private entityMemo;
+    /** The joins licensed under one cover's {@link Licence}, kept across its
+     *  re-covers (see {@link solve}). */
+    private readonly joinsKept;
     /** The derivation sink of the TOP cover, threaded into every nested
      *  completion so a produced form's own recompositions are reported in the
      *  same trace instead of vanishing after the first layer.  Undefined when
@@ -321,6 +377,21 @@ export declare class GraphSearch {
      *  most once per cover.  A Set, not a flag, because it states WHICH node is
      *  open — the invariant a reader needs to check the guard. */
     private recompleteOpen;
+    /** The ENTITIES a produced fact's bytes contain that lead somewhere — the
+     *  candidates a join may travel through.  The forms the fact CONTAINS, by the
+     *  same recogniser the query went through (so the evidence standard is the
+     *  query's), plus — because the recognition of a STORED WHOLE returns the
+     *  whole and stops (measured: one site, the fact's own node, for `The
+     *  director of Eva is Gustaf Molander.`) — the longest canonically-resolving
+     *  form at each offset.  A byte atom is never a subject.  The scan runs only
+     *  for a FORM (≥ W: per letter it measured 20-26 s in test/99), and each probe
+     *  is a `canonResolve` whose exact tier decides a miss by its segment probe,
+     *  without a fold.  The admission predicate is the store's `leadsSomewhere`
+     *  (edge or halo); the host lends its memoised form when it can.
+     *
+     *  The SOURCE of each proposal travels with it, so a refusal names which path
+     *  proposed the candidate.  Memoised per fact bytes ({@link entityMemo}). */
+    private entityProposals;
     /** DERIVE-THROUGH — a RULE this module's DeductionSystem was missing.  The
      *  A*LD library is untouched: this is one more `premises → conclusion + cost`
      *  rule in the system {@link buildSearch} hands to {@link lightestDerivation},
@@ -335,7 +406,10 @@ export declare class GraphSearch {
      *  fact reached through it.  On the ladder it is one STEP: a direct edge,
      *  exactly as following a literal continuation is.  Deterministic and
      *  point-probed (`resolve` + `nextFirst`, no scan), so it adds no read that
-     *  grows with the corpus.  The move is visible in the rationale as its own act
+     *  grows with the corpus.  Asked ONCE per fact a lightest derivation stood on
+     *  (the join license, {@link solve}) — never per fact the exploration merely
+     *  reached — so the number of facts it prices is the answer's, not the
+     *  corpus's.  The move is visible in the rationale as its own act
      *  (`classifyMove` reports `derive-through`), distinct from the
      *  byte-concatenating `fuse`/`splice` — and named `derive-through` rather than
      *  `join` so it cannot be read as the confluence mechanism's `Provenance`. */
@@ -343,8 +417,8 @@ export declare class GraphSearch {
     /** out(i,j,bytes,…): index it for the binary rules, then offer splicing a
      *  learnt connector (the in-search bridge), splitting (at a sub-leaf form
      *  boundary), bridging (cover(i) ∧ this → cover(j)), fusing with an adjacent
-     *  finalised out, and — for a produced fact — JOINING the entity it contains
-     *  with the query's tail ({@link deriveThrough}). */
+     *  finalised out, and — for a LICENSED fact — JOINING the entity it contains
+     *  with the query's tail ({@link deriveThrough}, granted in {@link solve}). */
     private outRules;
     /** Whether the query span [from, to) is wholly covered by RECOGNISED outs —
      *  the test that lets a connector jump across INTERIOR answers (an N-ary whole)