@hviana/sema 0.1.5 → 0.1.7

package/dist/src/mind/recognition.js

@@ -5,8 +5,8 @@
 //               that leads somewhere (has a continuation edge or a halo).
 //   segment   — leaf-parent segmentation using the geometry's own groupings.
 import { rItem } from "./trace.js";
-import { foldTree, gistOf, perceive, resolve } from "./primitives.js";
-import { leadsSomewhere } from "./traverse.js";
+import { foldTree, gistOf, latin1Key, perceive, resolve, } from "./primitives.js";
+import { atomIsHub, corpusN, leadsSomewhere } from "./traverse.js";
 import { chainReach, leafIdAt } from "./canonical.js";
 import { isChunk } from "../sema.js";
 /** Decompose a byte stream into every stored form that leads somewhere
@@ -22,179 +22,170 @@ import { isChunk } from "../sema.js";
  *
  *  Both O(n · maxGroup) bounded O(1) probes — never a scan of the corpus. */
 export function recognise(ctx, bytes) {
-  // Per-response memo (see MindContext.recogniseMemo): think, articulate and
-  // the pre-consume pass all recognise the same byte objects; each repeat is
-  // O(n·maxGroup²) store probes.  Skipped while tracing so every call still
-  // emits its rationale step.
-  if (ctx.recogniseMemo && !ctx.trace) {
-    const hit = ctx.recogniseMemo.get(bytes);
-    if (hit !== undefined) {
-      return hit;
-    }
-    const fresh = recogniseImpl(ctx, bytes);
-    ctx.recogniseMemo.set(bytes, fresh);
-    return fresh;
-  }
-  return recogniseImpl(ctx, bytes);
+    // Content-keyed memo — works for both single-turn respond() and multi-turn
+    // respondTurn() (where the map persists across calls).  Skipped while
+    // tracing so every call still emits its rationale step.
+    if (ctx.recogniseMemo && !ctx.trace) {
+        const key = latin1Key(bytes);
+        const hit = ctx.recogniseMemo.get(key);
+        if (hit !== undefined)
+            return hit;
+        const fresh = recogniseImpl(ctx, bytes);
+        ctx.recogniseMemo.set(key, fresh);
+        return fresh;
+    }
+    return recogniseImpl(ctx, bytes);
 }
 function recogniseImpl(ctx, bytes) {
-  const store = ctx.store;
-  const sites = [];
-  const leaves = [];
-  const splits = new Set();
-  if (bytes.length === 0) {
-    return { sites, leaves, splits };
-  }
-  // Span-resolve memo for THIS call: the structural pass (sub-runs inside
-  // leaf-parents) and the canonical pass (leaf-id chains) probe overlapping
-  // spans, and each resolve() is a full fold of the sub-span (fresh subarray
-  // objects — the per-response perceive memo cannot see them).  Keyed
-  // numerically by (start, end); resolve is pure and the store is read-only
-  // here, so a hit is exact.
-  const spanIds = new Map();
-  const resolveSpan = (start, end) => {
-    const key = start * (bytes.length + 1) + end;
-    let id = spanIds.get(key);
-    if (id === undefined) {
-      id = resolve(ctx, bytes.subarray(start, end));
-      spanIds.set(key, id);
-    }
-    return id;
-  };
-  const emit = (start, end, id) => {
-    if (leadsSomewhere(ctx, id)) {
-      sites.push({ start, end, payload: id });
-    }
-  };
-  // ── structural: the query's own perceived tree ──────────────────────
-  const starts = new Set();
-  starts.add(0);
-  foldTree(ctx, perceive(ctx, bytes), 0, (n, start, end, node) => {
-    if (n.kids === null) {
-      leaves.push({ start, end, bytes: n.leaf ?? new Uint8Array(0), node });
-    }
-    if (node !== null) {
-      emit(start, end, node);
-    }
-    if (isChunk(n)) {
-      starts.add(start);
-      // Try every sub-span within this leaf-parent.
-      const leafOffsets = [];
-      let off = start;
-      for (const k of n.kids) {
-        leafOffsets.push(off);
-        off += k.leaf?.length ?? 0;
-      }
-      for (let i = 0; i < n.kids.length; i++) {
-        const subIds = [];
-        for (let j = i; j < n.kids.length; j++) {
-          const kj = n.kids[j];
-          if (kj.kids !== null || !kj.leaf) {
-            break;
-          }
-          const lid = store.findLeaf(kj.leaf);
-          if (lid === null) {
-            break;
-          }
-          subIds.push(lid);
-          const branch = store.findBranch(subIds);
-          if (branch === null) {
-            continue;
-          }
-          const subEnd = leafOffsets[j] + (kj.leaf?.length ?? 0);
-          const resolved = resolveSpan(leafOffsets[i], subEnd);
-          if (resolved !== null) {
-            emit(leafOffsets[i], subEnd, resolved);
-          }
+    const store = ctx.store;
+    const sites = [];
+    const leaves = [];
+    const splits = new Set();
+    if (bytes.length === 0)
+        return { sites, leaves, splits };
+    // Span-resolve memo for THIS call: the structural pass (sub-runs inside
+    // leaf-parents) and the canonical pass (leaf-id chains) probe overlapping
+    // spans, and each resolve() is a full fold of the sub-span (fresh subarray
+    // objects — the per-response perceive memo cannot see them).  Keyed
+    // numerically by (start, end); resolve is pure and the store is read-only
+    // here, so a hit is exact.
+    const spanIds = new Map();
+    const resolveSpan = (start, end) => {
+        const key = start * (bytes.length + 1) + end;
+        let id = spanIds.get(key);
+        if (id === undefined) {
+            id = resolve(ctx, bytes.subarray(start, end));
+            spanIds.set(key, id);
+        }
+        return id;
+    };
+    // Byte atoms (implicit negative-id single-byte leaves) are admitted as
+    // recognised sites only while atoms can still DISCRIMINATE at this corpus
+    // scale (see {@link atomIsHub}).  On a small store a single-letter fact
+    // ("a" → "A") is genuine learnt content and its site is essential; on a
+    // large one every letter of every query would otherwise become a
+    // "recognised form" — the bridge then finds junction connectors between
+    // bare letters, cover follows edges hanging off them, and pure noise
+    // ("qq8f3kz9…") grounds to an arbitrary learnt sentence instead of
+    // silence.  Atoms stay available as leaves (PASS-carried literals) and
+    // through exact tier-0 resolution regardless.
+    const atomsAreHubs = atomIsHub(ctx, corpusN(ctx));
+    const emit = (start, end, id) => {
+        if (id < 0 && atomsAreHubs)
+            return;
+        if (leadsSomewhere(ctx, id)) {
+            sites.push({ start, end, payload: id });
+        }
+    };
+    // ── structural: the query's own perceived tree ──────────────────────
+    const starts = new Set();
+    starts.add(0);
+    foldTree(ctx, perceive(ctx, bytes), 0, (n, start, end, node) => {
+        if (n.kids === null) {
+            leaves.push({ start, end, bytes: n.leaf ?? new Uint8Array(0), node });
+        }
+        if (node !== null)
+            emit(start, end, node);
+        if (isChunk(n)) {
+            starts.add(start);
+            // Try every sub-span within this leaf-parent.
+            const leafOffsets = [];
+            let off = start;
+            for (const k of n.kids) {
+                leafOffsets.push(off);
+                off += k.leaf?.length ?? 0;
+            }
+            for (let i = 0; i < n.kids.length; i++) {
+                const subIds = [];
+                for (let j = i; j < n.kids.length; j++) {
+                    const kj = n.kids[j];
+                    if (kj.kids !== null || !kj.leaf)
+                        break;
+                    const lid = store.findLeaf(kj.leaf);
+                    if (lid === null)
+                        break;
+                    subIds.push(lid);
+                    const branch = store.findBranch(subIds);
+                    if (branch === null)
+                        continue;
+                    const subEnd = leafOffsets[j] + (kj.leaf?.length ?? 0);
+                    const resolved = resolveSpan(leafOffsets[i], subEnd);
+                    if (resolved !== null)
+                        emit(leafOffsets[i], subEnd, resolved);
+                }
+            }
+        }
+    });
+    // ── canonical: longest-known-leaf re-segmentation ──────────────────
+    const W = ctx.space.maxGroup;
+    const singleLeaf = new Array(bytes.length).fill(null);
+    for (let p = 0; p < bytes.length; p++) {
+        const id = leafIdAt(ctx, bytes, p);
+        if (id !== null)
+            singleLeaf[p] = { id, end: p + 1 };
+    }
+    const leafFrom = (p) => {
+        if (p >= bytes.length)
+            return null;
+        return singleLeaf[p];
+    };
+    const chunkEnd = new Uint32Array(bytes.length);
+    const sorted = [...starts].sort((a, b) => a - b);
+    for (let si = 0; si < sorted.length; si++) {
+        const chunkStart = sorted[si];
+        const chunkLimit = si + 1 < sorted.length ? sorted[si + 1] : bytes.length;
+        for (let p = chunkStart; p < chunkLimit; p++) {
+            chunkEnd[p] = chunkLimit;
         }
-      }
-    }
-  });
-  // ── canonical: longest-known-leaf re-segmentation ──────────────────
-  const W = ctx.space.maxGroup;
-  const singleLeaf = new Array(bytes.length).fill(null);
-  for (let p = 0; p < bytes.length; p++) {
-    const id = leafIdAt(ctx, bytes, p);
-    if (id !== null) {
-      singleLeaf[p] = { id, end: p + 1 };
-    }
-  }
-  const leafFrom = (p) => {
-    if (p >= bytes.length) {
-      return null;
-    }
-    return singleLeaf[p];
-  };
-  const chunkEnd = new Uint32Array(bytes.length);
-  const sorted = [...starts].sort((a, b) => a - b);
-  for (let si = 0; si < sorted.length; si++) {
-    const chunkStart = sorted[si];
-    const chunkLimit = si + 1 < sorted.length ? sorted[si + 1] : bytes.length;
-    for (let p = chunkStart; p < chunkLimit; p++) {
-      chunkEnd[p] = chunkLimit;
-    }
-  }
-  const tryChain = (p, maxIds) => {
-    const first = leafFrom(p);
-    if (!first) {
-      return;
-    }
-    emit(p, first.end, first.id);
-    const ids = [first.id];
-    let pos = first.end;
-    let prevId = null;
-    for (let depth = 1; pos < bytes.length && ids.length <= maxIds; depth++) {
-      const nx = leafFrom(pos);
-      if (!nx) {
-        break;
-      }
-      ids.push(nx.id);
-      pos = nx.end;
-      if (store.findBranch(ids) === null) {
-        continue;
-      }
-      const id = resolveSpan(p, pos);
-      if (id === null || id === prevId) {
-        continue;
-      }
-      prevId = id;
-      emit(p, pos, id);
-    }
-  };
-  for (let p = 0; p < bytes.length; p++) {
-    if (starts.has(p)) {
-      tryChain(p, chainReach(W)); // boundary start — full reach
-    } else {
-      const limit = chunkEnd[p] + W;
-      tryChain(p, Math.min(limit - p, chainReach(W)));
-    }
-  }
-  // ── splits: a form boundary that does not fall on a leaf edge ────────
-  const leafEdges = new Set([bytes.length]);
-  for (const lf of leaves) {
-    leafEdges.add(lf.start);
-  }
-  for (const s of sites) {
-    if (!leafEdges.has(s.start)) {
-      splits.add(s.start);
     }
-    if (!leafEdges.has(s.end)) {
-      splits.add(s.end);
+    const tryChain = (p, maxIds) => {
+        const first = leafFrom(p);
+        if (!first)
+            return;
+        emit(p, first.end, first.id);
+        const ids = [first.id];
+        let pos = first.end;
+        let prevId = null;
+        for (let depth = 1; pos < bytes.length && ids.length <= maxIds; depth++) {
+            const nx = leafFrom(pos);
+            if (!nx)
+                break;
+            ids.push(nx.id);
+            pos = nx.end;
+            if (store.findBranch(ids) === null)
+                continue;
+            const id = resolveSpan(p, pos);
+            if (id === null || id === prevId)
+                continue;
+            prevId = id;
+            emit(p, pos, id);
+        }
+    };
+    for (let p = 0; p < bytes.length; p++) {
+        if (starts.has(p)) {
+            tryChain(p, chainReach(W)); // boundary start — full reach
+        }
+        else {
+            const limit = chunkEnd[p] + W;
+            tryChain(p, Math.min(limit - p, chainReach(W)));
+        }
     }
-  }
-  ctx.trace?.step(
-    "recognise",
-    [rItem(bytes, "query")],
-    sites.map((s) =>
-      rItem(bytes.subarray(s.start, s.end), "form", s.payload, [
+    // ── splits: a form boundary that does not fall on a leaf edge ────────
+    const leafEdges = new Set([bytes.length]);
+    for (const lf of leaves)
+        leafEdges.add(lf.start);
+    for (const s of sites) {
+        if (!leafEdges.has(s.start))
+            splits.add(s.start);
+        if (!leafEdges.has(s.end))
+            splits.add(s.end);
+    }
+    ctx.trace?.step("recognise", [rItem(bytes, "query")], sites.map((s) => rItem(bytes.subarray(s.start, s.end), "form", s.payload, [
         s.start,
         s.end,
-      ])
-    ),
-    `decompose the query into ${sites.length} learnt form(s) that lead somewhere` +
-      ` (over ${leaves.length} perceived leaves)`,
-  );
-  return { sites, leaves, splits };
+    ])), `decompose the query into ${sites.length} learnt form(s) that lead somewhere` +
+        ` (over ${leaves.length} perceived leaves)`);
+    return { sites, leaves, splits };
 }
 /** Segment bytes using the geometry's own groupings — leaf-parent
  *  nodes from the perceived tree, with consecutive bare leaves merged
@@ -202,47 +193,44 @@ function recogniseImpl(ctx, bytes) {
  *  IN ISOLATION, so the same content has the same gist regardless of
  *  where it appears. */
 export function segment(ctx, bytes) {
-  const tree = perceive(ctx, bytes);
-  const out = [];
-  let pendingStart = -1;
-  let pendingEnd = -1;
-  const flush = () => {
-    if (pendingStart >= 0 && pendingEnd > pendingStart) {
-      out.push({
-        start: pendingStart,
-        end: pendingEnd,
-        v: gistOf(ctx, bytes.subarray(pendingStart, pendingEnd)),
-      });
-    }
-    pendingStart = -1;
-    pendingEnd = -1;
-  };
-  const walk = (n, start) => {
-    if (n.kids === null) {
-      const end = start + (n.leaf?.length ?? 0);
-      if (pendingStart < 0) {
-        pendingStart = start;
-      }
-      pendingEnd = end;
-      return end;
-    }
-    if (isChunk(n)) {
-      flush();
-      let end = start;
-      for (const c of n.kids) {
-        end += c.leaf?.length ?? 0;
-      }
-      out.push({ start, end, v: gistOf(ctx, bytes.subarray(start, end)) });
-      return end;
-    }
+    const tree = perceive(ctx, bytes);
+    const out = [];
+    let pendingStart = -1;
+    let pendingEnd = -1;
+    const flush = () => {
+        if (pendingStart >= 0 && pendingEnd > pendingStart) {
+            out.push({
+                start: pendingStart,
+                end: pendingEnd,
+                v: gistOf(ctx, bytes.subarray(pendingStart, pendingEnd)),
+            });
+        }
+        pendingStart = -1;
+        pendingEnd = -1;
+    };
+    const walk = (n, start) => {
+        if (n.kids === null) {
+            const end = start + (n.leaf?.length ?? 0);
+            if (pendingStart < 0)
+                pendingStart = start;
+            pendingEnd = end;
+            return end;
+        }
+        if (isChunk(n)) {
+            flush();
+            let end = start;
+            for (const c of n.kids)
+                end += c.leaf?.length ?? 0;
+            out.push({ start, end, v: gistOf(ctx, bytes.subarray(start, end)) });
+            return end;
+        }
+        flush();
+        let pos = start;
+        for (const c of n.kids)
+            pos = walk(c, pos);
+        return pos;
+    };
+    walk(tree, 0);
     flush();
-    let pos = start;
-    for (const c of n.kids) {
-      pos = walk(c, pos);
-    }
-    return pos;
-  };
-  walk(tree, 0);
-  flush();
-  return out;
+    return out;
 }

package/dist/src/mind/resonance.d.ts

@@ -2,12 +2,7 @@ import type { MindContext } from "./types.js";
 /** The connector that belongs BETWEEN two adjacent results — the graded
  *  junction ladder described in the module note above.  Returns null when
  *  the graph holds no evidence that the two ever ran together. */
-export declare function bridge(
-  ctx: MindContext,
-  left: Uint8Array,
-  right: Uint8Array,
-  interiorAllowance?: number,
-): Promise<Uint8Array | null>;
+export declare function bridge(ctx: MindContext, left: Uint8Array, right: Uint8Array, interiorAllowance?: number): Promise<Uint8Array | null>;
 /** Join two spans with the learnt connector between them, when one exists —
  *  the composition step every out-of-search assembly (multi-topic fusion,
  *  CAST's substitution and comparison) shares.  A miss joins the pieces BARE
@@ -15,26 +10,14 @@ export declare function bridge(
  *  so a degraded join is visible in the rationale regardless of which
  *  mechanism paid it.  (The in-search connector splice in graph-search.ts is
  *  the same concept inside the deduction, where the join is a costed rule.) */
-export declare function joinWithBridge(
-  ctx: MindContext,
-  left: Uint8Array,
-  right: Uint8Array,
-): Promise<Uint8Array>;
+export declare function joinWithBridge(ctx: MindContext, left: Uint8Array, right: Uint8Array): Promise<Uint8Array>;
 /** The pivot a produced answer bridges through: the longest UNCONSUMED learnt
  *  CONTEXT (a node bearing a continuation edge) whose bytes `answer` literally
  *  contains.  Candidates are gathered by resonating the answer's sub-regions
  *  (breadth-first, leaves skipped, probes capped by branch count), then
  *  confirmed by exact byte containment — a near-resonance alone never hops. */
-export declare function pivotInto(
-  ctx: MindContext,
-  answer: Uint8Array,
-  consumed: ReadonlySet<number>,
-): Promise<number | null>;
-export declare function meaningOf(
-  ctx: MindContext,
-  bytes: Uint8Array,
-  anchors: ReadonlyArray<{
+export declare function pivotInto(ctx: MindContext, answer: Uint8Array, consumed: ReadonlySet<number>): Promise<number | null>;
+export declare function meaningOf(ctx: MindContext, bytes: Uint8Array, anchors: ReadonlyArray<{
     name: string;
     form: Uint8Array;
-  }>,
-): Promise<string | null>;
+}>): Promise<string | null>;

package/dist/src/mind/trace.d.ts

@@ -1,34 +1,15 @@
 import type { MindContext } from "./types.js";
 import type { DerivationStep } from "./graph-search.js";
 import type { RationaleItem } from "./rationale.js";
-export declare function rItem(
-  bytes: Uint8Array,
-  role?: string,
-  node?: number,
-  span?: [number, number],
-): RationaleItem;
-export declare function rNode(
-  ctx: MindContext,
-  id: number,
-  role?: string,
-  score?: number,
-): RationaleItem;
-export declare function rDeriv(
-  ctx: MindContext,
-  it: DerivationStep["conclusion"],
-  role?: string,
-): RationaleItem;
+export declare function rItem(bytes: Uint8Array, role?: string, node?: number, span?: [number, number]): RationaleItem;
+export declare function rNode(ctx: MindContext, id: number, role?: string, score?: number): RationaleItem;
+export declare function rDeriv(ctx: MindContext, it: DerivationStep["conclusion"], role?: string): RationaleItem;
 /** The standard FALL-THROUGH closer every self-gating mechanism ends with:
  *  close the open scope with no outputs and the reason, and return null so
  *  the caller can `return fail("…")` in one expression.  `t` is the scope an
  *  enclosing `ctx.trace?.enter(...)` returned (undefined when not tracing). */
-export declare function traceFail(
-  t: {
+export declare function traceFail(t: {
     done(outputs: RationaleItem[], note?: string): void;
-  } | undefined,
-): (note: string) => null;
+} | undefined): (note: string) => null;
 export declare const MOVE_NOTE: Record<string, string>;
-export declare function traceDerivation(
-  ctx: MindContext,
-  steps: ReadonlyArray<DerivationStep>,
-): void;
+export declare function traceDerivation(ctx: MindContext, steps: ReadonlyArray<DerivationStep>): void;

package/dist/src/mind/trace.js

@@ -6,76 +6,68 @@
 import { read } from "./primitives.js";
 import { decodeText } from "./rationale.js";
 export function rItem(bytes, role, node, span) {
-  return {
-    text: decodeText(bytes),
-    role,
-    node: node ?? undefined,
-    span,
-  };
+    return {
+        text: decodeText(bytes),
+        role,
+        node: node ?? undefined,
+        span,
+    };
 }
 export function rNode(ctx, id, role, score) {
-  return {
-    text: decodeText(read(ctx, id)),
-    node: id,
-    role,
-    score,
-  };
+    return {
+        text: decodeText(read(ctx, id)),
+        node: id,
+        role,
+        score,
+    };
 }
 export function rDeriv(ctx, it, role) {
-  const text = it.bytes
-    ? decodeText(it.bytes)
-    : it.node !== undefined
-    ? decodeText(read(ctx, it.node))
-    : it.kind === "cover"
-    ? `cover@${it.span[0]}`
-    : `[${it.span[0]},${it.span[1]})`;
-  return { text, role: role ?? it.kind, node: it.node, span: it.span };
+    const text = it.bytes
+        ? decodeText(it.bytes)
+        : it.node !== undefined
+            ? decodeText(read(ctx, it.node))
+            : it.kind === "cover"
+                ? `cover@${it.span[0]}`
+                : `[${it.span[0]},${it.span[1]})`;
+    return { text, role: role ?? it.kind, node: it.node, span: it.span };
 }
 /** The standard FALL-THROUGH closer every self-gating mechanism ends with:
  *  close the open scope with no outputs and the reason, and return null so
  *  the caller can `return fail("…")` in one expression.  `t` is the scope an
  *  enclosing `ctx.trace?.enter(...)` returned (undefined when not tracing). */
 export function traceFail(t) {
-  return (note) => {
-    t?.done([], note);
-    return null;
-  };
+    return (note) => {
+        t?.done([], note);
+        return null;
+    };
 }
 export const MOVE_NOTE = {
-  "follow-edge": "follow a learned continuation edge — 'what follows what'",
-  "concept-hop": "jump a concept (halo) link — a synonym's edge",
-  "voice": "emit the asker's own wording for this form (articulation)",
-  "ground": "a chain reached its terminal answer",
-  "splice-connector": "splice a learnt connector between two rewrites",
-  "split": "cut a span at a sub-leaf form boundary so a form can be reached",
-  "fuse": "fuse adjacent fragments toward a deeper learned form",
-  "recompose": "recompose fused parts into a learned whole that leads on",
-  "bridge": "advance the cover frontier across this span",
-  "pool-vote":
-    "pool independent regions' evidence for a shared anchor (sum, not shortest path)",
-  "axiom": "a seed: a perceived leaf, recognised form, or computed result",
-  "step": "a derivation step",
+    "follow-edge": "follow a learned continuation edge — 'what follows what'",
+    "concept-hop": "jump a concept (halo) link — a synonym's edge",
+    "voice": "emit the asker's own wording for this form (articulation)",
+    "ground": "a chain reached its terminal answer",
+    "splice-connector": "splice a learnt connector between two rewrites",
+    "split": "cut a span at a sub-leaf form boundary so a form can be reached",
+    "fuse": "fuse adjacent fragments toward a deeper learned form",
+    "recompose": "recompose fused parts into a learned whole that leads on",
+    "bridge": "advance the cover frontier across this span",
+    "pool-vote": "pool independent regions' evidence for a shared anchor (sum, not shortest path)",
+    "axiom": "a seed: a perceived leaf, recognised form, or computed result",
+    "step": "a derivation step",
 };
 export function traceDerivation(ctx, steps) {
-  const t = ctx.trace;
-  if (!t) {
-    return;
-  }
-  const indexOfOrder = new Map();
-  for (const s of steps) {
-    const note = MOVE_NOTE[s.move] ?? s.move;
-    const deps = s.producers
-      .map((o) => indexOfOrder.get(o))
-      .filter((x) => x !== undefined);
-    const premises = s.premises.map((p) => rDeriv(ctx, p));
-    const conclusion = [rDeriv(ctx, s.conclusion)];
-    const index = t.step(
-      s.move,
-      premises,
-      conclusion,
-      s.cost > 0 ? `${note} (cost ${s.cost})` : note,
-      deps.length > 0 ? deps : undefined,
-    );
-    indexOfOrder.set(s.order, index);
-  }
+    const t = ctx.trace;
+    if (!t)
+        return;
+    const indexOfOrder = new Map();
+    for (const s of steps) {
+        const note = MOVE_NOTE[s.move] ?? s.move;
+        const deps = s.producers
+            .map((o) => indexOfOrder.get(o))
+            .filter((x) => x !== undefined);
+        const premises = s.premises.map((p) => rDeriv(ctx, p));
+        const conclusion = [rDeriv(ctx, s.conclusion)];
+        const index = t.step(s.move, premises, conclusion, s.cost > 0 ? `${note} (cost ${s.cost})` : note, deps.length > 0 ? deps : undefined);
+        indexOfOrder.set(s.order, index);
+    }
 }