@visual-z/xeno 0.8.4 → 0.9.1

package/src/core/derive.ts

@@ -1,516 +0,0 @@
-/**
- * deriveHandoff: segment events + previous handoff -> next handoff.
- *
- * Pure and total. No I/O, no clock, no randomness, no model call. Same inputs
- * always produce the same object, which is what makes the handoff diffable,
- * unit-testable and cheap enough that segments can be short (decisions D1, D2).
- *
- * Evidence freshness rule: a completion claim must cite an event from the SAME
- * segment. A gate that passed three segments ago is not proof about code that has
- * changed since -- that is the stale-evidence problem, so the citation fails.
- * Verification status, by contrast, carries forward as last-known with its
- * original timestamp, which is honest about what it is.
- */
-
-import type {
-  LogEvent, LineRange, NodeRef, EventId, CarryableEvent,
-} from "./events.ts";
-import { CARRYABLE_EVENTS } from "./events.ts";
-import { deriveWorkItems } from "./work-state.ts";
-import { deriveAcceptance } from "./acceptance.ts";
-import { deriveLoadedSkills } from "./skills.ts";
-import { deriveProcesses } from "./process-state.ts";
-import { deriveEvidenceLinks } from "./evidence-links.ts";
-import { deriveProgress } from "./progress.ts";
-import { isCommandResult, resolveEvidence, evidenceStale, eligibleProgressChecks } from "./evidence.ts";
-import type { BranchRecord } from "./handoff.ts";
-import {
-  HANDOFF_VERSION,
-  type Handoff, type CompletedItem, type UnverifiedClaim, type InFlightItem,
-  type BlockedItem, type DecisionItem, type PitfallItem, type FileAnchor,
-  type VerificationItem, type UserTurnRecord,
-} from "./handoff.ts";
-
-export interface DeriveConfig {
-  /** Where the agent can grep for anything a cap dropped. */
-  manifestPath: string;
-  maxUserTurns: number;
-  maxUserTurnBytes: number;
-}
-
-/**
- * Marks the open questions this module generates from branch state, so they
- * can be rebuilt each derivation instead of accumulating.
- */
-const UNRESOLVED_BRANCH_PREFIX = "branch ";
-
-export const DEFAULT_DERIVE_CONFIG: DeriveConfig = {
-  manifestPath: "log/manifest.json",
-  maxUserTurns: 200,
-  maxUserTurnBytes: 64_000,
-};
-
-export interface DeriveInput {
-  /** Previous segment's handoff, or null for segment 0. */
-  prev: Handoff | null;
-  /**
-   * Length of the path from the root to this node, inclusive.
-   *
-   * Supplied by the caller rather than derived from a node number, because
-   * allocation order is not an ordering over the tree: a node forked from an
-   * earlier one has a short path and a high number. deriveHandoff is pure and
-   * cannot read the log to count it, but readAncestry already returns
-   * `visited`, so the caller has the length in hand.
-   */
-  depth: number;
-  events: readonly LogEvent[];
-  /** Ref to the segment being closed, recorded as the next segment's predecessor. */
-  self: NodeRef;
-  config?: Partial<DeriveConfig>;
-}
-
-// --- helpers ---------------------------------------------------------------
-
-/** Coalesce overlapping or adjacent ranges into a minimal sorted set. */
-export function mergeRanges(ranges: readonly LineRange[]): LineRange[] {
-  if (ranges.length === 0) return [];
-  const sorted = [...ranges].sort((a, b) => a[0] - b[0] || a[1] - b[1]);
-  const out: LineRange[] = [[sorted[0]![0], sorted[0]![1]]];
-  for (let i = 1; i < sorted.length; i++) {
-    const cur = sorted[i]!;
-    const last = out[out.length - 1]!;
-    if (cur[0] <= last[1] + 1) {
-      out[out.length - 1] = [last[0], Math.max(last[1], cur[1])];
-    } else {
-      out.push([cur[0], cur[1]]);
-    }
-  }
-  return out;
-}
-
-/** First occurrence wins, so accumulation across segments is order-stable. */
-function dedupe<T>(items: readonly T[], key: (t: T) => string): T[] {
-  const seen = new Set<string>();
-  const out: T[] = [];
-  for (const it of items) {
-    const k = key(it);
-    if (!seen.has(k)) {
-      seen.add(k);
-      out.push(it);
-    }
-  }
-  return out;
-}
-
-// --- main ------------------------------------------------------------------
-
-export function deriveHandoff(input: DeriveInput): Handoff {
-  const cfg = { ...DEFAULT_DERIVE_CONFIG, ...input.config };
-  const { prev, depth, events } = input;
-
-  // Command results in this segment, in log order. The evidence index and the
-  // verification table are both built from this and nothing else -- exit codes,
-  // never the model's account of them.
-  const commands = events.filter(isCommandResult);
-
-  // -- objective: verbatim, set once, never rewritten -----------------------
-  // Skip user events a later interrupt cancelled: an abandoned prompt is not
-  // what the next segment is doing. If every user event in the segment was
-  // abandoned, keep the last one so EMPTY_OBJECTIVE cannot fire -- the mark
-  // lives on user_turns, not by blanking the field.
-  const abandonedIds = new Set(
-    events.filter((e): e is Extract<LogEvent, { t: "interrupt" }> => e.t === "interrupt")
-      .map((e) => e.user_id),
-  );
-  const users = events.filter((e): e is Extract<LogEvent, { t: "user" }> => e.t === "user");
-  const liveUsers = users.filter((e) => !abandonedIds.has(e.id));
-  const firstUser = liveUsers[0] ?? users.at(-1);
-  const objective = prev?.objective ?? (firstUser !== undefined ? firstUser.text : "");
-
-  // -- user turns: all of them, verbatim, accumulated ----------------------
-  // Abandoned turns stay: deleting them would rewrite history. The interrupt
-  // is a later record, so the mark is derived here rather than written back
-  // onto the user event (D8).
-  const newTurns: UserTurnRecord[] = users.map((e) => ({
-    at: e.at,
-    text: e.text,
-    ...(abandonedIds.has(e.id) ? { abandoned: true as const } : {}),
-  }));
-  const userTurns: UserTurnRecord[] = [...(prev?.user_turns ?? []), ...newTurns];
-
-  let dropped = prev?.user_turns_truncated?.dropped ?? 0;
-  // Drop oldest first: the very first turn survives in `objective` regardless.
-  while (
-    userTurns.length > cfg.maxUserTurns ||
-    (userTurns.length > 1 &&
-      userTurns.reduce((n, t) => n + t.text.length, 0) > cfg.maxUserTurnBytes)
-  ) {
-    userTurns.shift();
-    dropped++;
-  }
-
-  // -- completion claims resolved against the log --------------------------
-  const newCompleted: CompletedItem[] = [];
-  const unverified: UnverifiedClaim[] = [];
-
-  for (let i = 0; i < events.length; i++) {
-    const e = events[i]!;
-    if (e.t !== "claim" || e.work_id !== undefined) continue;
-    // Resolve against the most recent match AT OR BEFORE the claim. A claim is a
-    // statement about evidence available when it was made, so a later run must not
-    // retroactively change it -- that non-locality would mean appending an event
-    // could silently rewrite an earlier conclusion. Whether the gate is red *now*
-    // is separate information, carried by `verification` and repeated inline as
-    // `evidence_superseded` below.
-    const resolved = resolveEvidence(events.slice(0, i), e.evidence);
-    if (resolved.ok) newCompleted.push({ what: e.what, evidence: resolved.evidence });
-    else unverified.push({ what: e.what, claimed: e.evidence, reason: resolved.reason,
-      ...(resolved.exit !== undefined ? { exit: resolved.exit } : {}) });
-  }
-
-  const workItems = deriveWorkItems(prev?.state.work_items ?? [], events);
-  const identifiedCompleted: CompletedItem[] = workItems.flatMap(item => item.status === "completed" && item.evidence
-    ? [{ work_id: item.id, what: item.what, evidence: item.evidence }] : []);
-  const legacyCompleted = dedupe([...(prev?.state.completed ?? []).filter(item => item.work_id === undefined), ...newCompleted], c => c.what);
-  const completed = [...legacyCompleted, ...identifiedCompleted];
-  const completedSet = new Set(legacyCompleted.map(c => c.what));
-
-  // -- in flight: latest note per item wins --------------------------------
-  const inFlightMap = new Map<string, InFlightItem>();
-  for (const i of prev?.state.in_flight ?? []) if (i.work_id === undefined) inFlightMap.set(i.what, i);
-  for (const e of events) {
-    if (e.t === "next_action" && e.work_id === undefined) inFlightMap.set(e.what, { what: e.what, next_action: e.next_action });
-  }
-
-  // -- blocked -------------------------------------------------------------
-  const blockedItems: BlockedItem[] = [
-    ...(prev?.state.blocked ?? []).filter(item => item.work_id === undefined),
-    ...events.filter((e): e is Extract<LogEvent, { t: "blocked" }> => e.t === "blocked" && e.work_id === undefined)
-      .map((e) => ({ what: e.what, reason: e.reason })),
-  ];
-  const legacyBlocked = dedupe(blockedItems, b => b.what).filter(b => !completedSet.has(b.what));
-  const blocked = [...legacyBlocked, ...workItems.filter(item => item.status === "blocked")
-    .map(item => ({ work_id: item.id, what: item.what, reason: item.reason ?? "blocked" }))];
-  const blockedSet = new Set(legacyBlocked.map(b => b.what));
-
-  // Completed beats blocked beats in-flight, so an item never appears twice.
-  const inFlight = [...inFlightMap.values()].filter(
-    (i) => !completedSet.has(i.what) && !blockedSet.has(i.what),
-  ).concat(workItems.filter(item => item.status === "active")
-    .map(item => ({ work_id: item.id, what: item.what, next_action: item.next_action ?? "" })));
-
-  // -- branches: what this node opened, and what became of it --------------
-  //
-  // Spawn creates the record; joined attaches the reference; adopt and
-  // discard resolve it. An unresolved branch stays visible rather than
-  // silently accumulating, which is the whole of D16.
-  const branchMap = new Map<number, BranchRecord>();
-  for (const b of prev?.branches ?? []) branchMap.set(b.node, b);
-  for (const e of events) {
-    if (e.t === "spawn") {
-      branchMap.set(e.branch.node, {
-        node: e.branch.node,
-        spawned_at: e.id,
-        purpose: e.purpose,
-        ...(e.background ? { background: e.background } : {}),
-        resolution: null,
-      });
-      continue;
-    }
-    if (e.t !== "joined" && e.t !== "adopt" && e.t !== "discard") continue;
-    // A lifecycle event for a branch this node never spawned still records
-    // the branch: dropping it would hide a branch that exists.
-    const existing = branchMap.get(e.branch.node) ?? {
-      node: e.branch.node,
-      spawned_at: e.id,
-      purpose: "(spawn not recorded in this node)",
-      resolution: null,
-    };
-    if (e.t === "joined") {
-      branchMap.set(e.branch.node, {
-        ...existing,
-        handoff_ref: e.handoff_ref,
-        summary: e.summary,
-        ...(e.receipt_ref ? { receipt_ref: e.receipt_ref } : {}),
-        ...(e.outcome ? { outcome: e.outcome } : {}),
-      });
-    } else {
-      branchMap.set(e.branch.node, {
-        ...existing,
-        resolution: e.t === "adopt" ? "merged" : "discarded",
-      });
-    }
-  }
-  const branches = [...branchMap.values()].sort((a, b) => a.node - b.node);
-
-  // -- decisions / pitfalls / questions ------------------------------------
-  const decisions = dedupe<DecisionItem>(
-    [
-      ...(prev?.decisions ?? []),
-      ...events.filter((e): e is Extract<LogEvent, { t: "decision" }> => e.t === "decision")
-        .map((e) => ({
-          chose: e.chose, because: e.because,
-          ...(e.work_id ? { work_id: e.work_id, source: { node: input.self.node, event_id: e.id } } : {}),
-          ...(e.rejected !== undefined ? { rejected: e.rejected } : {}),
-        })),
-    ],
-    (d) => JSON.stringify([d.chose, d.because, ...(d.work_id ? [d.work_id] : [])]),
-  );
-
-  const pitfalls = dedupe<PitfallItem>(
-    [
-      ...(prev?.pitfalls ?? []),
-      ...events.filter((e): e is Extract<LogEvent, { t: "pitfall" }> => e.t === "pitfall")
-        .map((e) => ({ tried: e.tried, failed_because: e.failed_because,
-          ...(e.work_id ? { work_id: e.work_id, source: { node: input.self.node, event_id: e.id } } : {}) })),
-    ],
-    (p) => JSON.stringify([p.tried, p.failed_because, ...(p.work_id ? [p.work_id] : [])]),
-  );
-
-  const openQuestions = dedupe(
-    [
-      ...(prev?.open_questions ?? []).filter((q) => !q.startsWith(UNRESOLVED_BRANCH_PREFIX)),
-      ...events.filter((e): e is Extract<LogEvent, { t: "question" }> => e.t === "question")
-        .map((e) => e.text),
-      // Rebuilt from the current branch state each time rather than carried,
-      // so resolving a branch removes its question instead of leaving a stale
-      // one behind. The text names the node and the handoff so the next
-      // context can go read it rather than only learning that it exists.
-      ...branches
-        .filter((b) => b.resolution === null)
-        .map((b) =>
-          `${UNRESOLVED_BRANCH_PREFIX}${b.node} (${b.purpose}) is unresolved` +
-          `${b.handoff_ref ? `; it joined with ${b.handoff_ref}` : "; it has not joined yet"}` +
-          ` -- adopt it or discard it`,
-        ),
-    ],
-    (q) => q,
-  );
-
-  // -- file anchors: reference plus fingerprint, never content -------------
-  const anchors = new Map<string, {
-    path: string; sha256: string; ranges: LineRange[]; touched: Set<"read" | "edit">; stale?: true;
-  }>();
-  for (const a of prev?.file_anchors ?? []) {
-    anchors.set(a.path, {
-      path: a.path, sha256: a.sha256,
-      ranges: [...(a.read_ranges ?? [])], touched: new Set(a.touched),
-      ...(a.stale ? { stale: true } : {}),
-    });
-  }
-  for (const e of events) {
-    if (e.t === "checkpoint" && e.phase === "applied") for (const [path, change] of Object.entries(e.changes)) {
-      const anchor = anchors.get(path);
-      if (anchor) {
-        if (change.after?.sha256 !== anchor.sha256) anchor.stale = true;
-        else delete anchor.stale;
-      }
-    }
-    if (e.t === "workspace_observation" && e.changed || e.t === "checkpoint" && e.phase === "unavailable") {
-      for (const anchor of anchors.values()) anchor.stale = true;
-    }
-    if (e.t !== "tool_result" || !e.effect) continue;
-    const eff = e.effect;
-    if (eff.kind === "read") {
-      const cur = anchors.get(eff.path) ?? {
-        path: eff.path, sha256: eff.sha256, ranges: [], touched: new Set<"read" | "edit">(),
-      };
-      cur.sha256 = eff.sha256;
-      delete cur.stale;
-      cur.ranges.push(...(eff.ranges ?? []));
-      cur.touched.add("read");
-      anchors.set(eff.path, cur);
-    } else if (eff.kind === "edit") {
-      const cur = anchors.get(eff.path) ?? {
-        path: eff.path, sha256: eff.sha256_after, ranges: [], touched: new Set<"read" | "edit">(),
-      };
-      cur.sha256 = eff.sha256_after;
-      delete cur.stale;
-      cur.touched.add("edit");
-      anchors.set(eff.path, cur);
-    }
-  }
-  const fileAnchors: FileAnchor[] = [...anchors.values()]
-    .sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0))
-    .map((a) => {
-      const merged = mergeRanges(a.ranges);
-      return {
-        path: a.path, sha256: a.sha256,
-        ...(a.stale ? { stale: true } : {}),
-        ...(merged.length > 0 ? { read_ranges: merged } : {}),
-        touched: (["read", "edit"] as const).filter((k) => a.touched.has(k)),
-      };
-    });
-
-  // -- verification: last run per gate; unrun gates stay not_run -----------
-  const gateState = new Map<string, VerificationItem>();
-  for (const item of prev?.verification ?? []) gateState.set(item.gate, { ...item });
-  for (const c of commands) {
-    const gate = c.effect.gate;
-    if (gate === undefined) continue;
-    gateState.set(gate, {
-      gate, status: c.effect.exit === 0 ? "pass" : "fail", at: c.at, exit: c.effect.exit,
-      ...(c.effect.workspace_scope ? { workspace_scope: c.effect.workspace_scope } : {}),
-      ...(c.effect.workspace_observed === false ? { stale: true } : {}),
-      ...(c.effect.workspace_sha256 ? { workspace_sha256: c.effect.workspace_sha256 } : {}),
-    });
-  }
-  const verification = [...gateState.values()].sort((a, b) =>
-    a.gate < b.gate ? -1 : a.gate > b.gate ? 1 : 0,
-  );
-  for (const item of verification) {
-    const hit = commands.filter((c) => c.effect.gate === item.gate).at(-1);
-    if (evidenceStale(events, { command: hit?.effect.cmd ?? "", event_id: hit?.id ?? "", at: item.at ?? "", exit: item.exit ?? -1,
-      ...(item.workspace_scope ? { workspace_scope: item.workspace_scope } : {}),
-      ...(item.workspace_sha256 ? { workspace_sha256: item.workspace_sha256 } : {}),
-    }, item.stale)) item.stale = true;
-    else delete item.stale;
-  }
-
-  // -- mark completions whose gate has since gone red -------------------------
-  const failingGates = new Map(
-    verification.filter((v) => v.status === "fail").map((v) => [v.gate, v]),
-  );
-  const completedMarked: CompletedItem[] = completed.map((original) => {
-    const { evidence_stale: _old, ...base } = original;
-    const item: CompletedItem = evidenceStale(events, original.evidence, original.evidence_stale)
-      ? { ...base, evidence_stale: true } : base;
-    const gate = item.evidence.gate;
-    const failing = gate === undefined ? undefined : failingGates.get(gate);
-    if (!failing) {
-      // Drop any stale marker: the gate went green again.
-      const { evidence_superseded: _drop, ...rest } = item;
-      return rest;
-    }
-    return {
-      ...item,
-      evidence_superseded: {
-        gate: failing.gate,
-        status: "fail" as const,
-        ...(failing.exit !== undefined ? { exit: failing.exit } : {}),
-        ...(failing.at !== undefined ? { at: failing.at } : {}),
-      },
-    };
-  });
-
-  // -- last activity: derived, so it is present even with zero annotations --
-  let lastActivity: string | null = null;
-  for (const e of events) {
-    if (e.t === "tool_result" && e.effect) {
-      const eff = e.effect;
-      lastActivity =
-        eff.kind === "command" ? `ran ${eff.cmd} (exit ${eff.exit})`
-        : eff.kind === "edit" ? `edited ${eff.path}`
-        : `read ${eff.path}`;
-    } else if (e.t === "assistant") {
-      const text = e.blocks.find((b) => b.type === "text");
-      if (text && text.type === "text" && text.text.trim()) {
-        lastActivity = firstLine(text.text);
-      }
-    }
-  }
-  if (lastActivity === null) lastActivity = prev?.state.last_activity ?? null;
-
-  // -- progress (decision D9) ----------------------------------------------
-  const eligibleChecks = eligibleProgressChecks(events, new Set([...newCompleted, ...identifiedCompleted].map(item => item.evidence.event_id)), failingGates);
-  // A bounded view is presentation, not derivation input. Refuse to forget an
-  // omitted ledger, which would make old observations appear new after a cut.
-  if (prev?.history && Object.values(prev.history.sections).some((range) => range.offset > 0)) {
-    throw new Error("deriveHandoff requires full replay state, not a paginated handoff");
-  }
-  const progress = deriveProgress(prev?.progress_evidence ?? [], events, input.self.node, eligibleChecks);
-  const links = deriveEvidenceLinks(prev?.evidence_links ?? [], events);
-  const acceptance = deriveAcceptance(prev?.acceptance, events);
-  const loadedSkills = deriveLoadedSkills(prev?.loaded_skills ?? [], events, input.self.node);
-  const processes = deriveProcesses(prev?.processes ?? [], events, input.self.node);
-
-  const hasRemaining = inFlight.length > 0 || blocked.length > 0 || openQuestions.length > 0;
-  // A next action is a statement about the current state of the work, so it
-  // follows the evidence rule above: only one this segment recorded or
-  // refreshed counts. A carried one stays listed but no longer suppresses the
-  // boundary and continuation reminders that ask the model to confirm it.
-  const thisSegment = new Set(events.map((e) => e.id));
-  const freshUnscoped = new Set(events.flatMap((e) => e.t === "next_action" && e.work_id === undefined ? [e.what] : []));
-  const freshWork = new Set(workItems.filter((item) => thisSegment.has(item.updated_at)).map((item) => item.id));
-  const hasNextAction = inFlight.some((i) => i.next_action.trim().length > 0 &&
-    (i.work_id === undefined ? freshUnscoped.has(i.what) : freshWork.has(i.work_id)));
-
-  return {
-    handoff_version: HANDOFF_VERSION,
-    predecessor: input.self,
-    objective,
-    user_turns: userTurns,
-    ...(dropped > 0
-      ? { user_turns_truncated: { dropped, recover_from: [cfg.manifestPath] } }
-      : {}),
-    state: {
-      ...(workItems.length > 0 ? { work_items: workItems } : {}),
-      completed: completedMarked,
-      unverified_claims: dedupe([...(prev?.state.unverified_claims ?? []), ...unverified], (c) => JSON.stringify(c))
-        .filter((c) => !completedSet.has(c.what)),
-      in_flight: inFlight,
-      blocked,
-      last_activity: lastActivity,
-    },
-    decisions,
-    ...(acceptance ? { acceptance } : {}),
-    pitfalls,
-    file_anchors: fileAnchors,
-    verification,
-    branches,
-    open_questions: openQuestions,
-    progress_evidence: progress.evidence,
-    ...(links.length > 0 ? { evidence_links: links } : {}),
-    ...(loadedSkills.length > 0 ? { loaded_skills: loadedSkills } : {}),
-    ...(processes.length > 0 ? { processes } : {}),
-    continuation_valid: hasRemaining && hasNextAction,
-    budget: {
-      nodes_on_path: depth,
-      nodes_without_progress: progress.progressed
-        ? 0
-        : (prev?.budget.nodes_without_progress ?? 0) + 1,
-    },
-  };
-}
-
-function firstLine(s: string): string {
-  const line = s.trim().split("\n")[0] ?? "";
-  return line.length > 200 ? line.slice(0, 197) + "..." : line;
-}
-
-/**
- * Events an adopt carries into the node it opens.
- *
- * Adopting a branch replaces the mainline with it, and the branch's ancestry
- * stops at the fork point -- so everything the parent recorded after forking
- * is outside it, including the decision that chose the branch. That is the
- * least disposable record in the log, so it is carried rather than lost.
- *
- * Only annotations are carried. Harness events are either already in the
- * branch's ancestry (before the fork) or are parent actions the branch never
- * saw and should not inherit. Carrying annotations is free in context terms
- * because they never replay as messages; only derivation reads them.
- *
- * A fork point that is not in `events` carries nothing, rather than falling
- * back to all of them: an unknown fork point means the caller's picture of
- * the tree is wrong, and carrying everything would silently duplicate work
- * the branch already has.
- */
-export function carryForward(
-  events: readonly LogEvent[],
-  since: EventId,
-  fromNode = 0,
-): CarryableEvent[] {
-  const at = events.findIndex((e) => e.id === since);
-  if (at < 0) return [];
-  const carryable = new Set<string>(CARRYABLE_EVENTS);
-  return events
-    .slice(at + 1)
-    .filter((e): e is CarryableEvent => carryable.has(e.t))
-    .map((e) => ({
-      ...e,
-      // Provenance, so the handoff can tell what this node produced from what
-      // it inherited through an adopt.
-      carried_from: e.carried_from ?? { node: fromNode, event: e.id },
-    }));
-}

