@hviana/sema 0.1.0

package/test/09-edges.test.mjs

@@ -0,0 +1,65 @@
+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 txt = (r) => new TextDecoder().decode(r.bytes).replace(/\u0000+/g, "");
+const img = (n) => {
+  const g = { width: 4, height: 4, channels: 1, data: new Uint8Array(16) };
+  for (let i = 0; i < 16; i++) g.data[i] = (i * 13 + n * 41) & 0xff;
+  return g;
+};
+
+test("a 2KB document roundtrips exactly", async () => {
+  const m = new Mind({
+    seed: 7,
+  });
+  const doc = ("memory is the model. " + "the river cuts by content. ").repeat(
+    45,
+  ).slice(0, 2048);
+  const bytes = new TextEncoder().encode(doc);
+  const t = await m.ingest(bytes);
+  const out = await m.express(t.v);
+  assert.deepEqual([...out], [...bytes]);
+});
+
+test("respond accepts raw bytes", async () => {
+  const m = new Mind({
+    seed: 7,
+  });
+  await m.ingest([["what is ice?", "ice is frozen water"]]);
+  const r = await m.respond(new TextEncoder().encode("what is ice?"));
+  assert.equal(txt(r), "ice is frozen water");
+});
+
+test("an image can be a context: respond(image) → caption", async () => {
+  const m = new Mind({
+    seed: 7,
+  });
+  await m.ingest([[img(3), "a small grey cat"]]);
+  assert.equal(await m.respondText(img(3)), "a small grey cat");
+  // Unknown image: may return null or a closest approximation.
+  const r = await m.respond(img(4));
+  assert.ok(r.v !== undefined, "respond returns a valid response");
+});
+
+test("train([]) is a no-op that does not throw", async () => {
+  const m = new Mind({
+    seed: 7,
+  });
+  await m.ingest([]);
+  assert.equal((await m.respond("anything")).v, null);
+});
+
+test("very long single-token inputs roundtrip correctly", async () => {
+  const m = new Mind({
+    seed: 7,
+  });
+  for (const n of [513, 1025]) {
+    const bytes = new TextEncoder().encode("z".repeat(n));
+    const t = await m.ingest(bytes);
+    const out = await m.express(t.v);
+    assert.equal(out.length, n);
+    assert.ok([...out].every((b) => b === 122));
+  }
+});

package/test/11-universality.test.mjs

