@visual-z/xeno 0.8.4 → 0.9.0

package/src/core/history.ts

@@ -1,237 +0,0 @@
-/** D20: bounded carried state, with deterministic pages rebuilt from the log. */
-import { emitHandoff, type Handoff, type UserTurnRecord } from "./handoff.ts";
-import { estimateTokens } from "./tokens.ts";
-import { recoveryWorkingSet, recoveryWorkingSetV3 } from "./working-set.ts";
-import { recoveryInstructions } from "./prompt-policy.ts";
-import type { RecoveryNodes } from "./recovery-sources.ts";
-
-// A carried handoff must leave room for another segment's work. This budget is
-// the existing 5k work floor, not a new segment threshold or an accuracy claim.
-export const DEFAULT_HANDOFF_TOKENS = 5_000;
-export const HISTORY_SECTIONS = [
-  "user_turns", "state.completed", "state.unverified_claims", "state.in_flight",
-  "state.blocked", "decisions", "pitfalls", "file_anchors", "verification",
-  "branches", "open_questions", "progress_evidence",
-  "state.work_items",
-  "evidence_links",
-  "acceptance.criteria",
-  "acceptance.targets",
-  "loaded_skills",
-  "processes",
-] as const;
-export type HistorySection = (typeof HISTORY_SECTIONS)[number];
-
-export function historyItems(h: Handoff, section: HistorySection): readonly unknown[] {
-  switch (section) {
-    case "state.completed": return h.state.completed;
-    case "state.unverified_claims": return h.state.unverified_claims;
-    case "state.in_flight": return h.state.in_flight;
-    case "state.blocked": return h.state.blocked;
-    case "state.work_items": return h.state.work_items ?? [];
-    case "evidence_links": return h.evidence_links ?? [];
-    case "acceptance.criteria": return h.acceptance?.criteria ?? [];
-    case "acceptance.targets": return h.acceptance?.targets ?? [];
-    case "loaded_skills": return h.loaded_skills ?? [];
-    case "processes": return h.processes ?? [];
-    case "progress_evidence": return h.progress_evidence ?? [];
-    default: return h[section];
-  }
-}
-
-function suffixes(h: Handoff, offsets: Record<HistorySection, number>): Handoff {
-  return {
-    ...h,
-    user_turns: h.user_turns.slice(offsets.user_turns),
-    state: {
-      ...h.state,
-      completed: h.state.completed.slice(offsets["state.completed"]),
-      unverified_claims: h.state.unverified_claims.slice(offsets["state.unverified_claims"]),
-      in_flight: h.state.in_flight.slice(offsets["state.in_flight"]),
-      blocked: h.state.blocked.slice(offsets["state.blocked"]),
-      ...(h.state.work_items !== undefined ? { work_items: h.state.work_items.slice(offsets["state.work_items"] ?? 0) } : {}),
-    },
-    decisions: h.decisions.slice(offsets.decisions),
-    pitfalls: h.pitfalls.slice(offsets.pitfalls),
-    file_anchors: h.file_anchors.slice(offsets.file_anchors),
-    verification: h.verification.slice(offsets.verification),
-    branches: h.branches.slice(offsets.branches),
-    open_questions: h.open_questions.slice(offsets.open_questions),
-    progress_evidence: (h.progress_evidence ?? []).slice(offsets.progress_evidence),
-    ...(h.evidence_links !== undefined ? { evidence_links: h.evidence_links.slice(offsets.evidence_links ?? 0) } : {}),
-    ...(h.acceptance ? { acceptance: { ...h.acceptance, criteria: h.acceptance.criteria.slice(offsets["acceptance.criteria"] ?? 0),
-      ...(h.acceptance.targets ? { targets: h.acceptance.targets.slice(offsets["acceptance.targets"] ?? 0) } : {}) } } : {}),
-    ...(h.loaded_skills ? { loaded_skills: h.loaded_skills.slice(offsets.loaded_skills ?? 0) } : {}),
-    ...(h.processes ? { processes: h.processes.slice(offsets.processes ?? 0) } : {}),
-  };
-}
-
-/** Sections a handoff actually has; an absent new section must not change legacy projections or frozen replay. */
-function pageableSections(full: Handoff): HistorySection[] {
-  return HISTORY_SECTIONS.filter(section => (section !== "state.work_items" || full.state.work_items !== undefined) &&
-    (section !== "evidence_links" || full.evidence_links !== undefined) &&
-    (section !== "acceptance.criteria" || full.acceptance !== undefined) &&
-    (section !== "acceptance.targets" || full.acceptance?.targets !== undefined) &&
-    (section !== "loaded_skills" || full.loaded_skills !== undefined) &&
-    (section !== "processes" || full.processes !== undefined));
-}
-
-/** The v2 shape carrying `items.length - offset` newest items of every pageable section. */
-function carriedAt(full: Handoff, sections: readonly HistorySection[], offsets: Record<HistorySection, number>): Handoff {
-  return {
-    ...suffixes(full, offsets),
-    handoff_version: 2,
-    history: {
-      source: full.predecessor!,
-      sections: Object.fromEntries(sections.map((s) => [s, {
-        total: historyItems(full, s).length, offset: offsets[s],
-      }])),
-    },
-  };
-}
-
-const handoffSize = (h: Handoff): number => estimateTokens.count([], emitHandoff(h));
-
-/**
- * `priority` sections grow to completion, newest first, before any other
- * section gets an item; the rest then share what is left round-robin. The
- * default (none) is the original D20 order, which recorded cuts replay.
- */
-export function boundHandoff(full: Handoff, budget = DEFAULT_HANDOFF_TOKENS, priority: readonly HistorySection[] = []): Handoff {
-  if (!Number.isFinite(budget) || budget <= 0) throw new RangeError("handoff budget must be positive");
-  const size = handoffSize;
-  if (size(full) <= budget) return full;
-  if (full.predecessor === null) throw new Error("history requires an immutable source");
-  const sections = pageableSections(full);
-  const offsets = Object.fromEntries(sections.map((s) => [s, historyItems(full, s).length])) as Record<HistorySection, number>;
-  const build = (): Handoff => carriedAt(full, sections, offsets);
-  let carried = build();
-  // The objective stays verbatim (D2). An oversized objective is an explicit
-  // input problem; repeatedly cutting it would create an infinite cut loop.
-  if (size(carried) > budget) throw new RangeError("handoff scalar fields exceed budget; shorten the objective or frozen input");
-  const grow = (section: HistorySection): boolean => {
-    if (offsets[section] === 0) return false;
-    offsets[section]--;
-    const candidate = build();
-    if (size(candidate) <= budget) { carried = candidate; return true; }
-    offsets[section]++;
-    return false;
-  };
-  for (const section of priority) if (sections.includes(section)) while (grow(section)) { /* newest first until full or out of room */ }
-  const active = new Set<HistorySection>(sections.filter(section => !priority.includes(section)));
-  // Round-robin suffix growth prevents one long section starving every other
-  // category. Each retained range is contiguous and independently pageable.
-  while (active.size > 0) {
-    for (const section of active) if (!grow(section)) active.delete(section);
-  }
-  return carried;
-}
-
-export function historyPage(full: Handoff, section: HistorySection, offset: number, limit: number): {
-  total: number; offset: number; next: number | null; items: readonly unknown[];
-} {
-  if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(limit) || limit < 1) {
-    throw new RangeError("history offset and limit must be nonnegative/positive integers");
-  }
-  const items = historyItems(full, section);
-  const end = Math.min(items.length, offset + limit);
-  return { total: items.length, offset, next: end < items.length ? end : null, items: items.slice(offset, end) };
-}
-
-/** R9 uses the same budget; originals are supplied by the ancestry owner. */
-export function boundRecoveryHandoff(full: Handoff, nodes: RecoveryNodes, budget = DEFAULT_HANDOFF_TOKENS, tools?: readonly string[]): Handoff {
-  const legacy = boundHandoff(full, budget);
-  const view = recoveryWorkingSet(full, nodes, budget * .4, tools);
-  if (!view) return legacy;
-  let carried: Handoff;
-  try { carried = boundHandoff({ ...full, working_set: view }, budget); }
-  catch (error) { if (error instanceof RangeError) return legacy; throw error; }
-  // Whether the user turns survived bounding is known only now. The inline
-  // wording is shorter, so swapping it in cannot push the handoff over budget.
-  const inline = tools?.includes("history") && carried.user_turns_truncated === undefined && (carried.history?.sections["user_turns"]?.offset ?? 0) === 0;
-  return inline && carried.working_set ? { ...carried, working_set: { ...carried.working_set, recovery: recoveryInstructions(tools!, true) } } : carried;
-}
-
-/**
- * D8: join carried turns to their original user events to name attached images
- * by digest. Turns and events are both the active ancestry in log order; any
- * disagreement leaves the turns undecorated rather than guessing a pairing.
- */
-export function userTurnImages(turns: readonly UserTurnRecord[], nodes: RecoveryNodes): readonly UserTurnRecord[] {
-  const users = nodes.flatMap(part => part.events.flatMap(event => event.t === "user" ? [event] : []));
-  if (users.length !== turns.length || users.some((event, i) => event.at !== turns[i]!.at || event.text !== turns[i]!.text)) return turns;
-  return turns.map((turn, i) => {
-    const event = users[i]!;
-    return event.images?.length ? { ...turn, event: event.id,
-      images: event.images.map(({ sha256, name, width, height }) => ({ sha256, name, width, height })) } : turn;
-  });
-}
-
-/**
- * v3 carries one copy of each work item's prose. `state.in_flight` and
- * `state.blocked` are compatible projections of identified work (O.2), so a
- * leading run of items the carried `state.work_items` or working set already
- * hold moves into the existing page range, which `validateHandoff` accepts for
- * continuation; D20 arrays stay contiguous suffixes. A working-set entry whose
- * prose the carried `state.work_items` holds keeps only its id and status, since
- * `state.work_items` is the canonical identified work. Every change only
- * removes bytes, so the budget still holds.
- */
-function oneCopyOfWork(h: Handoff): Handoff {
-  const items = new Map((h.state.work_items ?? []).map(item => [item.id, item]));
-  const viewed = new Map((h.working_set?.work ?? []).map(entry => [entry.id, entry]));
-  const history = h.history && { ...h.history, sections: { ...h.history.sections } };
-  type Prose = { status: string; what?: string; next_action?: string; reason?: string };
-  const holders = (id: string | undefined): Prose[] => {
-    const found: Prose[] = [], item = id === undefined ? undefined : items.get(id), entry = id === undefined ? undefined : viewed.get(id);
-    if (item) found.push(item);
-    if (entry) found.push(entry);
-    return found;
-  };
-  const page = <T extends { work_id?: string }>(section: "state.in_flight" | "state.blocked", list: readonly T[], same: (item: T, holder: Prose) => boolean): readonly T[] => {
-    const range = history?.sections[section];
-    let skip = 0;
-    while (range && skip < list.length && holders(list[skip]!.work_id).some(holder => same(list[skip]!, holder))) skip++;
-    if (skip === 0) return list;
-    history!.sections[section] = { total: range!.total, offset: range!.offset + skip };
-    return list.slice(skip);
-  };
-  const in_flight = page("state.in_flight", h.state.in_flight, (item, holder) => holder.status === "active" && holder.what === item.what && holder.next_action === item.next_action);
-  const blocked = page("state.blocked", h.state.blocked, (item, holder) => holder.status === "blocked" && holder.what === item.what && holder.reason === item.reason);
-  const view = h.working_set && { ...h.working_set, work: h.working_set.work.map(entry => {
-    const item = items.get(entry.id);
-    if (!item || item.what !== entry.what || item.next_action !== entry.next_action || item.reason !== entry.reason) return entry;
-    const { what: _what, next_action: _next, reason: _reason, ...rest } = entry;
-    return rest;
-  }) };
-  return { ...h, ...(view ? { working_set: view } : {}), ...(history ? { history } : {}), state: { ...h.state, in_flight, blocked } };
-}
-
-const USERS_FIRST: readonly HistorySection[] = ["user_turns"];
-
-/**
- * Working set v3. User turns are the smallest, highest-value carried content
- * (Codex compaction likewise keeps user messages newest first, verbatim, under
- * its own cap), so they are reserved before the working set and before every
- * other page; only turns that alone exceed the budget are cut, newest kept.
- * While every turn is inline, user references would only point at text already
- * present, so the view leaves them out. The view keeps v2's 40% allocation
- * assumption, measured inside the handoff it is carried in.
- */
-export function boundRecoveryHandoffV3(full: Handoff, nodes: RecoveryNodes, budget = DEFAULT_HANDOFF_TOKENS, tools?: readonly string[]): Handoff {
-  if (!Number.isFinite(budget) || budget <= 0) throw new RangeError("handoff budget must be positive");
-  const base: Handoff = { ...full, user_turns: userTurnImages(full.user_turns, nodes) };
-  const plain = (): Handoff => oneCopyOfWork(boundHandoff(base, budget, USERS_FIRST));
-  if (base.predecessor === null) return plain();
-  const sections = pageableSections(base);
-  const empty = Object.fromEntries(sections.map((s) => [s, historyItems(base, s).length])) as Record<HistorySection, number>;
-  const withUsers = carriedAt(base, sections, { ...empty, user_turns: 0 });
-  const usersInline = base.user_turns_truncated === undefined && handoffSize(withUsers) <= budget;
-  const skeleton = usersInline ? withUsers : carriedAt(base, sections, empty);
-  const cap = Math.min(budget, handoffSize(skeleton) + budget * .4);
-  const recovery = recoveryInstructions(tools ?? ["history"], usersInline, base.user_turns.some(turn => turn.images !== undefined));
-  const view = recoveryWorkingSetV3(base, nodes, { users: !usersInline, recovery,
-    fits: candidate => handoffSize({ ...skeleton, working_set: candidate }) <= cap });
-  if (!view) return plain();
-  try { return oneCopyOfWork(boundHandoff({ ...base, working_set: view }, budget, USERS_FIRST)); }
-  catch (error) { if (error instanceof RangeError) return plain(); throw error; }
-}

