@hviana/sema 0.1.4 → 0.1.5

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

@@ -17,163 +17,225 @@ import { decodeText, unexplainedLabel } from "../rationale.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();
-    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);
+  const target = new Map();
+  const visited = new Set();
+  for (const { payload: n } of sites) {
+    if (visited.has(n)) {
+      continue;
     }
-    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)");
+    visited.add(n);
+    if (ctx.store.hasNext(n)) {
+      continue;
     }
-    return target;
+    const hop = await conceptHop(ctx, n);
+    if (hop !== null) {
+      target.set(n, hop);
+    }
+  }
+  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;
 }
 export async function resolveConnectors(ctx, sites) {
-    const links = new Map();
-    const ordered = [...sites].sort((a, b) => a.start - b.start);
-    const answerOf = (n) => guidedFirst(ctx, n) ?? n;
-    const bridgePair = async (l, r) => {
-        if (l === r || links.has(l + "," + r))
-            return;
-        const link = await bridge(ctx, read(ctx, l), read(ctx, r));
-        if (link !== null)
-            links.set(l + "," + r, link);
-    };
-    for (let i = 0; i + 1 < ordered.length; i++) {
-        if (ordered[i].end !== ordered[i + 1].start)
-            continue;
-        const lefts = [ordered[i].payload, answerOf(ordered[i].payload)];
-        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);
-            }
-        }
+  const links = new Map();
+  const ordered = [...sites].sort((a, b) => a.start - b.start);
+  const answerOf = (n) => guidedFirst(ctx, n) ?? n;
+  const bridgePair = async (l, r) => {
+    if (l === r || links.has(l + "," + r)) {
+      return;
+    }
+    const link = await bridge(ctx, read(ctx, l), read(ctx, r));
+    if (link !== null) {
+      links.set(l + "," + r, link);
     }
-    const orderedNodes = [];
-    const seenN = new Set();
-    for (const s of ordered) {
-        const node = guidedFirst(ctx, s.payload) ?? s.payload;
-        if (seenN.has(node))
-            continue;
-        seenN.add(node);
-        orderedNodes.push({ node, bytes: read(ctx, node) });
+  };
+  for (let i = 0; i + 1 < ordered.length; i++) {
+    if (ordered[i].end !== ordered[i + 1].start) {
+      continue;
     }
-    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;
-            const interior = await bridge(ctx, first.bytes, orderedNodes[m].bytes, allowance);
-            if (interior !== null)
-                links.set(key, interior);
-            middleBytes += orderedNodes[m].bytes.length;
-        }
+    const lefts = [ordered[i].payload, answerOf(ordered[i].payload)];
+    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 (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)");
+  }
+  const orderedNodes = [];
+  const seenN = new Set();
+  for (const s of ordered) {
+    const node = guidedFirst(ctx, s.payload) ?? s.payload;
+    if (seenN.has(node)) {
+      continue;
     }
-    return links;
+    seenN.add(node);
+    orderedNodes.push({ node, bytes: read(ctx, node) });
+  }
+  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;
+      const interior = await bridge(
+        ctx,
+        first.bytes,
+        orderedNodes[m].bytes,
+        allowance,
+      );
+      if (interior !== null) {
+        links.set(key, interior);
+      }
+      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;
 }
 // ── Pipeline mechanism ──────────────────────────────────────────────────────
 export const coverMechanism = {
-    name: "cover",
-    provenance: "cover",
-    async floor(_ctx, _query, _pre, _worthRunning) {
-        return 0;
-    },
-    async run(ctx, query, pre) {
-        const { rec, computed } = pre;
-        // Masking: computed spans are authoritative.  Remove recognised sites
-        // that overlap any computed span before building the cover search.
-        const sites = computed.length === 0
-            ? rec.sites
-            : rec.sites.filter((s) => !computed.some((u) => s.start < u.j && u.i < s.end));
-        if (computed.length > 0 && sites.length < rec.sites.length) {
-            ctx.trace?.step("maskByComputation", rec.sites.map((s) => rItem(query.subarray(s.start, s.end), "form", s.payload, [
-                s.start,
-                s.end,
-            ])), sites.map((s) => rItem(query.subarray(s.start, s.end), "form", s.payload, [
-                s.start,
-                s.end,
-            ])), "a computation always wins: recognised forms overlapping a computed span are dropped");
-        }
-        if (sites.length === 0 && computed.length === 0)
-            return [];
-        const connectors = await resolveConnectors(ctx, sites);
-        let splits = rec.splits;
-        if (computed.length > 0) {
-            splits = new Set(rec.splits);
-            for (const u of computed) {
-                splits.add(u.i);
-                splits.add(u.j);
-            }
-        }
-        const concepts = await resolveConcepts(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) => ({
-            i: u.i,
-            j: u.j,
-            bytes: u.bytes,
-            node: resolve(ctx, u.bytes) ?? undefined,
-        }));
-        const tCover = ctx.trace?.enter("cover", [
-            ...sites.map((s) => rItem(query.subarray(s.start, s.end), "form", s.payload, [
-                s.start,
-                s.end,
-            ])),
-            ...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);
-        const segs = solved && solved.segs;
-        tCover?.done(segs === null
-            ? []
-            : segs.map((s) => rItem(s.bytes, s.rec ? "chosen" : "bridge", s.node, [s.i, s.j])), segs === null
-            ? "no cover of the query composed"
-            : "lightest derivation: the chosen spans, left to right");
-        if (segs === null)
-            return [];
-        const composed = liftAnswer(segs, query.length);
-        if (composed === null)
-            return [];
-        ctx.trace?.step("liftAnswer", segs.map((s) => rItem(s.bytes, s.rec ? "chosen" : "scaffolding", s.node, [s.i, s.j])), [rItem(composed, "answer", resolve(ctx, composed) ?? undefined)], "lift the recognised region out of the asker's framing", tCover ? [tCover.index] : undefined);
-        // accounted = RECOGNISED cover spans only — PASS-carried bytes
-        // are priced in cost already; the diagnostic label reflects the
-        // same distinction.
-        const accounted = segs
-            .filter((s) => s.rec)
-            .map((s) => [s.i, s.j]);
-        return [{
-                bytes: composed,
-                accounted,
-                moves: 0,
-                weight: solved.cost, // A*LD derivation's g-value IS the weight
-                unexplained: unexplainedLabel(query, accounted),
-            }];
-    },
+  name: "cover",
+  provenance: "cover",
+  async floor(_ctx, _query, _pre, _worthRunning) {
+    return 0;
+  },
+  async run(ctx, query, pre) {
+    const { rec, computed } = pre;
+    // Masking: computed spans are authoritative.  Remove recognised sites
+    // that overlap any computed span before building the cover search.
+    const sites = computed.length === 0
+      ? rec.sites
+      : rec.sites.filter((s) =>
+        !computed.some((u) => s.start < u.j && u.i < s.end)
+      );
+    if (computed.length > 0 && sites.length < rec.sites.length) {
+      ctx.trace?.step(
+        "maskByComputation",
+        rec.sites.map((s) =>
+          rItem(query.subarray(s.start, s.end), "form", s.payload, [
+            s.start,
+            s.end,
+          ])
+        ),
+        sites.map((s) =>
+          rItem(query.subarray(s.start, s.end), "form", s.payload, [
+            s.start,
+            s.end,
+          ])
+        ),
+        "a computation always wins: recognised forms overlapping a computed span are dropped",
+      );
+    }
+    if (sites.length === 0 && computed.length === 0) {
+      return [];
+    }
+    const connectors = await resolveConnectors(ctx, sites);
+    let splits = rec.splits;
+    if (computed.length > 0) {
+      splits = new Set(rec.splits);
+      for (const u of computed) {
+        splits.add(u.i);
+        splits.add(u.j);
+      }
+    }
+    const concepts = await resolveConcepts(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) => ({
+      i: u.i,
+      j: u.j,
+      bytes: u.bytes,
+      node: resolve(ctx, u.bytes) ?? undefined,
+    }));
+    const tCover = ctx.trace?.enter("cover", [
+      ...sites.map((s) =>
+        rItem(query.subarray(s.start, s.end), "form", s.payload, [
+          s.start,
+          s.end,
+        ])
+      ),
+      ...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,
+    );
+    const segs = solved && solved.segs;
+    tCover?.done(
+      segs === null
+        ? []
+        : segs.map((s) =>
+          rItem(s.bytes, s.rec ? "chosen" : "bridge", s.node, [s.i, s.j])
+        ),
+      segs === null
+        ? "no cover of the query composed"
+        : "lightest derivation: the chosen spans, left to right",
+    );
+    if (segs === null) {
+      return [];
+    }
+    const composed = liftAnswer(segs, query.length);
+    if (composed === null) {
+      return [];
+    }
+    ctx.trace?.step(
+      "liftAnswer",
+      segs.map((s) =>
+        rItem(s.bytes, s.rec ? "chosen" : "scaffolding", s.node, [s.i, s.j])
+      ),
+      [rItem(composed, "answer", resolve(ctx, composed) ?? undefined)],
+      "lift the recognised region out of the asker's framing",
+      tCover ? [tCover.index] : undefined,
+    );
+    // accounted = RECOGNISED cover spans only — PASS-carried bytes
+    // are priced in cost already; the diagnostic label reflects the
+    // same distinction.
+    const accounted = segs
+      .filter((s) => s.rec)
+      .map((s) => [s.i, s.j]);
+    return [{
+      bytes: composed,
+      accounted,
+      moves: 0,
+      weight: solved.cost, // A*LD derivation's g-value IS the weight
+      unexplained: unexplainedLabel(query, accounted),
+    }];
+  },
 };

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

