@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

package/vendor/framey/dist/timeline-LHUUMK63.js

@@ -0,0 +1,1295 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  NEVER_VISIBLE,
+  describeProject
+} from "./chunk-73QVATIM.js";
+import "./chunk-LLMSX6V6.js";
+import {
+  resolveExtraPositionals
+} from "./chunk-5SG54JRS.js";
+import "./chunk-K4WKGXRC.js";
+import {
+  withMeta
+} from "./chunk-O4YRB27L.js";
+import {
+  resolveProject
+} from "./chunk-O7BGSQ5F.js";
+import {
+  applyFileMutations,
+  duplicateElementInHtml
+} from "./chunk-THJALHFJ.js";
+import {
+  patchElementInHtml,
+  removeElementFromHtml,
+  splitElementInHtml
+} from "./chunk-IUONB55J.js";
+import "./chunk-6JR2XUEE.js";
+import "./chunk-MI5FTLYK.js";
+import {
+  fileContentVersion
+} from "./chunk-YPRBGITP.js";
+import "./chunk-7JQFJ6JJ.js";
+import {
+  readCompositionFps
+} from "./chunk-KXTKKBOC.js";
+import "./chunk-P5ZBLXJ6.js";
+import {
+  ensureDOMParser
+} from "./chunk-442JNXRM.js";
+import "./chunk-FLREUEHW.js";
+import "./chunk-EOVYQ3IG.js";
+import "./chunk-GNEFDLFB.js";
+import "./chunk-2UZQHDM7.js";
+import "./chunk-NYEXNSHM.js";
+import {
+  assertKnownFlags
+} from "./chunk-U242RTCT.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import "./chunk-54HJ63Q2.js";
+import "./chunk-ISN5GRYI.js";
+import "./chunk-VORQIH64.js";
+import {
+  setCommandExitCode
+} from "./chunk-JVBRJMOP.js";
+import "./chunk-KLIKCX6Q.js";
+import "./chunk-EVMY7IPL.js";
+import "./chunk-7FMUTGOH.js";
+import "./chunk-TIQB63MX.js";
+import "./chunk-IZCW2NKT.js";
+import {
+  ensureHfIds
+} from "./chunk-RNV3DM4S.js";
+import {
+  fpsToNumber,
+  parseFpsWithDefault
+} from "./chunk-DLA44CMS.js";
+import "./chunk-UJZREAV6.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-X7HBSTCZ.js";
+import "./chunk-B7RJV74O.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-634HSJ3J.js";
+import "./chunk-FXMKHHPO.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-AHX34EFP.js";
+import "./chunk-T2EUWCJE.js";
+import "./chunk-T6AGUTZJ.js";
+import "./chunk-XT6MXC7A.js";
+import "./chunk-K4MJX7SR.js";
+import "./chunk-4UMPIPCQ.js";
+import "./chunk-4P7NX5BM.js";
+import "./chunk-VAS6HQX3.js";
+import "./chunk-6BNTGNGD.js";
+import "./chunk-CZGHFATT.js";
+import "./chunk-PKZ7RK5N.js";
+import "./chunk-W2LGJSEN.js";
+import {
+  isInsideSpan,
+  sameInstant,
+  spansShareTime
+} from "./chunk-MMQ52NIZ.js";
+import "./chunk-BSQ7XANM.js";
+import "./chunk-SDYDNHEE.js";
+import "./chunk-RXATE6FZ.js";
+import "./chunk-3422KMTD.js";
+import "./chunk-3GXQPCJC.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/timeline/formatTimeline.ts
+var BAR_WIDTH = 40;
+var n = (v) => String(Math.round(v * 1e3) / 1e3);
+function bar(row, total) {
+  if (total <= 0) return " ".repeat(BAR_WIDTH);
+  const known = row.durationAuthored || row.duration > 0;
+  const from = Math.max(0, Math.min(BAR_WIDTH - 1, Math.floor(row.absStart / total * BAR_WIDTH)));
+  const to = known ? row.absEnd / total * BAR_WIDTH : BAR_WIDTH;
+  const width = Math.max(1, Math.min(BAR_WIDTH, Math.ceil(to)) - from);
+  const fill = known ? "\u2588" : "\u2591";
+  return " ".repeat(from) + fill.repeat(width) + " ".repeat(BAR_WIDTH - from - width);
+}
+function durationNote(row) {
+  switch (row.durationSource) {
+    case "media":
+    case "default":
+      return `duration=${row.durationSource}`;
+    case "inner":
+      return "duration=inferred";
+    case "pending":
+      return `pending: ${row.pendingReason}`;
+    case "authored":
+    case null:
+      return false;
+  }
+}
+function syncNote(frames) {
+  if (!frames) return false;
+  return `out-of-sync=${frames > 0 ? "+" : ""}${frames}f`;
+}
+function details(row) {
+  const lanes = row.lanes.map(
+    (l) => `${l.target}[${l.points.map((p) => `${n(p.t)}:${n(p.v)}`).join(" ")}]`
+  );
+  return [
+    row.src && `src=${row.src}`,
+    row.volume !== null && `vol=${row.volume}`,
+    row.playbackRate !== null && `rate=${n(row.playbackRate)}`,
+    row.audioGroup && `group=${row.audioGroup}`,
+    syncNote(row.syncOffsetFrames),
+    durationNote(row),
+    row.sourceFile && !row.children.length && "children=unread",
+    row.laneError && `lanes unreadable: ${row.laneError}`,
+    ...lanes,
+    ...row.warnings.filter((w) => w.startsWith(NEVER_VISIBLE)).map((w) => `warning: ${w}`)
+  ].filter(Boolean).join(" ");
+}
+var span = (a, b) => `${n(a)}-${n(b)}s`;
+function line(row, total) {
+  const times = row.host ? `${span(row.absStart, row.absEnd)} (local ${span(row.start, row.end)}) nested in ${row.host} ${row.file}` : span(row.start, row.end);
+  return `  |${bar(row, total)}| ${row.ref} ${row.id} ${times} ${details(row)}`.trimEnd();
+}
+function header({ kind, rows }) {
+  const nested = rows.filter((r) => r.nested || r.parentRow).length;
+  const split = nested ? `: ${rows.length - nested} top-level, ${nested} nested` : "";
+  return `${kind} (${rows.length}${split})`;
+}
+function formatTimeline(timeline) {
+  const out = [`timeline ${n(timeline.duration)}s`];
+  for (const track of timeline.tracks) {
+    out.push("", header(track));
+    for (const row of track.rows) out.push(line(row, timeline.duration));
+  }
+  return out.join("\n");
+}
+
+// src/timeline/a2Commands.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join, relative } from "path";
+
+// src/timeline/resolveRef.ts
+function targetFor(row) {
+  if (row.ref.startsWith("#")) return { id: row.ref.slice(1) };
+  if (row.ref.startsWith("hf:")) return { hfId: row.ref.slice(3) };
+  return row.id && row.id !== row.kind ? { id: row.id } : null;
+}
+function resolveRef(timeline, ref) {
+  const rows = timeline.tracks.flatMap((track) => track.rows);
+  const matches = ref.startsWith("#") ? rows.filter((row2) => row2.ref === ref || row2.id === ref.slice(1)) : ref.startsWith("hf:") ? rows.filter((row2) => row2.ref === ref) : (() => {
+    const match = /^(video|graphics|captions|audio)\/(\d+)$/.exec(ref);
+    if (!match) return [];
+    const row2 = timeline.tracks.find((track) => track.kind === match[1])?.rows.find((candidate) => candidate.index === Number(match[2]));
+    return row2 ? [row2] : [];
+  })();
+  if (matches.length !== 1) {
+    return {
+      ok: false,
+      reason: matches.length === 0 ? `${ref} was not found` : `${ref} matches ${matches.length} rows`,
+      fix: 'add id="<name>" to the element in its source file, then retry with #<name>'
+    };
+  }
+  const row = matches[0];
+  const target = targetFor(row);
+  if (!target) {
+    return {
+      ok: false,
+      reason: `${ref} has no stable element id in ${row.file}`,
+      fix: `add id="<name>" to the element in ${row.file}, then retry with #<name>`
+    };
+  }
+  return { ok: true, row, target };
+}
+
+// src/timeline/timeExpr.ts
+function parseTimeExpression(expression, context) {
+  const raw = expression.trim();
+  if (raw === "end") return { ok: true, seconds: context.duration };
+  const frames = /^(-?\d+(?:\.\d+)?)f$/.exec(raw);
+  if (frames) return { ok: true, seconds: Number(frames[1]) / context.fps };
+  const absolute = /^\d+(?:\.\d+)?$/.test(raw);
+  const relative2 = /^[+-]\d+(?:\.\d+)?$/.test(raw);
+  if (absolute) return { ok: true, seconds: Number(raw) };
+  if (relative2) return { ok: true, seconds: context.row.start + Number(raw) };
+  const anchor = /^(after|before|start-of|end-of):(.+)$/.exec(raw);
+  if (!anchor) return { ok: false, reason: `invalid time expression: ${expression}` };
+  const row = context.resolveAnchor(anchor[2]);
+  if (!row) return { ok: false, reason: `anchor ref not found: ${anchor[2]}` };
+  switch (anchor[1]) {
+    case "after":
+    case "end-of":
+      return { ok: true, seconds: row.end };
+    case "before":
+    case "start-of":
+      return { ok: true, seconds: row.start };
+  }
+  return { ok: false, reason: `invalid time anchor: ${anchor[1]}` };
+}
+
+// src/timeline/a2Shared.ts
+import { readFileSync } from "fs";
+
+// src/timeline/a2Mutations.ts
+function parseSetAssignments(values) {
+  const assignments = [];
+  for (const value of values) {
+    const match = /^(volume|rate|track)=(.+)$/.exec(value);
+    if (!match) {
+      return {
+        ok: false,
+        reason: `unsupported set assignment ${value}`,
+        fix: "use volume=<number>, rate=<number>, or track=<number>"
+      };
+    }
+    const fieldValue = match[1];
+    if (!fieldValue) {
+      return {
+        ok: false,
+        reason: `unsupported set assignment ${value}`,
+        fix: "use volume=<number>, rate=<number>, or track=<number>"
+      };
+    }
+    const field = parseSetField(fieldValue);
+    const number = Number(match[2]);
+    if (!Number.isFinite(number) || field === "track" && !Number.isInteger(number)) {
+      return {
+        ok: false,
+        reason: `${field} must be a valid ${field === "track" ? "integer" : "number"}`,
+        fix: `pass ${field}=<number>`
+      };
+    }
+    if (field === "rate" && number <= 0) {
+      return { ok: false, reason: "rate must be positive", fix: "pass rate=<positive number>" };
+    }
+    assignments.push({ field, value: String(number) });
+  }
+  return { ok: true, assignments };
+}
+function parseSetField(value) {
+  switch (value) {
+    case "volume":
+    case "rate":
+    case "track":
+      return value;
+  }
+  throw new Error(`unsupported set field ${value}`);
+}
+
+// src/timeline/a2Shared.ts
+var FIELDS_READ_BY_VERB = {
+  move: ["time", "overwrite"],
+  trim: ["start", "end", "duration", "overwrite"],
+  split: ["time"],
+  delete: ["start", "end"],
+  set: ["volume", "rate", "track"],
+  duplicate: ["at"]
+};
+var allRows = (timeline) => timeline.tracks.flatMap((track) => track.rows);
+function refusal(reason, fix, json) {
+  setCommandExitCode(2);
+  const payload = { ok: false, reason, fix };
+  console.error(json ? JSON.stringify(payload, null, 2) : `${reason}; ${fix}.`);
+}
+var isFileChanged = (error) => error instanceof Error && error.message === "file changed since the timeline was read";
+function refuse(kind, detail, json) {
+  refusal(`${kind}: ${detail.reason}`, detail.fix, json);
+}
+function publicReceipt(receipt) {
+  return {
+    file: receipt.sourceFile,
+    version: receipt.version,
+    writeToken: receipt.writeToken,
+    changed: receipt.changed,
+    backupPath: receipt.backupPath
+  };
+}
+function fpsFor(indexPath) {
+  const parsed = parseFpsWithDefault(
+    readCompositionFps(readFileSync(indexPath, "utf-8")) ?? void 0
+  );
+  return fpsToNumber(parsed.ok ? parsed.value : { num: 30, den: 1 });
+}
+function declaredFps(source) {
+  const raw = readCompositionFps(source);
+  if (raw === null) return null;
+  const parsed = parseFpsWithDefault(raw);
+  return parsed.ok ? fpsToNumber(parsed.value) : null;
+}
+function splitBaseId(row) {
+  return row.ref.startsWith("hf:") ? row.ref.slice(3) : row.id;
+}
+function nextFreeSplitId(source, base) {
+  const document = new DOMParser().parseFromString(source, "text/html");
+  const existing = new Set(Array.from(document.querySelectorAll("[id]"), (element) => element.id));
+  const match = /^(.*)-(\d+)$/.exec(base);
+  const prefix = match && existing.has(match[1]) ? match[1] : base;
+  let suffix = 2;
+  while (existing.has(`${prefix}-${suffix}`)) suffix += 1;
+  return `${prefix}-${suffix}`;
+}
+function parseMutationTime(context, expression, fix) {
+  const value = context.parseTime(expression);
+  if (!value.ok) return { ok: false, reason: value.reason, fix };
+  if (value.seconds < 0 || value.seconds > context.duration) {
+    return {
+      ok: false,
+      reason: `time ${value.seconds} is outside the composition duration`,
+      fix: "pass a time between 0 and the composition duration"
+    };
+  }
+  return { ok: true, seconds: value.seconds };
+}
+function diff(before, after) {
+  if (before === after) return "";
+  const beforeLines = before.split("\n");
+  const afterLines = after.split("\n");
+  let prefix = 0;
+  while (prefix < beforeLines.length && prefix < afterLines.length && beforeLines[prefix] === afterLines[prefix]) {
+    prefix += 1;
+  }
+  let suffix = 0;
+  while (suffix < beforeLines.length - prefix && suffix < afterLines.length - prefix && beforeLines[beforeLines.length - suffix - 1] === afterLines[afterLines.length - suffix - 1]) {
+    suffix += 1;
+  }
+  const changedBefore = beforeLines.slice(prefix, beforeLines.length - suffix);
+  const changedAfter = afterLines.slice(prefix, afterLines.length - suffix);
+  const lines = [
+    "--- before",
+    "+++ after",
+    ...changedBefore.map((line2) => `-${line2}`),
+    ...changedAfter.map((line2) => `+${line2}`)
+  ];
+  const output = lines.join("\n");
+  return output.length <= 8e3 ? output : `${output.slice(0, 7997)}...`;
+}
+function isAncestorOf(ancestor, row, timeline) {
+  for (let pointer = row.parentRow; pointer; ) {
+    const parent = rowAt(timeline, pointer);
+    if (parent === ancestor) return true;
+    pointer = parent.parentRow;
+  }
+  return false;
+}
+function sameLineage(a, b, timeline) {
+  return isAncestorOf(a, b, timeline) || isAncestorOf(b, a, timeline);
+}
+function overlap(row, timeline, start, end) {
+  return allRows(timeline).find(
+    (candidate) => candidate !== row && !sameLineage(candidate, row, timeline) && candidate.file === row.file && candidate.trackIndex === row.trackIndex && spansShareTime(start, end, candidate.start, candidate.end)
+  );
+}
+function moveMutation(context, args) {
+  const expression = typeof args.time === "string" ? args.time : "";
+  const time = parseMutationTime(context, expression, "pass a valid time expression");
+  if (!time.ok) return time;
+  const end = time.seconds + context.row.duration;
+  if (end > context.duration) {
+    return {
+      ok: false,
+      reason: `move would end at ${end}, beyond composition duration ${context.duration}`,
+      fix: `choose a start at or before the latest valid start ${context.duration - context.row.duration}`
+    };
+  }
+  const operations = [
+    { type: "html-attribute", property: "data-start", value: String(time.seconds) }
+  ];
+  if (context.row.durationAuthored) {
+    operations.push(
+      { type: "html-attribute", property: "data-duration", value: String(context.row.duration) },
+      { type: "html-attribute", property: "data-end", value: null }
+    );
+  }
+  const patched = patchElementInHtml(context.before, context.resolved.target, operations);
+  if (!patched.matched) {
+    return { ok: false, reason: `${context.ref} was not found`, fix: "choose an existing clip" };
+  }
+  return {
+    ok: true,
+    after: patched.html,
+    nextStart: time.seconds,
+    nextDuration: context.row.duration
+  };
+}
+function splitMutation(context, args) {
+  const expression = typeof args.time === "string" ? args.time : "";
+  const time = parseMutationTime(context, expression, "pass a valid time expression");
+  if (!time.ok) return time;
+  const split = splitSource(
+    context,
+    context.before,
+    context.resolved.target,
+    time.seconds,
+    context.row.duration
+  );
+  if (!split.ok) return split;
+  return {
+    ok: true,
+    after: split.html,
+    nextStart: context.row.start,
+    nextDuration: context.row.duration
+  };
+}
+function splitSource(context, source, target, seconds, duration) {
+  const split = splitElementInHtml(
+    source,
+    target,
+    seconds,
+    nextFreeSplitId(source, splitBaseId(context.row)),
+    { start: context.row.start, duration, track: context.row.trackIndex }
+  );
+  if (!split.matched || !split.newId) {
+    return {
+      ok: false,
+      reason: `${context.ref} cannot be split at ${seconds}`,
+      fix: "choose a time inside the clip"
+    };
+  }
+  return { ok: true, html: split.html, newId: split.newId };
+}
+function trimMutation(context, args) {
+  const bounds = trimBounds(context, args);
+  if (!bounds.ok) return bounds;
+  const patched = patchElementInHtml(context.before, context.resolved.target, [
+    { type: "html-attribute", property: "data-start", value: String(bounds.nextStart) },
+    { type: "html-attribute", property: "data-duration", value: String(bounds.nextDuration) }
+  ]);
+  if (!patched.matched) {
+    return { ok: false, reason: `${context.ref} was not found`, fix: "choose an existing clip" };
+  }
+  return {
+    ok: true,
+    after: patched.html,
+    nextStart: bounds.nextStart,
+    nextDuration: bounds.nextDuration
+  };
+}
+function trimBounds(context, args) {
+  const input = trimInput(args);
+  if (!input.ok) return input;
+  const start = trimStart(context, input.start);
+  if (!start.ok) return start;
+  return finishTrim(
+    context,
+    start.seconds,
+    trimEnd(context, input.end),
+    trimDuration(context, input.duration)
+  );
+}
+function trimInput(args) {
+  const input = {
+    start: typeof args.start === "string" ? args.start : void 0,
+    end: typeof args.end === "string" ? args.end : void 0,
+    duration: typeof args.duration === "string" ? args.duration : void 0
+  };
+  if (input.start || input.end || input.duration) return { ok: true, ...input };
+  return {
+    ok: false,
+    reason: "trim requires --start, --end, or --duration",
+    fix: "pass one trim option"
+  };
+}
+var leavesNoLength = (start, duration) => duration <= 0 || sameInstant(start, start + duration);
+function finishTrim(context, nextStart, end, duration) {
+  if (end && !end.ok) return end;
+  if (duration && !duration.ok) return duration;
+  const nextDuration = duration?.seconds ?? (end ? durationUntil(nextStart, end.seconds) : context.row.duration);
+  if (leavesNoLength(nextStart, nextDuration)) {
+    return {
+      ok: false,
+      reason: "trim duration must be positive",
+      fix: "choose a later end or positive duration"
+    };
+  }
+  return { ok: true, nextStart, nextDuration };
+}
+function trimStart(context, expression) {
+  if (!expression) return { ok: true, seconds: context.row.start };
+  return parseMutationTime(context, expression, "pass a valid time expression");
+}
+function durationUntil(start, end) {
+  let duration = end - start;
+  while (duration > 0 && start + duration > end) duration = nextSmaller(duration);
+  return duration;
+}
+var float = new DataView(new ArrayBuffer(8));
+function nextSmaller(positive) {
+  float.setFloat64(0, positive);
+  float.setBigUint64(0, float.getBigUint64(0) - 1n);
+  return float.getFloat64(0);
+}
+function trimEnd(context, expression) {
+  if (!expression) return void 0;
+  return parseMutationTime(context, expression, "pass a valid time expression");
+}
+function trimDuration(context, expression) {
+  if (!expression) return void 0;
+  return parseMutationTime(context, expression, "pass a valid duration");
+}
+function deleteMutation(context, args) {
+  const { row, resolved } = context;
+  const range = deleteRange(context, args);
+  if (!range.ok) return range;
+  let html = context.before;
+  if (!sameInstant(range.end, row.end)) {
+    const tail = splitSource(context, html, resolved.target, range.end, row.duration);
+    if (!tail.ok) return tail;
+    html = tail.html;
+  }
+  let removed = resolved.target;
+  if (!sameInstant(range.start, row.start)) {
+    const middle = splitSource(context, html, resolved.target, range.start, range.end - row.start);
+    if (!middle.ok) return middle;
+    html = middle.html;
+    removed = { id: middle.newId };
+  }
+  return {
+    ok: true,
+    after: removeElementFromHtml(html, removed),
+    nextStart: row.start,
+    nextDuration: row.duration
+  };
+}
+function deleteRange(context, args) {
+  const { row } = context;
+  const bound = (value, fallback) => typeof value === "string" ? parseMutationTime(context, value, "pass a valid time expression") : { ok: true, seconds: fallback };
+  const start = bound(args.start, row.start);
+  if (!start.ok) return start;
+  const end = bound(args.end, row.end);
+  if (!end.ok) return end;
+  const inside = (seconds) => sameInstant(seconds, row.start) || sameInstant(seconds, row.end) || seconds > row.start && seconds < row.end;
+  if (!inside(start.seconds) || !inside(end.seconds)) {
+    return {
+      ok: false,
+      reason: `delete range ${start.seconds}-${end.seconds} is not inside ${context.ref} (${row.start}-${row.end})`,
+      fix: "pass --start and --end inside the clip"
+    };
+  }
+  if (end.seconds <= start.seconds || sameInstant(start.seconds, end.seconds)) {
+    return {
+      ok: false,
+      reason: "delete range must be positive",
+      fix: "pass an --end later than --start"
+    };
+  }
+  return { ok: true, start: start.seconds, end: end.seconds };
+}
+function setOperation(assignment) {
+  const property = assignment.field === "volume" ? "data-volume" : assignment.field === "rate" ? "data-playback-rate" : "data-track-index";
+  return { type: "html-attribute", property, value: assignment.value };
+}
+function setMutation(context, args) {
+  const positionalAssignments = positional(args).slice(1).filter((value) => typeof value === "string");
+  const namedAssignments = ["volume", "rate", "track"].flatMap((field) => {
+    const value = args[field];
+    return typeof value === "string" ? [`${field}=${value}`] : [];
+  });
+  const assignments = parseSetAssignments([...positionalAssignments, ...namedAssignments]);
+  if (!assignments.ok) return assignments;
+  const patched = patchElementInHtml(
+    context.before,
+    context.resolved.target,
+    assignments.assignments.map(setOperation)
+  );
+  if (!patched.matched) {
+    return { ok: false, reason: `${context.ref} was not found`, fix: "choose an existing clip" };
+  }
+  return {
+    ok: true,
+    after: patched.html,
+    nextStart: context.row.start,
+    nextDuration: context.row.duration
+  };
+}
+function duplicateMutation(context, args) {
+  const expression = typeof args.at === "string" ? args.at : String(context.row.end);
+  const time = parseMutationTime(context, expression, "pass a valid insertion time");
+  if (!time.ok) return time;
+  const duplicate = duplicateElementInHtml(
+    context.before,
+    context.resolved.target,
+    `${splitBaseId(context.row)}-copy`,
+    time.seconds
+  );
+  if (!duplicate.matched) {
+    return { ok: false, reason: `${context.ref} was not found`, fix: "choose an existing clip" };
+  }
+  return {
+    ok: true,
+    after: duplicate.html,
+    nextStart: time.seconds,
+    nextDuration: context.row.duration
+  };
+}
+function decideMutation(verb, context, args) {
+  switch (verb) {
+    case "move":
+      return moveMutation(context, args);
+    case "trim":
+      return trimMutation(context, args);
+    case "split":
+      return splitMutation(context, args);
+    case "delete":
+      return deleteMutation(context, args);
+    case "set":
+      return setMutation(context, args);
+    case "duplicate":
+      return duplicateMutation(context, args);
+  }
+}
+function rowAt(timeline, pointer) {
+  const track = timeline.tracks.find((candidate) => candidate.kind === pointer.kind);
+  if (!track) throw new Error(`missing track ${pointer.kind}`);
+  const row = track.rows[pointer.index];
+  if (!row) throw new Error(`missing row ${pointer.kind}/${pointer.index}`);
+  return row;
+}
+function positional(args) {
+  return Array.isArray(args._) ? args._.filter((value) => typeof value === "string") : [];
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mutationConflict(verb, overwrite, row, timeline, nextStart, nextDuration) {
+  if (verb === "duplicate") {
+    const conflict2 = allRows(timeline).find(
+      (candidate) => !sameLineage(candidate, row, timeline) && candidate.file === row.file && candidate.trackIndex === row.trackIndex && isInsideSpan(nextStart, candidate.start, candidate.end)
+    );
+    if (!conflict2) return null;
+    return {
+      reason: `duplicate insertion at ${nextStart} falls inside ${conflict2.ref}`,
+      fix: "choose a clip boundary or split the spanning clip first"
+    };
+  }
+  if (verb !== "move" && verb !== "trim" || overwrite) return null;
+  const conflict = overlap(row, timeline, nextStart, nextStart + nextDuration);
+  if (!conflict) return null;
+  return {
+    reason: `${row.ref} would overlap ${conflict.ref} at ${nextStart}-${nextStart + nextDuration}`,
+    fix: "pass --overwrite or move the named neighbour"
+  };
+}
+
+// src/timeline/a2Commands.ts
+async function runIds(args) {
+  const project = resolveProject(typeof args.dir === "string" ? args.dir : void 0);
+  const json = args.json === true;
+  ensureDOMParser();
+  const beforeTimeline = await describeProject(project.indexPath);
+  const files = [.../* @__PURE__ */ new Set(["index.html", ...allRows(beforeTimeline).map((row) => row.file)])];
+  const inputs = files.flatMap((file) => {
+    const before = readFileSync2(join(project.dir, file), "utf-8");
+    const after = ensureHfIds(before);
+    return after === before ? [] : [
+      {
+        sourceFile: file,
+        absPath: join(project.dir, file),
+        before,
+        after,
+        expectedVersion: fileContentVersion(before)
+      }
+    ];
+  });
+  let receipts = [];
+  try {
+    if (inputs.length > 0) receipts = applyFileMutations(project.dir, inputs);
+  } catch (error) {
+    if (isFileChanged(error)) return refusal(error.message, "re-run framey timeline ids", json);
+    throw error;
+  }
+  const afterTimeline = await describeProject(project.indexPath);
+  const result = {
+    ok: true,
+    receipt: receipts.map((receipt) => publicReceipt(receipt)),
+    file: files,
+    before: allRows(beforeTimeline),
+    after: allRows(afterTimeline),
+    diff: "",
+    warnings: []
+  };
+  if (json) console.log(JSON.stringify(withMeta(result), null, 2));
+  else console.log(`ids: stamped ${receipts.length} file${receipts.length === 1 ? "" : "s"}`);
+}
+var PLAN_VERBS = /* @__PURE__ */ new Set(["move", "trim", "split", "delete", "set", "duplicate"]);
+function preparePlanEdit(edit, timeline, sourceByFile) {
+  if (!isRecord(edit) || typeof edit.verb !== "string" || typeof edit.ref !== "string") {
+    return {
+      ok: false,
+      reason: "each edit needs a verb and ref",
+      fix: "pass {verb, ref, ...} objects"
+    };
+  }
+  if (!PLAN_VERBS.has(edit.verb)) {
+    return {
+      ok: false,
+      reason: `unsupported edit verb ${edit.verb}`,
+      fix: "use move, trim, split, delete, set, or duplicate"
+    };
+  }
+  const fields = FIELDS_READ_BY_VERB[edit.verb];
+  const unused = Object.keys(edit).find(
+    (key) => key !== "verb" && key !== "ref" && !fields.includes(key)
+  );
+  if (unused) {
+    return {
+      ok: false,
+      reason: `${edit.verb} does not use ${unused}`,
+      fix: `remove ${unused}; ${edit.verb} takes ${fields.join(", ")}`
+    };
+  }
+  const resolved = resolveRef(timeline, edit.ref);
+  if (!resolved.ok) return resolved;
+  const before = sourceByFile.get(resolved.row.file);
+  return before === void 0 ? { ok: false, reason: `${resolved.row.file} was not found`, fix: "choose an existing clip" } : { ok: true, edit, row: resolved.row, before, resolved };
+}
+function applyPlanEdit(edit, timeline, project, sourceByFile) {
+  const prepared = preparePlanEdit(edit, timeline, sourceByFile);
+  if (!prepared.ok) return prepared;
+  const { edit: planEdit, row, before, resolved } = prepared;
+  const verb = planEdit.verb;
+  const context = {
+    ref: planEdit.ref,
+    row,
+    before,
+    resolved,
+    parseTime: (expression) => parseTimeExpression(expression, {
+      row,
+      duration: timeline.duration,
+      fps: fpsFor(project.indexPath),
+      resolveAnchor: (anchorRef) => {
+        const anchor = resolveRef(timeline, anchorRef);
+        return anchor.ok ? anchor.row : void 0;
+      }
+    }),
+    duration: row.nested && row.hostRow ? rowAt(timeline, row.hostRow).duration : timeline.duration
+  };
+  const decision = decideMutation(verb, context, { ...planEdit, _: [planEdit.ref] });
+  if (!decision.ok) return { ok: false, reason: decision.reason, fix: decision.fix };
+  const conflict = mutationConflict(
+    verb,
+    planEdit.overwrite === true,
+    row,
+    timeline,
+    decision.nextStart,
+    decision.nextDuration
+  );
+  if (conflict) return { ok: false, reason: conflict.reason, fix: conflict.fix };
+  return { ok: true, file: row.file, after: decision.after };
+}
+function readEditPlan(file) {
+  const raw = file === "-" ? readFileSync2(0, "utf-8") : readFileSync2(file, "utf-8");
+  try {
+    const edits = JSON.parse(raw);
+    return Array.isArray(edits) ? { ok: true, edits } : { ok: false, reason: "edit plan must be a JSON array", fix: "pass a JSON array of edits" };
+  } catch {
+    return { ok: false, reason: "edit plan is not valid JSON", fix: "pass a JSON array of edits" };
+  }
+}
+function readPlanSources(timeline, project) {
+  const sourceByFile = /* @__PURE__ */ new Map();
+  const beforeByFile = /* @__PURE__ */ new Map();
+  for (const fileName of new Set(allRows(timeline).map((row) => row.file))) {
+    const source = readFileSync2(join(project.dir, fileName), "utf-8");
+    sourceByFile.set(fileName, source);
+    beforeByFile.set(fileName, source);
+  }
+  return { sourceByFile, beforeByFile };
+}
+async function applyPlanEdits(edits, timeline, project, sourceByFile) {
+  for (const edit of edits) {
+    const result = applyPlanEdit(edit, timeline, project, sourceByFile);
+    if (!result.ok) return result;
+    sourceByFile.set(result.file, result.after);
+    timeline = await describeProject(project.indexPath, void 0, sourceByFile);
+  }
+  return { ok: true };
+}
+async function runApply(args) {
+  const project = resolveProject(typeof args.dir === "string" ? args.dir : void 0);
+  const json = args.json === true;
+  const plan = args.plan === true;
+  const file = typeof args.file === "string" ? args.file : positional(args)[1];
+  if (!file)
+    return refuse(
+      "timeline apply",
+      { reason: "an edit plan is required", fix: "pass an edits.json path or -" },
+      json
+    );
+  const planInput = readEditPlan(file);
+  if (!planInput.ok) return refuse("timeline apply", planInput, json);
+  ensureDOMParser();
+  const timeline = await describeProject(project.indexPath);
+  const { sourceByFile, beforeByFile } = readPlanSources(timeline, project);
+  const editsResult = await applyPlanEdits(planInput.edits, timeline, project, sourceByFile);
+  if (!editsResult.ok) return refuse("timeline apply", editsResult, json);
+  const inputs = [...sourceByFile].flatMap(([fileName, after]) => {
+    const before = beforeByFile.get(fileName);
+    return after === before ? [] : [
+      {
+        sourceFile: fileName,
+        absPath: join(project.dir, fileName),
+        before,
+        after,
+        expectedVersion: fileContentVersion(before)
+      }
+    ];
+  });
+  const afterTimeline = await describeProject(project.indexPath, void 0, sourceByFile);
+  const result = {
+    ok: true,
+    planned: plan,
+    receipt: null,
+    file: inputs.map((input) => input.sourceFile),
+    before: allRows(timeline),
+    after: allRows(afterTimeline),
+    diff: inputs.map((input) => diff(input.before, input.after)).filter(Boolean).join("\n"),
+    warnings: []
+  };
+  if (!plan) {
+    const receipts = inputs.length > 0 ? applyFileMutations(project.dir, inputs) : [];
+    result.receipt = receipts.map((receipt) => publicReceipt(receipt));
+  }
+  if (json) console.log(JSON.stringify(withMeta(result), null, 2));
+  else
+    console.log(
+      `${plan ? "planned" : "applied"} ${inputs.length} file${inputs.length === 1 ? "" : "s"}`
+    );
+}
+function isUndoReceipt(value) {
+  return isRecord(value) && typeof value.file === "string" && typeof value.version === "string" && typeof value.backupPath === "string";
+}
+function readUndoInput(input) {
+  let raw;
+  try {
+    raw = readFileSync2(input, "utf-8");
+  } catch {
+    raw = input;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return {
+      ok: false,
+      reason: "undo receipt is not valid JSON",
+      fix: "pass the applied JSON receipt"
+    };
+  }
+  const value = isRecord(parsed) && "receipt" in parsed ? parsed.receipt : parsed;
+  const values = Array.isArray(value) ? value : [value];
+  if (!values.every(isUndoReceipt)) {
+    return {
+      ok: false,
+      reason: "undo receipt is missing file, version, or backupPath",
+      fix: "pass an applied timeline receipt"
+    };
+  }
+  return { ok: true, receipts: values, batch: Array.isArray(value) };
+}
+function refuseUndoError(error, projectDir, json) {
+  if (isRecord(error) && error.code === "ENOENT" && typeof error.path === "string")
+    return refuse(
+      "timeline undo",
+      {
+        reason: `undo file is missing: ${relative(projectDir, error.path).split("\\").join("/")}`,
+        fix: "restore the missing target or backup file before retrying undo"
+      },
+      json
+    );
+  if (isFileChanged(error))
+    return refusal(error.message, "read the latest timeline before retrying undo", json);
+  throw error;
+}
+async function runUndo(args) {
+  const project = resolveProject(typeof args.dir === "string" ? args.dir : void 0, {
+    requireIndex: false
+  });
+  const json = args.json === true;
+  const input = typeof args.receipt === "string" ? args.receipt : positional(args)[1];
+  if (!input)
+    return refuse(
+      "timeline undo",
+      { reason: "an undo receipt is required", fix: "pass the receipt JSON or its file" },
+      json
+    );
+  const undo = readUndoInput(input);
+  if (!undo.ok) return refuse("timeline undo", undo, json);
+  let receipts;
+  try {
+    const inputs = undo.receipts.map((receipt) => {
+      const target = join(project.dir, receipt.file);
+      return {
+        sourceFile: receipt.file,
+        absPath: target,
+        before: readFileSync2(target, "utf-8"),
+        after: readFileSync2(join(project.dir, receipt.backupPath), "utf-8"),
+        expectedVersion: receipt.version
+      };
+    });
+    receipts = applyFileMutations(project.dir, inputs);
+  } catch (error) {
+    return refuseUndoError(error, project.dir, json);
+  }
+  const result = {
+    ok: true,
+    receipt: receipts.map((receipt) => publicReceipt(receipt)),
+    file: undo.batch ? undo.receipts.map((receipt) => receipt.file) : undo.receipts[0].file
+  };
+  if (json) console.log(JSON.stringify(withMeta(result), null, 2));
+  else
+    console.log(
+      undo.batch ? `undid ${receipts.length} file${receipts.length === 1 ? "" : "s"}` : `undid ${undo.receipts[0].file}`
+    );
+}
+
+// src/timeline/a2MutationCommand.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join2 } from "path";
+async function runMutation(verb, args) {
+  const setup = await prepareMutation(args);
+  if (!setup.ok) return refusal(setup.reason, setup.fix, setup.json);
+  const decision = decideMutation(verb, setup.context, args);
+  if (!decision.ok) return refusal(decision.reason, decision.fix, setup.json);
+  await finishMutation(setup, verb, decision);
+}
+async function prepareMutation(args) {
+  const project = resolveProject(typeof args.dir === "string" ? args.dir : void 0);
+  const ref = typeof args.ref === "string" ? args.ref : "";
+  const json = args.json === true;
+  const plan = args.plan === true;
+  const overwrite = args.overwrite === true;
+  const snap = args.snap === true;
+  ensureDOMParser();
+  const indexSource = readFileSync3(project.indexPath, "utf-8");
+  const initialTimeline = await describeProject(
+    project.indexPath,
+    void 0,
+    /* @__PURE__ */ new Map([["index.html", indexSource]])
+  );
+  const projectFps = declaredFps(indexSource);
+  if (snap && projectFps === null) {
+    return {
+      ok: false,
+      reason: "project fps is unknown",
+      fix: "set data-fps on the project, then rerun with --snap",
+      json
+    };
+  }
+  const initialResolved = resolveRef(initialTimeline, ref);
+  if (!initialResolved.ok)
+    return { ok: false, reason: initialResolved.reason, fix: initialResolved.fix, json };
+  const initialRow = initialResolved.row;
+  const filePath = join2(project.dir, initialRow.file);
+  const before = readFileSync3(filePath, "utf-8");
+  const expectedVersion = fileContentVersion(before);
+  const sources = /* @__PURE__ */ new Map([
+    ["index.html", indexSource],
+    [initialRow.file, before]
+  ]);
+  const timeline = await describeProject(project.indexPath, void 0, sources);
+  const resolved = resolveRef(timeline, ref);
+  if (!resolved.ok) return { ok: false, reason: resolved.reason, fix: resolved.fix, json };
+  const row = resolved.row;
+  const anchor = (anchorRef) => {
+    const found = resolveRef(timeline, anchorRef);
+    return found.ok ? found.row : void 0;
+  };
+  const parseTime = (expression) => {
+    const parsed = parseTimeExpression(expression, {
+      row,
+      duration: timeline.duration,
+      fps: fpsFor(project.indexPath),
+      resolveAnchor: anchor
+    });
+    if (!parsed.ok || !snap) return parsed;
+    return { ok: true, seconds: Math.round(parsed.seconds * projectFps) / projectFps };
+  };
+  return {
+    ok: true,
+    project,
+    ref,
+    json,
+    plan,
+    overwrite,
+    timeline,
+    indexSource,
+    row,
+    resolved,
+    filePath,
+    before,
+    expectedVersion,
+    context: {
+      ref,
+      row,
+      before,
+      resolved,
+      parseTime,
+      // Nested rows use the visible host clip duration as their composition bound.
+      duration: row.nested && row.hostRow ? rowAt(timeline, row.hostRow).duration : timeline.duration
+    }
+  };
+}
+async function finishMutation(setup, verb, decision) {
+  const { after, nextStart, nextDuration } = decision;
+  const { ref, row, timeline, json, overwrite, project, before } = setup;
+  const refusalMessage = mutationRefusal(verb, after, before, ref);
+  if (refusalMessage) return refusal(refusalMessage.reason, refusalMessage.fix, json);
+  const conflict = mutationConflict(verb, overwrite, row, timeline, nextStart, nextDuration);
+  if (conflict) return refusal(conflict.reason, conflict.fix, json);
+  const describeSource = (source) => describeProject(
+    project.indexPath,
+    void 0,
+    /* @__PURE__ */ new Map([
+      ["index.html", setup.indexSource],
+      [row.file, source]
+    ])
+  );
+  const describedBefore = await describeSource(before);
+  const result = mutationResult(row, describedBefore, setup.plan);
+  if (setup.plan) return printPlan(result, json, timeline, describeSource, after, before);
+  return applyAndPrint({
+    setup,
+    verb,
+    json,
+    row,
+    nextStart,
+    nextDuration,
+    after,
+    before,
+    result,
+    describeSource
+  });
+}
+async function applyAndPrint(args) {
+  const receipt = applyMutation(args.setup, args.after);
+  if (receipt && "error" in receipt)
+    return refusal(receipt.error, "re-run framey timeline", args.json);
+  if (!receipt && args.after !== args.before) {
+    return refusal("mutation produced no receipt", "re-run framey timeline", args.json);
+  }
+  args.result.after = rowsForFile(await args.describeSource(args.after), args.row.file);
+  args.result.receipt = receipt ? publicReceipt(receipt) : null;
+  if (args.json) {
+    console.log(JSON.stringify(withMeta(args.result), null, 2));
+    return;
+  }
+  console.log(
+    `${args.verb} ${args.row.ref}: ${args.row.start}-${args.row.end}s -> ${args.nextStart}-${args.nextStart + args.nextDuration}s
+receipt: ${receipt?.version ?? "unchanged"}`
+  );
+}
+function rowsForFile(timeline, file) {
+  return allRows(timeline).filter((candidate) => candidate.file === file);
+}
+function mutationResult(row, before, planned) {
+  return {
+    ok: true,
+    receipt: null,
+    file: row.file,
+    before: rowsForFile(before, row.file),
+    after: [],
+    warnings: row.warnings,
+    planned
+  };
+}
+async function printPlan(result, json, timeline, describeSource, after, before) {
+  const plannedTimeline = await describeSource(after);
+  result.after = rowsForFile(plannedTimeline, result.file);
+  if (json) console.log(JSON.stringify(withMeta(result), null, 2));
+  else
+    console.log(
+      `${formatTimeline(timeline)}
+
+planned:
+${formatTimeline(plannedTimeline)}
+
+diff:
+${diff(before, after)}`
+    );
+}
+function applyMutation(setup, after) {
+  try {
+    return applyFileMutations(setup.project.dir, [
+      {
+        sourceFile: setup.row.file,
+        absPath: setup.filePath,
+        before: setup.before,
+        after,
+        expectedVersion: setup.expectedVersion
+      }
+    ])[0];
+  } catch (error) {
+    if (isFileChanged(error)) return { error: error.message };
+    throw error;
+  }
+}
+function mutationRefusal(verb, after, before, ref) {
+  if (verb !== "delete" || after !== before) return null;
+  return { reason: `${ref} was not found`, fix: "choose an existing clip" };
+}
+
+// src/commands/timeline.ts
+var examples = [
+  ["Show every track and clip of the project in the current directory", "framey timeline"],
+  ["Move a clip without writing", "framey timeline move '#hero' +2 --plan"],
+  ["Delete a clip and return a receipt", "framey timeline delete '#hero' --json"]
+];
+var MUTATION_OPTIONS = {
+  time: { type: "positional", required: true },
+  at: { type: "string" },
+  start: { type: "string" },
+  end: { type: "string" },
+  duration: { type: "string" },
+  volume: { type: "string" },
+  rate: { type: "string" },
+  track: { type: "string" },
+  overwrite: { type: "boolean", default: false }
+};
+function mutationCommand(verb) {
+  const fields = FIELDS_READ_BY_VERB[verb];
+  return defineCommand({
+    meta: { name: verb, description: `${verb} a timeline clip` },
+    args: {
+      ref: { type: "positional", required: true },
+      ...verb === "set" && { assignment: { type: "positional", required: false } },
+      ...Object.fromEntries(fields.map((field) => [field, MUTATION_OPTIONS[field]])),
+      dir: { type: "string" },
+      plan: { type: "boolean", default: false },
+      json: { type: "boolean", default: false },
+      ...verb !== "set" && { snap: { type: "boolean", default: false } }
+    },
+    async run({ args }) {
+      await runMutation(verb, args);
+    }
+  });
+}
+var subCommands = {
+  move: () => mutationCommand("move"),
+  trim: () => mutationCommand("trim"),
+  split: () => mutationCommand("split"),
+  delete: () => mutationCommand("delete"),
+  set: () => mutationCommand("set"),
+  duplicate: () => mutationCommand("duplicate"),
+  ids: () => defineCommand({
+    meta: { name: "ids", description: "Stamp stable ids on timeline clips" },
+    args: { dir: { type: "string" }, json: { type: "boolean", default: false } },
+    async run({ args }) {
+      await runIds(args);
+    }
+  }),
+  apply: () => defineCommand({
+    meta: { name: "apply", description: "Apply an atomic timeline edit plan" },
+    args: {
+      file: { type: "positional", required: true },
+      dir: { type: "string" },
+      json: { type: "boolean", default: false },
+      plan: { type: "boolean", default: false }
+    },
+    async run({ args }) {
+      await runApply(args);
+    }
+  }),
+  undo: () => defineCommand({
+    meta: { name: "undo", description: "Restore a timeline mutation receipt" },
+    args: {
+      receipt: { type: "positional", required: true },
+      dir: { type: "string" },
+      json: { type: "boolean", default: false }
+    },
+    async run({ args }) {
+      await runUndo(args);
+    }
+  })
+};
+function isTimelineSubcommand(first, rawArgs) {
+  if (!first || !Object.hasOwn(subCommands, first)) return false;
+  const separator = rawArgs.indexOf("--");
+  return separator < 0 || rawArgs.indexOf(first) < separator;
+}
+var timeline_default = defineCommand({
+  meta: { name: "timeline", description: "Print and edit the project's tracks and clips" },
+  args: {
+    dir: { type: "positional", description: "Project directory", required: false },
+    component: {
+      type: "string",
+      description: "Unique component selector, or JSON target {selector|hfId|ref}; runtime inspection"
+    },
+    at: { type: "string", description: "Global second; requires the inspector service" },
+    range: {
+      type: "string",
+      description: "Global start,end (half-open); requires the inspector service"
+    },
+    boundary: {
+      type: "string",
+      description: "Global boundary second; requires the inspector service"
+    },
+    generation: {
+      type: "string",
+      description: "Inspector generation for a continued runtime query"
+    },
+    offset: {
+      type: "string",
+      description: "Group offset for a continued runtime query"
+    },
+    json: { type: "boolean", description: "Output as JSON", default: false }
+  },
+  subCommands,
+  setup({ args, rawArgs, cmd }) {
+    const first = args._[0];
+    if (!first || isTimelineSubcommand(first, rawArgs)) return;
+    assertKnownFlags({ args: cmd.args }, rawArgs);
+    const separator = rawArgs.indexOf("--");
+    const directoryIndex = rawArgs.indexOf(first);
+    if (separator < 0 || directoryIndex < separator) rawArgs.splice(directoryIndex, 0, "--");
+  },
+  async run({ args, rawArgs, cmd }) {
+    if (isTimelineSubcommand(args._[0], rawArgs)) return;
+    resolveExtraPositionals({ args: cmd.args }, "timeline", args);
+    const project = resolveProject(args.dir);
+    if ([args.component, args.at, args.range, args.boundary].some((v) => v !== void 0)) {
+      const url = process.env.HF_INSPECT_URL;
+      if (!url || !/^http:\/\/(127\.0\.0\.1|localhost):\d+$/.test(url))
+        throw new Error(
+          "Runtime timeline queries require HF_INSPECT_URL from the existing inspector service."
+        );
+      const info = await fetch(`${url}/info`, { signal: AbortSignal.timeout(5e3) }).then(
+        (r) => r.json()
+      );
+      const { realpathSync } = await import("fs");
+      const { dirname } = await import("path");
+      if (realpathSync(info.project) !== realpathSync(dirname(project.indexPath)))
+        throw new Error("Inspector service belongs to another project");
+      const component = args.component?.trim().startsWith("{") ? JSON.parse(args.component) : args.component ? { selector: args.component } : void 0;
+      const response = await fetch(`${url}/timeline`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          component,
+          at: args.at === void 0 ? void 0 : Number(args.at),
+          range: args.range?.split(",").map(Number),
+          boundary: args.boundary === void 0 ? void 0 : Number(args.boundary),
+          generation: args.generation,
+          offset: args.offset === void 0 ? void 0 : Number(args.offset)
+        }),
+        signal: AbortSignal.timeout(6e4)
+      });
+      const result = await response.json();
+      if (!response.ok) throw new Error(result.error ?? "Timeline query failed");
+      console.log(args.json ? JSON.stringify(result) : result.text);
+      return;
+    }
+    ensureDOMParser();
+    const timeline = await describeProject(project.indexPath);
+    console.log(
+      args.json ? JSON.stringify(withMeta({ timeline }), null, 2) : formatTimeline(timeline)
+    );
+  }
+});
+export {
+  timeline_default as default,
+  examples
+};