package/src/core/image-limits.ts

@@ -1,72 +0,0 @@
-/** Admission, model detail and preview memory are separate budgets (D8). */
-export const MAX_IMAGE_SOURCE_BYTES = 64 * 1024 * 1024;
-/** Matches the native decoder's area cap; inspect headers before WASM allocates. */
-export const MAX_IMAGE_SOURCE_PIXELS = 25_000_000;
-/** More readable screenshots than 2000px, with at most 32 MiB RGBA per preview. */
-export const MAX_MODEL_IMAGE_SIDE = 4096;
-export const MAX_MODEL_IMAGE_PIXELS = 8 * 1024 * 1024;
-export interface ImageDimensions { readonly width: number; readonly height: number }
-
-/** Header-only probe. Decoders still validate the complete image afterward. */
-export function imageDimensions(bytes: Uint8Array, mime: string): ImageDimensions | undefined {
-  const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  const result = (width: number, height: number): ImageDimensions | undefined =>
-    Number.isSafeInteger(width) && Number.isSafeInteger(height) && width > 0 && height > 0 ? { width, height } : undefined;
-  if (mime === "image/png" && bytes.length >= 24) return result(v.getUint32(16), v.getUint32(20));
-  if (mime === "image/gif" && bytes.length >= 10) return result(v.getUint16(6, true), v.getUint16(8, true));
-  if (mime === "image/bmp" && bytes.length >= 26) {
-    const header = v.getUint32(14, true);
-    if (header === 12) return result(v.getUint16(18, true), v.getUint16(20, true));
-    if (header >= 40) return result(v.getInt32(18, true), Math.abs(v.getInt32(22, true)));
-    return undefined;
-  }
-  if (mime === "image/jpeg") {
-    let offset = 2;
-    while (offset + 3 < bytes.length) {
-      if (bytes[offset++] !== 255) return undefined;
-      while (bytes[offset] === 255) offset++;
-      const marker = bytes[offset++];
-      if (marker === undefined || marker === 0xda || marker === 0xd9) return undefined;
-      if (marker === 0x01 || (marker >= 0xd0 && marker <= 0xd8)) continue;
-      if (offset + 2 > bytes.length) return undefined;
-      const size = v.getUint16(offset);
-      if (size < 2 || offset + size > bytes.length) return undefined;
-      if (marker >= 0xc0 && marker <= 0xcf && ![0xc4, 0xc8, 0xcc].includes(marker)) {
-        return size >= 8 ? result(v.getUint16(offset + 5), v.getUint16(offset + 3)) : undefined;
-      }
-      offset += size;
-    }
-  }
-  if (mime === "image/webp") {
-    for (let offset = 12; offset + 8 <= bytes.length;) {
-      const size = v.getUint32(offset + 4, true), start = offset + 8;
-      if (start + size > bytes.length) return undefined;
-      const kind = String.fromCharCode(...bytes.subarray(offset, offset + 4));
-      const u24 = (at: number) => v.getUint8(at) | v.getUint8(at + 1) << 8 | v.getUint8(at + 2) << 16;
-      if (kind === "VP8X" && size >= 10) return result(u24(start + 4) + 1, u24(start + 7) + 1);
-      if (kind === "VP8L" && size >= 5 && bytes[start] === 0x2f) {
-        const packed = v.getUint32(start + 1, true);
-        return result((packed & 0x3fff) + 1, ((packed >>> 14) & 0x3fff) + 1);
-      }
-      if (kind === "VP8 " && size >= 10 && bytes[start + 3] === 0x9d && bytes[start + 4] === 1 && bytes[start + 5] === 0x2a)
-        return result(v.getUint16(start + 6, true) & 0x3fff, v.getUint16(start + 8, true) & 0x3fff);
-      offset = start + size + size % 2;
-    }
-  }
-  return undefined;
-}
-
-/** Floors keep the area bound exact; small inputs are never upscaled. */
-export function modelImageDimensions(image: ImageDimensions): ImageDimensions {
-  const scale = Math.min(1, MAX_MODEL_IMAGE_SIDE / image.width, MAX_MODEL_IMAGE_SIDE / image.height,
-    Math.sqrt(MAX_MODEL_IMAGE_PIXELS / image.width / image.height));
-  return { width: Math.max(1, Math.floor(image.width * scale)), height: Math.max(1, Math.floor(image.height * scale)) };
-}
-
-/** Pi rotates EXIF before resizing and rounds the short side; symmetric bounds preserve both orientations. */
-export function modelImageSide(image: ImageDimensions): number {
-  const long = Math.max(image.width, image.height), short = Math.min(image.width, image.height);
-  let side = Math.max(...Object.values(modelImageDimensions(image)));
-  while (side * Math.max(1, Math.round(short * side / long)) > MAX_MODEL_IMAGE_PIXELS) side--;
-  return side;
-}