@@ -17,29 +17,47 @@ import type { PipelineMechanism, Precomputed } from "../pipeline-mechanism.js";
  *  explained for one mechanism and not the other, and the asymmetry, not
  *  the answers' merits, decided the grounding.)  Null when no skill
  *  applies. */
-export declare function extractBySkill(ctx: MindContext, query: Uint8Array, pre: Precomputed): Promise<{
+export declare function extractBySkill(
+  ctx: MindContext,
+  query: Uint8Array,
+  pre: Precomputed,
+): Promise<
+  {
     bytes: Uint8Array;
     accounted: Array<[number, number]>;
     unexplained: string;
-} | null>;
+  } | null
+>;
 /** Decompose an answer into substrings of its surrounding context, in order —
  *  the STRONG span-shape reading (see the section note above).  Returns null
  *  when no greedy longest-run decomposition exists.  Adjacent runs that
  *  connect contiguously are merged. */
-export declare function answerRunsInContext(_ctx: MindContext, context: Uint8Array, answer: Uint8Array): Array<{
+export declare function answerRunsInContext(
+  _ctx: MindContext,
+  context: Uint8Array,
+  answer: Uint8Array,
+):
+  | Array<{
     start: number;
     end: number;
     ansLen: number;
-}> | null;
+  }>
+  | null;
 /** Check whether an anchor is a span-shaped skill exemplar: it represents a
  *  fact whose context and answer together form a span-in-context pattern.
  *  If the anchor has a nextOf continuation, that is the answer and the anchor
  *  itself is the context.  Otherwise the anchor's prevOf parents provide
  *  candidate contexts, and the longest one whose span is span-shaped wins. */
