@hviana/sema 0.1.5 → 0.1.6

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

@@ -6,13 +6,13 @@ import type { PipelineMechanism, Precomputed } from "../pipeline-mechanism.js";
  *  matches and one meet, STEP each).  `used` carries the pair's exemplar
  *  anchors so the reasoning stage does not re-speak them. */
 export interface JoinResult {
-  bytes: Uint8Array;
-  used: ReadonlySet<number>;
-  accounted: Array<[number, number]>;
-  moves: number;
-  /** A human-readable label for the query bytes the meet left unexplained —
-   *  purely diagnostic, never priced. */
-  unexplained: string;
+    bytes: Uint8Array;
+    used: ReadonlySet<number>;
+    accounted: Array<[number, number]>;
+    moves: number;
+    /** A human-readable label for the query bytes the meet left unexplained —
+     *  purely diagnostic, never priced. */
+    unexplained: string;
 }
 /** The main confluence entry point.  Given a query, detect whether it weaves
  *  two or more INDEPENDENT constraints (ranked anchors supported by disjoint
@@ -20,9 +20,5 @@ export interface JoinResult {
  *  identity, and return the discriminative content the streams share — the
  *  entity that satisfies all constraints at once.  Null when the query is
  *  not conjunctive or nothing lies in the intersection. */
-export declare function confluenceJoin(
-  ctx: MindContext,
-  query: Uint8Array,
-  pre: Precomputed,
-): Promise<JoinResult | null>;
+export declare function confluenceJoin(ctx: MindContext, query: Uint8Array, pre: Precomputed): Promise<JoinResult | null>;
 export declare const confluenceMechanism: PipelineMechanism;

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

