@hviana/sema 0.1.5 → 0.1.6

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

@@ -17,225 +17,163 @@ 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;
+    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);
     }
-    visited.add(n);
-    if (ctx.store.hasNext(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)");
     }
-    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;
+    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);
+    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);
+            }
+        }
     }
-  };
-  for (let i = 0; i + 1 < ordered.length; i++) {
-    if (ordered[i].end !== ordered[i + 1].start) {
-      continue;
+    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) });
     }
-    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 (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 orderedNodes = [];
-  const seenN = new Set();
-  for (const s of ordered) {
-    const node = guidedFirst(ctx, s.payload) ?? s.payload;
-    if (seenN.has(node)) {
-      continue;
+    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)");
     }
-    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;
+    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,47 +17,29 @@ 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
@@ -72,11 +54,7 @@ export declare function skillExemplar(
  *  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.
@@ -85,9 +63,5 @@ export declare function isSpanShaped(
  *  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;