@vfrey/vfrey 0.0.1 → 1.0.0-beta.1

package/vendor/framey/dist/gsapParserAcorn-LZJKCFQI.js

@@ -0,0 +1,30 @@
+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 {
+  buildArcPath,
+  editabilityForProvenance,
+  extractGsapLabels,
+  findTimelineScript,
+  gsapScriptMotionPathFirstUseIndex,
+  gsapScriptUsesMotionPath,
+  parseGsapScriptAcorn,
+  parseGsapScriptAcornForWrite,
+  scriptShape
+} from "./chunk-FLREUEHW.js";
+import "./chunk-RXATE6FZ.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  buildArcPath,
+  editabilityForProvenance,
+  extractGsapLabels,
+  findTimelineScript,
+  gsapScriptMotionPathFirstUseIndex,
+  gsapScriptUsesMotionPath,
+  parseGsapScriptAcorn,
+  parseGsapScriptAcornForWrite,
+  scriptShape
+};

package/vendor/framey/dist/help-VCB5X2HS.js

@@ -0,0 +1,184 @@
+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 {
+  renderUsage
+} from "./chunk-S3S4TGEH.js";
+import {
+  c
+} from "./chunk-VORQIH64.js";
+import {
+  VERSION
+} from "./chunk-AHX34EFP.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/help.ts
+var GROUPS = [
+  {
+    title: "Getting Started",
+    commands: [
+      ["init", "Scaffold a new composition project"],
+      ["add", "Install a block or component from the registry"],
+      ["catalog", "Browse and install blocks and components"],
+      ["preview", "Start the studio for previewing compositions"],
+      ["present", "Open a slideshow deck in presenter mode (with audience sync)"],
+      ["render", "Render a composition to MP4 or WebM"],
+      ["open", "Open a project in the HyperFrames desktop app"],
+      ["catch-up", "See what was done in the desktop app since you last looked"]
+    ]
+  },
+  {
+    title: "Project",
+    commands: [
+      ["lint", "Validate a composition for common mistakes"],
+      ["check", "Run lint, runtime validation, and layout inspection as one gate"],
+      [
+        "validate",
+        "Runtime-validate a composition in headless Chrome (JS errors, missing assets, contrast)"
+      ],
+      ["beats", "Detect beats in the music track and write beats/<audio>.json"],
+      ["audio", "Measure where sounds land: onsets, hits, loudness, silence, in film time"],
+      ["inspect", "Inspect rendered visual layout across the timeline"],
+      ["keyframes", "Inspect keyframes and render onion-shot diagnostics"],
+      ["snapshot", "Capture key frames as PNG screenshots for visual verification"],
+      [
+        "media-treatment",
+        "Discover, apply, or clear deterministic media treatments on media elements"
+      ],
+      [
+        "normalize-audio",
+        "Match one authored audio clip's loudness to another using integrated LUFS"
+      ],
+      [
+        "grade-compare",
+        "Render candidate color grades onto a reference frame as one labeled comparison PNG"
+      ],
+      ["compare", "Render composition variants into one labeled comparison sheet"],
+      ["info", "Print project metadata"],
+      ["compositions", "List all compositions in a project"],
+      ["timeline", "Print the project's tracks and clips"],
+      ["history", "List, undo and restore the project's recorded changes"],
+      ["docs", "View inline documentation in the terminal"]
+    ]
+  },
+  {
+    title: "Tooling",
+    commands: [
+      [
+        "benchmark",
+        "Render with preset fps/quality/worker configs and compare speed and file size"
+      ],
+      ["browser", "Manage the Chrome browser used for rendering"],
+      ["doctor", "Check system dependencies and environment"],
+      ["clean", "Find and remove what Framey left on disk"]
+    ]
+  },
+  {
+    title: "Deploy",
+    commands: [
+      ["lambda", "Deploy and drive distributed renders on AWS Lambda"],
+      ["cloudrun", "Deploy and drive distributed renders on Google Cloud Run"]
+    ]
+  },
+  {
+    title: "AI & Integrations",
+    commands: [
+      [
+        "transcribe",
+        "Transcribe audio/video to word-level timestamps, or import an existing transcript"
+      ],
+      ["models", "List or download on-device models (models list, models install parakeet)"],
+      ["tts", "Generate speech audio from text using a local AI model (Kokoro-82M)"],
+      ["remove-background", "Remove background from a video or image to produce transparent media"]
+    ]
+  },
+  {
+    title: "Settings",
+    commands: [["telemetry", "Manage anonymous usage telemetry"]]
+  }
+];
+var ROOT_EXAMPLES = [
+  ["Create a new project", "framey init my-video"],
+  ["Start the live preview studio", "framey preview"],
+  ["Render to MP4", "framey render -o out.mp4"],
+  ["Transparent WebM overlay", "framey render --format webm -o out.webm"],
+  ["Validate your composition", "framey lint"],
+  ["Inspect visual layout", "framey inspect"],
+  ["Check system dependencies", "framey doctor"]
+];
+async function loadExamples(name, parentName) {
+  if (parentName && parentName !== "framey") {
+    const examples = await tryLoadExamples(`./commands/${parentName}/${name}.js`);
+    if (examples) return examples;
+  }
+  return await tryLoadExamples(`./commands/${name}.js`);
+}
+async function tryLoadExamples(modulePath) {
+  try {
+    const mod = await import(modulePath);
+    return mod.examples;
+  } catch (err) {
+    if (err.code === "ERR_MODULE_NOT_FOUND") return void 0;
+    throw err;
+  }
+}
+var STATIC_EXAMPLES = {};
+function renderRootHelp() {
+  const NAME_COL = 19;
+  const CMD_COL = 46;
+  const lines = [];
+  lines.push(
+    `${c.bold("framey")} ${c.dim(`v${VERSION}`)} \u2014 Create and render HTML video compositions`
+  );
+  lines.push("");
+  lines.push(`${c.bold("Usage:")}  framey ${c.cyan("<command>")} [options]`);
+  lines.push("");
+  for (const group of GROUPS) {
+    lines.push(c.bold(`${group.title}:`));
+    for (const [name, desc] of group.commands) {
+      lines.push(`  ${c.cyan(name.padEnd(NAME_COL))}${desc}`);
+    }
+    lines.push("");
+  }
+  lines.push(c.bold("Examples:"));
+  for (const [comment, command] of ROOT_EXAMPLES) {
+    lines.push(`  ${c.dim("$")} ${command.padEnd(CMD_COL)} ${c.dim(comment)}`);
+  }
+  lines.push("");
+  lines.push(`Run ${c.cyan("framey <command> --help")} for more information about a command.`);
+  return lines.join("\n");
+}
+function formatExamples(examples) {
+  const lines = [];
+  lines.push(c.bold("Examples:"));
+  for (const [comment, command] of examples) {
+    lines.push(`  ${c.gray(`# ${comment}`)}`);
+    lines.push(`  ${command}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function showUsage(cmd, parent) {
+  if (!parent) {
+    console.log(renderRootHelp() + "\n");
+    return;
+  }
+  const meta = await (typeof cmd.meta === "function" ? cmd.meta() : cmd.meta);
+  const usage = await renderUsage(cmd, parent);
+  console.log(usage + "\n");
+  const name = meta?.name;
+  if (name) {
+    const parentMeta = await (typeof parent.meta === "function" ? parent.meta() : parent.meta);
+    const parentName = parentMeta?.name;
+    const examples = STATIC_EXAMPLES[name] ?? await loadExamples(name, parentName);
+    if (examples) {
+      console.log(formatExamples(examples) + "\n");
+    }
+  }
+}
+export {
+  showUsage
+};

package/vendor/framey/dist/history-ENGZEVFT.js

@@ -0,0 +1,471 @@
+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 {
+  Refusal,
+  endTurn,
+  historyDeps,
+  lastTurnParts,
+  withOwner,
+  withReader,
+  writeTurn
+} from "./chunk-IXU6PQSW.js";
+import "./chunk-X7MTZ4T2.js";
+import {
+  withMeta
+} from "./chunk-O4YRB27L.js";
+import "./chunk-O7BGSQ5F.js";
+import {
+  HistoryBusyError,
+  HistoryIdError,
+  HistoryRefusedError,
+  START
+} from "./chunk-YPRBGITP.js";
+import "./chunk-7JQFJ6JJ.js";
+import "./chunk-P5ZBLXJ6.js";
+import {
+  AmbiguousPreviewServerError
+} from "./chunk-DQBY7FRR.js";
+import "./chunk-EOVYQ3IG.js";
+import {
+  trackHistoryAction
+} from "./chunk-GNEFDLFB.js";
+import "./chunk-2UZQHDM7.js";
+import "./chunk-NYEXNSHM.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-EVMY7IPL.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-634HSJ3J.js";
+import "./chunk-FXMKHHPO.js";
+import "./chunk-AHX34EFP.js";
+import "./chunk-T2EUWCJE.js";
+import "./chunk-T6AGUTZJ.js";
+import "./chunk-XT6MXC7A.js";
+import "./chunk-W2LGJSEN.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/history.ts
+import { spawnSync } from "child_process";
+import {
+  closeSync,
+  fstatSync,
+  mkdirSync,
+  mkdtempSync,
+  openSync,
+  readSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { tmpdir } from "os";
+import { dirname, join } from "path";
+var examples = [
+  [
+    "What changed since your last turn, and who changed it",
+    "framey history --since mine --who claude"
+  ],
+  ["Label your writes as one entry", "framey history begin --who claude --label 'Bigger title'"],
+  ["Undo your newest entry after a failed check", "framey history undo --who claude"]
+];
+var YOU = { kind: "person", name: "You" };
+var withOwner2 = (action, dir, task) => withOwner(dir, (owner, turn, projectDir) => {
+  trackHistoryAction({ action, via: owner.via });
+  return task(owner, turn, projectDir);
+});
+var withReader2 = (action, dir, task) => withReader(dir, (reader) => {
+  trackHistoryAction({ action, via: reader.via });
+  return task(reader);
+});
+var whoOf = (name) => name ? { kind: "agent", name } : YOU;
+var short = (id) => id.slice(0, 8);
+function lastIndex(items, match) {
+  for (let index = items.length - 1; index >= 0; index -= 1) if (match(items[index])) return index;
+  return -1;
+}
+async function latestWrite(owner, turn) {
+  const entries = await owner.list();
+  return entries.reduce((latest, entry) => {
+    const same = entry.id === turn.id || turn.parts.includes(entry.id) || entry.who.kind === turn.who.kind && entry.who.name === turn.who.name && entry.label === turn.label && entry.startedAt === turn.startedAt;
+    return same ? Math.max(latest, entry.endedAt) : latest;
+  }, turn.lastWriteAt);
+}
+async function releaseOpenTurn(owner, turn, who, exclusive, projectDir) {
+  if (!turn) return;
+  if (owner.via !== "direct") {
+    if (!exclusive || turn.who.name === who.name) await endTurn(owner, turn, projectDir);
+    return;
+  }
+  const latest = await latestWrite(owner, turn);
+  const live = historyDeps.now() - latest <= historyDeps.turnIdleMs;
+  if (exclusive && live && turn.who.name !== who.name)
+    throw new Refusal(`${turn.who.name}'s turn is open; it has to end before yours begins`);
+  await endTurn(owner, turn, projectDir);
+}
+function entryOf(entries, ref) {
+  const found = entries.filter((entry) => entry.id.startsWith(ref));
+  if (found.length === 1) return found[0];
+  throw new Refusal(
+    found.length ? `"${ref}" matches ${found.length} entries` : `No entry "${ref}" in this history`
+  );
+}
+function timeOf(entries, ref) {
+  if (!/^\d{4}-\d\d-\d\d(T.+)?$/.test(ref) || entries.some((entry) => entry.id.startsWith(ref)))
+    return null;
+  const time = Date.parse(ref.includes("T") ? ref : `${ref}T00:00`);
+  const [year, month, date] = ref.slice(0, 10).split("-").map(Number);
+  const day = new Date(Date.UTC(year, month - 1, date));
+  if (Number.isNaN(time) || day.getUTCMonth() !== month - 1 || day.getUTCDate() !== date)
+    throw new Refusal(`"${ref}" is not a date`);
+  return time;
+}
+function pointOf(entries, ref) {
+  if (ref === START) return ref;
+  const time = timeOf(entries, ref);
+  if (time === null) return entryOf(entries, ref).id;
+  return entries[lastIndex(entries, (entry) => entry.endedAt <= time)]?.id ?? START;
+}
+function since(entries, ref, who) {
+  if (ref === "mine")
+    return entries.slice(lastIndex(entries, (entry) => entry.who.name === who.name) + 1);
+  const time = timeOf(entries, ref);
+  if (time !== null) return entries.filter((entry) => entry.endedAt > time);
+  return entries.slice(entries.indexOf(entryOf(entries, ref)) + 1);
+}
+function ago(at) {
+  const seconds = Math.max(0, Math.round((historyDeps.now() - at) / 1e3));
+  if (seconds < 60) return `${seconds}s ago`;
+  if (seconds < 3600) return `${Math.round(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.round(seconds / 3600)}h ago`;
+  return `${Math.round(seconds / 86400)}d ago`;
+}
+function endedTurnText(entry, parts) {
+  const earlier = parts.length - (entry ? 1 : 0);
+  const text = entry ? line(entry) : earlier ? "Nothing changed since this turn's last command." : "Nothing changed in this turn.";
+  return earlier ? `${text}
+(+${earlier} earlier part${earlier > 1 ? "s" : ""})` : text;
+}
+function line(entry) {
+  const paths = entry.files.map((file) => file.path);
+  const files = paths.slice(0, 2).join(", ") + (paths.length > 2 ? ` +${paths.length - 2}` : "");
+  const flags = "undone" in entry ? `${entry.undone ? " [undone]" : ""}${entry.pinned ? " [pinned]" : ""}` : "";
+  return `${short(entry.id)}  ${ago(entry.endedAt)}  ${entry.who.name}  ${entry.label}  (${files})${flags}`;
+}
+var publicEntry = (entry) => ({
+  id: entry.id,
+  who: entry.who,
+  label: entry.label,
+  startedAt: entry.startedAt,
+  endedAt: entry.endedAt,
+  files: entry.files.map((file) => file.path),
+  undone: entry.undone ?? false,
+  pinned: entry.pinned ?? false
+});
+var changeOf = (file) => file.before === null ? "added" : file.after === null ? "deleted" : "modified";
+function print(json, data, text) {
+  console.log(json ? JSON.stringify(withMeta(data), null, 2) : text);
+}
+async function textDiff(reader, entry) {
+  const work = mkdtempSync(join(tmpdir(), "hf-history-diff-"));
+  try {
+    const out = [];
+    for (const file of entry.files) {
+      const sides = await Promise.all(
+        [file.before, file.after].map((hash) => hash ? reader.blob(hash) : Buffer.alloc(0))
+      );
+      if (sides.some((bytes) => bytes.subarray(0, 8e3).includes(0))) {
+        out.push(`Binary ${file.path} changed`);
+        continue;
+      }
+      const [a, b] = ["a", "b"].map((side, index) => {
+        const path = join(side, file.path);
+        mkdirSync(dirname(join(work, path)), { recursive: true });
+        writeFileSync(join(work, path), sides[index]);
+        return path;
+      });
+      const outputPath = join(work, "diff");
+      const outputFd = openSync(outputPath, "w+", 384);
+      try {
+        const diff = spawnSync("git", ["diff", "--no-index", "--no-color", "--no-prefix", a, b], {
+          cwd: work,
+          encoding: "utf-8",
+          stdio: ["ignore", outputFd, "pipe"]
+        });
+        if (diff.error) throw new Refusal("--diff needs git on PATH");
+        const output = Buffer.alloc(fstatSync(outputFd).size);
+        let offset = 0;
+        while (offset < output.length) {
+          const count = readSync(outputFd, output, offset, output.length - offset, offset);
+          if (count === 0) break;
+          offset += count;
+        }
+        out.push(output.subarray(0, offset).toString("utf-8").trimEnd());
+      } finally {
+        closeSync(outputFd);
+      }
+    }
+    return out.join("\n");
+  } finally {
+    rmSync(work, { recursive: true, force: true });
+  }
+}
+function conflictText(entry, newer, files, again) {
+  return [
+    `${files.join(", ")} changed since "${entry.label}". Newer entries:`,
+    ...newer.map((later) => `  ${line(later)}`),
+    `Choose one:`,
+    `  framey history ${again} --just-this       put back only its files, over the newer edits to them`,
+    `  framey history ${again} --back-to-before  go back to before it, undoing the newer entries too`
+  ].join("\n");
+}
+function turnTargets(entries, who, dir) {
+  const inEffect = (entry) => !entry.undone && !entry.undoes;
+  const parts = lastTurnParts(dir, who.name);
+  const newest = entries[lastIndex(entries, (e) => e.who.name === who.name && inEffect(e))];
+  const targets = parts ? entries.filter((entry) => parts.includes(entry.id) && inEffect(entry)).reverse() : newest ? [newest] : [];
+  if (!targets.length)
+    throw new Refusal(
+      parts ? `${who.name}'s last turn has no change still in effect; undo an older entry by its id` : `${who.name} has no entry still in effect`
+    );
+  return targets;
+}
+async function undoWhole(owner, targets, who, mode) {
+  const undid = [];
+  for (const target of targets) {
+    const result = await owner.undo(target.id, who, mode);
+    if (!result.ok) {
+      for (const done of undid.reverse()) await owner.undo(done.undo.id, who);
+      return { undid: [], refused: { target, result } };
+    }
+    if (result.entry) undid.push({ target, undo: result.entry });
+  }
+  return { undid };
+}
+async function runUndo(args) {
+  const mode = args.justThis ? "just-this" : args.backToBefore ? "back-to-before" : void 0;
+  await withOwner2("undo", args.dir, async (owner, turn, projectDir) => {
+    const who = whoOf(args.who);
+    if (turn?.who.name === who.name) await endTurn(owner, turn, projectDir);
+    const entries = await owner.list();
+    const targets = args.ref ? [entryOf(entries, args.ref)] : turnTargets(entries, who, projectDir);
+    const { undid, refused } = await undoWhole(owner, targets, who, mode);
+    if (refused) {
+      const { target, result } = refused;
+      setCommandExitCode(2);
+      const now = await owner.list();
+      const newer = result.conflict.newer.map((id) => entryOf(now, id));
+      const again = args.ref ? `undo ${short(target.id)}` : `undo --who ${who.name}`;
+      return print(args.json, result, conflictText(target, newer, result.conflict.files, again));
+    }
+    print(
+      args.json,
+      {
+        ok: true,
+        entry: undid[0] ? publicEntry(undid[0].undo) : null,
+        entries: undid.map((done) => publicEntry(done.undo))
+      },
+      undid.map((done) => `Undid ${short(done.target.id)}: ${line(done.undo)}`).join("\n") || "Nothing to undo."
+    );
+  });
+}
+function guarded(run) {
+  return async (args) => {
+    try {
+      await run(args);
+    } catch (error) {
+      const refused = error instanceof Refusal || error instanceof AmbiguousPreviewServerError || error instanceof HistoryBusyError || error instanceof HistoryIdError || error instanceof HistoryRefusedError;
+      if (!refused) throw error;
+      setCommandExitCode(2);
+      const message = error instanceof HistoryBusyError ? `This project is open in another app (pid ${error.pid}), which keeps its history: undo, restore or pin there.` : error.message;
+      if (args.json) print(true, { ok: false, error: message }, message);
+      else console.error(message);
+    }
+  };
+}
+var common = {
+  dir: { type: "string", description: "Project directory (default: current)" },
+  json: { type: "boolean", description: "Output as JSON", default: false }
+};
+var sub = (name, description, args, run) => defineCommand({
+  meta: { name, description },
+  args: { ...common, ...args },
+  run: ({ args: parsed }) => guarded(run)(parsed)
+});
+var listEntries = async (args) => {
+  if (args._?.[0]) return;
+  await withReader2("list", args.dir, async (reader) => {
+    const all = await reader.list();
+    const picked = args.since ? since(all, args.since, whoOf(args.who)) : all;
+    const limit = Number(args.limit ?? 20);
+    if (!Number.isInteger(limit) || limit < 1)
+      throw new Refusal("--limit takes a whole number above 0");
+    const shown = picked.slice(-limit).reverse();
+    const more = picked.length - shown.length;
+    const text = shown.map(line).join("\n") || "No changes recorded.";
+    print(
+      args.json,
+      { entries: shown.map(publicEntry) },
+      more ? `${text}
+(${more} older; --limit)` : text
+    );
+  });
+};
+var history_default = defineCommand({
+  meta: { name: "history", description: "List, undo and restore the project's recorded changes" },
+  args: {
+    ...common,
+    since: { type: "string", description: "Only entries after an entry id, a time, or 'mine'" },
+    who: { type: "string", description: "Your name, for --since mine" },
+    limit: { type: "string", description: "Newest entries to show (default 20)" }
+  },
+  subCommands: {
+    show: () => sub(
+      "show",
+      "One entry's files, before and after",
+      { ref: { type: "positional", required: true }, diff: { type: "boolean", default: false } },
+      (args) => withReader2("show", args.dir, async (reader) => {
+        const entry = entryOf(await reader.list(), args.ref);
+        const changes = entry.files.map((file) => ({
+          path: file.path,
+          change: changeOf(file)
+        }));
+        const diff = args.diff ? await textDiff(reader, entry) : void 0;
+        const marks = changes.map((file) => `  ${file.change[0].toUpperCase()} ${file.path}`);
+        print(
+          args.json,
+          { entry: publicEntry(entry), changes, ...diff !== void 0 && { diff } },
+          `${line(entry)}
+${diff ?? marks.join("\n")}`
+        );
+      })
+    ),
+    undo: () => sub(
+      "undo",
+      "Undo an entry (default: your newest one still in effect)",
+      {
+        ref: { type: "positional", required: false },
+        who: { type: "string", description: "Your name" },
+        "just-this": { type: "boolean", default: false },
+        "back-to-before": { type: "boolean", default: false }
+      },
+      runUndo
+    ),
+    restore: () => sub(
+      "restore",
+      "Make the files what they were right after an entry, a time, or 'start'",
+      { ref: { type: "positional", required: true }, who: { type: "string" } },
+      (args) => withOwner2("restore", args.dir, async (owner) => {
+        const entry = await owner.restore(
+          pointOf(await owner.list(), args.ref),
+          whoOf(args.who)
+        );
+        print(
+          args.json,
+          { entry: entry && publicEntry(entry) },
+          entry ? `Restored: ${line(entry)}` : "Already there."
+        );
+      })
+    ),
+    peek: () => sub(
+      "peek",
+      "The files at an entry, a time, or 'start' (read-only); with a path, that file",
+      {
+        ref: { type: "positional", required: true },
+        path: { type: "positional", required: false }
+      },
+      (args) => withReader2("peek", args.dir, async (reader) => {
+        const files = await reader.peek(pointOf(await reader.list(), args.ref));
+        if (!files) throw new Refusal("That point is no longer kept");
+        if (!args.path) return print(args.json, { files }, Object.keys(files).join("\n"));
+        const hash = files[args.path];
+        if (!hash) throw new Refusal(`${args.path} did not exist then`);
+        process.stdout.write(await reader.blob(hash));
+      })
+    ),
+    pin: () => sub(
+      "pin",
+      "Keep an entry (and what it needs) when old history is trimmed",
+      { ref: { type: "positional", required: true }, off: { type: "boolean", default: false } },
+      (args) => withOwner2("pin", args.dir, async (owner) => {
+        const entry = entryOf(await owner.list(), args.ref);
+        await owner.pin(entry.id, !args.off);
+        print(
+          args.json,
+          { id: entry.id, pinned: !args.off },
+          `${args.off ? "Unpinned" : "Pinned"} ${short(entry.id)}`
+        );
+      })
+    ),
+    begin: () => sub(
+      "begin",
+      "Start a turn: your writes until `end` become one entry under your name",
+      {
+        who: { type: "string", required: true },
+        label: { type: "string", required: true },
+        exclusive: {
+          type: "boolean",
+          default: false,
+          description: "Refuse while another agent's turn is open, instead of ending it"
+        }
+      },
+      (args) => withOwner2("begin", args.dir, async (owner, turn, projectDir) => {
+        const who = whoOf(args.who);
+        await releaseOpenTurn(owner, turn, who, args.exclusive, projectDir);
+        const { id, startedAt } = await owner.begin(
+          who,
+          args.label,
+          args.exclusive && owner.via === "preview"
+        );
+        writeTurn(projectDir, {
+          via: owner.via,
+          id,
+          who,
+          label: args.label,
+          startedAt,
+          lastWriteAt: startedAt,
+          parts: []
+        });
+        print(args.json, { entryId: id }, short(id));
+      })
+    ),
+    end: () => sub(
+      "end",
+      "End your turn and print its entry",
+      {
+        who: { type: "string", description: "Refuse unless the open turn is this agent's" },
+        "if-open": {
+          type: "boolean",
+          default: false,
+          description: "Succeed with no entry when no turn is open"
+        }
+      },
+      (args) => withOwner2("end", args.dir, async (owner, turn, projectDir) => {
+        if (!turn && args.ifOpen)
+          return print(args.json, { entry: null, parts: [] }, "No turn is open.");
+        if (!turn) throw new Refusal("No turn is open; start one with history begin");
+        if (args.who !== void 0 && turn.who.name !== args.who)
+          throw new Refusal(`The open turn is ${turn.who.name}'s, not ${args.who}'s`);
+        const { entry, parts } = await endTurn(owner, turn, projectDir);
+        print(
+          args.json,
+          { entry: entry && publicEntry(entry), parts },
+          endedTurnText(entry, parts)
+        );
+      })
+    )
+  },
+  run: ({ args }) => guarded(listEntries)(args)
+});
+export {
+  history_default as default,
+  examples
+};