@visual-z/xeno 0.8.4 → 0.9.1

package/src/core/work-state.ts

@@ -1,154 +0,0 @@
-/** O.2: identity and lifecycle are explicit; only command evidence can verify completion. */
-import type { LogEvent } from "./events.ts";
-import type { Evidence } from "./handoff.ts";
-import { isCommandResult, resolveEvidence, evidenceStale } from "./evidence.ts";
-
-export type WorkItem = {
-  id: string;
-  what: string;
-  status: "active" | "blocked" | "completed" | "cancelled";
-  verification: "not_run" | "verified" | "unverified" | "stale";
-  opened_at: string;
-  updated_at: string;
-  next_action?: string;
-  reason?: string;
-  evidence?: Evidence;
-  /** Reopening keeps provenance without carrying a second copy of old proof. */
-  previous_evidence?: string;
-  depends_on?: readonly string[];
-  owner?: string;
-  owner_event?: string;
-};
-
-export type WorkReadiness = { ready: boolean; reason: "ready" | "waiting" | "blocked" | "closed" | "owned" | "missing"; waiting_for: string[] };
-export function workReadiness(items: readonly WorkItem[], id: string, actor?: string): WorkReadiness {
-  const item = items.find(work => work.id === id);
-  if (!item) return { ready: false, reason: "missing", waiting_for: [id] };
-  if (item.status === "completed" || item.status === "cancelled") return { ready: false, reason: "closed", waiting_for: [] };
-  const waiting = (item.depends_on ?? []).filter(dep => items.find(work => work.id === dep)?.status !== "completed");
-  const reason = item.status === "blocked" ? "blocked" : waiting.length ? "waiting" : item.owner && item.owner !== actor ? "owned" : "ready";
-  return { ready: reason === "ready", reason, waiting_for: [...waiting] };
-}
-
-function dependencyError(items: readonly WorkItem[], id: string, dependencies: readonly string[]): string | null {
-  if (new Set(dependencies).size !== dependencies.length) return "duplicate work dependencies";
-  if (dependencies.includes(id)) return "work dependency cycle: self dependency";
-  if (dependencies.some(dep => !items.some(item => item.id === dep))) return "unknown work dependency";
-  const seen = new Set<string>(), pending = [...dependencies];
-  while (pending.length) {
-    const dep = pending.pop()!;
-    if (dep === id) return "work dependency cycle";
-    if (seen.has(dep)) continue;
-    seen.add(dep); pending.push(...items.find(item => item.id === dep)?.depends_on ?? []);
-  }
-  return null;
-}
-
-/** O.2: sibling sessions may choose the same local label without aliasing work. */
-export function scopedWorkId(namespace: string, requested: string, items: readonly WorkItem[]): string {
-  return items.some(item => item.id === requested) || requested.startsWith(`${namespace}:`)
-    ? requested : `${namespace}:${requested}`;
-}
-
-function unknownWork(id: string): string {
-  return `unknown work_id ${id}; create it with a next note (kind=next) first`;
-}
-
-export function workChangeError(items: readonly WorkItem[], event: LogEvent): string | null {
-  if (!("work_id" in event) || event.work_id === undefined) return null;
-  const item = items.find(item => item.id === event.work_id);
-  if ((event.t === "next_action" || event.t === "work_dependencies") && event.depends_on !== undefined) {
-    const error = dependencyError(items, event.work_id, event.depends_on);
-    if (error) return error;
-  }
-  // Every unknown-id rejection names the way to make the id exist, or the model retries the same call.
-  if (event.t === "work_dependencies" && !item) return unknownWork(event.work_id);
-  if (event.t === "work_owner") {
-    if (!item) return unknownWork(event.work_id);
-    if (event.operation === "release") return item.owner === event.owner ? null : "only the recorded owner can release work";
-    const ready = workReadiness(items, item.id, event.owner);
-    return ready.ready ? null : `work ${item.id} is ${ready.reason}; cannot claim it`;
-  }
-  if (event.t === "claim" && item && (item.depends_on ?? []).some(dep => items.find(work => work.id === dep)?.status !== "completed")) return "work dependencies are not completed";
-  if (event.t === "work_status") {
-    // D15 carries post-fork instructions, not their whole history. A harness-
-    // authenticated transition may seed intent in the adopted branch, never proof.
-    if (!item && !event.carried_from) return `unknown work_id ${event.work_id}; create it with a next note first`;
-    if (!item) return event.operation !== "cancel" && !event.next_action?.trim()
-      ? "reactivating work requires a current next_action" : null;
-    if (event.operation === "unblock" && item.status !== "blocked") return `work ${item.id} is not blocked`;
-    if (event.operation === "reopen" && item.status !== "completed" && item.status !== "cancelled") {
-      return `work ${item.id} is not closed; update its next action or unblock it`;
-    }
-    if (event.operation !== "cancel" && !event.next_action?.trim()) return "reactivating work requires a current next_action";
-  } else if (event.t === "claim" && !item) {
-    return `unknown work_id ${event.work_id}; record a next note before doing and verifying the work`;
-  } else if (item && (item.status === "completed" || item.status === "cancelled")) {
-    return `work ${item.id} is ${item.status}; explicitly reopen it before updating it`;
-  } else if (event.t === "claim" && item?.status === "blocked") {
-    return `work ${item.id} is blocked; explicitly unblock it before completing it`;
-  }
-  return null;
-}
-
-export function deriveWorkItems(previous: readonly WorkItem[], events: readonly LogEvent[]): WorkItem[] {
-  const items = new Map(previous.map(item => [item.id, { ...item }]));
-  for (let index = 0; index < events.length; index++) {
-    const event = events[index]!;
-    if ((event.t !== "next_action" && event.t !== "blocked" && event.t !== "work_status" && event.t !== "claim" && event.t !== "work_dependencies" && event.t !== "work_owner") ||
-        event.work_id === undefined || workChangeError([...items.values()], event)) continue;
-    const old = items.get(event.work_id);
-    const item: WorkItem = old ? { ...old, what: event.t === "work_owner" || event.t === "work_dependencies" ? old.what : event.what, updated_at: event.id } : {
-      id: event.work_id, what: event.what, status: "active", verification: "not_run",
-      opened_at: event.id, updated_at: event.id,
-    };
-    if (event.t === "next_action") { item.next_action = event.next_action; if (event.depends_on !== undefined) item.depends_on = [...event.depends_on]; }
-    else if (event.t === "work_dependencies") item.depends_on = [...event.depends_on];
-    else if (event.t === "work_owner") {
-      if (event.operation === "claim") { item.owner = event.owner; item.owner_event = event.id; }
-      else { delete item.owner; delete item.owner_event; }
-    }
-    else if (event.t === "blocked") {
-      item.status = "blocked";
-      item.reason = event.reason;
-    } else if (event.t === "work_status") {
-      if (event.operation === "cancel") {
-        item.status = "cancelled";
-        item.reason = event.reason ?? "cancelled";
-        delete item.next_action;
-      } else {
-        item.status = "active";
-        item.next_action = event.next_action!;
-        delete item.reason;
-        if (event.operation === "reopen") {
-          item.opened_at = event.id;
-          item.verification = "not_run";
-          if (item.evidence) item.previous_evidence = item.evidence.event_id;
-          delete item.evidence;
-        }
-      }
-    } else if (event.t === "claim") {
-      // Preserve D11's same-segment rule and require proof from this activation.
-      const resolved = resolveEvidence(events.slice(0, index), event.evidence, item.opened_at);
-      if (resolved.ok) {
-        item.status = "completed";
-        item.verification = "verified";
-        item.evidence = resolved.evidence;
-        delete item.reason;
-        delete item.next_action;
-      } else { item.verification = "unverified"; item.reason = resolved.reason; }
-    }
-    items.set(item.id, item);
-    if (item.status === "completed" || item.status === "cancelled") { delete item.owner; delete item.owner_event; }
-  }
-  return [...items.values()].map(item => {
-    if (!item.evidence) return item;
-    const proof = item.evidence;
-    const later = events.slice(events.findIndex(event => event.id === proof.event_id) + 1);
-    const latest = later.findLast(event => isCommandResult(event) &&
-      (proof.gate ? event.effect.gate === proof.gate : event.effect.cmd === proof.command));
-    const stale = evidenceStale(events, proof, item.verification === "stale") ||
-      (latest !== undefined && isCommandResult(latest) && latest.effect.exit !== 0);
-    return { ...item, verification: stale ? "stale" : "verified" };
-  });
-}