package/src/core/images.ts

@@ -1,46 +0,0 @@
-/** Immutable attachment metadata; D8 stores bytes once and projects references without I/O. */
-export interface ImageRef {
-  readonly sha256: string;
-  readonly mimeType: "image/png" | "image/jpeg" | "image/gif" | "image/webp";
-  readonly width: number;
-  readonly height: number;
-  readonly bytes: number;
-  readonly name: string;
-  /** Submission-time policy; enabling images later cannot rewrite an earlier request prefix. */
-  readonly blocked?: true;
-  readonly original?: { readonly sha256: string; readonly width: number; readonly height: number };
-}
-export interface ImageContent { readonly type: "image"; readonly image: ImageRef; readonly data?: string }
-export type UserInput = string | { readonly text: string; readonly images?: readonly ImageRef[] };
-export function validImageRef(value: unknown): value is ImageRef {
-  if (!value || typeof value !== "object") return false;
-  const v = value as Record<string, unknown>;
-  const digest = (s: unknown) => typeof s === "string" && /^[a-f0-9]{64}$/.test(s);
-  const positive = (n: unknown) => typeof n === "number" && Number.isSafeInteger(n) && n > 0;
-  if (v["blocked"] !== undefined && v["blocked"] !== true) return false;
-  if (!digest(v["sha256"]) || !positive(v["width"]) || !positive(v["height"]) || !positive(v["bytes"]) ||
-      typeof v["name"] !== "string" || !["image/png", "image/jpeg", "image/gif", "image/webp"].includes(String(v["mimeType"]))) return false;
-  if (v["original"] === undefined) return true;
-  if (!v["original"] || typeof v["original"] !== "object") return false;
-  const o = v["original"] as Record<string, unknown>;
-  return digest(o["sha256"]) && positive(o["width"]) && positive(o["height"]);
-}
-export function submissionImages(images: readonly ImageRef[], blocked: boolean): ImageRef[] {
-  return images.map(image => {
-    if (!validImageRef(image)) throw new Error("Invalid image reference");
-    const { sha256, mimeType, width, height, bytes, name, original } = image;
-    return { sha256, mimeType, width, height, bytes, name, ...(original ? { original } : {}), ...(blocked ? { blocked: true as const } : {}) };
-  });
-}
-export function userInputData(input: UserInput, blocked?: boolean): { text: string; images?: readonly ImageRef[] } {
-  return typeof input === "string" ? { text: input } : { text: input.text,
-    ...(input.images?.length ? { images: blocked === undefined ? input.images : submissionImages(input.images, blocked) } : {}) };
-}
-export function imageDescription(image: ImageRef): string {
-  const original = image.original;
-  return `[Image: ${image.name}, ${image.width}x${image.height}${original ? `; original ${original.width}x${original.height}, coordinate scale ${(original.width / image.width).toFixed(2)}` : ""}]`;
-}
-/** Assumption, not provider billing: 32px patches plus framing; anchors replace this after the response. */
-export function estimateImageTokens(image: Pick<ImageRef, "width" | "height">): number {
-  return 256 + Math.ceil(image.width / 32) * Math.ceil(image.height / 32) * 2;
-}

