@hviana/sema 0.9.0 → 0.9.1

package/test/152-the-read-side-names-as-the-write-side.test.mjs

@@ -0,0 +1,146 @@
+// 152-the-read-side-names-as-the-write-side.test.mjs — a stored deposit asked
+// verbatim resolves to itself, however the store named its branches.
+//
+// THE DEFECT.  `intern` (store.ts) names a branch by its children; when they
+// name none, it looks up the FLAT node over the same bytes and reuses it (step
+// 1b, "same bytes, same node").  Every deposit interns flat nodes — its whole
+// input and each canonical window — so a later deposit whose fold grouped
+// `ver` + `!` was stored with an earlier deposit's window `ver!` as that
+// child.  The read side (`exactNode`, `foldTree`) named branches by their
+// children alone, so it could never name such a deposit again: measured on the
+// 31.7M-node store, 7 of 80 dialogue turns asked verbatim resolved to nothing
+// and fell to the composition path (seconds instead of milliseconds).
+//
+// Pinned:
+//   152.1 the deposit resolves to its own context node, which leads to its
+//         continuation — through a branch named by its bytes;
+//   152.2 the identity fold and the vector fold name the same node;
+//   152.3 it is answered on the exact path — the cover alone, no consensus
+//         climb — not after the whole market (which reached the same reply
+//         through recall, 6 mechanism runs and a climb, before the fix).
+//   152.4 a name found ONLY through the bytes (a flat index entry, no learnt
+//         structure) is where the exact lookup used to miss, so `resolve`
+//         still asks the canonical class there — which holds the learnt
+//         member that continues;
+//   152.5 recognition does the same, so a query named only by such an entry
+//         is answered through the equivalent form that continues.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind } from "../dist/src/index.js";
+import { SQliteStore } from "../dist/src/store-sqlite.js";
+import {
+  exactNaming,
+  exactNode,
+  foldTree,
+  perceive,
+  resolve,
+} from "../dist/src/mind/primitives.js";
+import { textCanon } from "../dist/src/canon.js";
+
+const QUERY = "Hey, Sarah. Come check out my new river!";
+const REPLY = "Wow, you dug a trench.";
+const enc = (s) => new TextEncoder().encode(s);
+const dec = (b) => new TextDecoder().decode(b);
+
+async function fixture() {
+  const mind = new Mind({
+    seed: 7,
+    profile: true,
+    store: new SQliteStore({ path: ":memory:" }),
+  });
+  // `Clever!` interns the canonical window `ver!` FIRST, so the pair's own
+  // fold — which groups `ver` + `!` — is stored with that window as the child.
+  await mind.ingest([["Clever!", "a word"], [QUERY, REPLY]]);
+  return mind;
+}
+
+test("152.1 a deposit stored through a flat window resolves to its own context", async () => {
+  const mind = await fixture();
+  mind.beginResponse();
+  try {
+    const id = resolve(mind, enc(QUERY));
+    assert.notEqual(id, null, "the stored deposit must resolve");
+    const next = mind.store.nextFirst(id, 1);
+    assert.equal(dec(mind.store.bytes(next[0])), REPLY);
+    assert.ok(
+      mind.meter.flatBranchNames > 0,
+      "the fixture must exercise a branch the store named by its bytes",
+    );
+  } finally {
+    mind.endResponse();
+  }
+  await mind.store.close();
+});
+
+test("152.2 the identity fold and the vector fold name the same node", async () => {
+  const mind = await fixture();
+  mind.beginResponse();
+  try {
+    const bytes = enc(QUERY);
+    const viaIdentity = exactNode(mind, bytes);
+    const viaVectors = foldTree(mind, perceive(mind, bytes), 0).node;
+    assert.notEqual(viaIdentity, null);
+    assert.equal(viaIdentity, viaVectors);
+  } finally {
+    mind.endResponse();
+  }
+  await mind.store.close();
+});
+
+test("152.3 the deposit asked verbatim is answered on the exact path", async () => {
+  const mind = await fixture();
+  assert.equal(await mind.respondText(QUERY), REPLY);
+  const c = mind.lastCost.counters;
+  assert.equal(c.mechanismRuns, 1, "the cover alone must ground it");
+  assert.equal(c.climbs ?? 0, 0, "no consensus climb may run");
+  await mind.store.close();
+});
+
+/** A flat index entry for `tonight` with NO learnt structure over those bytes —
+ *  the state the 31.7M-node store holds for it (written by an earlier deposit
+ *  path; today's deposits always intern the structure beside the flat copy, so
+ *  the state is built through the store's own write API) — and the case-folded
+ *  `Tonight`, learnt with a continuation. */
+async function byteOnly() {
+  const mind = new Mind({
+    seed: 7,
+    profile: true,
+    store: new SQliteStore({ path: ":memory:", D: 1024, maxGroup: 4 }),
+  });
+  await mind.ingest([[
+    "Tonight",
+    "The composer of Tonight is Leonard Bernstein.",
+  ]]);
+  await mind.store.putBranch(
+    Array.from(enc("tonight"), (b) => -(b + 1)),
+    new Float32Array(1024).fill(1 / 32),
+  );
+  await mind.buildCanonIndex();
+  return mind;
+}
+
+test("152.4 a name found only through the bytes still asks the canonical class", async () => {
+  const mind = await byteOnly();
+  mind.beginResponse(undefined, textCanon);
+  try {
+    const named = exactNaming(mind, enc("tonight"));
+    assert.notEqual(named.id, null, "the flat entry names the bytes");
+    assert.equal(named.byBytes, true, "…and nothing but the bytes names them");
+    const id = resolve(mind, enc("tonight"));
+    assert.equal(dec(mind.store.bytes(id)), "Tonight");
+    assert.ok(mind.store.hasNext(id), "the class member that continues");
+  } finally {
+    mind.endResponse();
+  }
+  await mind.store.close();
+});
+
+test("152.5 a query named only by bytes is answered through the form that continues", async () => {
+  const mind = await byteOnly();
+  assert.equal(
+    await mind.respondText("tonight"),
+    "The composer of Tonight is Leonard Bernstein.",
+  );
+  await mind.store.close();
+});