@@ -0,0 +1,180 @@
+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 img = (n) => {
+  const g = { width: 4, height: 4, channels: 1, data: new Uint8Array(16) };
+  for (let i = 0; i < 16; i++) g.data[i] = (i * 13 + n * 41) & 0xff;
+  return g;
+};
+
+// The mechanism has no concept of language: perception cuts bytes by
+// outline, recall completes episodes, thinking rewrites licensed parts.
+// These tests assert the LAW — same behaviour regardless of script,
+// script-mixing, or where in the stream a known part stands.
+
+const TABLE = [
+  ["1+2", "3"],
+  ["2+2", "4"],
+  ["2+3", "5"],
+  ["3+3", "6"],
+  ["3+5", "8"],
+  ["4+3", "7"],
+  ["2+5", "7"],
+  ["1+5", "6"],
+  ["6+1", "7"],
+  ["4+1", "5"],
+];
+const txt = (r) => new TextDecoder().decode(r.bytes).replace(/\u0000+/g, "");
+
+test("concepts fuse across scripts: 氷 + hielo + ice", async () => {
+  for (const seed of [1, 7, 42]) {
+    const m = new Mind({
+      seed,
+    });
+    await m.ingest([
+      ["ice", "ice is frozen water"],
+      [img(1), "ice"],
+      [img(2), "ice"],
+      [img(1), "hielo"],
+      [img(2), "hielo"],
+      [img(1), "氷"],
+      [img(2), "氷"],
+    ]);
+    assert.equal(
+      await m.respondText("氷"),
+      "氷 is frozen water",
+      `seed ${seed}`,
+    );
+    assert.equal(
+      await m.respondText("hielo"),
+      "hielo is frozen water",
+      `seed ${seed}`,
+    );
+  }
+});
+
+test("a known part answers wherever it stands, whatever surrounds it", async () => {
+  // Frame language and fact position are irrelevant to the law. Before
+  // the byte-window glance, mid-stream facts answered on ~2/8 seeds and
+  // stream-initial on 8/8 — a position accident posing as capability.
+  const frames = [
+    "2+2 equals what?",
+    "¿cuánto es 2+2 dime?",
+    "2+2 は何ですか",
+    "dime 2+2 は何 please",
+  ];
+  for (const seed of [1, 7, 42, 99]) {
+    const m = new Mind({
+      seed,
+    });
+    await m.ingest(TABLE);
+    for (const q of frames) {
+      assert.equal(txt(await m.respond(q)), "4", `seed ${seed} "${q}"`);
+    }
+  }
+});
+
+// ARTICULATION — the production-direction half of the concept law.
+// Recognition settles any name onto its gist (comprehension crosses
+// names inward); articulation chooses, among gist-equal forms, the
+// ASKER's form (production crosses names outward). No translation
+// machinery: the conceive merge read outward.
+
+const ground = (name, a, b) => [
+  [img(a), name],
+  [img(b), name],
+];
+
+test("the answer speaks in the asker's name — across scripts", async () => {
+  for (const seed of [1, 7, 42]) {
+    const m = new Mind({
+      seed,
+    });
+    await m.ingest([
+      ["ice", "ice is frozen water"],
+      ...ground("ice", 1, 2),
+      ...ground("hielo", 1, 2),
+      ...ground("氷", 1, 2),
+    ]);
+    assert.equal(
+      await m.respondText("hielo"),
+      "hielo is frozen water",
+      `seed ${seed}`,
+    );
+    assert.equal(
+      await m.respondText("氷"),
+      "氷 is frozen water",
+      `seed ${seed}`,
+    );
+    assert.equal(
+      await m.respondText("ice"),
+      "ice is frozen water",
+      `seed ${seed} own name unchanged`,
+    );
+  }
+});
+
+test("a name inside a mixed-script frame voices the answer", async () => {
+  const m = new Mind({
+    seed: 7,
+  });
+  await m.ingest([
+    ["ice", "ice is frozen water"],
+    ...ground("ice", 1, 2),
+    ...ground("氷", 1, 2),
+  ]);
+  assert.equal(await m.respondText("¿qué es 氷 ahora?"), "氷 is frozen water");
+});
+
+test("question-level + word-level concepts compose: cross-language QA, fully voiced", async () => {
+  for (const seed of [1, 7, 42]) {
+    const m = new Mind({
+      seed,
+    });
+    await m.ingest([
+      ["what is ice?", "ice is frozen water"],
+      ...ground("what is ice?", 5, 6),
+      ...ground("¿qué es hielo?", 5, 6),
+      ...ground("ice", 1, 2),
+      ...ground("hielo", 1, 2),
+    ]);
+    assert.equal(
+      await m.respondText("¿qué es hielo?"),
+      "hielo is frozen water",
+      `seed ${seed}`,
+    );
+  }
+});
+
+test("the floor does not name: single-byte forms never voice", async () => {
+  // digit answers can over-fuse by halo resemblance ({6,7}); a query's
+  // operand must never re-voice the answer
+  const TABLE = [
+    ["1+2", "3"],
+    ["2+2", "4"],
+    ["2+3", "5"],
+    ["3+3", "6"],
+    ["3+5", "8"],
+    ["4+3", "7"],
+    ["2+5", "7"],
+    ["1+5", "6"],
+    ["6+1", "7"],
+    ["4+1", "5"],
+  ];
+  for (const seed of [1, 7, 42]) {
+    const m = new Mind({
+      seed,
+    });
+    await m.ingest(TABLE);
+    for (const [q, want] of [["6+1", "7"], ["2+5", "7"], ["1+5", "6"]]) {
+      const r = await m.respond(q);
+      const got = new TextDecoder().decode(r.bytes).replace(/\u0000+/g, "");
+      assert.ok(
+        r.v === null || got === want,
+        `seed ${seed} "${q}" -> "${got}"`,
+      );
+    }
+  }
+});

