@hviana/sema 0.9.0 → 0.9.1

package/dist/src/mind/learning.js

@@ -5,7 +5,7 @@
 import { addInto, normalize, zeros } from "../vec.js";
 import { bindSeat, companySignature, isChunk } from "../sema.js";
 import { changedNodes } from "./types.js";
-import { inputBytes, perceiveDeposit, resolve, } from "./primitives.js";
+import { inputBytes, perceiveDeposit, resolve } from "./primitives.js";
 import { canonicalWindows, leafIdPrefix } from "./canonical.js";
 import { rItem, rNode } from "./trace.js";
 import { hubBound } from "./traverse.js";

package/dist/src/mind/mechanisms/cover.d.ts

@@ -1,6 +1,22 @@
 import type { MindContext } from "../types.js";
-import type { Site } from "../graph-search.js";
+import type { ConceptLicence, ConnectorLicence, Site } from "../graph-search.js";
 import type { PipelineMechanism } from "../pipeline-mechanism.js";
-export declare function resolveConcepts(ctx: MindContext, sites: Site[]): Promise<Map<number, number>>;
-export declare function resolveConnectors(ctx: MindContext, sites: ReadonlyArray<Site>, query?: Uint8Array): Promise<Map<string, Uint8Array>>;
+/** The concept hops the cover may take, OFFERED up front and looked up only
+ *  when the search asks (see {@link Licence}): every recognised form with no
+ *  continuation of its own may borrow a halo sibling's. */
+export interface CoverConcepts extends ConceptLicence {
+    /** Look up the asked forms' concept targets not yet granted. */
+    grant(nodes: Iterable<number>): Promise<void>;
+}
+export declare function offerConcepts(ctx: MindContext, sites: ReadonlyArray<Site>): CoverConcepts;
+/** The connectors the cover may splice, OFFERED up front and BRIDGED only when
+ *  the search asks (see {@link ConnectorLicence}): every pair a learnt whole
+ *  could run together — two touching sites, each side as itself or as its
+ *  answer, in both orders — and, when three or more answers are recognised, the
+ *  first answer to each later one (the N-ary whole). */
+export interface CoverConnectors extends ConnectorLicence {
+    /** Bridge the asked pairs not yet granted. */
+    grant(keys: Iterable<string>): Promise<void>;
+}
+export declare function offerConnectors(ctx: MindContext, sites: ReadonlyArray<Site>, query?: Uint8Array): CoverConnectors;
 export declare const coverMechanism: PipelineMechanism;

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

@@ -16,31 +16,38 @@ import { liftAnswer, liftedScaffolding, segRestatesQuery } from "../types.js";
 import { decodeText } from "../rationale.js";
 import { insideAnsweredTurn, restates } from "../derivation.js";
 import { rItem, rNode, traceDerivation } from "../trace.js";