package/test/153-a-cheaper-bound-is-looked-at-first.test.mjs

@@ -0,0 +1,155 @@
+// 153-a-cheaper-bound-is-looked-at-first.test.mjs — the market and the span
+// probe do the same work for less.
+//
+// THE MARKET.  Mechanisms run in declared order and are pruned by the
+// incumbent — but a mechanism floored LOWER than one about to invest, declared
+// after it, could not prune it.  Measured on the 31.7M-node store: a query that
+// opens a trained form (#114 of the battery) was won by prefix-completion at
+// grade 1 after CAST (floor grade 2) had paid the consensus climb and the weave,
+// and confluence, extraction and reference their reads.  The grounding loop now
+// runs such a mechanism AHEAD (pipeline.ts, "a cheaper bound is looked at before
+// a dearer one is paid for") and skips what cannot beat the grade it reaches.
+//
+// THE SPAN PROBE.  Recognition's interior pass probes every span of up to
+// `reach` bytes past each endpoint, and each probe hashed its span from the
+// start — O(n·reach²) bytes (251,660,406 for one response on that store).
+// `Store.flatSpans` extends the hash a start was last probed at instead.
+//
+// Pinned:
+//   153.1 a mechanism floored below CAST's, run ahead, skips CAST and the rest
+//         of the composition market — and the weave is never paid for;
+//   153.2 the decision is the declared order's: the same answer, from the same
+//         mechanism, as a market whose bounds are hidden from the run-ahead;
+//   153.3 a bound that does not undercut the dearer floor runs nothing ahead:
+//         a query the cover grounds whole runs the cover alone;
+//   153.4 the span prober answers exactly `findFlatBranch` over the same span,
+//         in every order a scanner can ask in.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind } from "../dist/src/index.js";
+import { SQliteStore } from "../dist/src/store-sqlite.js";
+
+const FORM =
+  "What time does the movie start? We would need to start between 7-7:30pm";
+const QUERY = "What time does the movie start?";
+
+async function fixture() {
+  const mind = new Mind({
+    seed: 7,
+    profile: true,
+    store: new SQliteStore({ path: ":memory:" }),
+  });
+  await mind.ingest([
+    [FORM, "Sure, let me check the showtimes."],
+    ["Do you like thrillers?", "Yes, I love them."],
+    ["The movie was great.", "I agree."],
+  ]);
+  return mind;
+}
+
+/** The decision a market reaches when no mechanism can be run ahead: every
+ *  floor answers the run-ahead's refusing probe with 0, which no later floor
+ *  undercuts — so the loop is the plain declared-order loop.  (A real
+ *  `worthRunning` accepts a floor of −∞; only the refusing probe declines it.) */
+function declaredOrder(mind) {
+  for (let i = 0; i < mind.mechanisms.length; i++) {
+    const m = mind.mechanisms[i];
+    mind.mechanisms[i] = {
+      ...m,
+      floor: (ctx, q, pre, worth) =>
+        worth(-Infinity) ? m.floor(ctx, q, pre, worth) : Promise.resolve(0),
+      run: m.run.bind(m),
+    };
+  }
+}
+
+/** The winning candidate's provenance, read off the rationale. */
+async function decide(mind, q) {
+  let winner = null;
+  const answer = await mind.respondText(q, (s) => {
+    if (s.mechanism.at(-1) === "decideGrounding") {
+      winner = s.data.candidates.find((c) => c.decided);
+    }
+  });
+  return { answer, winner };
+}
+
+test("153.1 a cheaper bound run ahead skips the composition market", async () => {
+  const mind = await fixture();
+  const answer = await mind.respondText(QUERY);
+  const c = mind.lastCost.counters;
+  const phases = mind.lastCost.phases;
+  assert.equal(answer, "Sure, let me check the showtimes.");
+  assert.ok(
+    c.mechanismsBounded >= 4,
+    `cast, confluence, extraction and reference are bounded out: ${c.mechanismsBounded}`,
+  );
+  assert.equal(phases["cast.run"], undefined, "CAST never runs");
+  assert.equal(phases["weave"], undefined, "the weave is never paid for");
+  await mind.store.close();
+});
+
+test("153.2 the decision is the declared order's", async () => {
+  const ahead = await fixture();
+  const plain = await fixture();
+  declaredOrder(plain);
+  const a = await decide(ahead, QUERY);
+  const p = await decide(plain, QUERY);
+  assert.equal(a.answer, p.answer);
+  assert.equal(a.winner.provenance, p.winner.provenance);
+  assert.equal(a.winner.weight, p.winner.weight);
+  // …and the oracle really is the dearer market: there, CAST paid for the
+  // weave, and confluence ran.
+  assert.ok(plain.lastCost.phases["weave"] !== undefined);
+  assert.ok(plain.lastCost.phases["confluence.run"] !== undefined);
+  assert.equal(ahead.lastCost.phases["confluence.run"], undefined);
+  await ahead.store.close();
+  await plain.store.close();
+});
+
+test("153.3 a cover that grounds whole runs nothing ahead", async () => {
+  const mind = await fixture();
+  assert.equal(
+    await mind.respondText("Do you like thrillers?"),
+    "Yes, I love them.",
+  );
+  const c = mind.lastCost.counters;
+  assert.equal(c.mechanismRuns, 1, "the cover alone");
+  assert.equal(c.mechanismsBounded ?? 0, 0);
+  await mind.store.close();
+});
+
+test("153.4 the span prober answers exactly findFlatBranch", async () => {
+  const mind = await fixture();
+  const store = mind.store;
+  const bytes = new TextEncoder().encode(
+    `${FORM} Do you like thrillers? The movie was great. ${QUERY}`,
+  );
+  const n = bytes.length;
+  const want = (s, e) => store.findFlatBranch(bytes.subarray(s, e));
+  const probe = store.flatSpans(bytes);
+  let hits = 0, asked = 0;
+  const check = (s, e) => {
+    const got = probe(s, e);
+    assert.equal(got, want(s, e), `span [${s},${e})`);
+    asked++;
+    if (got !== null) hits++;
+  };
+  // Ends ascending per start (the extension path)…
+  for (let e = 1; e <= n; e++) {
+    for (let s = Math.max(0, e - 40); s < e; s++) {
+      check(s, e);
+    }
+  }
+  // …a suffix then its one-byte trim (the short path), and revisits that end
+  // BEFORE the last probe of their start (the rehash path).
+  for (let s = n - 1; s >= 0; s--) {
+    check(s, n);
+    check(s, n - 1 > s ? n - 1 : n);
+    check(s, Math.min(n, s + 3));
+  }
+  assert.ok(asked > 5_000, `probes asked: ${asked}`);
+  assert.ok(hits > 50, `the buffer must hold stored flat spans: ${hits}`);
+  await store.close();
+});