package/src/core/integration-health.ts

@@ -1,34 +0,0 @@
-/** Q.13: observed connectivity is a cache, never authorization or replay evidence. */
-export type IntegrationFailureCode = "offline" | "rate_limited" | "auth_required" | "protocol_error" | "timeout" | "unknown";
-export type IntegrationTime = { at: number; tick: number };
-export type IntegrationHealth = {
-  state: "not_checked" | "ready" | "backoff" | "auth_required" | "protocol_error";
-  observed: IntegrationTime | null;
-  failures: number;
-  retryAt: number | null;
-  error: IntegrationFailureCode | null;
-};
-// Assumed bounds, not measured optima: avoid tight failure loops and unbounded server delays.
-export const INTEGRATION_BACKOFF_MS = 1_000;
-export const MAX_INTEGRATION_BACKOFF_MS = 60_000;
-export const INTEGRATION_HEALTH_TTL_MS = 30_000;
-
-export function initialIntegrationHealth(): IntegrationHealth {
-  return { state: "not_checked", observed: null, failures: 0, retryAt: null, error: null };
-}
-export function readyIntegrationHealth(now: IntegrationTime): IntegrationHealth {
-  return { ...initialIntegrationHealth(), state: "ready", observed: { ...now } };
-}
-export function failedIntegrationHealth(previous: IntegrationHealth, error: IntegrationFailureCode, now: IntegrationTime, retryAfterMs?: number): IntegrationHealth {
-  const failures = Math.min(16, previous.failures + 1);
-  const delay = Math.min(MAX_INTEGRATION_BACKOFF_MS, Math.max(INTEGRATION_BACKOFF_MS * 2 ** (failures - 1),
-    Number.isFinite(retryAfterMs) ? Math.max(0, retryAfterMs!) : 0));
-  const state = error === "auth_required" || error === "protocol_error" ? error : "backoff";
-  return { state, observed: { ...now }, failures, retryAt: state === "backoff" ? now.tick + delay : null, error };
-}
-export function integrationHealthView(health: IntegrationHealth, now: IntegrationTime) {
-  const age = health.observed === null ? null : Math.max(0, now.tick - health.observed.tick);
-  return { state: health.state, observed_at: health.observed?.at ?? null, age_ms: age,
-    stale: age === null || age >= INTEGRATION_HEALTH_TTL_MS, error: health.error,
-    failures: health.failures, retry_after_ms: health.retryAt === null ? null : Math.max(0, health.retryAt - now.tick) };
-}