-// ── Concept / connector pre-resolution ──────────────────────────────────────
-export async function resolveConcepts(ctx, sites) {
-    const target = new Map();
-    const visited = new Set();
+export function offerConcepts(ctx, sites) {
+    const offered = new Set();
     for (const { payload: n } of sites) {
-        if (visited.has(n))
-            continue;
-        visited.add(n);
-        if (ctx.store.hasNext(n))
-            continue;
-        const hop = await conceptHop(ctx, n);
-        if (hop !== null)
-            target.set(n, hop);
+        if (!offered.has(n) && !ctx.store.hasNext(n))
+            offered.add(n);
     }
-    if (target.size > 0) {
-        ctx.trace?.step("resolveConcepts", [...target.keys()].map((n) => rNode(ctx, n, "edgeless-form")), [...target.values()].map((h) => rNode(ctx, h, "concept-sibling")), "borrow a synonym's continuation edge for each edge-less form (a concept/halo hop)");
-    }
-    return target;
+    const granted = new Map();
+    return {
+        offered,
+        granted,
+        asked: new Set(),
+        async grant(nodes) {
+            const found = [];
+            for (const n of nodes) {
+                if (granted.has(n))
+                    continue;
+                const hop = await conceptHop(ctx, n);
+                granted.set(n, hop);
+                if (hop !== null)
+                    found.push([n, hop]);
+            }
+            if (found.length > 0) {
+                ctx.trace?.step("resolveConcepts", found.map(([n]) => rNode(ctx, n, "edgeless-form")), found.map(([, h]) => rNode(ctx, h, "concept-sibling")), "borrow a synonym's continuation edge for each edge-less form the search reached (a concept/halo hop)");
+            }
+        },
+    };
 }
-export async function resolveConnectors(ctx, sites, query) {
-    const links = new Map();
+export function offerConnectors(ctx, sites, query) {
     const answerOf = (n) => guidedFirst(ctx, n) ?? n;
     // A site's continuation already present elsewhere in the query is stale
     // transcript evidence: cover still needs the site for structural context,
-    // but liftAnswer will trim that continuation as already answered. Building
+    // but liftAnswer will trim that continuation as already answered. Offering
     // pairwise/n-ary bridges for it can only create connectors that are later
     // discarded — a semantically neutral gate (it removes work whose product
     // liftAnswer throws away), and a cumulative (multi-turn) query is exactly
@@ -81,15 +88,7 @@ export async function resolveConnectors(ctx, sites, query) {
             return restates(query, bytes, 0);
         });
     });
