@hviana/sema 0.9.0 → 0.9.1

package/dist/src/mind/graph-search.js

@@ -48,9 +48,6 @@ function pushInto(mp, k, v) {
     else
         mp.set(k, [v]);
 }
-/** Read the chosen spans back off a derivation: the goal is a chain of bridge
- *  steps, each whose second premise is the `out` it crossed.  Walk the chain to
- *  the axiom and reverse into left-to-right order. */
 /** The BYTE TERM of a derivation's cost: how many bytes its bridge rule charged
  *  at PASS each — read back off the rule that charged them (`bridgeRule`:
  *  `o.rec ? MICRO : PASS * (o.j - o.i)`), so the split exists in ONE place and
@@ -74,6 +71,9 @@ function readBridgedBytes(derivation) {
     }
     return bytes;
 }
+/** Read the chosen spans back off a derivation: the goal is a chain of bridge
+ *  steps, each whose second premise is the `out` it crossed.  Walk the chain to
+ *  the axiom and reverse into left-to-right order. */
 function readCover(derivation) {
     const segs = [];
     let node = derivation;
@@ -95,6 +95,43 @@ function readCover(derivation) {
     segs.reverse();
     return segs;
 }
+/** The chart's canonical key — an item's boundary signature (see
+ *  {@link DeductionSystem.key}).  Module-level because the join license
+ *  ({@link GraphSearch.solve}) names facts by the same key the chart does. */
+function chartKey(it) {
+    if (it.kind === "cover")
+        return "c" + it.p;
+    if (it.kind === "form") {
+        return `f${it.i}.${it.j}.${it.node}.${it.via ? 1 : 0}.${it.rcmp ? 1 : 0}${it.ask ? "?" : ""}`;
+    }
+    return `o${it.i}.${it.j}.${it.cover ? 1 : 0}.${it.rec ? 1 : 0}.${it.fix ? 1 : 0}.${it.throughFact ? 1 : 0}.${it.node ?? -1}.${latin1(it.bytes)}`;
+}
+/** The facts a derivation STANDS ON — every node-bearing `out` in its proof
+ *  tree, premises before conclusions, each once. */
+function factsOf(root) {
+    const out = [];
+    const seen = new Set();
+    const walk = (d) => {
+        if (seen.has(d))
+            return;
+        seen.add(d);
+        for (const p of d.premises)
+            walk(p);
+        if (d.item.kind === "out" && d.item.node !== undefined)
+            out.push(d.item);
+    };
+    walk(root);
+    return out;
+}
+/** Whether a run asked for anything — its cover is then provisional. */
+function asked(concepts, connectors) {
+    return concepts.asked.size > 0 || (connectors?.asked.size ?? 0) > 0;
+}
+/** Nothing offered: a cover with no async premises (a nested completion,
+ *  articulation's revoicing). */
+export function noLicence() {
+    return { offered: new Set(), granted: new Map(), asked: new Set() };
+}
 /** Flatten a {@link GItem} into the {@link DerivationItem} a rationale shows. */
 function derivationItem(it) {
     if (it.kind === "cover")
@@ -217,17 +254,9 @@ export class GraphSearch {
         this.maxGroup = maxGroup;
         this.host = host;
     }
-    /** 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).
+    /** 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
@@ -251,8 +280,10 @@ export 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, sites, conceptTarget, leaves, splits, substitutions, connectors, computedResults, 
+     *  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, sites, concepts, leaves, splits, substitutions, connectors, computedResults, 
     /** 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
@@ -265,11 +296,15 @@ export class GraphSearch {
         // through (completion is cover, recursively — see {@link recompleteNode}).
         this.recompleteOpen.clear();
         this.recompleteMemo = new Map();
+        this.entityMemo = new Map();
         // The top cover's derivation sink is threaded into every nested completion
         // so the recompositions a produced form needs are reported in the same
         // trace instead of vanishing after the first layer.
         this.derivationSink = onDerivation;
-        const solved = this.solve(queryLen, { sites, leaves, splits }, conceptTarget, substitutions, connectors, computedResults, onDerivation);
+        concepts.asked.clear();
+        if (connectors)
+            connectors.asked.clear();
+        const solved = this.solve(queryLen, { sites, leaves, splits }, concepts, substitutions, connectors, computedResults, onDerivation);
         // Deepening runs HERE, once, on the derivation the top cover CHOSE — never
         // inside the nested solve a completion runs.  Nesting the deepening is what
         // made per-query cost track how densely the corpus interconnects the forms
@@ -277,7 +312,10 @@ export class GraphSearch {
         // continuations instead of following the chain the answer itself licensed.
         // With deepening only at the top, `recompleteNode` walks the accepted chain
         // one link at a time (its own memo and stack), so the work is the answer's.
-        return solved === null ? null : {
+        // A provisional cover is not deepened: it is about to be re-covered.
+        if (solved === null || asked(concepts, connectors))
+            return solved;
+        return {
             segs: this.deepen(solved.segs),
             cost: solved.cost,
             moves: solved.moves,
@@ -296,18 +334,78 @@ export class GraphSearch {
      *  decomposition may therefore run as deep as the graph licenses — three
      *  decomposes, two recomposes, any mix — and stops only when it reaches a node
      *  that leads nowhere new, never at an arbitrary count. */
-    solve(spanLen, recognition, conceptTarget, substitutions, connectors, computedResults, onDerivation) {
-        const system = this.buildSearch(spanLen, recognition.sites, conceptTarget, recognition.leaves, recognition.splits, substitutions, connectors, computedResults);
+    solve(spanLen, recognition, concepts, substitutions, connectors, computedResults, onDerivation) {
+        // The query's own bytes, tiled from its perceived leaves.  A JOIN reads the
+        // tail a produced fact's contained entity has to combine with, and the
+        // search otherwise only ever sees positions, never the bytes behind them.
+        const queryBytes = new Uint8Array(spanLen);
+        for (const lf of recognition.leaves) {
+            queryBytes.set(lf.bytes.subarray(0, lf.end - lf.start), lf.start);
+        }
+        // The nodes this span's recognition names — read ONCE per solve, on the first
+        // join that asks, instead of re-reading the memo per fact.
+        let queryNodeSet;
+        const queryNodes = () => queryNodeSet ??= new Set((this.host.recogniseSpan?.(queryBytes)?.sites ?? []).map((s) => s.payload));
+        // THE JOIN DERIVES THROUGH THE FACTS THE DERIVATION STANDS ON — never
+        // through every fact the exploration REACHES.  How many facts the search
+        // reaches is set by how densely the corpus interconnects the forms on the
+        // way (a dialogue hub's continuations, walked to their fixpoints, are
+        // thousands), and pricing a join from each of them made the work track the
+        // corpus instead of the answer: measured on the 31.7M-node store, a 46-byte
+        // query reached 2,000+ fixpoints in a minute, each paying an entity scan,
+        // past 10 GB.  It is the trap {@link recompleteNode} already records, and
+        // the same cure as {@link deepen}: the expensive step runs on what the
+        // lightest derivation CHOSE.
+        //
+        // So the search runs to its lightest derivation, the facts that derivation
+        // stands on are LICENSED — their joins computed once — and it runs again
+        // with those joins as ordinary rules of the same system, priced exactly as
+        // before (the fact's own cost + STEP).  A join's conclusion is itself a fact
+        // the next derivation may stand on, so chains extend round by round until
+        // no newly licensed fact joins anything: the depth is the answer's, never a
+        // count.  A round is re-run only when a newly licensed fact DOES join, so a
+        // query whose facts join nothing pays one search, as before.
+        //
+        // The joins a covering round licensed are KEPT across a licence's re-covers:
+        // a round that asked for nothing is the very round the next re-cover repeats
+        // (see {@link Licence}), so its joins are the ones that re-cover would grant
+        // again.
+        const joins = this.joinsKept.get(concepts) ?? new Map();
+        this.joinsKept.set(concepts, joins);
         // Search-effort accounting (src/meter.ts): the chart's pops/pushes are
         // the cover's real cost, and a heuristic that stops being admissible
         // shows up as a pop count that explodes while the answer stays the same.
         const meter = this.host.meter;
-        const stats = meter ? { pops: 0, pushes: 0 } : undefined;
-        const derivation = lightestDerivation(system, stats);
-        if (meter && stats) {
-            meter.searches++;
-            meter.searchPops += stats.pops;
-            meter.searchPushes += stats.pushes;
+        let derivation;
+        for (;;) {
+            const system = this.buildSearch(spanLen, recognition.sites, concepts, recognition.leaves, recognition.splits, queryBytes, joins, substitutions, connectors, computedResults);
+            const stats = meter ? { pops: 0, pushes: 0 } : undefined;
+            derivation = lightestDerivation(system, stats);
+            if (meter && stats) {
+                meter.searches++;
+                meter.searchPops += stats.pops;
+                meter.searchPushes += stats.pushes;
+            }
+            // A round that ASKED for a connector is provisional: return it before any
+            // join is licensed from a derivation the granted connectors may change.
+            if (derivation === null || asked(concepts, connectors))
+                break;
+            let joined = false;
+            for (const fact of factsOf(derivation)) {
+                const k = chartKey(fact);
+                if (joins.has(k))
+                    continue;
+                if (meter)
+                    meter.joinFacts++;
+                const granted = [
+                    ...this.deriveThrough(fact, queryBytes, spanLen, queryNodes),
+                ].map((r) => ({ conclusion: r.conclusion, cost: r.cost }));
+                joins.set(k, granted);
+                if (granted.length > 0)
+                    joined = true;
+            }
+            if (!joined)
+                break;
         }
         // When covering under a substitution map (articulation), a form→out rule is
         // the form EMITTING the asker's voice, not grounding to its own answer — so
@@ -354,20 +452,13 @@ export class GraphSearch {
      *  adjacent fragments toward a known leaf (findLeaf) or branch (findBranch);
      *  a completion fused with its neighbour may spell a deeper learned form the
      *  flat probes can't name, recovered canonically by {@link resolve}. */
-    buildSearch(queryLen, sites, conceptTarget, leaves, splits, substitutions, connectors, computedResults) {
+    buildSearch(queryLen, sites, concepts, leaves, splits, queryBytes, joins, substitutions, connectors, computedResults) {
         const W = this.maxGroup; // fusible span ceiling (shortest composite bound)
         // Same corpus-scale hub floor {@link atomIsHub}/{@link atomReach} (traverse.ts)
         // derive for byte atoms — see {@link hubBound} below for why this module
         // states the formula itself instead of importing it.
         const atomsAreHubs = Math.max(1, Math.ceil((this.store.edgeSourceCount() * W) / 256)) > this.hubBound();
         const nodeBytes = (n) => this.store.bytesPrefix(n, ALL);
-        // The query's own bytes, tiled from its perceived leaves.  A JOIN reads the
-        // tail a produced fact's contained entity has to combine with, and `buildSearch`
-        // otherwise only ever sees positions, never the bytes behind them.
-        const queryBytes = new Uint8Array(queryLen);
-        for (const lf of leaves) {
-            queryBytes.set(lf.bytes.subarray(0, lf.end - lf.start), lf.start);
-        }
         // Content-addressed probes over the store's hash-cons maps — the same keys
         // training filled.  No byte-by-byte trie walk.
         const findLeafU = (b) => this.store.findLeaf(b) ?? undefined;
@@ -378,30 +469,80 @@ export class GraphSearch {
         const outsByEnd = new Map();
         const outsByNode = new Map();
         const coverableByStart = new Map();
-        // Index the connectors by their left and right answer-node, so the connector
-        // rule iterates only this out's FEW resolved partners (selective, and for the
-        // N-ary case O(parts) keys) instead of scanning every position pair — what
-        // keeps the in-search bridge bounded when many parts are recognised at once.
+        // Index the offered connectors by their left and right answer-node, so the
+        // connector rule iterates only this out's FEW offered partners (selective,
+        // and for the N-ary case O(parts) keys) instead of scanning every position
+        // pair — what keeps the in-search bridge bounded when many parts are
+        // recognised at once.
         const linksByLeft = new Map();
         const linksByRight = new Map();
         if (connectors) {
-            for (const [key, bytes] of connectors) {
+            for (const key of connectors.offered) {
                 const comma = key.indexOf(",");
                 const l = Number(key.slice(0, comma));
                 const r = Number(key.slice(comma + 1));
-                pushInto(linksByLeft, l, [r, bytes]);
-                pushInto(linksByRight, r, [l, bytes]);
+                pushInto(linksByLeft, l, [r, key]);
+                pushInto(linksByRight, r, [l, key]);
             }
         }
-        return {
-            key(it) {
-                if (it.kind === "cover")
-                    return "c" + it.p;
-                if (it.kind === "form") {
-                    return `f${it.i}.${it.j}.${it.node}.${it.via ? 1 : 0}.${it.rcmp ? 1 : 0}`;
+        // A SPAN'S CHEAPEST COMPLETION DOMINATES THE REST.  Coverage is positional:
+        // every recognised completion of [i, j) advances the cover from i to j at
+        // the same MICRO, so for the goal only the cheapest matters.  What else a
+        // completion can do turns on its BYTES — fuse it with a neighbour, splice a
+        // connector, join through it — and those rules fire from the completion the
+        // search would stand on for that span, never from every alternative it
+        // reached: the cure {@link deepen} and the join license already apply, for
+        // the same trap.  Measured on the 31.7M-node store, a 46-byte dialogue query
+        // reached 60,530 continuation forms and 57,072 fixpoints for its few spans —
+        // a greeting's thousands of replies, each a fixpoint at the same depth — and
+        // canonically resolved every one of them fused with its neighbours (5.4 s
+        // of an 8.6 s cover) to stand, in the end, on two hops.
+        //
+        // So a form or completion of [i, j) whose cost has reached that of a
+        // completion of [i, j) already yielded is DOMINATED and fires nothing: every
+        // completion it could lead to costs at least as much (local costs are
+        // non-negative and a form's rules keep its span), and a tie goes to the one
+        // yielded first — the evidence-preferred continuation, yielded first by
+        // {@link formRules}.  This is also what makes the stop-here offer a real
+        // horizon: a chain deeper than its first hop's stop (STEP + CONCEPT) is
+        // dominated by it, where before the PASS-priced goal let the search buy a
+        // thousand hops to look for one more byte.
+        const spanBest = new Map();
+        const spanOf = (i, j) => i * (queryLen + 1) + j;
+        const completes = (it) => it.kind === "out" && it.rec && it.cover;
+        const dominated = (it, cost) => {
+            if (it.kind === "cover")
+                return false;
+            if (it.kind === "out" && !completes(it))
+                return false;
+            const best = spanBest.get(spanOf(it.i, it.j));
+            if (best === undefined || best.cost > cost) {
+                if (completes(it))
+                    spanBest.set(spanOf(it.i, it.j), { cost, item: it });
+                return false;
+            }
+            return best.item !== it &&
+                (it.kind !== "out" || chartKey(best.item) !== chartKey(it));
+        };
+        const completing = function* (rules, costOf) {
+            for (const r of rules) {
+                const c = r.conclusion;
+                if (completes(c)) {
+                    let cost = r.cost;
+                    for (const p of r.premises)
+                        cost += costOf(p);
+                    const s = spanOf(c.i, c.j);
+                    const best = spanBest.get(s);
+                    if (best === undefined || cost < best.cost) {
+                        spanBest.set(s, { cost, item: c });
+                    }
                 }
-                return `o${it.i}.${it.j}.${it.cover ? 1 : 0}.${it.rec ? 1 : 0}.${it.fix ? 1 : 0}.${it.throughFact ? 1 : 0}.${it.node ?? -1}.${latin1(it.bytes)}`;
-            },
+                yield r;
+            }
+        };
+        const meter = this.host.meter;
+        return {
+            key: chartKey,
             *axioms() {
                 yield { item: { kind: "cover", p: 0 }, cost: 0 };
                 // One out per tree leaf — content-defined chunks, far fewer than bytes.
@@ -487,14 +628,19 @@ export class GraphSearch {
                 const right = it.kind === "cover" ? it.p : it.j;
                 return (queryLen - right) * MICRO;
             },
-            rules: (it) => {
+            rules: (it, costOf) => {
                 if (it.kind === "cover") {
                     return this.coverRules(it, coversDone, coverableByStart);
                 }
+                if (dominated(it, costOf(it))) {
+                    if (meter)
+                        meter.searchDominated++;
+                    return [];
+                }
                 if (it.kind === "form") {
-                    return this.formRules(it, conceptTarget, substitutions, nodeBytes, queryLen);
+                    return completing(this.formRules(it, concepts, substitutions, nodeBytes), costOf);
                 }
-                return this.outRules(it, {
+                return completing(this.outRules(it, {
                     W,
                     splits,
                     atomsAreHubs,
@@ -507,9 +653,9 @@ export class GraphSearch {
                     findBranchU,
                     linksByLeft,
                     linksByRight,
-                    queryBytes,
-                    queryLen,
-                });
+                    connectors,
+                    joins,
+                }), costOf);
             },
         };
     }
@@ -551,16 +697,22 @@ export class GraphSearch {
     }
     /** 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. */
-    trySplice(l, r, link, outsByEnd) {
+     *  separator — and the pair's connector is granted and learnt.  A qualifying
+     *  pair not yet granted is ASKED for (see {@link ConnectorLicence}). */
+    trySplice(l, r, key, licence, outsByEnd) {
         if (!l.rec || !r.rec || r.i < l.j)
             return null;
         if (!this.gapRecognised(l.j, r.i, outsByEnd))
             return null;
+        const link = licence.granted.get(key);
+        if (link === undefined)
+            licence.asked.add(key);
+        if (!link)
+            return null;
         return {
             premises: [l, r],
             conclusion: {
@@ -577,7 +729,12 @@ export class GraphSearch {
     }
     /** form(i,j,node,via): follow the graph out of `node`, or (in articulation)
      *  emit its substitute voice directly. */
-    *formRules(it, conceptTarget, substitutions, nodeBytes, queryLen) {
+    *formRules(it, concepts, substitutions, nodeBytes) {
+        // An asking form reached the agenda's front: the hop it stands for is due.
+        if (it.ask) {
+            concepts.asked.add(it.node);
+            return;
+        }
         // Articulation: emit voice bytes at the recognised span; the hop/concept/
         // emit chain is suppressed — the form contributes only its substitute.
         if (substitutions) {
@@ -611,41 +768,17 @@ export class GraphSearch {
             // guard then dead-ends it) with no way to reach the forward edge.
             // Forking offers every continuation as its own rule so the one that
             // genuinely advances (not a duplicate) is still reachable.
-            // A CHAIN HOP OFFERS ONLY WHAT THE QUESTION CAN PAY FOR.
             //
-            // `hubBound` = √N is the READ cap — every read here stays inside it — but
-            // it is not an exploration bound: measured, a hub of degree 1083 sits
-            // BELOW √N = 1559, so a hop offered all 1083 continuations, the chart grew
-            // to 3113 outs for a two-word question, and since every out with an
-            // uncovered tail probes its tail's prefixes (measured: 16 885 canonical
-            // probes = 87% of that query's work, and its 270 MB peak / 256 MB OOM),
-            // the cost came from OFFERING rather than from reading.
-            //
-            // The bound is derived, not tuned: a derivation of L hops consumes ~L
-            // units of the question, so a hop cannot be paid for by offering more
-            // continuations than the question has units —
-            // `ceil(queryLen / W)`, floored at 2 for plurality. It is QUERY-sized
-            // (invariant 5: no per-query read grows with N) and it leaves `hubBound`
-            // and every read untouched.
-            // THE OFFER IS THE CORPUS'S OWN STRUCTURE, and the search pays for
-            // exploring it.  There is no offer cap here any more: the traversal cap I
-            // had put on this hop was a short-circuit — it bounded what a hop could
-            // OFFER instead of charging for it — and it was not needed.
-            //
-            // MEASURED in the regime where it used to bite (`hubBound = ceil(√N)`
-            // GREATER than the hub's degree — reached in a fixture by choosing the
-            // degree below √N, so the trained store is not needed): with the cap the
-            // offer was 8/9/9 continuations at degrees 35/70/120; without it, 52/84/120
-            // — and the WORK is LINEAR in the degree, not quadratic: pushes 262/296/332,
-            // perceptions 530/592/757, while the PEAK is identical with and without the
-            // cap (218/415/689 MB against 215/410/662) because it is set by the store,
-            // not by the fan-out.  What made this hop expensive was never the fan-out
-            // breadth: it was the per-offer work, two duplicate/oversized computations
-            // since removed (the per-offset canonical scan, and the tail scan now
-            // restricted to the fold's boundaries).
-            //
-            // The residual, stated: the trained store's hub (degree 1 083) is an
-            // EXTRAPOLATION from this linear shape, not a measurement.
+            // THE OFFER IS THE CORPUS'S OWN STRUCTURE, and the search pays for it.
+            // In the closure law's terms (derivation.ts) a hop is a MOVE — it reaches
+            // structure the derivation has not stood on — so it is admitted on that
+            // ground and priced one STEP; the A*LD search, not a count, decides how
+            // many are worth taking.  `hubBound` is the READ cap (invariant 5) and
+            // nothing else bounds the offer: a cap on what a hop may OFFER was tried
+            // and removed as a short-circuit (trap 13).  Measured with the hub's
+            // degree below √N: the work is LINEAR in the degree (pushes 262/296/332 at
+            // degrees 35/70/120) and the peak is set by the store, not the fan-out
+            // (test/112 pins the non-quadratic shape).
             const nx = this.store.nextFirst(it.node, this.hubBound());
             // Count what is OFFERED, not what was read: the evidence-preferred
             // continuation is yielded too, even when it lies outside the cap.
@@ -799,8 +932,26 @@ export class GraphSearch {
             // Recognised but edge-less: borrow a concept (halo) sibling's edge.  No
             // edge and no concept means the form leads nowhere — it yields no rule, so
             // a query of only such forms produces no derivation, and think is silent.
-            const target = conceptTarget.get(it.node);
-            if (target !== undefined) {
+            // An offered form not yet granted yields the hop's ASKING form at the
+            // hop's own cost and span (see {@link Licence}).
+            if (!concepts.offered.has(it.node))
+                return;
+            const target = concepts.granted.get(it.node);
+            if (target === undefined) {
+                yield {
+                    premises: [it],
+                    conclusion: {
+                        kind: "form",
+                        i: it.i,
+                        j: it.j,
+                        node: it.node,
+                        via: true,
+                        ask: true,
+                    },
+                    cost: CONCEPT,
+                };
+            }
+            else if (target !== null) {
                 yield {
                     premises: [it],
                     conclusion: {
@@ -937,7 +1088,7 @@ export class GraphSearch {
                 sites: [...recognised, ...structural],
                 leaves: rec.leaves,
                 splits: rec.splits,
-            }, new Map(), undefined, undefined, undefined, this.derivationSink);
+            }, noLicence(), undefined, undefined, undefined, this.derivationSink);
             const answer = solved && concatBytes(solved.segs.map((s) => s.bytes));
             // ACCEPT, then CONTINUE THE CHAIN — but only along an accepted
             // completion.  A re-cover whose result is not itself a learnt node (the
@@ -966,6 +1117,14 @@ export class GraphSearch {
      *  outs of a long query re-cover each distinct node at most once); reset at the
      *  top of {@link cover}. */
     recompleteMemo = new Map();
+    /** {@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}. */
+    entityMemo = new Map();
+    /** The joins licensed under one cover's {@link Licence}, kept across its
+     *  re-covers (see {@link solve}). */
+    joinsKept = new WeakMap();
     /** 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
@@ -980,6 +1139,57 @@ export 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. */
     recompleteOpen = new Set();
+    /** 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}). */
+    entityProposals(factBytes) {
+        const memoKey = latin1(factBytes);
+        const hit = this.entityMemo.get(memoKey);
+        if (hit !== undefined)
+            return hit;
+        const leads = (id) => this.host.leadsSomewhere !== undefined
+            ? this.host.leadsSomewhere(id)
+            : this.store.leadsSomewhere(id);
+        const sites = this.host.recogniseSpan?.(factBytes)?.sites ?? [];
+        const proposed = new Map();
+        const source = new Map();
+        for (const s of sites) {
+            if (s.payload >= 0 && leads(s.payload)) {
+                proposed.set(s.payload, this.store.bytesPrefix(s.payload, ALL));
+                source.set(s.payload, "recognised site");
+            }
+        }
+        const W = this.maxGroup;
+        if (this.host.canonResolve !== undefined && factBytes.length >= W) {
+            const canon = this.host.canonResolve.bind(this.host);
+            for (let start = 0; start < factBytes.length; start++) {
+                for (let end = factBytes.length; end - start >= W; end--) {
+                    const id = canon(factBytes.subarray(start, end));
+                    if (id === null)
+                        continue;
+                    if (leads(id)) {
+                        proposed.set(id, this.store.bytesPrefix(id, ALL));
+                        source.set(id, "canonical fold");
+                    }
+                    break; // the longest form at this offset wins
+                }
+            }
+        }
+        const out = { proposed, source, sites };
+        this.entityMemo.set(memoKey, out);
+        return out;
+    }
     /** 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},
@@ -994,19 +1204,22 @@ export 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`. */
-    *deriveThrough(fact, queryBytes, queryLen) {
+    *deriveThrough(fact, queryBytes, queryLen, queryNodes) {
         if (!this.host.recogniseSpan)
             return;
         const tail = queryBytes.subarray(fact.j, queryLen);
         if (tail.length === 0)
             return;
-        // Report ONLY the invocations that could have joined: the search asks this
-        // rule for every finalized out with a node, which includes the one-byte
-        // outs the cover bridges with — measured, 68 refusals for a single
+        // Report ONLY the invocations that could have joined: a derivation stands on
+        // node-bearing outs of every width, including the one-byte outs the cover
+        // bridges with — measured, 68 refusals for a single
         // 3-relation query, all of them letters.  A form shorter than one window is
         // not a fact a join could travel through, so it is not a refusal worth
         // reporting; W is the same line the rest of the mind draws between a chance
@@ -1016,65 +1229,20 @@ export class GraphSearch {
         // same recogniser the query went through, so the evidence standard is the
         // query's.  A byte atom is never a subject; the fact's own node is the span
         // itself, not an entity inside it.  The admission predicate has ONE
-        // definition — `traverse.ts`'s `leadsSomewhere` (edge or halo); the host
-        // LENDS it when it can (Mind does, with the response-scoped struct cache),
-        // and a bare host falls back to the raw-store probe, so the search stays
+        // definition — the store's `leadsSomewhere` (edge or halo); the host LENDS
+        // its memoised form when it can (Mind does, with the response-scoped struct
+        // cache), and a bare host asks the store directly, so the search stays
         // host-based.
-        const factRec = this.host.recogniseSpan(fact.bytes);
-        const leads = (id) => this.host.leadsSomewhere !== undefined
-            ? this.host.leadsSomewhere(id)
-            : this.store.hasNext(id) || this.store.hasHalo(id);
+        const { proposed, source, sites: factSites } = this.entityProposals(fact.bytes);
         // THE QUERY'S OWN SUBJECT, CANONICALLY.  The filter used raw bytes and the
         // store's nodes are canonical, so `Eiffel Tower country` in the query did
         // not match the deposited `eiffel tower country` — measured, that is the
-        // trap's wrong answer.
-        //
-        // TAKEN FROM THE RECOGNITION THE RESPONSE ALREADY COMPUTED — the host's
-        // `recogniseSpan`, the same surface the rest of this search uses — not from
-        // a second offset scan.  `canonicalQueryNodes` re-derived, per byte offset,
-        // what `recognise` had already resolved once per query (its memo is keyed by
-        // content), and that scan was the largest single cost the DIANOT join added:
-        // measured against the pre-change tree, the same fixture and the same test
-        // were 21 s slower with the scan than without it.  A recognised site IS a
-        // canonical node of the query that can lead somewhere, which is exactly the
-        // set this filter wants, and it costs nothing to read.
-        const queryNodes = new Set((this.host.recogniseSpan?.(queryBytes)?.sites ?? []).map((s) => s.payload));
-        // TWO SOURCES, ONE ADMISSION.  The recognition of a STORED WHOLE returns the
-        // whole and stops — measured: for `The director of Eva is Gustaf Molander.`
-        // it yields exactly ONE site, the fact's own node — so the entity a join
-        // exists for is never proposed.  The canonical fold is the second source,
-        // and the scan runs only for a FORM (≥ W: a one-byte out is not something to
-        // join through, and running it per letter measured 20-26 s in test/99).
-        const W = this.maxGroup;
-        const proposed = new Map();
-        // The SOURCE of each proposal travels with it: a refusal that names only the
-        // bytes leaves the next reader guessing which path proposed them — three
-        // attempts at the chained join were spent fixing paths that never produced
-        // the offending candidate.
-        const source = new Map();
-        for (const s of factRec.sites) {
-            if (s.payload >= 0 && leads(s.payload)) {
-                proposed.set(s.payload, this.store.bytesPrefix(s.payload, ALL));
-                source.set(s.payload, "recognised site");
-            }
-        }
-        if (this.host.canonResolve !== undefined && fact.bytes.length >= W) {
-            const canon = this.host.canonResolve.bind(this.host);
-            for (let start = 0; start < fact.bytes.length; start++) {
-                for (let end = fact.bytes.length; end - start >= W; end--) {
-                    const id = canon(fact.bytes.subarray(start, end));
-                    if (id === null)
-                        continue;
-                    if (leads(id)) {
-                        proposed.set(id, this.store.bytesPrefix(id, ALL));
-                        source.set(id, "canonical fold");
-                    }
-                    break; // the longest form at this offset wins
-                }
-            }
-        }
+        // trap's wrong answer.  Read from the recognition the response already
+        // computed (`queryNodes`, once per solve), never from a second offset scan:
+        // a per-offset `canonicalQueryNodes` re-derived what `recognise` had
+        // resolved once, and was the largest single cost the join first added.
         const leading = [...proposed]
-            .filter(([payload]) => payload !== fact.node && !queryNodes.has(payload))
+            .filter(([payload]) => payload !== fact.node && !queryNodes().has(payload))
             .map(([payload, bytes]) => ({ payload, bytes }));
         // …then prefer the entity the query did NOT name, and the MAXIMAL one.  The
         // join exists to reach the subject the query never wrote, so:
@@ -1093,8 +1261,8 @@ export class GraphSearch {
                 // Report WHAT the recognition returned, not just that nothing led: the
                 // count and the first few site texts are the difference between "the
                 // fact was not recognised" and "it was recognised but nothing led".
-                const seen = factRec.sites.slice(0, 3).map((s) => this.store.bytesPrefix(s.payload, ALL));
-                this.host.reportSearch?.("deriveThroughMiss", [fact.bytes, tail, ...seen], `no entity inside the fact leads anywhere — ${factRec.sites.length} site(s) recognised inside it`);
+                const seen = factSites.slice(0, 3).map((s) => this.store.bytesPrefix(s.payload, ALL));
+                this.host.reportSearch?.("deriveThroughMiss", [fact.bytes, tail, ...seen], `no entity inside the fact leads anywhere — ${factSites.length} site(s) recognised inside it`);
             }
         }
         const candidates = leading
@@ -1199,12 +1367,12 @@ export 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}). */
     *outRules(it, ctx) {
         const { splits, coversDone, outsByStart, outsByEnd, coverableByStart } = ctx;
         const outsByNode = ctx.outsByNode;
-        const byRight = ctx.linksByRight ?? new Map();
+        const byRight = ctx.linksByRight;
         pushInto(outsByStart, it.i, it);
         pushInto(outsByEnd, it.j, it);
         if (it.rec && it.node !== undefined)
@@ -1221,24 +1389,26 @@ export class GraphSearch {
         // Points 2 & 5) — but NEVER across the asker's own unrecognised separator (a
         // space, comma), so "ice fire" stays "cold hot", never "cold or hot".
         //
-        // Cost stays bounded by iterating only the FEW resolved connector targets of
+        // Cost stays bounded by iterating only the FEW offered connector targets of
         // this out's node (links are selective and, for the N-ary case, keyed first→
         // later — O(parts), not O(parts²)), and matching them against finalised outs
-        // by node id, rather than scanning every position pair.
+        // by node id, rather than scanning every position pair.  A pair is bridged
+        // only once its two premises have met here ({@link ConnectorLicence}).
         const byLeft = ctx.linksByLeft;
-        if (byLeft && it.rec && it.node !== undefined) {
-            // L = this out, R = a later out whose node is a resolved target.
-            for (const [rNode, link] of byLeft.get(it.node) ?? []) {
+        const licence = ctx.connectors;
+        if (licence && it.rec && it.node !== undefined) {
+            // L = this out, R = a later out whose node is an offered target.
+            for (const [rNode, key] of byLeft.get(it.node) ?? []) {
                 for (const r of outsByNode.get(rNode) ?? []) {
-                    const rule = this.trySplice(it, r, link, outsByEnd);
+                    const rule = this.trySplice(it, r, key, licence, outsByEnd);
                     if (rule)
                         yield rule;
                 }
             }
-            // R = this out, L = an earlier out whose node has a resolved target here.
-            for (const [lNode, link] of byRight.get(it.node) ?? []) {
+            // R = this out, L = an earlier out whose node has an offered target here.
+            for (const [lNode, key] of byRight.get(it.node) ?? []) {
                 for (const l of outsByNode.get(lNode) ?? []) {
-                    const rule = this.trySplice(l, it, link, outsByEnd);
+                    const rule = this.trySplice(l, it, key, licence, outsByEnd);
                     if (rule)
                         yield rule;
                 }
@@ -1300,10 +1470,11 @@ export class GraphSearch {
         // continuation is the derived answer — a genuine relational join, distinct
         // from the confluence mechanism's `join` PROVENANCE — and not the
         // juxtaposition the cover produces when the intermediate key IS named.
-        // Fired per finalized out with a node, so it is the search's own rule, on
-        // the ladder, memoised by {@link key}, and bounded by the fact's own length.
-        if (it.node !== undefined) {
-            yield* this.deriveThrough(it, ctx.queryBytes, ctx.queryLen);
+        // On the ladder and memoised by {@link key} like every rule, but fired only
+        // for a fact the solve has LICENSED (a fact a lightest derivation stood on —
+        // see {@link solve}), from the joins computed for it once.
+        for (const g of ctx.joins.get(chartKey(it)) ?? []) {
+            yield { premises: [it], conclusion: g.conclusion, cost: g.cost };
         }
     }
     /** Whether the query span [from, to) is wholly covered by RECOGNISED outs —