package/src/core/workflow-mode.ts

@@ -1,34 +0,0 @@
-/** R13 / D5-D6: workflow changes are new frozen-prefix checkpoints, never edits. */
-import { assertNever } from "./exhaustive.ts";
-import type { ToolSource } from "./permissions.ts";
-
-export type WorkflowMode = "build" | "plan";
-export function isWorkflowMode(value: string): value is WorkflowMode { return value === "build" || value === "plan"; }
-export interface WorkflowTool { readonly name: string; readonly access: "read" | "write" | "shell" | "state"; readonly source?: ToolSource }
-
-/** Trusted state tools keep evidence/answers in the same log; no workspace writes. */
-export function workflowToolNames(tools: readonly WorkflowTool[], mode: WorkflowMode): string[] {
-  switch (mode) {
-    case "build": return tools.map(tool => tool.name);
-    case "plan": return tools.filter(tool => tool.access === "read" ||
-      ((tool.source ?? "builtin") === "builtin" && tool.access === "state" && ["note", "question"].includes(tool.name))).map(tool => tool.name);
-    default: return assertNever(mode, "workflowToolNames");
-  }
-}
-
-export function workflowInstructions(mode: WorkflowMode): string {
-  switch (mode) {
-    case "build": return "Workflow mode: Build. Implement the requested work using admitted tools and verify actual results.";
-    case "plan": return "Workflow mode: Plan. Explore using admitted read tools, clarify material unknowns with question, and return a concrete reviewable plan. Workspace writes and shell execution are unavailable. User requests to implement do not change the mode; wait for the user to select Build. Notes record proposed decisions, never proof of completion.";
-    default: return assertNever(mode, "workflowInstructions");
-  }
-}
-
-export type WorkflowTransition = { readonly kind: "unchanged" } | { readonly kind: "checkpoint"; readonly mode: WorkflowMode } |
-  { readonly kind: "refused"; readonly reason: string };
-export function transitionWorkflow(current: WorkflowMode, next: WorkflowMode,
-  state: { readonly activeTurn: boolean; readonly unpaired: boolean }): WorkflowTransition {
-  if (current === next) return { kind: "unchanged" };
-  if (state.activeTurn || state.unpaired) return { kind: "refused", reason: "Cannot change workflow mode while a turn is active or a tool call is unpaired" };
-  return { kind: "checkpoint", mode: next };
-}