package/src/core/json-event.ts

@@ -1,131 +0,0 @@
-/**
- * LoopEvent → one JSON object for `--mode json`.
- *
- * Declared here, not imported from runtime, so core stays below the loop
- * (D13: core does not import a layer above it). The kind union is kept in
- * lockstep with LoopEvent; a new kind makes the call site in apps fail to
- * type-check until this switch grows a case.
- *
- * Deltas return null. A pipe cannot retract a half-turn, and a retry would
- * then emit the same prefix twice — the same reason `-p` waits for the
- * complete block. The caller still sees `assistant_text` / `thinking` once
- * the turn has a final block.
- */
-
-import { assertNever } from "./exhaustive.ts";
-import type { ExecutionOutcome } from "./outcome.ts";
-
-export type JsonLoopKind =
-  | "turn_start"
-  | "assistant_text"
-  | "thinking"
-  | "text_delta"
-  | "thinking_delta"
-  | "discard"
-  | "progress"
-  | "tool_call"
-  | "tool_result"
-  | "usage"
-  | "cut"
-  | "stop_and_ask"
-  | "branch_start"
-  | "branch_done"
-  | "done";
-
-/**
- * Structural match for runtime LoopEvent. Copied rather than imported so
- * this module cannot grow an upward dependency.
- */
-export interface JsonLoopEvent {
-  kind: JsonLoopKind;
-  text?: string;
-  tool?: { name: string; input: unknown };
-  ok?: boolean;
-  usage?: {
-    input_tokens: number;
-    output_tokens: number;
-    cache_creation_input_tokens: number;
-    cache_read_input_tokens: number;
-    node: number;
-    ms: number;
-  };
-  prefix?: string;
-  node?: number;
-  reason?: string;
-  at?: number;
-  outcome?: ExecutionOutcome;
-}
-
-/**
- * `null` means an internal event that must not go on the wire.
- * `at` is supplied by the caller (ISO from the session clock) so this
- * function stays free of Date.
- */
-export function toJsonEvent(e: JsonLoopEvent, at: string): Record<string, unknown> | null {
-  switch (e.kind) {
-    case "text_delta":
-    case "thinking_delta":
-    case "discard":
-    case "progress":
-      return null;
-    case "assistant_text":
-      return { type: "assistant_text", text: e.text ?? "", at };
-    case "thinking":
-      return { type: "thinking", text: e.text ?? "", at };
-    case "tool_call":
-      return { type: "tool_call", tool: e.tool ?? { name: "", input: {} }, at };
-    case "tool_result":
-      return { type: "tool_result", text: e.text ?? "", ok: e.ok !== false,
-        ...(e.outcome ? { outcome: e.outcome } : {}), at };
-    case "usage":
-      return {
-        type: "usage",
-        ...(e.usage !== undefined
-          ? {
-              usage: {
-                input_tokens: e.usage.input_tokens,
-                output_tokens: e.usage.output_tokens,
-                cache_creation_input_tokens: e.usage.cache_creation_input_tokens,
-                cache_read_input_tokens: e.usage.cache_read_input_tokens,
-                node: e.usage.node,
-                ms: e.usage.ms,
-              },
-            }
-          : {}),
-        ...(e.prefix !== undefined ? { prefix: e.prefix } : {}),
-        ok: e.ok !== false,
-        at,
-      };
-    case "turn_start":
-      return { type: "turn_start", ...(e.node !== undefined ? { node: e.node } : {}), at };
-    case "cut":
-      return {
-        type: "cut",
-        ...(e.node !== undefined ? { node: e.node } : {}),
-        ...(e.reason !== undefined ? { reason: e.reason } : {}),
-        at,
-      };
-    case "stop_and_ask":
-      return { type: "stop_and_ask", ...(e.reason !== undefined ? { reason: e.reason } : {}), at };
-    case "done":
-      return { type: "done", ...(e.reason !== undefined ? { reason: e.reason } : {}),
-        ...(e.outcome ? { outcome: e.outcome } : {}), at };
-    case "branch_start":
-      return {
-        type: "branch_start",
-        ...(e.node !== undefined ? { node: e.node } : {}),
-        ...(e.reason !== undefined ? { reason: e.reason } : {}),
-        at,
-      };
-    case "branch_done":
-      return {
-        type: "branch_done",
-        ...(e.outcome ? { outcome: e.outcome } : {}),
-        ...(e.node !== undefined ? { node: e.node } : {}),
-        ...(e.text !== undefined ? { text: e.text } : {}),
-        at,
-      };
-    default:
-      return assertNever(e.kind, "toJsonEvent");
-  }
-}