-    const bridgePair = async (l, r) => {
-        if (l === r || links.has(l + "," + r))
-            return;
-        if (ctx.meter)
-            ctx.meter.coverBridges++;
-        const link = await bridge(ctx, read(ctx, l), read(ctx, r));
-        if (link !== null)
-            links.set(l + "," + r, link);
-    };
+    const pairwise = new Set();
     for (let i = 0; i + 1 < ordered.length; i++) {
         if (ordered[i].end !== ordered[i + 1].start)
             continue;
@@ -97,8 +96,10 @@ export async function resolveConnectors(ctx, sites, query) {
         const rights = [ordered[i + 1].payload, answerOf(ordered[i + 1].payload)];
         for (const l of new Set(lefts)) {
             for (const r of new Set(rights)) {
-                await bridgePair(l, r);
-                await bridgePair(r, l);
+                if (l === r)
+                    continue;
+                pairwise.add(l + "," + r);
+                pairwise.add(r + "," + l);
             }
         }
     }
@@ -111,37 +112,61 @@ export async function resolveConnectors(ctx, sites, query) {
         seenN.add(node);
         orderedNodes.push({ node, bytes: read(ctx, node) });
     }
+    const nary = new Map();
     if (orderedNodes.length >= 3) {
         const first = orderedNodes[0];
         const W = ctx.space.maxGroup;
         let middleBytes = 0; // Σ bytes of the answers BETWEEN first and m-th
         for (let m = 1; m < orderedNodes.length; m++) {
-            const key = first.node + "," + orderedNodes[m].node;
-            if (links.has(key)) {
-                middleBytes += orderedNodes[m].bytes.length;
-                continue;
-            }
             // The N-ary interior legitimately holds every intermediate answer
             // plus one W-quantum of glue per joint — pass that allowance so the
-            // bridge's phrase-scale cap admits the whole learnt run.
-            const allowance = middleBytes + (m + 1) * W;
-            if (ctx.meter) {
-                ctx.meter.coverBridges++;
-                ctx.meter.coverAllowanceBytes += allowance;
-            }
-            const interior = await bridge(ctx, first.bytes, orderedNodes[m].bytes, allowance);
-            if (interior !== null)
-                links.set(key, interior);
+            // bridge's phrase-scale cap admits the whole learnt run.  Asked only
+            // when the pairwise bridge of the same key (if offered) found nothing.
+            nary.set(first.node + "," + orderedNodes[m].node, {
+                left: first.bytes,
+                right: orderedNodes[m].bytes,
+                allowance: middleBytes + (m + 1) * W,
+            });
             middleBytes += orderedNodes[m].bytes.length;
         }
     }
-    if (links.size > 0) {
-        ctx.trace?.step("resolveConnectors", ordered.map((s) => rItem(read(ctx, s.payload), "answer", s.payload)), [...links.entries()].map(([pair, bytes]) => ({
-            text: `${pair}: "${decodeText(bytes)}"`,
-            role: "connector",
-        })), "the bytes the graph splices between adjacent answers (asked of the gist space)");
-    }
-    return links;
+    const granted = new Map();
+    return {
+        offered: new Set([...pairwise, ...nary.keys()]),
+        granted,
+        asked: new Set(),
+        async grant(keys) {
+            const found = [];
+            for (const key of keys) {
+                if (granted.has(key))
+                    continue;
+                let link = null;
+                if (pairwise.has(key)) {
+                    const comma = key.indexOf(",");
+                    if (ctx.meter)
+                        ctx.meter.coverBridges++;
+                    link = await bridge(ctx, read(ctx, Number(key.slice(0, comma))), read(ctx, Number(key.slice(comma + 1))));
+                }
+                const whole = nary.get(key);
+                if (link === null && whole !== undefined) {
+                    if (ctx.meter) {
+                        ctx.meter.coverBridges++;
+                        ctx.meter.coverAllowanceBytes += whole.allowance;
+                    }
+                    link = await bridge(ctx, whole.left, whole.right, whole.allowance);
+                }
+                granted.set(key, link);
+                if (link !== null)
+                    found.push([key, link]);
+            }
+            if (found.length > 0) {
+                ctx.trace?.step("resolveConnectors", ordered.map((s) => rItem(read(ctx, s.payload), "answer", s.payload)), found.map(([pair, bytes]) => ({
+                    text: `${pair}: "${decodeText(bytes)}"`,
+                    role: "connector",
+                })), "the bytes the graph splices between adjacent answers the search reached (asked of the gist space)");
+            }
+        },
+    };
 }
 // ── Pipeline mechanism ──────────────────────────────────────────────────────
 export const coverMechanism = {
@@ -169,8 +194,8 @@ export const coverMechanism = {
         if (sites.length === 0 && computed.length === 0)
             return [];
         const connectors = ctx.meter
-            ? await ctx.meter.time("cover.resolveConnectors", () => resolveConnectors(ctx, sites, query))
-            : await resolveConnectors(ctx, sites, query);
+            ? ctx.meter.timeSync("cover.offerConnectors", () => offerConnectors(ctx, sites, query))
+            : offerConnectors(ctx, sites, query);
         let splits = rec.splits;
         if (computed.length > 0) {
             splits = new Set(rec.splits);
@@ -180,13 +205,11 @@ export const coverMechanism = {
             }
         }
         const concepts = ctx.meter
-            ? await ctx.meter.time("cover.resolveConcepts", () => resolveConcepts(ctx, sites))
-            : await resolveConcepts(ctx, sites);
+            ? ctx.meter.timeSync("cover.offerConcepts", () => offerConcepts(ctx, sites))
+            : offerConcepts(ctx, sites);
         const coverDeps = [
             ctx.trace?.lastIndex("recognise"),
             ctx.trace?.lastIndex("computeExtensions"),
-            ctx.trace?.lastIndex("resolveConcepts"),
-            ctx.trace?.lastIndex("resolveConnectors"),
         ].filter((x) => x !== undefined);
         // Convert ComputedSpan[] to ComputedResult[] for the graph search.
         const computedResults = computed.map((u) => ({
@@ -202,7 +225,27 @@ export const coverMechanism = {
             ])),
             ...computedResults.map((u) => rItem(u.bytes, "computed")),
         ], coverDeps.length ? coverDeps : undefined);
-        const solved = ctx.search.cover(query.length, sites, concepts, rec.leaves, splits, undefined, connectors, computedResults, ctx.trace ? (steps) => traceDerivation(ctx, steps) : undefined);
+        // COVER, GRANT WHAT IT ASKED, COVER AGAIN — until a cover asks for nothing
+        // (see Licence in graph-search.ts).  Only the final cover's derivations reach the
+        // rationale; a provisional one is superseded, not part of the answer.
+        let derivations = [];
+        let solved;
+        for (;;) {
+            derivations = [];
+            solved = ctx.search.cover(query.length, sites, concepts, rec.leaves, splits, undefined, connectors, computedResults, ctx.trace ? (steps) => derivations.push(steps) : undefined);
+            if (concepts.asked.size === 0 && connectors.asked.size === 0)
+                break;
+            const grant = async () => {
+                await concepts.grant([...concepts.asked]);
+                await connectors.grant([...connectors.asked]);
+            };
+            if (ctx.meter)
+                await ctx.meter.time("cover.grant", grant);
+            else
+                await grant();
+        }
+        for (const steps of derivations)
+            traceDerivation(ctx, steps);
         const segs = solved && solved.segs;
         tCover?.done(segs === null
             ? []

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

@@ -32,7 +32,6 @@ export async function recallByResonance(ctx, query, pre) {
             ...(complete ? { complete } : {}),
         };
     };
-    const k = pre.k;
     const queryGist = pre.guide;
     // 0. Exact self-match — content-addressed, deterministic.
     const qId = pre.queryResolved;

package/dist/src/mind/mind.js

@@ -11,14 +11,14 @@
 import { makeKeyring, rng, setVecConfig } from "../vec.js";
 import { sampleCorpus, searchCorpus } from "./corpus.js";
 import { Alphabet } from "../alphabet.js";
-import { contentFoldIncremental, reachThreshold, } from "../geometry.js";
+import { contentFoldIncremental, reachThreshold } from "../geometry.js";
 import { keyEnds } from "./canonical.js";
 import { BoundedMap } from "../store.js";
 import { SQliteStore } from "../store-sqlite.js";
 import { resolveConfig } from "../config.js";
 import { canonHash, textCanon, textEdgeTrim } from "../canon.js";
 import { bytesEqual, concat2 } from "../bytes.js";
-import { GraphSearch, } from "./graph-search.js";
+import { GraphSearch } from "./graph-search.js";
 import { Alu } from "../alu/src/index.js";
 import { decodeText, Rationale, } from "./rationale.js";
 import { canonResolve as canonResolveImpl, gistOf, inputBytes, perceive as perceiveImpl, perceiveKey, resolve as resolveImpl, } from "./primitives.js";

package/dist/src/mind/pipeline.d.ts

@@ -1,6 +1,6 @@
 import type { MindContext } from "./types.js";
 import { type PipelineMechanism } from "./pipeline-mechanism.js";
-export { resolveConcepts, resolveConnectors } from "./mechanisms/cover.js";
+export { offerConcepts, offerConnectors } from "./mechanisms/cover.js";
 export { aluToMechanism } from "./mechanisms/alu.js";
 export declare const defaultMechanisms: PipelineMechanism[];
 export type Provenance = "cast" | "join" | "cover" | "extract" | "reference" | "recall" | "recall-echo" | "prefix";
@@ -60,6 +60,10 @@ export interface RegimePredictionData {
      *  CAST's floor) — the bar the incumbent must sit at or below for the
      *  consensus climb to be skipped. */
     climbFloorGrade: number;
+    /** The lowest grade reached by a mechanism run AHEAD of a dearer one (see
+     *  the grounding loop), when one ran and grounded: a bound below
+     *  `climbFloorGrade` makes the regime retrieval whatever the incumbent. */
+    boundGrade?: number;
 }
 /** Think: a single lightest-derivation exploration of the Sema graph.
  *