@higgsfield/video-editor-mcp 1.0.7 → 1.1.1-dev.0

package/node_modules/@higgsfield/higgsedit/dist/chunk-2JYLVSVV.mjs

@@ -0,0 +1,1594 @@
+#!/usr/bin/env node
+import { createRequire as __higgseditRequire } from "node:module";
+import { fileURLToPath as __higgseditPath } from "node:url";
+const require = __higgseditRequire(import.meta.url);
+const __filename = __higgseditPath(import.meta.url);
+const __dirname = __filename.slice(0, __filename.lastIndexOf("/"));
+import {
+  api,
+  openCapture,
+  render
+} from "./chunk-NARTAWRN.mjs";
+import {
+  addPreset,
+  presetCatalogue,
+  presetsDir,
+  readManifest
+} from "./chunk-YLVXQIPX.mjs";
+import {
+  analyze,
+  applyEdits
+} from "./chunk-MV2JTTBQ.mjs";
+import {
+  MEDIA_UPLOAD_TEMP_PREFIX,
+  MediaUploads,
+  PACKAGED,
+  json,
+  listMediaFiles,
+  packagedAsset,
+  pageBundle,
+  readBody,
+  sendFile,
+  startServer
+} from "./chunk-7PYXSJS7.mjs";
+import "./chunk-UDL5AHKO.mjs";
+import {
+  fontFiles,
+  inside,
+  readSources,
+  rel,
+  sourceFiles
+} from "./chunk-LTKMGZ6T.mjs";
+import {
+  CHROME_VERSION
+} from "./chunk-P2BGHTRR.mjs";
+import {
+  SelectError,
+  parsePrompt,
+  requireSelectBackend,
+  select,
+  track
+} from "./chunk-WENFTPXQ.mjs";
+import "./chunk-QJTILFBS.mjs";
+import {
+  ffmpeg,
+  requireTool
+} from "./chunk-PAHMD6SU.mjs";
+import "./chunk-NUXTKQNM.mjs";
+import "./chunk-2VKQHJMM.mjs";
+import "./chunk-BV5COOQZ.mjs";
+import {
+  parseTime
+} from "./chunk-F7YUKEI5.mjs";
+import "./chunk-MCVD2ZQV.mjs";
+import "./chunk-75WO2NOF.mjs";
+
+// src/dev.ts
+import { existsSync as existsSync4, linkSync, lstatSync as lstatSync2, mkdirSync as mkdirSync4, mkdtempSync, readdirSync as readdirSync3, readFileSync as readFileSync4, renameSync as renameSync4, rmSync as rmSync3, statSync as statSync4, watch } from "node:fs";
+import { basename, extname, join as join5 } from "node:path";
+
+// src/editor-build.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+var EDITOR = join(import.meta.dirname, "../../editor");
+var EDITOR_DIST = PACKAGED ? join(import.meta.dirname, "editor") : join(EDITOR, "dist");
+var EDITOR_MANIFEST = "editor/.vite/manifest.json";
+var MANIFEST = join(EDITOR_DIST, ".vite/manifest.json");
+function newest(dir) {
+  let t = 0;
+  for (const e of readdirSync(dir, { withFileTypes: true })) {
+    const p = join(dir, e.name);
+    t = Math.max(t, e.isDirectory() ? newest(p) : statSync(p).mtimeMs);
+  }
+  return t;
+}
+var PACKAGES = ["editor-document", "editor-kernel", "encoder", "jsx", "reconciler", "runtime", "writeback", "ui-kit", "mcp-app", "mcp-ui-resources"];
+var inputs = () => [join(EDITOR, "src"), ...PACKAGES.map((p) => join(EDITOR, `../../packages/${p}/src`))].filter((dir) => existsSync(dir));
+var MissingEditorError = class extends Error {
+  constructor() {
+    super("this higgsedit build has no editor page: install the plugin build, or run `higgsedit dev` from a checkout");
+  }
+};
+var building;
+async function editorEntry(log = () => {
+}) {
+  if (PACKAGED) {
+    const manifest = packagedAsset(EDITOR_MANIFEST);
+    if (!existsSync(manifest)) throw new MissingEditorError();
+    return manifestEntry(readFileSync(manifest, "utf8"));
+  }
+  const stale = !existsSync(MANIFEST) || inputs().some((dir) => newest(dir) > statSync(MANIFEST).mtimeMs);
+  if (stale) {
+    building ??= (async () => {
+      log("building the editor page\u2026");
+      const t0 = performance.now();
+      const { build } = await import("vite");
+      const env = process.env.NODE_ENV;
+      process.env.NODE_ENV = "production";
+      try {
+        await build({ configFile: join(EDITOR, "vite.config.ts"), logLevel: "error", mode: "production" });
+      } finally {
+        process.env.NODE_ENV = env;
+      }
+      log(`built the editor page in ${Math.round(performance.now() - t0)} ms`);
+    })().finally(() => {
+      building = void 0;
+    });
+    await building;
+  }
+  return manifestEntry(readFileSync(MANIFEST, "utf8"));
+}
+var editorFile = (rel2) => PACKAGED ? packagedAsset(`editor/${rel2}`) : join(EDITOR_DIST, rel2);
+function manifestEntry(text) {
+  const manifest = JSON.parse(text);
+  const entry = Object.values(manifest).find((m) => m.isEntry);
+  if (!entry) throw new Error("the editor manifest has no entry");
+  return { script: entry.file, styles: entry.css ?? [] };
+}
+
+// src/export-settings.ts
+var capabilities;
+var hasEncoder = (output, name) => new RegExp(`^\\s*[A-Z.]{6}\\s+${name}\\s`, "m").test(output);
+function nativeExportCapabilities() {
+  capabilities ??= new Promise((resolve, reject) => {
+    const child = ffmpeg(["-encoders"]);
+    let output = "";
+    const timeout = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error("native encoder inspection timed out"));
+    }, 15e3);
+    child.stdout.on("data", (chunk) => {
+      output += chunk.toString();
+    });
+    child.once("error", (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+    child.once("close", (code) => {
+      clearTimeout(timeout);
+      if (code !== 0) return reject(new Error("could not inspect native video encoders"));
+      const videoCodecs = [];
+      if (hasEncoder(output, "libx264")) videoCodecs.push("avc");
+      if (hasEncoder(output, "libx265")) videoCodecs.push("hevc");
+      resolve({
+        containers: videoCodecs.length ? ["mp4"] : [],
+        videoCodecs,
+        audioCodecs: hasEncoder(output, "aac") ? ["aac"] : [],
+        sampleRates: [44100, 48e3, 96e3],
+        audioOnly: false
+      });
+    });
+  }).catch((error) => {
+    capabilities = void 0;
+    throw error;
+  });
+  return capabilities;
+}
+function object(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${label} must be an object`);
+  return value;
+}
+function number(value, label, min, max, integer = false) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max || integer && !Number.isInteger(value))
+    throw new Error(
+      `${label} must be ${integer ? "an integer" : "a number"} between ${min} and ${max}`
+    );
+  return value;
+}
+function member(value, allowed, label) {
+  const match = allowed.find((item) => item === value);
+  if (match === void 0) throw new Error(`unsupported ${label}: ${String(value)}`);
+  return match;
+}
+function validateRenderRequest(input, supported) {
+  const body = object(input, "render request");
+  const out = {
+    depth: body.depth === void 0 ? 8 : member(body.depth, [8, 10], "bit depth"),
+    allowFontFallback: body.allowFontFallback === true
+  };
+  if (body.fileName !== void 0) {
+    if (typeof body.fileName !== "string" || !body.fileName.trim() || body.fileName.length > 180 || Array.from(body.fileName).some((char) => char.charCodeAt(0) < 32))
+      throw new Error("fileName must be a nonempty filename of at most 180 characters");
+    out.fileName = body.fileName;
+  }
+  if (body.sceneId !== void 0) {
+    if (typeof body.sceneId !== "string" || !body.sceneId || body.sceneId.length > 1024)
+      throw new Error("sceneId must be a nonempty scene identifier");
+    out.sceneId = body.sceneId;
+  }
+  for (const key of ["from", "to"]) {
+    const value = body[key];
+    if (value === void 0) continue;
+    if (typeof value !== "number" && typeof value !== "string" || typeof value === "string" && value.length > 64)
+      throw new Error(`${key} must be a nonnegative time`);
+    const time = parseTime(
+      typeof value === "string" && /^\d+(\.\d+)?$/.test(value) ? Number(value) : value,
+      30
+    );
+    if (time === void 0 || !Number.isFinite(time) || time < 0)
+      throw new Error(`${key} must be a nonnegative time`);
+    out[key] = String(value);
+  }
+  if (body.spec === void 0) return out;
+  const spec = object(body.spec, "spec"), video = object(spec.video, "spec.video (audio-only export is unavailable)");
+  const width = number(video.width, "video width", 2, 8192, true), height = number(video.height, "video height", 2, 8192, true);
+  if (width % 2 || height % 2 || width * height > 35389440)
+    throw new Error("video dimensions must be even and no larger than 8K");
+  const normalized = {
+    container: member(spec.container, supported.containers, "container"),
+    video: {
+      width,
+      height,
+      fps: number(video.fps, "video fps", 1, 120),
+      codec: member(video.codec, supported.videoCodecs, "video codec")
+    },
+    audio: null
+  };
+  if (video.bitrate !== void 0)
+    normalized.video.bitrate = number(video.bitrate, "video bitrate", 1e3, 1e9, true);
+  if (spec.audio !== null) {
+    const audio = object(spec.audio, "spec.audio");
+    normalized.audio = {
+      codec: member(audio.codec, supported.audioCodecs, "audio codec"),
+      sampleRate: member(audio.sampleRate, supported.sampleRates, "audio sample rate"),
+      channels: member(audio.channels, [1, 2], "audio channels")
+    };
+    if (audio.bitrate !== void 0)
+      normalized.audio.bitrate = number(audio.bitrate, "audio bitrate", 16e3, 1024e3, true);
+  }
+  out.depth = 8;
+  out.spec = normalized;
+  return out;
+}
+
+// src/history.ts
+import { randomUUID } from "node:crypto";
+import { closeSync, constants, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync as readFileSync2, readSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+var MAX_BYTES = 16 * 1024 * 1024;
+var MAX_ENTRIES = 100;
+var STALE = "edit history changed in another editor; reopen the project before editing or undoing";
+var message = (error) => error instanceof Error ? error.message : String(error);
+var missing = (error) => error instanceof Error && "code" in error && error.code === "ENOENT";
+var record = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var safePath = (path) => !/[\\\0]/.test(path) && path.split("/").every((part) => part !== "" && part !== "." && part !== ".." && part !== ".higgsedit-cache") && !/^[A-Za-z]:/.test(path);
+var identity = (stat) => `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+function encode(undo, redo, revision, text = (entry) => JSON.stringify(entryValue(entry))) {
+  return `{"version":1,"revision":${JSON.stringify(revision)},"undo":[${undo.map(text).join(",")}],"redo":[${redo.map(text).join(",")}]}`;
+}
+var entryValue = ({ name, files }) => ({ name, files: [...files].map(([path, texts]) => ({ path, ...texts })) });
+function decode(text) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return;
+  }
+  if (!record(value) || value.version !== 1 || typeof value.revision !== "string" || !Array.isArray(value.undo) || !Array.isArray(value.redo) || value.undo.length + value.redo.length > MAX_ENTRIES) return;
+  const entries = (stack) => {
+    const result = [];
+    for (const entry of stack) {
+      if (!record(entry) || typeof entry.name !== "string" || !Array.isArray(entry.files) || !entry.files.length) return;
+      const files = /* @__PURE__ */ new Map();
+      for (const file of entry.files) {
+        if (!record(file) || typeof file.path !== "string" || !safePath(file.path) || typeof file.before !== "string" || typeof file.after !== "string" || files.has(file.path)) return;
+        files.set(file.path, { before: file.before, after: file.after });
+      }
+      result.push({ name: entry.name, files });
+    }
+    return result;
+  };
+  const undo = entries(value.undo), redo = entries(value.redo);
+  return undo && redo ? { undo, redo } : void 0;
+}
+var EditHistory = class {
+  constructor(dir, onWrite, limits = {}) {
+    this.dir = dir;
+    this.onWrite = onWrite;
+    this.maxBytes = Math.min(MAX_BYTES, limits.maxBytes ?? MAX_BYTES);
+    this.maxEntries = Math.min(MAX_ENTRIES, limits.maxEntries ?? MAX_ENTRIES);
+    if (!Number.isSafeInteger(this.maxBytes) || this.maxBytes < 100 || !Number.isSafeInteger(this.maxEntries) || this.maxEntries < 1) throw new Error("invalid edit history limits");
+    try {
+      const saved = this.readJournal();
+      this.revision = saved.revision;
+      const parsed = saved.text === void 0 ? void 0 : decode(saved.text);
+      if (parsed) {
+        const bounded = this.bound(parsed.undo, parsed.redo);
+        this.undoStack = bounded.undo;
+        this.redoStack = bounded.redo;
+      }
+    } catch {
+    }
+  }
+  dir;
+  onWrite;
+  undoStack = [];
+  redoStack = [];
+  revision = "missing";
+  maxBytes;
+  maxEntries;
+  // Committed entries never change. Weak keys release evicted history and abandoned transactions.
+  encoded = /* @__PURE__ */ new WeakMap();
+  begin(name) {
+    if (typeof name !== "string") throw new Error("edit history name must be a string");
+    this.assertCurrent();
+    const entry = { name, files: /* @__PURE__ */ new Map() };
+    const previousWrites = /* @__PURE__ */ new Map();
+    const fileBytes = /* @__PURE__ */ new Map();
+    let entryBytes = Buffer.byteLength(encode([entry], [], randomUUID()));
+    let finished = false;
+    return {
+      onWrite: (path, text) => {
+        if (finished) throw new Error("edit history transaction already finished");
+        const prior = entry.files.get(path);
+        const current = this.readSource(path);
+        if (prior && current !== prior.after) throw new Error(`${path} changed outside the editor since ${entry.name}`);
+        const texts = { before: prior?.before ?? current, after: text };
+        const bytes = Buffer.byteLength(JSON.stringify({ path, ...texts }));
+        const nextBytes = entryBytes - (fileBytes.get(path) ?? 0) + bytes + (!prior && entry.files.size ? 1 : 0);
+        if (nextBytes > this.maxBytes) throw new Error(`edit history size limit exceeded (${this.maxBytes} bytes); split the edit or reduce the affected source files`);
+        entryBytes = nextBytes;
+        fileBytes.set(path, bytes);
+        previousWrites.set(path, current);
+        entry.files.set(path, texts);
+        this.encoded.delete(entry);
+        this.onWrite?.(path, text);
+      },
+      commit: () => {
+        if (finished) throw new Error("edit history transaction already finished");
+        if (entry.files.size) {
+          this.checkSources(entry, "after");
+          this.publish([...this.undoStack, entry], []);
+        }
+        finished = true;
+      },
+      rollback: () => {
+        if (finished) return;
+        this.restore(entry, "after", "before", previousWrites);
+        finished = true;
+      }
+    };
+  }
+  state() {
+    return {
+      canUndo: this.undoStack.length > 0,
+      canRedo: this.redoStack.length > 0,
+      undoName: this.undoStack.at(-1)?.name ?? null,
+      redoName: this.redoStack.at(-1)?.name ?? null
+    };
+  }
+  undo() {
+    return this.step(this.undoStack, this.redoStack, "after", "before");
+  }
+  redo() {
+    return this.step(this.redoStack, this.undoStack, "before", "after");
+  }
+  step(from, to, expect, write) {
+    const entry = from.at(-1);
+    if (!entry) return { ok: false, reason: `nothing to ${write === "before" ? "undo" : "redo"}` };
+    try {
+      this.assertCurrent();
+      this.checkSources(entry, expect);
+    } catch (error) {
+      return { ok: false, reason: message(error) };
+    }
+    try {
+      for (const [path, texts] of entry.files) this.write(path, texts[write]);
+      const remaining = from.slice(0, -1), moved = [...to, entry];
+      this.publish(write === "before" ? remaining : moved, write === "before" ? moved : remaining);
+    } catch (error) {
+      try {
+        this.restore(entry, write, expect);
+      } catch (rollbackError) {
+        return { ok: false, reason: `${message(error)}; rollback failed: ${message(rollbackError)}` };
+      }
+      return { ok: false, reason: message(error) };
+    }
+    return { ok: true, written: [...entry.files.keys()] };
+  }
+  checkSources(entry, expect) {
+    for (const [path, texts] of entry.files) {
+      if (this.readSource(path) !== texts[expect]) throw new Error(`${path} changed outside the editor since ${entry.name}`);
+    }
+  }
+  /** A failed write may still contain the original text. Never roll back someone else's version. */
+  restore(entry, expect, restore, previousWrites) {
+    const pending = [];
+    for (const [path, texts] of entry.files) {
+      const current = this.readSource(path);
+      if (current === texts[restore]) continue;
+      if (current !== texts[expect] && current !== previousWrites?.get(path)) throw new Error(`${path} changed outside the editor since ${entry.name}`);
+      pending.push([path, texts[restore]]);
+    }
+    for (const [path, text] of pending) this.write(path, text);
+  }
+  readSource(path) {
+    if (!safePath(path)) throw new Error("unsafe edit history source path");
+    let target = this.dir;
+    for (const part of path.split("/")) {
+      target = join2(target, part);
+      try {
+        if (lstatSync(target).isSymbolicLink()) throw new Error(`${path} is a symlink; cannot restore edit history`);
+      } catch (error) {
+        if (missing(error)) throw new Error(`${path} no longer exists`, { cause: error });
+        throw error;
+      }
+    }
+    return readFileSync2(target, "utf8");
+  }
+  write(path, text) {
+    const target = join2(this.dir, path);
+    this.onWrite?.(path, text);
+    this.atomicWrite(target, text, lstatSync(target).mode & 511);
+  }
+  cacheDir() {
+    const cache = join2(this.dir, ".higgsedit-cache");
+    try {
+      const stat = lstatSync(cache);
+      if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error("unsafe edit history cache directory");
+    } catch (error) {
+      if (!missing(error)) throw error;
+    }
+    return cache;
+  }
+  readJournal() {
+    const file = join2(this.cacheDir(), "history.json");
+    let fd;
+    try {
+      if (!lstatSync(file).isFile()) throw new Error("edit history journal is not a regular file");
+      fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    } catch (error) {
+      if (missing(error)) return { revision: "missing" };
+      throw new Error(`cannot read edit history: ${message(error)}`, { cause: error });
+    }
+    try {
+      const stat = fstatSync(fd, { bigint: true });
+      if (!stat.isFile()) throw new Error("edit history journal is not a regular file");
+      const revision = identity(stat);
+      if (stat.size > BigInt(this.maxBytes)) return { revision };
+      const bytes = Buffer.alloc(Number(stat.size) + 1);
+      let length = 0, count = 0;
+      do {
+        count = readSync(fd, bytes, length, bytes.length - length, null);
+        length += count;
+      } while (count && length < bytes.length);
+      if (BigInt(length) !== stat.size || identity(fstatSync(fd, { bigint: true })) !== revision) throw new Error("edit history changed while reading");
+      const data = bytes.subarray(0, length);
+      return { revision, text: data.toString("utf8") };
+    } finally {
+      closeSync(fd);
+    }
+  }
+  assertCurrent() {
+    let revision;
+    try {
+      const stat = lstatSync(join2(this.cacheDir(), "history.json"), { bigint: true });
+      if (!stat.isFile()) throw new Error("edit history journal is not a regular file");
+      revision = identity(stat);
+    } catch (error) {
+      if (!missing(error)) throw error;
+      revision = "missing";
+    }
+    if (revision !== this.revision) throw new Error(STALE);
+  }
+  serialized(entry) {
+    let saved = this.encoded.get(entry);
+    if (!saved) {
+      const text = JSON.stringify(entryValue(entry));
+      saved = { text, bytes: Buffer.byteLength(text) };
+      this.encoded.set(entry, saved);
+    }
+    return saved;
+  }
+  bound(undo, redo) {
+    const revision = randomUUID();
+    const sized = (stack) => stack.map((entry) => ({ entry, bytes: this.serialized(entry).bytes }));
+    const keepUndo = sized(undo), keepRedo = sized(redo);
+    let bytes = Buffer.byteLength(encode([], [], revision)) + [...keepUndo, ...keepRedo].reduce((sum, entry) => sum + entry.bytes, 0);
+    const separators = () => Math.max(0, keepUndo.length - 1) + Math.max(0, keepRedo.length - 1);
+    while (keepUndo.length + keepRedo.length > this.maxEntries || bytes + separators() > this.maxBytes) {
+      const removed = keepUndo.length > 1 || !keepRedo.length ? keepUndo.shift() : keepRedo.shift();
+      if (!removed) throw new Error("edit history size limit exceeded");
+      bytes -= removed.bytes;
+    }
+    undo = keepUndo.map(({ entry }) => entry);
+    redo = keepRedo.map(({ entry }) => entry);
+    return { undo, redo, text: encode(undo, redo, revision, (entry) => this.serialized(entry).text) };
+  }
+  publish(undo, redo) {
+    const next = this.bound(undo, redo);
+    this.assertCurrent();
+    const cache = this.cacheDir();
+    mkdirSync(cache, { recursive: true, mode: 448 });
+    const target = join2(cache, "history.json");
+    try {
+      this.revision = this.atomicWrite(target, next.text, 384);
+    } catch (error) {
+      throw new Error(`cannot save edit history: ${message(error)}`, { cause: error });
+    }
+    this.undoStack = next.undo;
+    this.redoStack = next.redo;
+  }
+  atomicWrite(target, text, mode) {
+    const tmp = `${target}.higgsedit-${process.pid}-${randomUUID()}.tmp`;
+    let published = false;
+    let fd;
+    try {
+      fd = openSync(tmp, "wx", mode);
+      writeFileSync(fd, text);
+      fsyncSync(fd);
+      renameSync(tmp, target);
+      published = true;
+      return identity(fstatSync(fd, { bigint: true }));
+    } finally {
+      try {
+        if (fd !== void 0) closeSync(fd);
+      } finally {
+        if (!published) {
+          try {
+            unlinkSync(tmp);
+          } catch {
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/prerender.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync as readdirSync2, renameSync as renameSync2, rmSync, statSync as statSync2, utimesSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { once } from "node:events";
+import { join as join3, posix } from "node:path";
+var PRERENDER_DIR = ".higgsedit/prerender";
+var DEFAULT_CAP_MB = 1024;
+var GOP_SECONDS = 0.5;
+var CLIENT_TTL_MS = 5 * 6e4;
+var PROGRESS_MS = 250;
+var IDLE_MS = 6e4;
+var OUTRUN = "the sources changed since the editor asked";
+var sha = (text) => createHash("sha256").update(text).digest("hex");
+var even = (n) => Math.max(2, Math.round(n / 2) * 2);
+function glob(pattern) {
+  return new RegExp(`^${pattern.split("*").map((s) => s.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join("[^/]*")}$`);
+}
+var Prerenderer = class {
+  constructor(dir, onEvent = () => {
+  }, log = () => {
+  }, opts = {}) {
+    this.dir = dir;
+    this.onEvent = onEvent;
+    this.log = log;
+    this.root = join3(dir, PRERENDER_DIR);
+    this.capBytes = (opts.capMb ?? Number(process.env.HIGGSEDIT_PRERENDER_MB ?? DEFAULT_CAP_MB)) * 1024 * 1024;
+  }
+  dir;
+  onEvent;
+  log;
+  root;
+  wanted = [];
+  /** Each editor's last wish list, by the id it sends. */
+  clients = /* @__PURE__ */ new Map();
+  playhead = 0;
+  status = /* @__PURE__ */ new Map();
+  current;
+  running = false;
+  capture;
+  loadedSources;
+  idle;
+  stopped = false;
+  renderer;
+  capBytes;
+  /** What the picture is drawn by: the capture page's code and the pinned Chrome. */
+  rendererId() {
+    this.renderer ??= pageBundle("capture-page").then((code) => sha(`${CHROME_VERSION}
+${code}`));
+    return this.renderer;
+  }
+  /** Size and mtime of every project file `patterns` name (`*` within one path segment), and of the project's fonts. */
+  hostPart(patterns) {
+    const lines = [];
+    for (const pattern of patterns) {
+      const rel2 = posix.normalize(pattern.replace(/^\/+/, ""));
+      if (rel2.startsWith("..")) continue;
+      const files = rel2.includes("*") ? this.expand(rel2) : [rel2];
+      for (const f of files) {
+        try {
+          const st = statSync2(join3(this.dir, f));
+          if (st.isFile()) lines.push(`${f} ${st.size} ${st.mtimeMs}`);
+        } catch {
+          lines.push(`${f} -`);
+        }
+      }
+    }
+    for (const f of fontFiles(this.dir)) {
+      const st = statSync2(join3(this.dir, f));
+      lines.push(`font ${f} ${st.size} ${st.mtimeMs}`);
+    }
+    return lines.join("\n");
+  }
+  expand(pattern) {
+    const dir = posix.dirname(pattern);
+    if (dir.includes("*")) return [];
+    const re = glob(posix.basename(pattern));
+    try {
+      return readdirSync2(join3(this.dir, dir)).filter((n) => re.test(n)).map((n) => posix.join(dir, n)).toSorted();
+    } catch {
+      return [];
+    }
+  }
+  /** The cache id of `target` at its size. */
+  async idOf(target) {
+    return sha(`${target.digest}
+${this.hostPart(target.media)}
+${await this.rendererId()}
+${target.size}`).slice(0, 32);
+  }
+  entry(id) {
+    try {
+      return JSON.parse(readFileSync3(join3(this.root, `${id}.json`), "utf8"));
+    } catch {
+      return void 0;
+    }
+  }
+  /** The cache file `name` (`<id>.mp4`, …) if it exists; marks it used. */
+  lookup(name) {
+    if (!/^[0-9a-f]{32}(\.matte)?\.(mp4|json)$/.test(name)) return void 0;
+    const file = join3(this.root, name);
+    if (!existsSync2(file)) return void 0;
+    const meta = join3(this.root, `${name.slice(0, 32)}.json`);
+    const now = /* @__PURE__ */ new Date();
+    try {
+      utimesSync(meta, now, now);
+    } catch {
+    }
+    return file;
+  }
+  /**
+   * One editor's current wish list (`client` names the editor: two tabs on one project each keep theirs): what each
+   * target's state is now. Targets no editor wants any more leave the queue and a render of one is cancelled; the
+   * rest render nearest the latest `playhead` (root seconds) first.
+   */
+  async request(targets, playhead = 0, client = "") {
+    const ids = await Promise.all(targets.map((t) => this.idOf(t)));
+    const now = Date.now();
+    this.clients.set(client, { targets: targets.map((t, i) => ({ ...t, id: ids[i] })), at: now });
+    for (const [c, w] of this.clients) if (now - w.at > CLIENT_TTL_MS && c !== client) this.clients.delete(c);
+    const wanted = /* @__PURE__ */ new Map();
+    for (const w of this.clients.values()) for (const t of w.targets) wanted.set(t.id, t);
+    this.wanted = [...wanted.values()];
+    this.playhead = playhead;
+    if (process.env.HIGGSEDIT_PRERENDER_DEBUG) this.log(`prerender request ${client}: ${targets.map((t, i) => `${t.key}=${ids[i].slice(0, 8)}@${t.size}`).join(", ") || "(none)"}`);
+    if (this.current && !wanted.has(this.current.id)) {
+      this.log(`prerender: cancelled ${this.current.id.slice(0, 8)} (no longer wanted)`);
+      this.current.abort.abort();
+    }
+    for (const id of this.status.keys()) if (!wanted.has(id) && this.current?.id !== id) this.status.delete(id);
+    const out = targets.map((t, i) => this.statusOf(t, ids[i]));
+    for (const t of this.wanted) this.statusOf(t, t.id);
+    this.kick();
+    return out;
+  }
+  statusOf(t, id) {
+    const known = this.status.get(id);
+    if (known && known.state !== "queued" && !(known.state === "failed" && known.error === OUTRUN)) return known;
+    const entry = this.entry(id);
+    const s = entry ? { node: t.key, id, state: entry.inexact ? "inexact" : "ready", done: entry.frames, total: entry.frames } : { node: t.key, id, state: "queued", done: 0, total: t.frames };
+    if (entry) this.lookup(`${id}.json`);
+    this.status.set(id, s);
+    return s;
+  }
+  /** Statuses of what was last asked for. */
+  statuses() {
+    return [...this.status.values()];
+  }
+  next() {
+    const dist = (t) => {
+      const start = t.rootStart + t.offset;
+      const end = start + t.frames / t.fps;
+      return this.playhead < start ? start - this.playhead : this.playhead > end ? this.playhead - end : 0;
+    };
+    return this.wanted.filter((t) => this.status.get(t.id)?.state === "queued").toSorted((a, b) => dist(a) - dist(b))[0];
+  }
+  kick() {
+    if (this.running || this.stopped) return;
+    this.running = true;
+    void this.loop().finally(() => {
+      this.running = false;
+    });
+  }
+  async loop() {
+    for (let job = this.next(); job && !this.stopped; job = this.next()) {
+      if (this.idle) clearTimeout(this.idle);
+      const abort = new AbortController();
+      this.current = { id: job.id, abort };
+      const s = this.status.get(job.id);
+      s.state = "rendering";
+      this.onEvent({ ...s });
+      try {
+        const entry = await this.render(job, abort.signal, (done) => {
+          s.done = done;
+        });
+        s.state = entry.inexact ? "inexact" : "ready";
+        s.done = s.total = entry.frames;
+        this.log(`prerender ${job.key}: ${entry.frames} frames ${entry.width}x${entry.height} in ${(entry.renderMs / 1e3).toFixed(1)} s, ${(entry.bytes / 1e6).toFixed(1)} MB${entry.inexact ? " (inexact: blend over transparency)" : ""}`);
+        this.evict();
+      } catch (error) {
+        const message2 = error instanceof Error ? error.message : String(error);
+        if (abort.signal.aborted) this.status.delete(job.id);
+        else {
+          s.state = "failed";
+          s.error = message2;
+          this.log(`prerender ${job.key}: ${message2}`);
+        }
+      } finally {
+        this.current = void 0;
+      }
+      if (this.status.has(job.id)) this.onEvent({ ...s });
+    }
+    this.idle = setTimeout(() => void this.closeCapture(), IDLE_MS);
+  }
+  async session() {
+    this.capture ??= openCapture(this.dir, 8);
+    const session = await this.capture;
+    const sources = JSON.stringify(readSources(this.dir)) + JSON.stringify(fontFiles(this.dir));
+    if (this.loadedSources === void 0) this.loadedSources = sources;
+    else if (this.loadedSources !== sources) {
+      await session.reload();
+      this.loadedSources = sources;
+    }
+    return session;
+  }
+  async closeCapture() {
+    const capture = this.capture;
+    this.capture = void 0;
+    this.loadedSources = void 0;
+    await (await capture?.catch(() => void 0))?.close();
+  }
+  async render(job, signal, progress) {
+    const started = performance.now();
+    const session = await this.session();
+    const page = pageApi(session.page);
+    const input = (await page.inputs()).find((i) => i.key === job.key);
+    if (!input) throw new Error(`${job.key} is not something to pre-render in the current sources`);
+    const id = await this.idOf({ ...input, size: job.size });
+    if (id !== job.id) throw new Error(OUTRUN);
+    const height = even(job.size);
+    const width = even(input.width * height / input.height);
+    mkdirSync2(this.root, { recursive: true });
+    const ignore = join3(this.root, "..", ".gitignore");
+    if (!existsSync2(ignore)) writeFileSync2(ignore, "*\n");
+    const colour = join3(this.root, `${id}.part.mp4`);
+    const matte = join3(this.root, `${id}.matte.part.mp4`);
+    const gop = String(Math.max(1, Math.round(input.fps * GOP_SECONDS)));
+    const tags = ["-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709"];
+    const encoder = ffmpeg(
+      [
+        "-y",
+        "-f",
+        "rawvideo",
+        "-pix_fmt",
+        "rgba",
+        "-s",
+        `${width}x${height}`,
+        "-framerate",
+        String(input.fps),
+        "-i",
+        "pipe:0",
+        "-filter_complex",
+        "[0:v]split[c][a];[c]scale=out_color_matrix=bt709:out_range=limited:flags=accurate_rnd+full_chroma_int,format=yuv420p,setparams=color_primaries=bt709:color_trc=bt709:colorspace=bt709:range=tv[v];[a]alphaextract,format=gray,scale=in_range=full:out_range=full,format=yuv420p[m]",
+        "-map",
+        "[v]",
+        "-c:v",
+        "libx264",
+        "-preset",
+        "veryfast",
+        "-crf",
+        "16",
+        "-bf",
+        "0",
+        "-g",
+        gop,
+        ...tags,
+        "-color_range",
+        "tv",
+        "-movflags",
+        "+faststart",
+        "-an",
+        colour,
+        "-map",
+        "[m]",
+        "-c:v",
+        "libx264",
+        "-preset",
+        "veryfast",
+        "-crf",
+        "4",
+        "-bf",
+        "0",
+        "-g",
+        gop,
+        ...tags,
+        "-color_range",
+        "pc",
+        "-movflags",
+        "+faststart",
+        "-an",
+        matte
+      ],
+      "pipe"
+    );
+    let stderr = "";
+    encoder.stderr.on("data", (d) => stderr += d.toString());
+    const exited = once(encoder, "close");
+    const stdin = encoder.stdin;
+    const bytes = width * height * 4;
+    const sink = session.sink(async (_n, body) => {
+      if (body.length !== bytes) throw new Error(`frame body is ${body.length} bytes, expected ${bytes}`);
+      if (!stdin.write(body)) await once(stdin, "drain");
+    });
+    let opaque = true;
+    let lastEvent = 0;
+    const s = this.status.get(job.id);
+    try {
+      for (let i = 0; i < input.frames; i++) {
+        if (signal.aborted || this.stopped) throw new Error("cancelled");
+        const r = await page.raw(job.key, input.firstFrame + i, height, `${sink}/${i}`);
+        opaque &&= r.opaque;
+        progress(i + 1);
+        if (s && performance.now() - lastEvent > PROGRESS_MS) {
+          lastEvent = performance.now();
+          this.onEvent({ ...s });
+        }
+      }
+      const misses = await api(session.page).fontMisses();
+      if (misses.length) throw new Error(`fonts did not load (${misses.map((m) => m.family).join(", ")}); not caching a fallback`);
+    } catch (error) {
+      stdin.destroy();
+      encoder.kill("SIGKILL");
+      await exited;
+      rmSync(colour, { force: true });
+      rmSync(matte, { force: true });
+      throw error;
+    }
+    stdin.end();
+    const [code] = await exited;
+    if (code !== 0) {
+      rmSync(colour, { force: true });
+      rmSync(matte, { force: true });
+      throw new Error(`ffmpeg exited with ${code}: ${stderr.trim()}`);
+    }
+    const inexact = input.blend && !opaque;
+    const entry = { node: job.key, width, height, fps: input.fps, frames: input.frames, offset: input.offset, opaque, inexact, renderMs: Math.round(performance.now() - started), bytes: 0 };
+    if (inexact) {
+      rmSync(colour, { force: true });
+      rmSync(matte, { force: true });
+    } else {
+      renameSync2(colour, join3(this.root, `${id}.mp4`));
+      if (opaque) rmSync(matte, { force: true });
+      else renameSync2(matte, join3(this.root, `${id}.matte.mp4`));
+      entry.bytes = statSync2(join3(this.root, `${id}.mp4`)).size + (opaque ? 0 : statSync2(join3(this.root, `${id}.matte.mp4`)).size);
+    }
+    writeFileSync2(join3(this.root, `${id}.json.part`), JSON.stringify(entry));
+    renameSync2(join3(this.root, `${id}.json.part`), join3(this.root, `${id}.json`));
+    return entry;
+  }
+  /** Drops the least recently used pictures until the folder fits its cap; never one the editor asked for last. */
+  evict() {
+    let names;
+    try {
+      names = readdirSync2(this.root);
+    } catch {
+      return;
+    }
+    const wanted = new Set(this.wanted.map((t) => t.id));
+    const groups = /* @__PURE__ */ new Map();
+    for (const n of names) {
+      const id = n.slice(0, 32);
+      if (!/^[0-9a-f]{32}/.test(id) || n.includes(".part")) continue;
+      const st = statSync2(join3(this.root, n));
+      const g = groups.get(id) ?? { size: 0, used: 0 };
+      g.size += st.size;
+      if (n.endsWith(".json")) g.used = st.mtimeMs;
+      groups.set(id, g);
+    }
+    let total = [...groups.values()].reduce((a, g) => a + g.size, 0);
+    for (const [id, g] of [...groups].toSorted((a, b) => a[1].used - b[1].used)) {
+      if (total <= this.capBytes) break;
+      if (wanted.has(id)) continue;
+      for (const ext of [".json", ".mp4", ".matte.mp4"]) rmSync(join3(this.root, `${id}${ext}`), { force: true });
+      total -= g.size;
+    }
+  }
+  async stop() {
+    this.stopped = true;
+    this.current?.abort.abort();
+    if (this.idle) clearTimeout(this.idle);
+    await this.closeCapture();
+  }
+  /** The inputs the capture page computes for the current sources (the CLI and tests stand in for the editor with these). */
+  async inputs() {
+    return pageApi((await this.session()).page).inputs();
+  }
+};
+var pageApi = (page) => ({
+  inputs: () => page.evaluate(() => globalThis.higgsedit.prerenderInputs()),
+  raw: (key, frame, height, url) => page.evaluate(({ key: key2, frame: frame2, height: height2, url: url2 }) => globalThis.higgsedit.prerenderRaw(key2, frame2, height2, url2), { key, frame, height, url })
+});
+
+// src/proxy.ts
+import { execFile } from "node:child_process";
+import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, renameSync as renameSync3, rmSync as rmSync2, statSync as statSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+var VIDEO = /\.(mp4|mov|m4v|mkv|webm)$/i;
+var SKIP = /(^|\/)(node_modules|\.git|\.higgsedit-cache|\.higgsedit|renders|dist)(\/|$)/;
+var LONG_SIDE = 1920;
+var DECODABLE = /* @__PURE__ */ new Set(["h264", "hevc", "vp9", "av1"]);
+var needsProxy = (p) => p.width * p.height > LONG_SIDE * 1088 || !DECODABLE.has(p.codec);
+var even2 = (n) => Math.max(2, Math.round(n / 2) * 2);
+var QUIET_MS = 400;
+var TRACKED_LIMIT = 1024;
+var Proxies = class {
+  constructor(dir, onReady, log = () => {
+  }) {
+    this.dir = dir;
+    this.onReady = onReady;
+    this.log = log;
+    this.root = join4(dir, ".higgsedit-cache", "proxies");
+  }
+  dir;
+  onReady;
+  log;
+  root;
+  // Recent actual preview requests bound both pending work and cached no-proxy decisions.
+  candidates = /* @__PURE__ */ new Map();
+  active;
+  timer;
+  abort = new AbortController();
+  current;
+  stopped = false;
+  version(rel2) {
+    try {
+      const st = statSync3(join4(this.dir, rel2));
+      if (!st.isFile()) return void 0;
+      return { key: createHash2("sha1").update(`${rel2}\0${st.size}\0${st.mtimeMs}\0${st.ctimeMs}\0${st.ino}`).digest("hex").slice(0, 20), mtime: st.mtimeMs };
+    } catch {
+      return void 0;
+    }
+  }
+  /** The finished proxy for a project-relative video path, if there is one. */
+  lookup(rel2) {
+    const key = this.version(rel2)?.key;
+    const file = key && join4(this.root, `${key}.mp4`);
+    return file && existsSync3(file) ? file : void 0;
+  }
+  /** Only /preview/ demand starts work; watcher events refresh previously requested footage. */
+  consider(rel2, requested = false) {
+    if (this.stopped || !VIDEO.test(rel2) || SKIP.test(rel2)) return;
+    const prior = this.candidates.get(rel2);
+    if (!requested && !prior) return;
+    const version = this.version(rel2);
+    if (!version) {
+      this.candidates.delete(rel2);
+      return;
+    }
+    const now = Date.now();
+    const candidate = prior?.key === version.key ? prior : { ...version, readyAt: now + Math.min(QUIET_MS, Math.max(0, QUIET_MS - (now - version.mtime))), done: existsSync3(join4(this.root, `${version.key}.mp4`)) };
+    if (requested && candidate.retryAt !== void 0 && now >= candidate.retryAt) {
+      candidate.done = false;
+      candidate.retryAt = void 0;
+    }
+    if (requested) this.candidates.delete(rel2);
+    this.candidates.set(rel2, candidate);
+    while (this.candidates.size > TRACKED_LIMIT) {
+      for (const path of this.candidates.keys()) {
+        if (path !== this.active) {
+          this.candidates.delete(path);
+          break;
+        }
+      }
+    }
+    this.schedule();
+  }
+  schedule() {
+    clearTimeout(this.timer);
+    this.timer = void 0;
+    if (this.stopped || this.active) return;
+    let next = Infinity;
+    for (const [rel2, candidate] of this.candidates) {
+      if (candidate.done) continue;
+      if (candidate.readyAt > Date.now()) {
+        next = Math.min(next, candidate.readyAt);
+        continue;
+      }
+      const version = this.version(rel2);
+      if (!version) {
+        this.candidates.delete(rel2);
+        continue;
+      }
+      if (version.key !== candidate.key) {
+        Object.assign(candidate, version, { readyAt: Date.now() + QUIET_MS });
+        next = Math.min(next, candidate.readyAt);
+        continue;
+      }
+      this.active = rel2;
+      void this.make(rel2, candidate.key).then(() => {
+        if (this.candidates.get(rel2)?.key === candidate.key) candidate.done = true;
+      }, (error) => {
+        if (this.stopped) return;
+        candidate.done = true;
+        candidate.retryAt = Date.now() + 5e3;
+        this.log(`proxy for ${rel2} failed: ${error instanceof Error ? error.message : String(error)}`);
+      }).finally(() => {
+        this.active = void 0;
+        this.consider(rel2);
+        this.schedule();
+      });
+      return;
+    }
+    if (Number.isFinite(next)) this.timer = setTimeout(() => this.schedule(), Math.max(0, next - Date.now()));
+  }
+  async make(rel2, key) {
+    const file = join4(this.dir, rel2);
+    if (this.lookup(rel2)) return;
+    const { stdout } = await run(requireTool("ffprobe"), ["-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height,codec_name,time_base", "-of", "json", file], { maxBuffer: 1 << 20, timeout: 3e4, signal: this.abort.signal });
+    if (this.stopped || this.version(rel2)?.key !== key) return;
+    const data = JSON.parse(stdout);
+    const stream = data?.streams?.[0];
+    if (!stream || typeof stream.width !== "number" || stream.width <= 0 || typeof stream.height !== "number" || stream.height <= 0 || typeof stream.codec_name !== "string") throw new Error("invalid video stream metadata");
+    const facts = { width: stream.width, height: stream.height, codec: stream.codec_name };
+    if (!needsProxy(facts)) return;
+    const timescale = Number(String(stream.time_base).split("/")[1]) || 9e4;
+    const scale = LONG_SIDE / Math.max(facts.width, facts.height);
+    const [w, h] = scale < 1 ? [even2(facts.width * scale), even2(facts.height * scale)] : [even2(facts.width), even2(facts.height)];
+    mkdirSync3(this.root, { recursive: true });
+    const out = join4(this.root, `${key}.mp4`);
+    const part = join4(this.root, `${key}.${randomUUID2()}.part.mp4`);
+    const t0 = performance.now();
+    this.log(`making a preview proxy for ${rel2} (${facts.width}\xD7${facts.height} \u2192 ${w}\xD7${h})\u2026`);
+    const args = ["-y", "-i", file, "-map", "0:v:0", "-map", "0:a:0?", "-vf", `scale=${w}:${h}`, "-c:v", "libx264", "-preset", "veryfast", "-crf", "20", "-bf", "0", "-g", "12", "-pix_fmt", "yuv420p"];
+    args.push("-fps_mode", "passthrough", "-video_track_timescale", String(timescale), "-c:a", "aac", "-b:a", "160k", "-movflags", "+faststart", part);
+    try {
+      await new Promise((resolve, reject) => {
+        const p = ffmpeg(args);
+        this.current = p;
+        let err = "";
+        p.stderr.on("data", (d) => {
+          err = (err + d.toString()).slice(-16384);
+        });
+        p.on("error", reject);
+        p.on("close", (code) => {
+          if (this.current === p) this.current = void 0;
+          if (code === 0) resolve();
+          else reject(new Error(err.trim() || `ffmpeg exited with ${code}`));
+        });
+      });
+      if (this.stopped || this.version(rel2)?.key !== key) return;
+      renameSync3(part, out);
+      this.log(`proxy for ${rel2} ready in ${((performance.now() - t0) / 1e3).toFixed(1)} s`);
+      this.onReady(`./${rel2}`);
+    } finally {
+      rmSync2(part, { force: true });
+    }
+  }
+  stop() {
+    this.stopped = true;
+    clearTimeout(this.timer);
+    this.candidates.clear();
+    this.abort.abort();
+    this.current?.kill("SIGKILL");
+  }
+};
+
+// src/dev.ts
+var escapeHtml = (s) => s.replace(/[&<>"]/g, (c) => `&#${c.charCodeAt(0)};`);
+var EDITOR_HTML = (name, entry) => `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="color-scheme" content="dark">
+<title>higgsedit \xB7 ${escapeHtml(name)}</title>
+${entry.styles.map((s) => `<link rel="stylesheet" href="/__higgsedit/editor/${s}">`).join("\n")}
+<script>window.higgseditProject = ${JSON.stringify({ name }).replace(/</g, "\\u003c")};</script>
+</head>
+<body>
+<div id="app"></div>
+<script type="module" src="/__higgsedit/editor/${entry.script}"></script>
+</body>
+</html>`;
+var seconds = (v, what) => {
+  if (v === void 0 || v === null) return void 0;
+  if (typeof v !== "number" || !(v >= 0)) throw new SelectError(`${what} must be source seconds, not ${JSON.stringify(v)}`, 400);
+  return v;
+};
+function selectRequest(dir, raw) {
+  let body;
+  try {
+    body = JSON.parse(raw || "{}");
+  } catch {
+    throw new SelectError("the body must be JSON", 400);
+  }
+  const src = typeof body.src === "string" ? body.src : "";
+  const file = inside(dir, src);
+  if (!file) throw new SelectError(`${src} is outside the project`, 403);
+  if (!src || !existsSync4(file)) throw new SelectError(`${src || "src"}: no such file in the project`, 404);
+  const pick = body.pick;
+  if (pick !== void 0 && pick !== null && !(Array.isArray(pick) && pick.length === 4 && pick.every((v) => typeof v === "number" && v >= 0 && v <= 1))) {
+    throw new SelectError("pick must be the object's box [x0, y0, x1, y1] in 0..1", 400);
+  }
+  const start = seconds(body.start, "start");
+  const end = seconds(body.end, "end");
+  return {
+    file,
+    stem: basename(file, extname(file)),
+    time: seconds(body.time, "time") ?? 0,
+    prompt: parsePrompt(body.prompt),
+    ...Array.isArray(pick) ? { pick } : {},
+    ...start !== void 0 ? { start } : {},
+    ...end !== void 0 ? { end } : {}
+  };
+}
+async function startDev(dir, port = 0, options = {}) {
+  const presets = presetsDir(options.presets);
+  const mediaUploads = new MediaUploads(dir, options.mediaUploads);
+  const clients = /* @__PURE__ */ new Set();
+  const known = /* @__PURE__ */ new Map();
+  for (const f of sourceFiles(dir)) known.set(f, readFileSync4(join5(dir, f), "utf8"));
+  const ownWrites = /* @__PURE__ */ new Map();
+  const history = new EditHistory(dir, (path, text) => ownWrites.set(path, text));
+  const broadcast = (event) => {
+    const data = `data: ${JSON.stringify(event)}
+
+`;
+    for (const c of clients) c.write(data);
+  };
+  let timer;
+  let firstSeen = 0;
+  const flush = () => {
+    timer = void 0;
+    const changed = [];
+    let origin = "external";
+    let mtime = 0;
+    let present;
+    try {
+      present = sourceFiles(dir);
+    } catch {
+      present = [];
+    }
+    for (const f of /* @__PURE__ */ new Set([...present, ...known.keys()])) {
+      let text;
+      try {
+        text = readFileSync4(join5(dir, f), "utf8");
+        mtime = Math.max(mtime, statSync4(join5(dir, f)).mtimeMs);
+      } catch {
+        text = void 0;
+      }
+      if (text === known.get(f)) continue;
+      if (text === void 0) known.delete(f);
+      else known.set(f, text);
+      if (ownWrites.get(f) === text) {
+        origin = "editor";
+        ownWrites.delete(f);
+      }
+      changed.push(f);
+    }
+    if (changed.length) broadcast({ type: "change", files: changed, origin, detectedAt: firstSeen, mtime, undo: history.state() });
+  };
+  const proxies = new Proxies(dir, (src) => broadcast({ type: "proxy", src }), (line) => console.log(line));
+  const prerender = new Prerenderer(dir, (status) => broadcast({ type: "prerender", ...status }), (line) => console.log(line));
+  const watcher = watch(dir, { recursive: true }, (_event, name) => {
+    const file = (name ?? "").split("\\").join("/");
+    if (/(^|\/)(node_modules|\.git|\.higgsedit-cache|\.higgsedit|renders)(\/|$)/.test(file)) return;
+    if (file.split("/").some((part) => part.startsWith(MEDIA_UPLOAD_TEMP_PREFIX))) return;
+    proxies.consider(file);
+    if (file === "media" || file.startsWith("media/")) return;
+    if (!timer) firstSeen = Date.now();
+    if (!timer) timer = setTimeout(flush, 15);
+  });
+  const jobs = /* @__PURE__ */ new Map();
+  let jobSeq = 0;
+  const tracks = /* @__PURE__ */ new Map();
+  let stopping = false;
+  let mutations = 0;
+  let stopped;
+  const busy = () => mediaUploads.busy || mutations > 0 || [...jobs.values()].some((job) => job.state === "running") || [...tracks.values()].some((job) => job.state.status === "running");
+  const server = await startServer(
+    dir,
+    [
+      (req, res, url) => {
+        if (stopping) {
+          res.setHeader("retry-after", "1");
+          json(res, 503, { error: "editor is stopping" });
+          return true;
+        }
+        if (url.pathname === "/api/idle-stop" && req.method === "POST") {
+          if (busy()) {
+            json(res, 409, { busy: true });
+            return true;
+          }
+          stopping = true;
+          res.once("finish", () => {
+            options.onIdleStop?.();
+            void stop();
+          });
+          json(res, 200, { stopping: true });
+          return true;
+        }
+        if (req.method !== "GET" && req.method !== "HEAD") {
+          mutations++;
+          let released = false;
+          const release = () => {
+            if (!released) {
+              released = true;
+              mutations--;
+            }
+          };
+          res.once("finish", release);
+          res.once("close", release);
+        }
+        return false;
+      },
+      (req, res, url) => mediaUploads.handle(req, res, url),
+      (req, res, url) => {
+        if (url.pathname !== "/api/activity" || req.method !== "GET") return false;
+        json(res, 200, { busy: busy() });
+        return true;
+      },
+      async (req, res, url) => {
+        if (url.pathname !== "/" && url.pathname !== "/index.html") return false;
+        let entry;
+        try {
+          entry = await editorEntry((line) => console.log(line));
+        } catch (error) {
+          if (!(error instanceof MissingEditorError)) throw error;
+          res.statusCode = 404;
+          res.end(error.message);
+          return true;
+        }
+        res.setHeader("content-type", "text/html; charset=utf-8");
+        res.setHeader("cache-control", "no-cache");
+        res.end(EDITOR_HTML(dir.split("/").at(-1) ?? "project", entry));
+        void req;
+        return true;
+      },
+      (req, res, url) => {
+        if (!url.pathname.startsWith("/__higgsedit/editor/")) return false;
+        const rel2 = decodeURIComponent(url.pathname.slice("/__higgsedit/editor/".length));
+        if (rel2.split("/").some((p) => p === ".." || p.startsWith("."))) {
+          res.statusCode = 403;
+          res.end();
+          return true;
+        }
+        sendFile(req, res, editorFile(rel2));
+        return true;
+      },
+      (req, res, url) => {
+        if (url.pathname !== "/api/events") return false;
+        res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" });
+        res.write(`data: ${JSON.stringify({ type: "hello" })}
+
+`);
+        clients.add(res);
+        req.on("close", () => clients.delete(res));
+        return true;
+      },
+      async (req, res, url) => {
+        if (url.pathname !== "/api/edit" || req.method !== "POST") return false;
+        const body = JSON.parse((await readBody(req)).toString());
+        const tx = history.begin(body.name ?? "Edit");
+        try {
+          const results = applyEdits(dir, body.edits, { onWrite: tx.onWrite, ...body.dryRun ? { dryRun: true } : {} });
+          if (results.every((r) => r.ok)) tx.commit();
+          else tx.rollback();
+          json(res, 200, { ok: results.every((r) => r.ok), results, undo: history.state() });
+        } catch (error) {
+          tx.rollback();
+          throw error;
+        }
+        return true;
+      },
+      (req, res, url) => {
+        if (url.pathname !== "/api/undo" && url.pathname !== "/api/redo" || req.method !== "POST") return false;
+        const r = url.pathname === "/api/undo" ? history.undo() : history.redo();
+        json(res, 200, { ...r, undo: history.state() });
+        return true;
+      },
+      async (req, res, url) => {
+        if (!url.pathname.startsWith("/api/render")) return false;
+        if (url.pathname === "/api/render/capabilities" && req.method === "GET") {
+          try {
+            json(res, 200, await nativeExportCapabilities());
+          } catch (error) {
+            json(res, 503, { error: error instanceof Error ? error.message : String(error) });
+          }
+          return true;
+        }
+        if (url.pathname === "/api/render" && req.method === "POST") {
+          if ([...jobs.values()].some((j) => j.state === "running")) {
+            json(res, 409, { error: "a render is already running" });
+            return true;
+          }
+          let body;
+          try {
+            const raw = JSON.parse((await readBody(req)).toString() || "{}");
+            body = validateRenderRequest(raw, await nativeExportCapabilities());
+          } catch (error) {
+            json(res, 400, { error: error instanceof Error ? error.message : String(error) });
+            return true;
+          }
+          if ([...jobs.values()].some((j) => j.state === "running")) {
+            json(res, 409, { error: "a render is already running" });
+            return true;
+          }
+          const requested = (body.fileName ?? "render.mp4").replace(/[/\\]/g, "_");
+          const name = requested.endsWith(".mp4") ? requested : `${requested}.mp4`;
+          const renders = join5(dir, "renders");
+          mkdirSync4(renders, { recursive: true });
+          const directory = lstatSync2(renders);
+          if (!directory.isDirectory() || directory.isSymbolicLink()) {
+            json(res, 400, { error: "renders must be a project directory, not a symbolic link" });
+            return true;
+          }
+          const stage = mkdtempSync(join5(renders, ".export-"));
+          const stageIdentity = lstatSync2(stage);
+          const out = join5(stage, "output.mp4");
+          const id2 = String(++jobSeq);
+          const job2 = { state: "running", done: 0, total: 0, abort: new AbortController() };
+          jobs.set(id2, job2);
+          void (async () => {
+            try {
+              const report = await render(dir, {
+                out,
+                depth: body.depth ?? 8,
+                allowFontFallback: body.allowFontFallback === true,
+                ...body.spec ? { spec: body.spec } : {},
+                ...body.sceneId ? { sceneId: body.sceneId } : {},
+                ...body.from !== void 0 ? { from: body.from } : {},
+                ...body.to !== void 0 ? { to: body.to } : {},
+                signal: job2.abort.signal,
+                onProgress: (done, total) => {
+                  job2.done = done;
+                  job2.total = total;
+                }
+              });
+              if (job2.abort.signal.aborted) throw Object.assign(new Error("render cancelled"), { name: "RenderCancelledError" });
+              const current = lstatSync2(renders);
+              if (!current.isDirectory() || current.isSymbolicLink() || current.dev !== directory.dev || current.ino !== directory.ino) throw new Error("renders directory changed during export");
+              const output = lstatSync2(out);
+              if (!output.isFile() || output.isSymbolicLink() || output.size === 0) throw new Error("render did not produce a complete file");
+              const occupied = new Set(readdirSync3(renders));
+              for (let n = 1; ; n++) {
+                const candidate = n === 1 ? name : `${name.slice(0, -4)}-${n}.mp4`;
+                if (occupied.has(candidate)) continue;
+                try {
+                  linkSync(out, join5(renders, candidate));
+                } catch (error) {
+                  const code = error.code;
+                  if (code === "EEXIST") continue;
+                  if (!["ENOTSUP", "EOPNOTSUPP", "EPERM", "EXDEV", "ENOSYS"].includes(code ?? "")) throw error;
+                  const reserved = mkdtempSync(join5(renders, `${name.slice(0, -4)}-`));
+                  try {
+                    renameSync4(out, join5(reserved, name));
+                  } catch (error2) {
+                    rmSync3(reserved, { recursive: true, force: true });
+                    throw error2;
+                  }
+                  job2.out = `renders/${reserved.slice(renders.length + 1)}/${name}`;
+                  break;
+                }
+                job2.out = `renders/${candidate}`;
+                break;
+              }
+              job2.state = "done";
+              job2.msPerFrame = report.msPerFrame;
+            } catch (error) {
+              job2.state = job2.abort.signal.aborted || error instanceof Error && error.name === "RenderCancelledError" ? "cancelled" : "failed";
+              job2.error = error instanceof Error ? error.message : String(error);
+            } finally {
+              try {
+                const current = lstatSync2(stage);
+                if (current.dev === stageIdentity.dev && current.ino === stageIdentity.ino && !current.isSymbolicLink()) rmSync3(stage, { recursive: true, force: true });
+              } catch (error) {
+                if (error.code !== "ENOENT") console.warn("Could not remove export staging directory:", error instanceof Error ? error.message : String(error));
+              }
+            }
+          })();
+          json(res, 200, { id: id2 });
+          return true;
+        }
+        const id = url.searchParams.get("id") ?? "";
+        const job = jobs.get(id);
+        if (!job) {
+          json(res, 404, { error: `no render ${id}` });
+          return true;
+        }
+        if (url.pathname === "/api/render/cancel" && job.state === "running") job.abort.abort();
+        const { abort: _abort, ...status } = job;
+        void _abort;
+        json(res, 200, status);
+        return true;
+      },
+      async (req, res, url) => {
+        if (url.pathname !== "/api/select" && !url.pathname.startsWith("/api/select/")) return false;
+        try {
+          if (url.pathname === "/api/select" && req.method === "POST") {
+            requireSelectBackend();
+            const r = selectRequest(dir, (await readBody(req)).toString());
+            json(res, 200, await select(r.file, r.time, r.prompt));
+            return true;
+          }
+          if (url.pathname === "/api/select/tracks" && req.method === "POST") {
+            requireSelectBackend();
+            const r = selectRequest(dir, (await readBody(req)).toString());
+            const taken = (path) => existsSync4(path) || [...tracks.values()].some((t) => t.out === path);
+            let out = join5(dir, "masks", `${r.stem}.mask`);
+            for (let n = 2; taken(out); n++) out = join5(dir, "masks", `${r.stem}-${n}.mask`);
+            const id2 = String(tracks.size + 1);
+            const job = { out, state: { status: "running" } };
+            tracks.set(id2, job);
+            track(r.file, {
+              time: r.time,
+              prompt: r.prompt,
+              ...r.pick ? { pick: r.pick } : {},
+              ...r.start !== void 0 ? { start: r.start } : {},
+              ...r.end !== void 0 ? { end: r.end } : {},
+              out,
+              onProgress: (done, total) => {
+                job.state = { status: "running", progress: { done, total } };
+              }
+            }).then(
+              (result) => {
+                job.state = { status: "succeeded", mask: rel(dir, result.path) };
+              },
+              (error) => {
+                job.state = { status: "failed", error: error instanceof Error ? error.message : String(error) };
+              }
+            );
+            json(res, 202, { id: id2 });
+            return true;
+          }
+          const id = /^\/api\/select\/tracks\/([^/]+)$/.exec(url.pathname)?.[1];
+          if (id !== void 0 && req.method === "GET") {
+            const job = tracks.get(decodeURIComponent(id));
+            if (job) json(res, 200, job.state);
+            else json(res, 404, { error: `no track ${decodeURIComponent(id)}` });
+            return true;
+          }
+          json(res, 404, { error: `no route ${req.method ?? "GET"} ${url.pathname}` });
+        } catch (error) {
+          const e = error instanceof SelectError ? error : void 0;
+          json(res, e?.status ?? 500, { error: error instanceof Error ? error.message : String(error), ...e?.code ? { code: e.code } : {} });
+        }
+        return true;
+      },
+      (req, res, url) => {
+        if (!url.pathname.startsWith("/preview/")) return false;
+        const rel2 = decodeURIComponent(url.pathname.slice("/preview/".length));
+        const file = inside(dir, rel2);
+        if (!file) {
+          res.statusCode = 403;
+          res.end();
+          return true;
+        }
+        if (rel2.startsWith(`${PRERENDER_DIR}/`)) {
+          const cached = prerender.lookup(rel2.slice(PRERENDER_DIR.length + 1));
+          if (cached) sendFile(req, res, cached);
+          else json(res, 404, { error: `no pre-rendered preview ${rel2}` });
+          return true;
+        }
+        proxies.consider(rel2, true);
+        const proxy = proxies.lookup(rel2);
+        if (proxy) res.setHeader("x-higgsedit-proxy", "1");
+        sendFile(req, res, proxy ?? file);
+        return true;
+      },
+      async (req, res, url) => {
+        if (url.pathname !== "/api/prerender") return false;
+        if (req.method === "GET") {
+          json(res, 200, { statuses: prerender.statuses() });
+          return true;
+        }
+        try {
+          const body = JSON.parse((await readBody(req)).toString() || "{}");
+          json(res, 200, { statuses: await prerender.request(body.targets ?? [], body.playhead ?? 0, body.client ?? "") });
+        } catch (error) {
+          json(res, 400, { error: error instanceof Error ? error.message : String(error) });
+        }
+        return true;
+      },
+      (req, res, url) => {
+        if (url.pathname !== "/api/presets") return false;
+        json(res, 200, presetCatalogue(presets));
+        return true;
+      },
+      (req, res, url) => {
+        const id = /^\/api\/presets\/([^/]+)\/preview\.mp4$/.exec(url.pathname)?.[1];
+        if (!id) return false;
+        const preset = readManifest(presets)?.find((p) => p.id === decodeURIComponent(id));
+        if (!preset) {
+          res.statusCode = 404;
+          res.end("not found");
+          return true;
+        }
+        sendFile(req, res, join5(presets, preset.preview));
+        return true;
+      },
+      async (req, res, url) => {
+        if (url.pathname !== "/api/presets/add" || req.method !== "POST") return false;
+        const body = JSON.parse((await readBody(req)).toString());
+        const preset = readManifest(presets)?.find((p) => p.id === body.id);
+        if (!preset) {
+          json(res, 404, { ok: false, error: `no preset ${body.id} installed` });
+          return true;
+        }
+        const tx = history.begin(`Add preset ${preset.name}`);
+        try {
+          const r = addPreset(dir, preset, body, tx.onWrite, presets);
+          if (r.ok) tx.commit();
+          else tx.rollback();
+          if ("error" in r) json(res, 400, r);
+          else json(res, 200, { ...r, undo: history.state() });
+          return true;
+        } catch (error) {
+          tx.rollback();
+          throw error;
+        }
+      },
+      (req, res, url) => {
+        if (url.pathname !== "/api/history") return false;
+        json(res, 200, history.state());
+        void req;
+        return true;
+      },
+      async (req, res, url) => {
+        if (url.pathname !== "/api/media") return false;
+        const media = join5(dir, "media");
+        const files = listMediaFiles(media);
+        json(res, 200, { files });
+        return true;
+      },
+      (req, res, url) => {
+        if (url.pathname !== "/api/analyze") return false;
+        const key = url.searchParams.get("key") ?? "";
+        const names = (url.searchParams.get("names") ?? "").split(",").filter(Boolean);
+        json(res, 200, analyze(dir, key, names));
+        void req;
+        return true;
+      }
+    ],
+    port
+  );
+  function stop() {
+    stopping = true;
+    return stopped ??= (async () => {
+      clearTimeout(timer);
+      watcher.close();
+      await mediaUploads.close();
+      proxies.stop();
+      await prerender.stop();
+      for (const c of clients) c.end();
+      await server.close();
+    })();
+  }
+  return { ...server, stop };
+}
+async function dev(dir, port, presets) {
+  const server = await startDev(dir, port, { presets, onIdleStop: () => quit() });
+  console.log(`higgsedit dev  ${dir}
+  editor  ${server.origin}/`);
+  const quit = () => {
+    setTimeout(() => process.exit(0), 3e3).unref();
+    void server.stop().finally(() => process.exit(0));
+  };
+  process.once("SIGTERM", quit);
+  process.once("SIGINT", quit);
+}
+export {
+  dev,
+  startDev
+};