package/test/24-generalization.test.mjs

@@ -264,6 +264,38 @@ test("3.1 — a two-topic query fuses BOTH points of attention", async () => {
   );
 });
 
+test("3.1 — the second topic is fused on its OWN wording, never on a sub-window anchor", async () => {
+  // Observed before the fix (attention.ts canonicalChunkId): the region
+  // `ace and ` — inside the OTHER topic's words, "workplace and about" — had a
+  // saturated window replaced by its unsaturated 2-byte prefix `e `, that
+  // sub-window anchor voted for the Dream Team context, and its position was
+  // the "second cluster" the dispersion gate let the topic through on.  The
+  // fusion passed on scaffolding.  Pinned here: the Dream Team root is a
+  // committed point of attention whose every contributing region lies in the
+  // topic's own words, AND it is fused into the answer.
+  const m = await twoTopicMind();
+  let anchors = null;
+  const got = await m.respondText(TWO_TOPIC_QUERY, (s) => {
+    if (s.mechanism.at(-1) === "climbConsensus" && s.data?.anchors) {
+      anchors = s.data.anchors;
+    }
+  });
+  const topic = (a) =>
+    new TextDecoder().decode(m.store.bytes(a.anchor)).includes("Dream Team");
+  const root = anchors?.find((a) => a.commit.status === "root" && topic(a));
+  await m.store.close();
+  assert.ok(root, "the Dream Team context must be a committed root");
+  const own = TWO_TOPIC_QUERY.indexOf(" the 1992 Dream Team");
+  const foreign = root.contributingSpans.filter(([s]) => s < own);
+  assert.deepEqual(
+    foreign,
+    [],
+    `the Dream Team root is supported from outside its own words: ` +
+      JSON.stringify(foreign.map(([s, e]) => TWO_TOPIC_QUERY.slice(s, e))),
+  );
+  assert.match(got, /Barcelona|gold|Dream Team/i);
+});
+
 test("3.1 — the trace surfaces MORE THAN ONE ordered anchor for a two-topic query", async () => {
   const m = await twoTopicMind();
   const steps = [];

package/test/36-bloom.test.mjs

@@ -14,11 +14,18 @@
 //                       persisted filter (or a stale one); reopen must
 //                       rebuild/top-up from the table and STILL dedup all
 //                       previously-minted content, with zero duplicates.
+//
+// The CANON index's filter (canon_bloom) has the same hazard — a false
+// negative there is a canonical form `canonFind` silently fails to propose —
+// and is pinned the same way: across reopen, across rows added after a
+// persisted filter exists, and against a writer that adds rows without
+// touching the filter (its stamp disagrees with the meta, so it is rebuilt).
 
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
 import { rmSync } from "node:fs";
+import { DatabaseSync } from "node:sqlite";
 import { SQliteStore } from "../dist/src/store-sqlite.js";
 
 const cleanup = (path) => {
@@ -121,3 +128,49 @@ test("crash: reopen after an unclean exit still dedups everything", (t) => {
   execFileSync(process.execPath, ["-e", phase2], { stdio: "pipe" });
   assert.ok(true);
 });
+
+test("canon filter: persisted with its rows, rebuilt when its stamp is stale", async (t) => {
+  const path = `/tmp/bloom-canon-${process.pid}`;
+  t.after(() => cleanup(path));
+  const H = (i) => (i * 2654435761) >>> 0;
+  const findsAll = (s, from, to) => {
+    for (let i = from; i < to; i++) {
+      assert.deepEqual(s.canonFind(H(i)), [i], `canon row ${i} not proposed`);
+    }
+  };
+
+  // Session 1: rows written by the store itself, then committed and closed.
+  let s = new SQliteStore({ path, D: 64 });
+  await s.size();
+  for (let i = 0; i < 200; i++) s.canonAdd(H(i), i);
+  await s.setMeta("canon.upto", "200");
+  s.commit();
+  findsAll(s, 0, 200);
+  await s.close();
+
+  // Session 2: the persisted filter is loaded, and rows added on top of it
+  // are seen in this session and after the next reopen.
+  s = new SQliteStore({ path, D: 64 });
+  await s.size();
+  findsAll(s, 0, 200);
+  for (let i = 200; i < 300; i++) s.canonAdd(H(i), i);
+  await s.setMeta("canon.upto", "300");
+  s.commit();
+  findsAll(s, 0, 300);
+  await s.close();
+
+  // A writer that knows nothing of the filter (an older build) adds rows and
+  // advances the cursor, as every canon build does.
+  const db = new DatabaseSync(path + ".sqlite");
+  for (let i = 300; i < 350; i++) {
+    db.prepare("INSERT INTO canon (h, id) VALUES (?, ?)").run(H(i), i);
+  }
+  db.prepare("UPDATE meta SET val = '350' WHERE key = 'canon.upto'").run();
+  db.close();
+
+  s = new SQliteStore({ path, D: 64 });
+  await s.size();
+  findsAll(s, 0, 350);
+  assert.deepEqual(s.canonFind(H(9999)), [], "an absent key is not proposed");
+  await s.close();
+});

package/test/37-cluster-dispersion-fusion.test.mjs

@@ -215,3 +215,78 @@ test("fuseAttention: 1 cluster, low breadth — neither measure saves it (the li
   );
   await m.store.close();
 });
+
+// ═══════════════════════════════════════════════════════════════════════════
+// The dispersion question asked of the CONTEXT (reasoning.ts sharedPlaces).
+// The votes that land on a root are a lossy witness of where the query and the
+// root's context agree: a region votes once, for its top anchor, so a frame
+// every context shares corroborates whichever anchor a tie hands it.  The
+// context's own bytes answer the question exactly — at window scale, in how
+// many separate places of the query does it share content?  These two cases
+// pin both directions with REAL anchors (a stored context and its learnt
+// continuation), each fabricated as a one-cluster, low-breadth root so that
+// only the new reading can decide.
+// ═══════════════════════════════════════════════════════════════════════════
+
+async function sharedPlacesCase(contextText, query) {
+  const m = mk(1);
+  await m.ingest([
+    ...CORPUS,
+    [contextText, "the omega continuation"],
+  ]);
+  const q = enc(query);
+  m.beginResponse();
+  const anchor = m.recogniseSpan(enc(contextText)).sites
+    .find((s) => s.start === 0 && s.end === contextText.length)?.payload;
+  m.endResponse();
+  assert.ok(anchor !== undefined, "the context must be a stored form");
+  const root = {
+    anchor,
+    vote: 1,
+    idfVote: 1,
+    peak: 1,
+    start: 0,
+    end: q.length,
+    clusters: 1,
+    breadth: 0.1,
+  };
+  const placeholder = { ...root, start: q.length, end: q.length };
+  const primary = enc("PRIMARYANCHORTEXT");
+  const out = dec(
+    (await fuseAttention(m, q, {
+      product: primary,
+      accounted: [],
+      remainder: [],
+      cost: 0,
+    }, {
+      attention: async () => ({
+        roots: [placeholder, root],
+        ranked: [placeholder, root],
+      }),
+      guide: gistOf(m, q),
+    })).product,
+  );
+  await m.store.close();
+  return { out, primary: dec(primary) };
+}
+
+test("fuseAttention: a context sharing ONE phrase with the query does not fuse, however long the phrase (the live echo shape)", async () => {
+  // The live defect's shape: the query's closing phrase is byte-identical to
+  // how an unrelated conversation ended.  Many windows, ONE place.
+  const { out, primary } = await sharedPlacesCase(
+    "Thank you very much!",
+    "red circle then 2+2 equals what. Thank you very much!",
+  );
+  assert.equal(out, primary, `a one-place echo fused in: "${out}"`);
+});
+
+test("fuseAttention: a context sharing TWO separate places with the query fuses, even when its votes formed one cluster", async () => {
+  const { out, primary } = await sharedPlacesCase(
+    "red circle at noon, and then: Thank you very much!",
+    "red circle then 2+2 equals what. Thank you very much!",
+  );
+  assert.ok(
+    out.includes("omega") && out.includes(primary),
+    `a two-place context must fuse in, got "${out}"`,
+  );
+});

package/test/48-recognise-turn-connective.test.mjs

@@ -32,7 +32,8 @@ import assert from "node:assert/strict";
 import { Mind, SQliteStore } from "../dist/src/index.js";
 import { textCanon } from "../dist/src/canon.js";
 import { recognise } from "../dist/src/mind/recognition.js";
-import { latin1Key, perceive, resolve } from "../dist/src/mind/primitives.js";
+import { perceive, resolve } from "../dist/src/mind/primitives.js";
+import { latin1 } from "../dist/src/bytes.js";
 
 const enc = (s) => new TextEncoder().encode(s);
 const dec = (b) => new TextDecoder().decode(b).replace(/\0+$/, "");
@@ -71,7 +72,7 @@ test("recognise(): a real leading connective word ('And ') still finds the train
   const boundaries = [30, 61];
   m.perceiveMemo = new Map();
   m.perceiveMemo.set(
-    latin1Key(query),
+    latin1(query),
     perceive(m, query, undefined, undefined, boundaries),
   );
 

package/test/55-cost-meter.test.mjs

@@ -156,10 +156,10 @@ test("7. a bigger query costs more than a smaller one", async () => {
     "the capital of France is and the capital of Japan is and Paris is in",
   );
   const big = mind.lastCost.counters;
-  assert.ok(
-    big.perceivedBytes > small.perceivedBytes,
-    "perception cost tracks query length",
-  );
+  // Fold work in both of its forms: the vector fold (perception) and the
+  // identity fold `exactNode` reads a node id through without vectors.
+  const folded = (c) => (c.perceivedBytes ?? 0) + (c.identityBytes ?? 0);
+  assert.ok(folded(big) > folded(small), "fold cost tracks query length");
   await mind.store.close();
 });
 

package/test/90-connector-read-cap.test.mjs

@@ -1,7 +1,7 @@
 // 90-connector-read-cap.test.mjs — the "already answered" probe must read by
 // the QUERY, not by the corpus.
 //
-// `resolveConnectors` (src/mind/mechanisms/cover.ts) drops a site whose
+// `offerConnectors` (src/mind/mechanisms/cover.ts) drops a site whose
 // continuation already appears elsewhere in the query — stale transcript
 // evidence, whose bridges would only be discarded later.  The test is a
 // substring search, so it needs the candidate's bytes; it used to reconstruct
@@ -28,7 +28,7 @@
 // B reconstructed against a 3-byte prompt. So the invariant here is per-read
 // SIZE.
 //
-// It is measured by calling `resolveConnectors` DIRECTLY and diffing the meter
+// It is measured by calling `offerConnectors` DIRECTLY and diffing the meter
 // across it.  A whole-response counter cannot express this: `bytesRead` sums
 // every reader in the pipeline, and the answer itself is a long continuation
 // that is legitimately read in full — an earlier draft of this file asserted on
@@ -46,7 +46,7 @@ import { test } from "node:test";
 import assert from "node:assert/strict";
 import { Mind } from "../dist/src/index.js";
 import { SQliteStore } from "../dist/src/store-sqlite.js";
-import { resolveConnectors } from "../dist/src/mind/mechanisms/cover.js";
+import { offerConnectors } from "../dist/src/mind/mechanisms/cover.js";
 
 /** Learnt CONTINUATIONS far longer than the query that will be asked — the
  *  shape the cap governs: an uncapped probe reconstructs each one in full
@@ -80,7 +80,7 @@ test("connector probe reads by the query, not by the learnt continuation", async
   mind.beginResponse();
   try {
     const { sites } = mind.recogniseSpan(bytes);
-    // EXACT ISOLATION.  resolveConnectors also reads bytes the probe has
+    // EXACT ISOLATION.  offerConnectors also reads bytes the probe has
     // nothing to do with (the n-ary bridge reads each ordered node in full, and
     // legitimately so).  The probe itself early-returns when answeredSpans is
     // empty, so running the SAME call both ways and differencing leaves exactly
@@ -88,12 +88,12 @@ test("connector probe reads by the query, not by the learnt continuation", async
     const m = mind.meter;
     mind.answeredSpans = [];
     const a0 = m.byteReads, b0 = m.bytesRead;
-    await resolveConnectors(mind, sites, bytes);
+    offerConnectors(mind, sites, bytes);
     const baseReads = m.byteReads - a0, baseBytes = m.bytesRead - b0;
 
     mind.answeredSpans = [[0, 1]];
     const a1 = m.byteReads, b1 = m.bytesRead;
-    await resolveConnectors(mind, sites, bytes);
+    offerConnectors(mind, sites, bytes);
     const reads = (m.byteReads - a1) - baseReads;
     const read = (m.bytesRead - b1) - baseBytes;
 
@@ -107,7 +107,7 @@ test("connector probe reads by the query, not by the learnt continuation", async
     // below is trivially true and proves nothing.
     assert.ok(
       reads > 0,
-      `resolveConnectors made no byte reads — the probe never ran (sites=${sites.length}), ` +
+      `offerConnectors made no byte reads — the probe never ran (sites=${sites.length}), ` +
         `so this file is not testing anything`,
     );