package/test/13-conversation.test.mjs

@@ -0,0 +1,228 @@
+// 13-conversation.test.mjs — multi-turn conversation context.
+//
+// The question under test: when a conversation has many turns, does a later
+// turn still have the context established earlier? Plain adjacency (each
+// episode = previous turn → next turn) keeps only ONE turn of context, so it
+// cannot tell apart two conversations that share a turn but differ earlier.
+//
+// ─────────────────────────────────────────────────────────────────────────
+// Two functions drive every test:
+//
+//   teachConversation(mind, turns)  — accumulate prior turns into the context
+//   predictNext(mind, priorTurns)   — join prior turns and recall the next
+//
+// The assertions describe BEHAVIOUR only — they never mention how context is
+// represented — so they stay valid for any implementation.
+//
+// Note: Sema trains on the accumulated context string ("turn0\nturn1\nturn2")
+// and queries the same accumulated string at inference. This is not a
+// weakness — LLMs work the same way: a chat model receives the full
+// conversation history as its prompt, and that same history must be
+// provided at inference to produce the next turn. The difference is in
+// how the answer is produced: Sema composes it from learned graph forms;
+// an LLM samples it from a parametric distribution. Neither is "just a
+// lookup."
+// ─────────────────────────────────────────────────────────────────────────
+
+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 newMind = () => new Mind({ seed: 7 });
+
+// ═══════════════════════════════════════════════════════════════════════
+// teachConversation — store one conversation (an ordered list of turns).
+//
+// Accumulate every prior turn into the context so each episode carries the
+// full conversation history:  (t₀ → t₁), (t₀+t₁ → t₂), (t₀+t₁+t₂ → t₃) …
+// A pivot turn ("what is its name?") that appears in two conversations now
+// produces different episode vectors because the context side encodes which
+// conversation it belongs to.  All SEMA operations remain sublinear — the
+// river cuts any context into O(log N) chunks regardless of length.
+// ═══════════════════════════════════════════════════════════════════════
+async function teachConversation(mind, turns) {
+  for (let i = 0; i + 1 < turns.length; i++) {
+    const context = turns.slice(0, i + 1).join("\n");
+    await mind.ingest(context, turns[i + 1]);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// predictNext — given the turns spoken so far, predict the next turn.
+//
+// Join every prior turn into one accumulated context, mirroring the storage
+// pattern in teachConversation.  The resulting query string is the exact
+// context side of the matching episode, so recall resolves unambiguously.
+// ═══════════════════════════════════════════════════════════════════════
+async function predictNext(mind, priorTurns) {
+  const context = priorTurns.join("\n");
+  return await mind.respondText(context);
+}
+
+// A small convenience: teach a conversation, then ask for the continuation
+// after the first `k` turns.
+async function continueAfter(turns, k) {
+  const mind = newMind();
+  await teachConversation(mind, turns);
+  const out = await predictNext(mind, turns.slice(0, k));
+  await mind.store.close();
+  return out;
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// Section A — basic completion (passes with one turn of context)
+// ═══════════════════════════════════════════════════════════════════════
+
+const CHAT = [
+  "good morning",
+  "hello there",
+  "are you ready to start?",
+  "yes, let us begin",
+];
+
+test("A1: first turn completes", async () => {
+  assert.equal(await continueAfter(CHAT, 1), "hello there");
+});
+
+test("A2: middle turn completes", async () => {
+  assert.equal(await continueAfter(CHAT, 2), "are you ready to start?");
+});
+
+test("A3: last step completes", async () => {
+  assert.equal(await continueAfter(CHAT, 3), "yes, let us begin");
+});
+
+// ═══════════════════════════════════════════════════════════════════════
+// Section B — context disambiguates a shared pivot turn  (TARGET)
+//
+// Both conversations contain the identical turn "what is its name?". Adjacency
+// binds that turn to two different answers, so without earlier context the
+// continuation is ambiguous. The earlier turn ("a cat" vs "a dog") must decide.
+// ═══════════════════════════════════════════════════════════════════════
+
+const CAT = ["I adopted a cat", "what is its name?", "her name is Whiskers"];
+const DOG = ["I adopted a dog", "what is its name?", "his name is Rex"];
+
+async function teachBoth() {
+  const mind = newMind();
+  await teachConversation(mind, CAT);
+  await teachConversation(mind, DOG);
+  return mind;
+}
+
+test("B1: earlier context selects the cat's answer", async () => {
+  const mind = await teachBoth();
+  assert.equal(
+    await predictNext(mind, ["I adopted a cat", "what is its name?"]),
+    "her name is Whiskers",
+  );
+  await mind.store.close();
+});
+
+test("B2: earlier context selects the dog's answer", async () => {
+  const mind = await teachBoth();
+  assert.equal(
+    await predictNext(mind, ["I adopted a dog", "what is its name?"]),
+    "his name is Rex",
+  );
+  await mind.store.close();
+});
+
+test("B3: the same pivot yields DIFFERENT answers per conversation", async () => {
+  const mind = await teachBoth();
+  const a = await predictNext(mind, ["I adopted a cat", "what is its name?"]);
+  const b = await predictNext(mind, ["I adopted a dog", "what is its name?"]);
+  assert.notEqual(a, b);
+  await mind.store.close();
+});
+
+// ═══════════════════════════════════════════════════════════════════════
+// Section C — context that lives SEVERAL turns back  (TARGET)
+//
+// The distinguishing turn ("Japan" vs "Italy") is two turns before the shared
+// pivot, so it is invisible to adjacency AND to any fixed small window. Only an
+// accumulated context carries it forward.
+// ═══════════════════════════════════════════════════════════════════════
+
+const TRIP_JP = [
+  "we are planning a vacation",
+  "I want to visit Japan",
+  "what should we see first?",
+  "start with Tokyo",
+];
+const TRIP_IT = [
+  "we are planning a vacation",
+  "I want to visit Italy",
+  "what should we see first?",
+  "start with Rome",
+];
+
+async function teachTrips() {
+  const mind = newMind();
+  await teachConversation(mind, TRIP_JP);
+  await teachConversation(mind, TRIP_IT);
+  return mind;
+}
+
+test("C1: Japan context (2 turns back) selects Tokyo", async () => {
+  const mind = await teachTrips();
+  assert.equal(
+    await predictNext(mind, TRIP_JP.slice(0, 3)),
+    "start with Tokyo",
+  );
+  await mind.store.close();
+});
+
+test("C2: Italy context (2 turns back) selects Rome", async () => {
+  const mind = await teachTrips();
+  assert.equal(
+    await predictNext(mind, TRIP_IT.slice(0, 3)),
+    "start with Rome",
+  );
+  await mind.store.close();
+});
+
+// ═══════════════════════════════════════════════════════════════════════
+// Section D — length & determinism  (TARGET for the long-range case)
+//
+// A longer conversation that still hinges on an early distinguishing turn:
+// there must be no per-conversation turn cap, and repeating the experiment
+// must give the same answer.
+// ═══════════════════════════════════════════════════════════════════════
+
+const longTrip = (place, first) => [
+  "hello",
+  `I am organising a long trip to ${place}`,
+  "that sounds exciting",
+  "we have two weeks",
+  "and a generous budget",
+  "we love food and history",
+  "what should we see first?",
+  `start with ${first}`,
+];
+
+test("D1: an early turn decides the answer many turns later", async () => {
+  const mind = newMind();
+  await teachConversation(mind, longTrip("Japan", "Tokyo"));
+  await teachConversation(mind, longTrip("Italy", "Rome"));
+  const jp = await predictNext(mind, longTrip("Japan", "Tokyo").slice(0, 7));
+  const it = await predictNext(mind, longTrip("Italy", "Rome").slice(0, 7));
+  assert.equal(jp, "start with Tokyo");
+  assert.equal(it, "start with Rome");
+  await mind.store.close();
+});
+
+test("D2: prediction is deterministic across runs", async () => {
+  const run = async () => {
+    const mind = newMind();
+    await teachConversation(mind, CAT);
+    const out = await predictNext(mind, [
+      "I adopted a cat",
+      "what is its name?",
+    ]);
+    await mind.store.close();
+    return out;
+  };
+  assert.equal(await run(), await run());
+});