package/src/core/draft-images.ts

@@ -1,56 +0,0 @@
-import type { ImageRef } from "./images.ts";
-
-/** D8: draft labels carry identity; bytes remain immutable blob references. */
-export interface DraftImageSpan {
-  readonly id: number;
-  readonly start: number;
-  readonly end: number;
-  readonly image: ImageRef;
-}
-
-export function imageMarker(id: number): string { return `[Image #${id}]`; }
-
-export function draftImageSpans(text: string, registry: ReadonlyMap<number, ImageRef>): DraftImageSpan[] {
-  const spans: DraftImageSpan[] = [];
-  for (const match of text.matchAll(/\[Image #(\d+)\]/g)) {
-    const id = Number(match[1]), image = registry.get(id);
-    if (image) spans.push({ id, start: match.index, end: match.index + match[0].length, image });
-  }
-  return spans;
-}
-
-/** Only registered, surviving tags are sent. Unknown lookalikes remain literal text. */
-export function draftImageInput(text: string, registry: ReadonlyMap<number, ImageRef>): { text: string; images: ImageRef[] } {
-  const spans = draftImageSpans(text, registry), images: ImageRef[] = [], seen = new Set<number>();
-  let plain = "", from = 0;
-  for (const span of spans) {
-    plain += text.slice(from, span.start); from = span.end;
-    if (!seen.has(span.id)) { images.push(span.image); seen.add(span.id); }
-  }
-  return { text: (plain + text.slice(from)).trim(), images };
-}
-
-/** Adjacency includes one horizontal space, never another line or distant prose. */
-export function focusedDraftImage(text: string, cursor: number, registry: ReadonlyMap<number, ImageRef>): DraftImageSpan | undefined {
-  const spans = draftImageSpans(text, registry);
-  return spans.find(span => cursor >= span.start && cursor < span.end)
-    ?? spans.find(span => cursor === span.end)
-    ?? spans.find(span => (cursor === span.end + 1 && /[ \t]/.test(text[span.end] ?? "")) ||
-      (cursor === span.start - 1 && /[ \t]/.test(text[cursor] ?? "")));
-}
-
-/** Merge registered labels before word/grapheme navigation and wrapping share them. */
-export function segmentDraftImages(text: string, segments: Iterable<Intl.SegmentData>, registry: ReadonlyMap<number, ImageRef>): Intl.SegmentData[] {
-  const spans = draftImageSpans(text, registry);
-  if (!spans.length) return [...segments];
-  const result: Intl.SegmentData[] = [];
-  let index = 0;
-  for (const segment of segments) {
-    while (spans[index] && spans[index]!.end <= segment.index) index++;
-    const span = spans[index];
-    if (span && segment.index >= span.start && segment.index < span.end) {
-      if (segment.index === span.start) result.push({ segment: text.slice(span.start, span.end), index: span.start, input: text });
-    } else result.push(segment);
-  }
-  return result;
-}