-export declare function skillExemplar(ctx: MindContext, anchor: number, guide?: Vec | null): Promise<{
+export declare function skillExemplar(
+  ctx: MindContext,
+  anchor: number,
+  guide?: Vec | null,
+): Promise<
+  {
     contextBytes: Uint8Array;
     answerBytes: Uint8Array;
-} | null>;
+  } | null
+>;
 /** Whether the answer is a SPARSE subsequence of the context (bytes in
  *  order, arbitrary gaps) — the OPEN span-shape reading (see the section
  *  note above).  This is what lets extraction validate a MULTI-PIECE
@@ -54,7 +72,11 @@ export declare function skillExemplar(ctx: MindContext, anchor: number, guide?:
  *  with the same truth value.  The old pre-check re-perceived the context
  *  (a full river fold) per CANDIDATE in skillExemplar's √N-capped loop —
  *  pure cost, no discrimination. */
-export declare function isSpanShaped(_ctx: MindContext, context: Uint8Array, answer: Uint8Array): boolean;
+export declare function isSpanShaped(
+  _ctx: MindContext,
+  context: Uint8Array,
+  answer: Uint8Array,
+): boolean;
 /** STRICT containment: the answer's resolved node appears in the context's
  *  folded tree, or the answer occurs as one CONTIGUOUS byte run of the
  *  context.  This is real evidence the answer was drawn from the context.
@@ -63,5 +85,9 @@ export declare function isSpanShaped(_ctx: MindContext, context: Uint8Array, ans
  *  queries ("cold" is a gap-tolerant subsequence of most sentences holding
  *  c…o…l…d in order), and gating fusion on it silently starved multi-topic
  *  queries of their further points of attention. */
-export declare function containsSpan(ctx: MindContext, context: Uint8Array, answer: Uint8Array): boolean;
+export declare function containsSpan(
+  ctx: MindContext,
+  context: Uint8Array,
+  answer: Uint8Array,
+): boolean;
 export declare const extractionMechanism: PipelineMechanism;