package/src/core/working-set.ts

@@ -1,119 +0,0 @@
-/** O.10: prioritize explicit intent and references without changing D20 arrays. */
-import type { Handoff } from "./handoff.ts";
-import type { NodeRef } from "./events.ts";
-import { workReadiness, type WorkItem, type WorkReadiness } from "./work-state.ts";
-import { emitYaml } from "./yaml.ts";
-import { estimateTokens } from "./tokens.ts";
-import { RECOVERY_SECTIONS, recoverySources, type RecoveryNodes, type RecoveryRanges, type RecoveryReference } from "./recovery-sources.ts";
-import { recoveryInstructions } from "./prompt-policy.ts";
-
-/**
- * The cut format new sessions record. Live cuts, cold replay and interrupted-cut
- * repair all select through `carriedHandoff`, so this is only the default for
- * cuts not yet written; a recorded version is never reinterpreted.
- */
-export const CURRENT_WORKING_SET_VERSION = 3;
-
-export type WorkingSet = {
-  version: 1 | 2 | 3; source: NodeRef;
-  /** v3 omits `what`, `next_action` and `reason` when the carried `state.work_items` holds the same item. */
-  work: (Pick<WorkItem, "id" | "status" | "next_action" | "reason" | "depends_on" | "owner"> & { what?: string; readiness?: WorkReadiness })[];
-  references: ({ node?: number; event: string; kind: string; work?: string } & Partial<Omit<RecoveryReference, "node" | "event" | "kind" | "work">>)[];
-  omitted: { work: number; references: number };
-  recovery_sections?: RecoveryRanges;
-  recovery: string;
-};
-
-export function workingSet(full: Handoff, budget: number): WorkingSet | null {
-  if (!full.predecessor) return null;
-  const items = (full.state.work_items ?? []).filter(item => item.status === "blocked" || item.status === "active")
-    .toSorted((a, b) => Number(b.status === "blocked") - Number(a.status === "blocked") || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
-  const active = new Set(items.map(item => item.id));
-  const references: WorkingSet["references"] = [
-    ...(full.evidence_links ?? []).filter(link => active.has(link.work) && !link.superseded_by)
-      .map(link => ({ event: link.event, kind: "evidence", work: link.work })),
-    ...full.decisions.filter(item => item.work_id && active.has(item.work_id) && item.source)
-      .map(item => ({ node: item.source!.node, event: item.source!.event_id, kind: "decision", work: item.work_id! })),
-    ...full.pitfalls.filter(item => item.work_id && active.has(item.work_id) && item.source)
-      .map(item => ({ node: item.source!.node, event: item.source!.event_id, kind: "pitfall", work: item.work_id! })),
-    ...(full.progress_evidence ?? []).toReversed().map(item => ({ node: item.source.node, event: item.source.event_id, kind: item.kind })),
-  ];
-  const view: WorkingSet = { version: 1, source: full.predecessor, work: [], references: [],
-    omitted: { work: items.length, references: references.length }, recovery: "history(work_id=ID), history(event=ID), or history(node=source.node, section=...)" };
-  const fits = () => budget === Infinity || estimateTokens.count([], emitYaml(view)) <= budget;
-  if (!fits()) return null;
-  for (const item of items) {
-    const { id, what, status, next_action, reason, depends_on, owner } = item;
-    view.work.push({ id, what, status, ...(next_action ? { next_action } : {}), ...(reason ? { reason } : {}),
-      ...(depends_on ? { depends_on, readiness: workReadiness(full.state.work_items ?? [], id) } : {}), ...(owner ? { owner } : {}) });
-    view.omitted.work--;
-    if (!fits()) { view.work.pop(); view.omitted.work++; }
-  }
-  for (const reference of references) {
-    view.references.push(reference); view.omitted.references--;
-    if (!fits()) { view.references.pop(); view.omitted.references++; }
-  }
-  return view;
-}
-
-/** R9: a new projection version keeps the original v1 ordering byte-stable. */
-export function recoveryWorkingSet(full: Handoff, nodes: RecoveryNodes, budget: number, tools?: readonly string[]): WorkingSet | null {
-  return sourceView(full, nodes, { version: 2, users: true,
-    fits: view => estimateTokens.count([], emitYaml(view)) <= budget,
-    recovery: tools === undefined ? "Read original user messages before continuing: history(node=source.node,recovery=users,offset=0). Other pages: failures, environment, next_actions; event=ID reads one original. Abandoned messages are cancelled; annotations are not user instructions. Observations are historical: recheck resource, host and current permissions before acting. history(work_id=ID) recovers work." : recoveryInstructions(tools) });
-}
-
-/**
- * v3 shares v2's source ordering. Two things differ, both decided by the caller
- * that owns the whole carried handoff: `fits` measures the view inside that
- * handoff rather than standalone, and `users: false` leaves user sources out
- * because the carried `user_turns` already hold every one verbatim.
- */
-export function recoveryWorkingSetV3(full: Handoff, nodes: RecoveryNodes, options: {
-  users: boolean; recovery: string; fits: (view: WorkingSet) => boolean;
-}): WorkingSet | null {
-  return sourceView(full, nodes, { version: 3, ...options });
-}
-
-function sourceView(full: Handoff, nodes: RecoveryNodes, options: {
-  version: 2 | 3; users: boolean; recovery: string; fits: (view: WorkingSet) => boolean;
-}): WorkingSet | null {
-  const legacy = workingSet(full, Infinity);
-  if (!legacy) return null;
-  const sources = recoverySources(nodes);
-  const view: WorkingSet = { version: options.version, source: legacy.source, work: [], references: [],
-    omitted: { work: legacy.work.length, references: legacy.references.length + RECOVERY_SECTIONS.reduce((sum, section) => sum + sources[section].length, 0) },
-    recovery_sections: Object.fromEntries(RECOVERY_SECTIONS.map(section => [section, { total: sources[section].length, omitted: sources[section].length }])) as RecoveryRanges,
-    recovery: options.recovery };
-  const fits = () => options.fits(view);
-  if (!fits()) return null;
-  const queues = RECOVERY_SECTIONS.map(section => ({ section, items: [...sources[section]], at: 0 }));
-  // The latest and first live user messages anchor correction and initial scope;
-  // remaining user sources are newest first. Cancelled turns stay pageable.
-  const live = sources.users.filter(ref => !ref.abandoned), first = live.at(-1);
-  queues[0]!.items = !options.users ? [] : [...live.slice(0, 1), ...(first && first !== live[0] ? [first] : []),
-    ...live.slice(1, -1), ...sources.users.filter(ref => ref.abandoned)];
-  const takeReference = (reference: WorkingSet["references"][number], section?: keyof RecoveryRanges) => {
-    view.references.push(reference); view.omitted.references--;
-    if (section) view.recovery_sections![section].omitted--;
-    if (!fits()) {
-      view.references.pop(); view.omitted.references++;
-      if (section) view.recovery_sections![section].omitted++;
-    }
-  };
-  // One source per role precedes work prose; round-robin growth thereafter
-  // prevents a long task list or repeated failures starving other categories.
-  for (const queue of queues) { const reference = queue.items[queue.at++]; if (reference) takeReference(reference, queue.section); }
-  let at = 0;
-  while (at < legacy.work.length || at < legacy.references.length || queues.some(queue => queue.at < queue.items.length)) {
-    const work = legacy.work[at];
-    if (work) {
-      view.work.push(work); view.omitted.work--;
-      if (!fits()) { view.work.pop(); view.omitted.work++; }
-    }
-    for (const queue of queues) { const reference = queue.items[queue.at++]; if (reference) takeReference(reference, queue.section); }
-    const reference = legacy.references[at++];
-    if (reference) takeReference(reference);
-  }
-  return view;
-}

package/src/core/yaml.ts

@@ -1,282 +0,0 @@
-/**
- * Restricted, deterministic YAML emitter.
- *
- * Why hand-written instead of a dependency: YAML emitters differ in indentation,
- * quoting and line-wrapping defaults, so the usual advice is "pick one writer and
- * pin its version". A restricted emitter removes the version-drift risk entirely --
- * the format is fixed by construction, not by someone else's defaults.
- *
- * Guarantees:
- *   - Block style only (the sole exception is `[]` / `{}` for empty collections).
- *   - Indent 2, LF endings, exactly one trailing newline, no trailing whitespace.
- *   - No anchors or aliases, so no topological-ordering hazard.
- *   - Key order comes from an explicit `keyOrder` resolver; unlisted keys are
- *     appended in sorted order so a new field can never silently vanish.
- *   - Byte-identical output for equal input: emit(x) === emit(structuredClone(x)).
- *
- * Supported value types: string, finite number, boolean, null, array, plain object.
- * `undefined` values are omitted (that is how optional fields disappear); `null` is
- * emitted explicitly, so "absent" and "present but empty" stay distinguishable.
- */
-
-export type YamlValue =
-  | string
-  | number
-  | boolean
-  | null
-  | undefined
-  | readonly YamlValue[]
-  | { readonly [key: string]: YamlValue };
-
-export interface EmitOptions {
-  /**
-   * Returns the preferred key order for the object at `path`, or undefined to
-   * sort alphabetically. Keys returned but absent from the object are skipped;
-   * keys present but unlisted are appended in sorted order.
-   */
-  keyOrder?: (path: readonly string[]) => readonly string[] | undefined;
-}
-
-const INDENT = "  ";
-
-/**
- * Short all-scalar arrays render in flow style (`[1, 120]`). Nested block
- * sequences are legal but read badly -- a line range would otherwise print as
- * "- - 1" / "  - 120" -- and this file is meant to be reviewed by a person.
- * The rule is a fixed predicate, so output stays deterministic.
- */
-const FLOW_MAX_WIDTH = 60;
-
-/** YAML 1.1-era tokens that a bare scalar must not collide with. */
-const RESERVED_PLAIN =
-  /^(|~|null|Null|NULL|true|True|TRUE|false|False|FALSE|yes|Yes|YES|no|No|NO|on|On|ON|off|Off|OFF|y|Y|n|N)$/;
-
-const NUMBER_LIKE =
-  /^[+-]?(\d[\d_]*\.?[\d_]*|\.[\d_]+)([eE][+-]?\d+)?$|^[+-]?0[xXoObB][0-9a-fA-F_]+$|^[+-]?\.(inf|Inf|INF)$|^\.(nan|NaN|NAN)$/;
-
-/** Leading characters that carry structural meaning in YAML. */
-const LEADING_INDICATOR = new Set([
-  "-", "?", ":", ",", "[", "]", "{", "}", "#", "&", "*", "!",
-  "|", ">", "'", '"', "%", "@", "`",
-]);
-
-function hasControlChars(s: string): boolean {
-  for (const ch of s) {
-    const c = ch.codePointAt(0)!;
-    // Allow \n (handled by the block-scalar path); reject every other control char.
-    if ((c < 0x20 && c !== 0x0a) || c === 0x7f) return true;
-  }
-  return false;
-}
-
-function isPlainSafe(s: string): boolean {
-  if (s.length === 0) return false;
-  if (s !== s.trim()) return false;
-  if (s.includes("\n") || hasControlChars(s)) return false;
-  if (LEADING_INDICATOR.has(s[0]!)) return false;
-  if (RESERVED_PLAIN.test(s) || NUMBER_LIKE.test(s)) return false;
-  // ": " opens a mapping; " #" opens a comment; a trailing ":" also reads as a key.
-  if (s.includes(": ") || s.includes(" #") || s.endsWith(":")) return false;
-  return true;
-}
-
-function quoteDouble(s: string): string {
-  let out = '"';
-  for (const ch of s) {
-    const c = ch.codePointAt(0)!;
-    if (ch === '"') out += '\\"';
-    else if (ch === "\\") out += "\\\\";
-    else if (ch === "\n") out += "\\n";
-    else if (ch === "\t") out += "\\t";
-    else if (ch === "\r") out += "\\r";
-    else if (c < 0x20 || c === 0x7f) out += "\\x" + c.toString(16).padStart(2, "0");
-    else out += ch;
-  }
-  return out + '"';
-}
-
-/**
- * A multi-line string is only emitted as a block scalar when every line is clean.
- * Leading whitespace on the first line would need an explicit indentation
- * indicator, and trailing whitespace on any line would violate the
- * no-trailing-whitespace guarantee -- both fall back to a double-quoted scalar,
- * which is always correct if less pretty.
- */
-function canUseBlockScalar(s: string): boolean {
-  if (!s.includes("\n")) return false;
-  if (hasControlChars(s)) return false;
-  // `|+` (keep) is the most ambiguous corner of the spec -- parsers disagree about
-  // trailing blank lines at EOF. Two or more trailing newlines therefore fall back
-  // to a quoted scalar rather than relying on that behaviour.
-  if (/\n\n$/.test(s)) return false;
-  const lines = s.split("\n");
-  const firstNonEmpty = lines.find((l) => l.length > 0);
-  if (firstNonEmpty !== undefined && /^\s/.test(firstNonEmpty)) return false;
-  for (const line of lines) {
-    if (line.length > 0 && line !== line.replace(/\s+$/, "")) return false;
-  }
-  return true;
-}
-
-function blockScalar(s: string, indent: string): string {
-  // canUseBlockScalar() guarantees at most one trailing newline here.
-  const trailing = /\n*$/.exec(s)![0].length;
-  const header = trailing === 0 ? "|-" : "|";
-  const body = trailing === 0 ? s : s.slice(0, -1);
-  const inner = indent + INDENT;
-  const lines = body.split("\n").map((l) => (l.length === 0 ? "" : inner + l));
-  return header + "\n" + lines.join("\n");
-}
-
-function scalar(v: string | number | boolean | null, indent: string): string {
-  if (v === null) return "null";
-  if (typeof v === "boolean") return v ? "true" : "false";
-  if (typeof v === "number") {
-    if (!Number.isFinite(v)) {
-      throw new TypeError(`yaml: non-finite number is not emittable: ${v}`);
-    }
-    // Number#toString is the shortest round-trippable form, hence deterministic.
-    // String(-0) drops the sign, so spell it out.
-    return Object.is(v, -0) ? "-0" : String(v);
-  }
-  if (canUseBlockScalar(v)) return blockScalar(v, indent);
-  if (isPlainSafe(v)) return v;
-  return quoteDouble(v);
-}
-
-function isPlainObject(v: unknown): v is { readonly [key: string]: YamlValue } {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-
-type Scalar = string | number | boolean | null;
-
-function isScalar(v: YamlValue): v is Scalar {
-  return v === null || ["string", "number", "boolean"].includes(typeof v);
-}
-
-/**
- * Returns the flow rendering (`[a, b]`) when every element is a scalar that needs
- * no block form and the result fits FLOW_MAX_WIDTH; otherwise undefined, and the
- * caller falls back to block style.
- */
-function tryFlow(items: readonly YamlValue[]): string | undefined {
-  if (items.length === 0) return undefined;
-  if (!items.every(isScalar)) return undefined;
-  const parts: string[] = [];
-  for (const item of items as readonly Scalar[]) {
-    if (typeof item === "string" && item.includes("\n")) return undefined;
-    parts.push(scalar(item, ""));
-  }
-  const text = "[" + parts.join(", ") + "]";
-  return text.length <= FLOW_MAX_WIDTH ? text : undefined;
-}
-
-function orderedKeys(
-  obj: { readonly [key: string]: YamlValue },
-  path: readonly string[],
-  opts: EmitOptions,
-): string[] {
-  const present = Object.keys(obj).filter((k) => obj[k] !== undefined);
-  const preferred = opts.keyOrder?.(path);
-  if (!preferred) return present.sort();
-  const set = new Set(present);
-  const ordered = preferred.filter((k) => set.has(k));
-  const rest = present.filter((k) => !preferred.includes(k)).sort();
-  return [...ordered, ...rest];
-}
-
-function emitKey(k: string): string {
-  return isPlainSafe(k) ? k : quoteDouble(k);
-}
-
-function emitNode(
-  v: YamlValue,
-  indent: string,
-  path: readonly string[],
-  opts: EmitOptions,
-  lines: string[],
-): void {
-  if (Array.isArray(v)) {
-    const items = v.filter((x) => x !== undefined);
-    if (items.length === 0) {
-      lines[lines.length - 1] += " []";
-      return;
-    }
-    for (const item of items) {
-      if (Array.isArray(item)) {
-        const flow = tryFlow(item);
-        if (flow !== undefined) {
-          lines.push(indent + "- " + flow);
-          continue;
-        }
-      }
-      if (Array.isArray(item) || isPlainObject(item)) {
-        const before = lines.length;
-        lines.push(indent + "-");
-        emitNode(item, indent + INDENT, path, opts, lines);
-        // Hoist the first child onto the dash line: "- key: value".
-        const dashLine = lines[before]!;
-        const firstChild = lines[before + 1];
-        if (firstChild !== undefined && dashLine === indent + "-") {
-          lines.splice(before, 2, indent + "- " + firstChild.slice(indent.length + INDENT.length));
-        }
-      } else {
-        lines.push(indent + "- " + scalar(item as string | number | boolean | null, indent));
-      }
-    }
-    return;
-  }
-
-  if (isPlainObject(v)) {
-    const keys = orderedKeys(v, path, opts);
-    if (keys.length === 0) {
-      lines[lines.length - 1] += " {}";
-      return;
-    }
-    for (const k of keys) {
-      const child = v[k]!;
-      const childPath = [...path, k];
-      if (Array.isArray(child)) {
-        const items = child.filter((x) => x !== undefined);
-        const flow = tryFlow(items);
-        if (items.length === 0) {
-          lines.push(indent + emitKey(k) + ": []");
-        } else if (flow !== undefined) {
-          lines.push(indent + emitKey(k) + ": " + flow);
-        } else {
-          lines.push(indent + emitKey(k) + ":");
-          // Indent sequences under their key; valid either way, but readable.
-          emitNode(child, indent + INDENT, childPath, opts, lines);
-        }
-      } else if (isPlainObject(child)) {
-        if (orderedKeys(child, childPath, opts).length === 0) {
-          lines.push(indent + emitKey(k) + ": {}");
-        } else {
-          lines.push(indent + emitKey(k) + ":");
-          emitNode(child, indent + INDENT, childPath, opts, lines);
-        }
-      } else {
-        lines.push(
-          indent + emitKey(k) + ": " +
-            scalar(child as string | number | boolean | null, indent),
-        );
-      }
-    }
-    return;
-  }
-
-  lines.push(indent + scalar(v as string | number | boolean | null, indent));
-}
-
-/** Emit `value` as deterministic block-style YAML with a single trailing newline. */
-export function emitYaml(value: YamlValue, opts: EmitOptions = {}): string {
-  if (value === undefined) return "";
-  const lines: string[] = [];
-  if (Array.isArray(value) || isPlainObject(value)) {
-    emitNode(value, "", [], opts, lines);
-  } else {
-    lines.push(scalar(value as string | number | boolean | null, ""));
-  }
-  if (lines.length === 0) return "{}\n";
-  return lines.join("\n") + "\n";
-}