@@ -51,194 +51,163 @@ import { rItem, rNode } from "../trace.js";
  *  entity that satisfies all constraints at once.  Null when the query is
  *  not conjunctive or nothing lies in the intersection. */
 export async function confluenceJoin(ctx, query, pre) {
-  const W = ctx.space.maxGroup;
-  if (query.length < 2 * W || ctx.store.edgeSourceCount() === 0) {
-    return null;
-  }
-  const { ranked } = await pre.attention();
-  if (ranked.length < 2) {
-    return null;
-  }
-  const N = corpusN(ctx);
-  // Response-scoped shared memos: the anchor-window identities and the
-  // structural-IDF reach live on Precomputed, so any other identity-based
-  // mechanism in the same response reuses them.
-  const reachMemo = pre.reachMemo;
-  const windowsOfAnchor = (anchor) => pre.windowsOf(anchor);
-  // The query's own window identities, offset → id (the canonical
-  // content-addressed read, canonical.windowIds): whatever the meet shares
-  // with the query is the CONSTRAINT being re-named (or its scaffolding),
-  // never the open seat the question asks for — subtracted by identity,
-  // below.
-  const queryWin = pre.queryWindows;
-  const queryIds = new Set(queryWin.values());
-  const streams = [];
-  const rankedCapped = ranked.length > pre.k ? ranked.slice(0, pre.k) : ranked;
-  for (const cand of rankedCapped) {
-    if (streams.some((s) => s.anchor === cand.anchor)) {
-      continue;
-    }
-    const ids = new Set(windowsOfAnchor(cand.anchor).values());
-    if (ids.size === 0) {
-      continue;
-    }
-    const cover = [];
-    const held = [];
-    let curC = null;
-    let curH = null;
-    for (const [off, wid] of queryWin) {
-      if (!ids.has(wid)) {
-        continue;
-      }
-      if (curH !== null && off <= curH[1]) {
-        curH[1] = off + W;
-      } else {
-        held.push(curH = [off, off + W]);
-      }
-      if (dominates(reachOf(ctx, wid, N, reachMemo), N)) {
-        continue; // scaffolding never binds
-      }
-      if (curC !== null && off <= curC[1]) {
-        curC[1] = off + W;
-      } else {
-        cover.push(curC = [off, off + W]);
-      }
-    }
-    if (cover.length > 0) {
-      streams.push({ anchor: cand.anchor, vote: cand.vote, ids, cover, held });
-    }
-  }
-  if (streams.length < 2) {
-    return null;
-  }
-  // Two streams are INDEPENDENT constraints when the query content they
-  // hold is disjoint — each answers a different part of what was asked.
-  const disjoint = (a, b) =>
-    a.cover.every(([as, ae]) =>
-      b.cover.every(([bs, be]) => be <= as || bs >= ae)
-    );
-  let met = null;
-  for (let i = 0; i < streams.length; i++) {
-    for (let j = i + 1; j < streams.length; j++) {
-      const a = streams[i];
-      const b = streams[j];
-      if (!disjoint(a, b)) {
-        continue;
-      }
-      const wa = windowsOfAnchor(a.anchor);
-      const wb = b.ids;
-      // ── The MEET: in both anchors, not in the query ────────────────────
-      // Offsets of A whose window id is shared with B and absent from the
-      // query — merged into maximal contiguous spans (windows overlap, so
-      // consecutive shared offsets weave one span).
-      const spans = [];
-      let cur = null;
-      for (const [off, wid] of wa) {
-        const inMeet = wb.has(wid) && !queryIds.has(wid);
-        if (inMeet) {
-          if (cur !== null && off <= cur[1]) {
-            cur[1] = off + W;
-          } else {
-            spans.push(cur = [off, off + W]);
-          }
-        }
-      }
-      if (spans.length === 0) {
-        continue;
-      }
-      const aBytes = read(ctx, a.anchor);
-      for (const [s, e] of spans) {
-        // Scaffolding gate: the span's MOST discriminative window decides.
-        // Content reaching a corpus MAJORITY of contexts discriminates
-        // nothing (the same half-dominance convention every wrapper test
-        // uses); the query-subtraction above already removed everything the
-        // question names, so what survives here is a genuine open-seat
-        // entity.
-        let reach = Infinity;
-        for (let off = s; off + W <= e; off++) {
-          const wid = wa.get(off);
-          if (wid !== undefined && wb.has(wid) && !queryIds.has(wid)) {
-            reach = Math.min(reach, reachOf(ctx, wid, N, reachMemo));
-          }
+    const W = ctx.space.maxGroup;
+    if (query.length < 2 * W || ctx.store.edgeSourceCount() === 0)
+        return null;
+    const { ranked } = await pre.attention();
+    if (ranked.length < 2)
+        return null;
+    const N = corpusN(ctx);
+    // Response-scoped shared memos: the anchor-window identities and the
+    // structural-IDF reach live on Precomputed, so any other identity-based
+    // mechanism in the same response reuses them.
+    const reachMemo = pre.reachMemo;
+    const windowsOfAnchor = (anchor) => pre.windowsOf(anchor);
+    // The query's own window identities, offset → id (the canonical
+    // content-addressed read, canonical.windowIds): whatever the meet shares
+    // with the query is the CONSTRAINT being re-named (or its scaffolding),
+    // never the open seat the question asks for — subtracted by identity,
+    // below.
+    const queryWin = pre.queryWindows;
+    const queryIds = new Set(queryWin.values());
+    const streams = [];
+    const rankedCapped = ranked.length > pre.k ? ranked.slice(0, pre.k) : ranked;
+    for (const cand of rankedCapped) {
+        if (streams.some((s) => s.anchor === cand.anchor))
+            continue;
+        const ids = new Set(windowsOfAnchor(cand.anchor).values());
+        if (ids.size === 0)
+            continue;
+        const cover = [];
+        const held = [];
+        let curC = null;
+        let curH = null;
+        for (const [off, wid] of queryWin) {
+            if (!ids.has(wid))
+                continue;
+            if (curH !== null && off <= curH[1])
+                curH[1] = off + W;
+            else
+                held.push(curH = [off, off + W]);
+            if (dominates(reachOf(ctx, wid, N, reachMemo), N))
+                continue; // scaffolding never binds
+            if (curC !== null && off <= curC[1])
+                curC[1] = off + W;
+            else
+                cover.push(curC = [off, off + W]);
         }
-        if (!isFinite(reach) || dominates(reach, N)) {
-          continue;
+        if (cover.length > 0) {
+            streams.push({ anchor: cand.anchor, vote: cand.vote, ids, cover, held });
         }
-        const len = e - s;
-        if (
-          met === null || reach < met.reach ||
-          (reach === met.reach && len > met.len)
-        ) {
-          met = { bytes: aBytes.subarray(s, e), reach, len, a, b };
+    }
+    if (streams.length < 2)
+        return null;
+    // Two streams are INDEPENDENT constraints when the query content they
+    // hold is disjoint — each answers a different part of what was asked.
+    const disjoint = (a, b) => a.cover.every(([as, ae]) => b.cover.every(([bs, be]) => be <= as || bs >= ae));
+    let met = null;
+    for (let i = 0; i < streams.length; i++) {
+        for (let j = i + 1; j < streams.length; j++) {
+            const a = streams[i];
+            const b = streams[j];
+            if (!disjoint(a, b))
+                continue;
+            const wa = windowsOfAnchor(a.anchor);
+            const wb = b.ids;
+            // ── The MEET: in both anchors, not in the query ────────────────────
+            // Offsets of A whose window id is shared with B and absent from the
+            // query — merged into maximal contiguous spans (windows overlap, so
+            // consecutive shared offsets weave one span).
+            const spans = [];
+            let cur = null;
+            for (const [off, wid] of wa) {
+                const inMeet = wb.has(wid) && !queryIds.has(wid);
+                if (inMeet) {
+                    if (cur !== null && off <= cur[1])
+                        cur[1] = off + W;
+                    else
+                        spans.push(cur = [off, off + W]);
+                }
+            }
+            if (spans.length === 0)
+                continue;
+            const aBytes = read(ctx, a.anchor);
+            for (const [s, e] of spans) {
+                // Scaffolding gate: the span's MOST discriminative window decides.
+                // Content reaching a corpus MAJORITY of contexts discriminates
+                // nothing (the same half-dominance convention every wrapper test
+                // uses); the query-subtraction above already removed everything the
+                // question names, so what survives here is a genuine open-seat
+                // entity.
+                let reach = Infinity;
+                for (let off = s; off + W <= e; off++) {
+                    const wid = wa.get(off);
+                    if (wid !== undefined && wb.has(wid) && !queryIds.has(wid)) {
+                        reach = Math.min(reach, reachOf(ctx, wid, N, reachMemo));
+                    }
+                }
+                if (!isFinite(reach) || dominates(reach, N))
+                    continue;
+                const len = e - s;
+                if (met === null || reach < met.reach ||
+                    (reach === met.reach && len > met.len)) {
+                    met = { bytes: aBytes.subarray(s, e), reach, len, a, b };
+                }
+            }
         }
-      }
     }
-  }
-  if (met === null) {
-    return null;
-  }
-  const t = ctx.trace?.enter("confluence", [rItem(query, "query")]);
-  ctx.trace?.step(
-    "intersectEvidence",
-    [
-      rNode(ctx, met.a.anchor, "constraint", met.a.vote),
-      rNode(ctx, met.b.anchor, "constraint", met.b.vote),
-    ],
-    [rItem(met.bytes, "meet")],
-    `the discriminative content BOTH constraints' evidence shares, by content-addressed identity (reach ${met.reach} of ${N} contexts)`,
-  );
-  t?.done(
-    [rItem(met.bytes, "answer")],
-    "conjunctive join — the entity where the independent evidence streams meet",
-  );
-  // Evidence: the query spans whose content the two streams hold by
-  // identity (scaffolding included — held, not just the binding cover);
-  // the acts were two constraint matches and one meet.
-  const accounted = [
-    ...met.a.held,
-    ...met.b.held,
-  ];
-  return {
-    bytes: met.bytes,
-    used: new Set([met.a.anchor, met.b.anchor]),
-    accounted,
-    moves: 3 * STEP,
-    unexplained: unexplainedLabel(query, accounted),
-  };
+    if (met === null)
+        return null;
+    const t = ctx.trace?.enter("confluence", [rItem(query, "query")]);
+    ctx.trace?.step("intersectEvidence", [
+        rNode(ctx, met.a.anchor, "constraint", met.a.vote),
+        rNode(ctx, met.b.anchor, "constraint", met.b.vote),
+    ], [rItem(met.bytes, "meet")], `the discriminative content BOTH constraints' evidence shares, by content-addressed identity (reach ${met.reach} of ${N} contexts)`);
+    t?.done([rItem(met.bytes, "answer")], "conjunctive join — the entity where the independent evidence streams meet");
+    // Evidence: the query spans whose content the two streams hold by
+    // identity (scaffolding included — held, not just the binding cover);
+    // the acts were two constraint matches and one meet.
+    const accounted = [
+        ...met.a.held,
+        ...met.b.held,
+    ];
+    return {
+        bytes: met.bytes,
+        used: new Set([met.a.anchor, met.b.anchor]),
+        accounted,
+        moves: 3 * STEP,
+        unexplained: unexplainedLabel(query, accounted),
+    };
 }
 // ── Pipeline mechanism ──────────────────────────────────────────────────────
 export const confluenceMechanism = {
-  name: "confluence",
-  provenance: "join",
-  async floor(_ctx, query, pre, worthRunning) {
-    const W = _ctx.space.maxGroup;
-    if (query.length < 2 * W || _ctx.store.edgeSourceCount() === 0) {
-      return null;
-    }
-    // Confluence's floor is always exactly 3*STEP when it exists — same
-    // investment discipline as CAST's (see cast.ts): when the bound already
-    // cannot beat the incumbent, return it UNINVESTED (never first-touch the
-    // climb just to be pruned) and let the pipeline record the truthful
-    // "cannot beat incumbent" note.
-    if (!worthRunning(3 * STEP)) {
-      return 3 * STEP;
-    }
-    if ((await pre.attention()).ranked.length < 2) {
-      return null;
-    }
-    return 3 * STEP;
-  },
-  async run(ctx, query, pre) {
-    const met = await confluenceJoin(ctx, query, pre);
-    if (!met) {
-      return [];
-    }
-    return [{
-      bytes: met.bytes,
-      accounted: met.accounted,
-      moves: met.moves,
-      used: met.used,
-      unexplained: met.unexplained,
-    }];
-  },
+    name: "confluence",
+    provenance: "join",
+    async floor(_ctx, query, pre, worthRunning) {
+        const W = _ctx.space.maxGroup;
+        if (query.length < 2 * W || _ctx.store.edgeSourceCount() === 0)
+            return null;
+        // Confluence's floor is always exactly 3*STEP when it exists — same
+        // investment discipline as CAST's (see cast.ts): when the bound already
+        // cannot beat the incumbent, return it UNINVESTED (never first-touch the
+        // climb just to be pruned) and let the pipeline record the truthful
+        // "cannot beat incumbent" note.
+        if (!worthRunning(3 * STEP))
+            return 3 * STEP;
+        if ((await pre.attention()).ranked.length < 2)
+            return null;
+        return 3 * STEP;
+    },
+    async run(ctx, query, pre) {
+        const met = await confluenceJoin(ctx, query, pre);
+        if (!met)
+            return [];
+        return [{
+                bytes: met.bytes,
+                accounted: met.accounted,
+                moves: met.moves,
+                used: met.used,
+                unexplained: met.unexplained,
+            }];
+    },
 };

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

@@ -1,12 +1,6 @@
 import type { MindContext } from "../types.js";
 import type { 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>,
-): Promise<Map<string, Uint8Array>>;
+export declare function resolveConcepts(ctx: MindContext, sites: Site[]): Promise<Map<number, number>>;
+export declare function resolveConnectors(ctx: MindContext, sites: ReadonlyArray<Site>): Promise<Map<string, Uint8Array>>;
 export declare const coverMechanism: PipelineMechanism;