package/src/core/json-pointer.ts

@@ -1,46 +0,0 @@
-/** Parsed-JSON traversal and recoverable diagnostics (research N.5, RFC 6901). */
-// Assumed diagnostic budget, not a data limit: show only complete short keys.
-// Twelve forty-unit keys keep even JSON-escaped control characters below 4 KiB.
-const HINT_KEYS = 12;
-const HINT_KEY_UNITS = 40;
-
-export function validateJsonPointer(pointer: string): void {
-  if ((pointer !== "" && !pointer.startsWith("/")) || /~(?:[^01]|$)/.test(pointer)) {
-    throw new Error('invalid JSON pointer: use "" for the root, / between keys, ~0 for ~ and ~1 for /');
-  }
-}
-
-function arrayIndex(key: string, length: number): boolean {
-  const index = Number(key);
-  return /^(0|[1-9][0-9]*)$/.test(key) && Number.isSafeInteger(index) && index < length;
-}
-
-function missingPointer(parent: unknown, segment: number): Error {
-  const array = Array.isArray(parent);
-  const kind = parent === null ? "null" : array ? "array" : typeof parent;
-  const keys = parent !== null && typeof parent === "object"
-    ? Object.keys(parent).filter((key) => !array || arrayIndex(key, parent.length)) : [];
-  const shown = keys.filter((key) => key.length <= HINT_KEY_UNITS).sort().slice(0, HINT_KEYS);
-  // Segment ordinal identifies the valid prefix without echoing unbounded input
-  // paths or source values. Omitted names remain readable through that prefix.
-  return new Error(`JSON pointer does not exist at segment ${segment}; parent type: ${kind}. ` +
-    `Available keys (${shown.length} of ${keys.length}): ${JSON.stringify(shown)}; ` +
-    `${keys.length - shown.length} omitted (long names or diagnostic budget). ` +
-    `Inspect the pointer prefix before segment ${segment}; use pointer="" for the document root. ` +
-    "The pointer / selects an empty key, not the root.");
-}
-
-export function resolveJsonPointer(document: unknown, pointer: string): unknown {
-  validateJsonPointer(pointer);
-  if (pointer === "") return document;
-  let value = document;
-  for (const [index, raw] of pointer.slice(1).split("/").entries()) {
-    const key = raw.replaceAll("~1", "/").replaceAll("~0", "~");
-    if (value === null || typeof value !== "object" ||
-        (Array.isArray(value) && !arrayIndex(key, value.length)) || !Object.hasOwn(value, key)) {
-      throw missingPointer(value, index + 1);
-    }
-    value = (value as Record<string, unknown>)[key];
-  }
-  return value;
-}