@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/studioServer-UWRBPIOJ.js

@@ -0,0 +1,1457 @@
+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 {
+  renderJobObservabilityTelemetryPayload,
+  renderObservabilityTelemetryPayload
+} from "./chunk-VXVRPIJA.js";
+import {
+  seekCompositionTimeline
+} from "./chunk-YQZNILVH.js";
+import "./chunk-5Z63TBTX.js";
+import "./chunk-7HG4BFIN.js";
+import "./chunk-HRUGC23L.js";
+import "./chunk-YEIFI443.js";
+import {
+  DEFAULT_HISTORY_ROOT,
+  DELETED_VERSION,
+  HistoryBusyError,
+  HistoryClosedError,
+  PREVIEW_BUNDLE_OPTIONS,
+  affectsPreview,
+  affectsProjectSignature,
+  clearElementScreenshotIsolation,
+  compositionsAffectedBy,
+  createBackgroundRemovalJob,
+  createPreviewDocumentStore,
+  createProjectSignature,
+  createStudioApi,
+  fileContentVersion,
+  getElementScreenshotClip,
+  getMimeType,
+  historyCache,
+  identifyFileWrite,
+  openProjectHistory,
+  stampProjectHfIds,
+  thumbnailDeviceScaleFactor
+} from "./chunk-S7NPLFWV.js";
+import "./chunk-RMHUQGRK.js";
+import {
+  isAtomicTempPath,
+  replaceFileAtomically
+} from "./chunk-EOVYQ3IG.js";
+import "./chunk-QC4FJVLM.js";
+import "./chunk-TCLGPL65.js";
+import {
+  HANDOFF_READY,
+  desktopDownloadUrl,
+  desktopInstalled,
+  openInDesktop
+} from "./chunk-GULOKZLI.js";
+import "./chunk-IHFUKJOR.js";
+import {
+  resolveCaptureBrowserGpuMode,
+  resolveLocalBrowserGpuMode
+} from "./chunk-XS4EJSKU.js";
+import {
+  resolveRenderBrowser
+} from "./chunk-FCSIGXXP.js";
+import "./chunk-PFCFR3KZ.js";
+import {
+  resolveAutoProxy
+} from "./chunk-CFKU7HTK.js";
+import "./chunk-XT7X6QCP.js";
+import "./chunk-4YYJOFKS.js";
+import "./chunk-HVW7ABXD.js";
+import "./chunk-LYNI3FOL.js";
+import "./chunk-CWPVM2QV.js";
+import "./chunk-A2Z4Z4VL.js";
+import "./chunk-AWDFDFI3.js";
+import "./chunk-P6LJ4Y32.js";
+import "./chunk-GMECXFAN.js";
+import "./chunk-TVCRUG2S.js";
+import "./chunk-4NWOGZZS.js";
+import {
+  trackRenderComplete,
+  trackRenderError
+} from "./chunk-JTHMTOMQ.js";
+import {
+  canaryDecisionsForStudio,
+  resetTelemetryPostureCache,
+  shouldTrack
+} from "./chunk-EISRN4E6.js";
+import "./chunk-VWG7OQKU.js";
+import "./chunk-ZTZA4UWZ.js";
+import {
+  bytesToMb,
+  detectAgentRuntime
+} from "./chunk-IUZFXWSV.js";
+import "./chunk-AMKC3AXA.js";
+import "./chunk-54HJ63Q2.js";
+import "./chunk-PBN6GBJE.js";
+import {
+  createStudioManualEditsRenderBodyScript
+} from "./chunk-KC5XXX3X.js";
+import "./chunk-TJSTGSAW.js";
+import {
+  assertWebGpuAdapterAvailable,
+  compositionRequiresWebGpu
+} from "./chunk-K2FTXJYH.js";
+import {
+  fpsToNumber
+} from "./chunk-2YN64IN5.js";
+import "./chunk-AVUUN2XD.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-Z6B37SNM.js";
+import "./chunk-HWKCIWQT.js";
+import "./chunk-VC76R6W2.js";
+import {
+  realpath
+} from "./chunk-OFQWTKPW.js";
+import "./chunk-4PFZPP2N.js";
+import {
+  runRenderSetupWorker
+} from "./chunk-LCSMOLGX.js";
+import "./chunk-TWWSYAKJ.js";
+import {
+  isWithinProjectRoot
+} from "./chunk-ZJUKFZ2P.js";
+import "./chunk-HBBJFK6I.js";
+import "./chunk-PJ3HDUCY.js";
+import "./chunk-TQFG7HTI.js";
+import "./chunk-GK4AIFIH.js";
+import "./chunk-2PSPARWP.js";
+import "./chunk-K4WIOZFP.js";
+import {
+  readConfig,
+  readConfigFresh
+} from "./chunk-XUXGIA7H.js";
+import "./chunk-WERLJGIC.js";
+import {
+  isDevMode
+} from "./chunk-ISN5GRYI.js";
+import {
+  VERSION
+} from "./chunk-FLWXXDNS.js";
+import "./chunk-KNU5COPB.js";
+import "./chunk-3GXQPCJC.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-PMRBLBUP.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/server/studioServer.ts
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync as statSync2, writeFileSync, unlinkSync } from "fs";
+import { createHash as createHash2 } from "crypto";
+import { fileURLToPath } from "url";
+import { resolve as resolve2, join as join2, basename, relative as relative2, sep as sep2 } from "path";
+
+// src/server/readBundleFile.ts
+import { openSync, fstatSync, closeSync, statSync, readFileSync, constants } from "fs";
+function readBundleFile(filePath) {
+  let fd;
+  try {
+    fd = openSync(filePath, constants.O_RDONLY | constants.O_NONBLOCK);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR"))
+      return null;
+    if (!statSync(filePath, { throwIfNoEntry: false })?.isFile()) return null;
+    throw error;
+  }
+  try {
+    if (!fstatSync(fd).isFile()) return null;
+    return readFileSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+
+// src/server/fileWatcher.ts
+import { lstatSync, readdirSync, watch } from "fs";
+import { join, relative, sep } from "path";
+var WATCHER_EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+  ".cache",
+  ".git",
+  ".hyperframes",
+  ".next",
+  ".thumbnails",
+  ".transcode-cache",
+  ".vite",
+  ".waveform-cache",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules",
+  "outputs",
+  "renders"
+]);
+var QUIET_MS = 30;
+var BURST_MS = 300;
+function shouldWatchProjectFile(filename) {
+  if (!filename || isAtomicTempPath(filename)) return false;
+  const parts = filename.split(/[\\/]+/);
+  return !parts.some((part) => WATCHER_EXCLUDED_DIRS.has(part));
+}
+function isDirectory(path) {
+  try {
+    return lstatSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function watchProjectTree(projectDir, onChange) {
+  if (process.platform !== "linux") {
+    const tree = watch(projectDir, { recursive: true }, (_event, filename) => {
+      if (filename) onChange(filename.toString());
+    });
+    tree.on("error", () => tree.close());
+    return () => tree.close();
+  }
+  const directories = /* @__PURE__ */ new Map();
+  const unwatch = (dir) => {
+    for (const [watched, watcher] of directories) {
+      if (watched === dir || watched.startsWith(dir + sep)) {
+        watcher.close();
+        directories.delete(watched);
+      }
+    }
+  };
+  const watchDirectory = (dir) => {
+    if (directories.has(dir)) return;
+    let watcher;
+    try {
+      watcher = watch(dir, { persistent: true }, (event, name) => {
+        if (!name) return;
+        const path = join(dir, name.toString());
+        onChange(relative(projectDir, path));
+        if (event !== "rename") return;
+        if (isDirectory(path)) descend(path);
+        else unwatch(path);
+      });
+    } catch (error) {
+      if (dir === projectDir) throw error;
+      return;
+    }
+    watcher.on("error", () => unwatch(dir));
+    directories.set(dir, watcher);
+    let entries = [];
+    try {
+      entries = readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join(dir, entry.name));
+    } catch {
+    }
+    for (const child of entries) descend(child);
+  };
+  const descend = (dir) => {
+    const rel = relative(projectDir, dir);
+    if (shouldWatchProjectFile(rel) || rel === ".hyperframes") watchDirectory(dir);
+  };
+  watchDirectory(projectDir);
+  return () => {
+    for (const watcher of directories.values()) watcher.close();
+    directories.clear();
+  };
+}
+function createProjectWatcher(projectDir) {
+  const listeners = /* @__PURE__ */ new Set();
+  const pendingPaths = /* @__PURE__ */ new Set();
+  let debounceTimer = null;
+  let lastFlushAt = Number.NEGATIVE_INFINITY;
+  let closeTree = null;
+  try {
+    closeTree = watchProjectTree(projectDir, (relativePath) => {
+      if (!shouldWatchProjectFile(relativePath) && !affectsProjectSignature(projectDir, join(projectDir, relativePath))) {
+        return;
+      }
+      pendingPaths.add(relativePath);
+      if (debounceTimer) clearTimeout(debounceTimer);
+      const delay = Math.max(QUIET_MS, lastFlushAt + BURST_MS - Date.now());
+      debounceTimer = setTimeout(() => {
+        const changedPaths = [...pendingPaths];
+        pendingPaths.clear();
+        debounceTimer = null;
+        lastFlushAt = Date.now();
+        for (const changedPath of changedPaths) {
+          for (const fn of listeners) {
+            fn(changedPath);
+          }
+        }
+      }, delay);
+    });
+  } catch {
+  }
+  return {
+    addListener(fn) {
+      listeners.add(fn);
+    },
+    removeListener(fn) {
+      listeners.delete(fn);
+    },
+    close() {
+      if (debounceTimer) clearTimeout(debounceTimer);
+      pendingPaths.clear();
+      closeTree?.();
+      listeners.clear();
+    }
+  };
+}
+
+// src/server/runtimeSource.ts
+import { createHash } from "crypto";
+import { existsSync } from "fs";
+import { resolve, dirname } from "path";
+var ARTIFACT_NAMES = ["hyperframe-runtime.js", "hyperframe.runtime.iife.js"];
+async function loadRuntimeSource() {
+  return await buildFromSource() ?? await getInlinedRuntime() ?? readPrebuiltArtifact();
+}
+async function loadRuntimeSourceSignature() {
+  const source = await loadRuntimeSource();
+  if (!source) return null;
+  return createHash("sha256").update(source).digest("hex");
+}
+function hashSignatureParts(parts) {
+  const hash = createHash("sha256");
+  for (const part of parts) {
+    hash.update(part ?? "");
+    hash.update("\n--hf-signature-part--\n");
+  }
+  return hash.digest("hex");
+}
+var ENTRY_TS = resolve(__dirname, "..", "..", "..", "core", "src", "runtime", "entry.ts");
+async function buildFromSource() {
+  if (!existsSync(ENTRY_TS)) return null;
+  try {
+    const mod = await import("./dist-S3PJNPXQ.js");
+    if (typeof mod.loadHyperframeRuntimeSource === "function") {
+      const source = mod.loadHyperframeRuntimeSource();
+      if (source) return source;
+    }
+  } catch {
+  }
+  return null;
+}
+async function getInlinedRuntime() {
+  try {
+    const mod = await import("./dist-S3PJNPXQ.js");
+    if (typeof mod.getHyperframeRuntimeScript === "function") {
+      return mod.getHyperframeRuntimeScript() ?? null;
+    }
+  } catch {
+  }
+  return null;
+}
+function readPrebuiltArtifact() {
+  return readFromDir(__dirname) ?? readFromCoreDistDir() ?? readFromNodeModules();
+}
+function readFromDir(dir) {
+  for (const name of ARTIFACT_NAMES) {
+    const path = resolve(dir, name);
+    const content = readBundleFile(path);
+    if (content !== null) return content.toString("utf-8");
+  }
+  return null;
+}
+function readFromCoreDistDir() {
+  return readFromDir(resolve(__dirname, "..", "..", "..", "core", "dist"));
+}
+function readFromNodeModules() {
+  const subPaths = ["node_modules/hyperframes/dist", "node_modules/@hyperframes/core/dist"];
+  let dir = __dirname;
+  for (; ; ) {
+    for (const sub of subPaths) {
+      const result = readFromDir(resolve(dir, sub));
+      if (result) return result;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+// src/server/telemetryIdentity.ts
+import { hostname, networkInterfaces } from "os";
+function resolveCliTelemetryDistinctId() {
+  try {
+    if (!shouldTrack()) return null;
+    const id = readConfig().anonymousId;
+    return typeof id === "string" && id.length > 0 ? id : null;
+  } catch {
+    return null;
+  }
+}
+function resolveCliBucketSeed() {
+  try {
+    if (!shouldTrack()) return null;
+    const seed = readConfig().bucketSeed;
+    return typeof seed === "string" && seed.length > 0 ? seed : null;
+  } catch {
+    return null;
+  }
+}
+function isLoopbackHost(host) {
+  if (!host) return false;
+  const bracketed = /^\[([^\]]+)\]/.exec(host);
+  const hostname2 = (bracketed ? bracketed[1] : host.split(":")[0])?.toLowerCase() ?? "";
+  if (hostname2 === "localhost" || hostname2 === "::1" || hostname2 === "0:0:0:0:0:0:0:1") return true;
+  return /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(hostname2);
+}
+function encodeInlineScriptValue(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\//g, "\\/");
+}
+function encodeInlineScriptJson(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\//g, "\\/");
+}
+function resolveCliCanaryDecisions() {
+  try {
+    const decisions = canaryDecisionsForStudio();
+    return Object.keys(decisions).length > 0 ? decisions : null;
+  } catch {
+    return null;
+  }
+}
+function buildCliIdentityScript(options = {}) {
+  const { includeIdentity = true } = options;
+  const parts = [];
+  parts.push(`window.__HF_CLI_TELEMETRY_DISABLED=${!shouldTrack()};`);
+  const cliId = includeIdentity ? resolveCliTelemetryDistinctId() : null;
+  if (cliId) {
+    parts.push(`window.__HF_CLI_DISTINCT_ID=${encodeInlineScriptValue(cliId)};`);
+    const seed = resolveCliBucketSeed();
+    if (seed) parts.push(`window.__HF_CLI_BUCKET_SEED=${encodeInlineScriptValue(seed)};`);
+  }
+  const decisions = resolveCliCanaryDecisions();
+  if (decisions !== null) {
+    parts.push(`window.__HF_CLI_CANARY_DECISIONS=${encodeInlineScriptJson(decisions)};`);
+  }
+  const agent = shouldTrack() ? detectAgentRuntime() : null;
+  if (agent) {
+    parts.push(`window.__HF_CLI_AGENT_RUNTIME=${encodeInlineScriptValue(agent)};`);
+  }
+  return parts.length === 0 ? "" : `<script>${parts.join("")}</script>`;
+}
+function buildStudioHeadScripts(envScript, options = {}) {
+  return `${buildCliIdentityScript(options)}${envScript}`;
+}
+function hostnameOf(host) {
+  if (!host) return "";
+  const bracketed = /^\[([^\]]+)\]/.exec(host);
+  return (bracketed ? bracketed[1] : host.split(":")[0])?.toLowerCase() ?? "";
+}
+function localNames() {
+  const names = /* @__PURE__ */ new Set();
+  try {
+    for (const entries of Object.values(networkInterfaces())) {
+      for (const entry of entries ?? []) names.add(entry.address.toLowerCase());
+    }
+    const self = hostname().toLowerCase();
+    if (self !== "") {
+      names.add(self);
+      names.add(`${self}.local`);
+      const short = self.split(".")[0];
+      if (short !== void 0 && short !== "") {
+        names.add(short);
+        names.add(`${short}.local`);
+      }
+    }
+  } catch {
+  }
+  return names;
+}
+function hostMatchesBind(host, bind) {
+  const requested = hostnameOf(host);
+  if (requested === "") return false;
+  const bound = bind.toLowerCase();
+  if (requested === bound) return true;
+  return bound === "0.0.0.0" || bound === "::" || bound === "*" ? localNames().has(requested) : false;
+}
+function identityAllowed(host) {
+  if (isLoopbackHost(host)) return true;
+  const bind = (process.env["HYPERFRAMES_PREVIEW_HOST"] ?? "").trim();
+  if (bind === "" || isLoopbackHost(bind)) return false;
+  return hostMatchesBind(host, bind);
+}
+function refreshTelemetryPosture() {
+  try {
+    readConfigFresh();
+    resetTelemetryPostureCache();
+  } catch {
+  }
+}
+function buildStudioHeadScriptsForHost(envScript, host) {
+  refreshTelemetryPosture();
+  return buildStudioHeadScripts(envScript, { includeIdentity: identityAllowed(host) });
+}
+
+// src/server/studioRenderTelemetry.ts
+import { freemem } from "os";
+function memSnapshot() {
+  return {
+    peakMemoryMb: bytesToMb(process.memoryUsage.rss()),
+    memoryFreeMb: bytesToMb(freemem())
+  };
+}
+function stagesPayload(stages) {
+  return {
+    stageCompileMs: stages.compileMs,
+    stageVideoExtractMs: stages.videoExtractMs,
+    stageAudioProcessMs: stages.audioProcessMs,
+    stageCaptureMs: stages.captureMs,
+    stageCaptureSetupMs: stages.captureSetupMs,
+    stageCaptureFrameMs: stages.captureFrameMs,
+    stageEncodeMs: stages.encodeMs,
+    stageAssembleMs: stages.assembleMs
+  };
+}
+function extractPayload(extract) {
+  if (!extract) return {};
+  return {
+    extractResolveMs: extract.resolveMs,
+    extractHdrProbeMs: extract.hdrProbeMs,
+    extractHdrPreflightMs: extract.hdrPreflightMs,
+    extractHdrPreflightCount: extract.hdrPreflightCount,
+    extractVfrProbeMs: extract.vfrProbeMs,
+    extractVfrPreflightMs: extract.vfrPreflightMs,
+    extractVfrPreflightCount: extract.vfrPreflightCount,
+    extractPhase3Ms: extract.extractMs,
+    extractCacheHits: extract.cacheHits,
+    extractCacheMisses: extract.cacheMisses
+  };
+}
+function perfPayload(perf, elapsedMs) {
+  if (!perf) return {};
+  const compositionDurationMs = Math.round(perf.compositionDurationSeconds * 1e3);
+  const speedRatio = compositionDurationMs > 0 && elapsedMs > 0 ? Math.round(compositionDurationMs / elapsedMs * 100) / 100 : void 0;
+  return {
+    workers: perf.workers,
+    compositionDurationMs,
+    compositionWidth: perf.resolution.width,
+    compositionHeight: perf.resolution.height,
+    totalFrames: perf.totalFrames,
+    speedRatio,
+    captureAvgMs: perf.captureAvgMs,
+    capturePeakMs: perf.capturePeakMs,
+    tmpPeakBytes: perf.tmpPeakBytes,
+    ...stagesPayload(perf.stages),
+    ...extractPayload(perf.videoExtractBreakdown),
+    ...renderObservabilityTelemetryPayload(perf.observability)
+  };
+}
+function emitStudioRenderError(opts, elapsedMs, failedStage, err, job) {
+  if (opts.telemetryOptOut === true) return;
+  trackRenderError({
+    fps: fpsToNumber(opts.fps),
+    quality: opts.quality,
+    docker: false,
+    source: "studio",
+    failedStage,
+    errorMessage: err instanceof Error ? err.message : String(err),
+    elapsedMs,
+    outputFormat: opts.format,
+    outputResolutionPreset: opts.outputResolution,
+    distinctId: opts.distinctId,
+    ...renderJobObservabilityTelemetryPayload(job),
+    ...memSnapshot()
+  });
+}
+function emitStudioRenderComplete(opts, elapsedMs, perf) {
+  if (opts.telemetryOptOut === true) return;
+  trackRenderComplete({
+    durationMs: elapsedMs,
+    fps: fpsToNumber(opts.fps),
+    quality: opts.quality,
+    docker: false,
+    gpu: false,
+    source: "studio",
+    outputFormat: opts.format,
+    outputResolutionPreset: opts.outputResolution,
+    distinctId: opts.distinctId,
+    ...perfPayload(perf, elapsedMs),
+    ...memSnapshot()
+  });
+}
+
+// src/server/desktopRoutes.ts
+function sameOriginPost(headers) {
+  const { host, origin, fetchSite } = headers;
+  if (!host || !identityAllowed(host)) return false;
+  if (fetchSite && fetchSite !== "same-origin") return false;
+  return origin === void 0 || origin === `http://${host}`;
+}
+function mountDesktopRoutes(app, projectDir, {
+  ready = HANDOFF_READY,
+  open = openInDesktop,
+  platform = process.platform,
+  installed = () => desktopInstalled({ platform })
+} = {}) {
+  const downloadUrl = desktopDownloadUrl(platform);
+  app.get(
+    "/api/open-in-desktop",
+    (c) => c.json({ available: downloadUrl !== null || installed(), handoff: ready, downloadUrl })
+  );
+  app.post("/api/open-in-desktop", (c) => {
+    const allowed = sameOriginPost({
+      host: c.req.header("host"),
+      origin: c.req.header("origin"),
+      fetchSite: c.req.header("sec-fetch-site")
+    });
+    if (!allowed) return c.json({ error: "forbidden" }, 403);
+    if (!ready)
+      return c.json({
+        opened: false,
+        reason: "handoff-unavailable",
+        downloadUrl
+      });
+    return c.json(open(projectDir));
+  });
+}
+
+// src/server/thumbnailPages.ts
+function createThumbnailPages(maxPages = 2, idleMs = 1e3) {
+  const pages = /* @__PURE__ */ new Map();
+  const drop = (url) => {
+    const entry = pages.get(url);
+    if (!entry) return;
+    pages.delete(url);
+    clearTimeout(entry.idleTimer);
+    void entry.queue.then(() => entry.page).then((page) => page.close()).catch(() => {
+    });
+  };
+  const entryFor = (browser, url, version, time, load) => {
+    const existing = pages.get(url);
+    if (existing && existing.browser === browser && existing.version === version && existing.shownUpTo <= time) {
+      existing.shownUpTo = time;
+      return existing;
+    }
+    drop(url);
+    const page = browser.newPage().then(async (created) => {
+      try {
+        await load(created);
+      } catch (error) {
+        await created.close().catch(() => {
+        });
+        throw error;
+      }
+      return created;
+    });
+    const entry = { browser, version, shownUpTo: time, page, queue: Promise.resolve() };
+    pages.set(url, entry);
+    while (pages.size > maxPages) drop(pages.keys().next().value);
+    return entry;
+  };
+  const armIdleClose = (url, entry) => {
+    if (pages.get(url) !== entry) return;
+    clearTimeout(entry.idleTimer);
+    entry.idleTimer = setTimeout(() => {
+      if (pages.get(url) === entry) drop(url);
+    }, idleMs);
+    entry.idleTimer.unref?.();
+  };
+  return {
+    async withPage(browser, url, version, time, load, use) {
+      const current = entryFor(browser, url, version, time, load);
+      clearTimeout(current.idleTimer);
+      const run = current.queue.then(async () => use(await current.page));
+      current.queue = run.catch(() => {
+      });
+      try {
+        return await run;
+      } catch (error) {
+        if (pages.get(url) === current) drop(url);
+        throw error;
+      } finally {
+        armIdleClose(url, current);
+      }
+    },
+    closeAll() {
+      for (const url of [...pages.keys()]) drop(url);
+    }
+  };
+}
+
+// src/server/studioServer.ts
+var STUDIO_MANUAL_EDITS_PATH = ".hyperframes/studio-manual-edits.json";
+var RENDER_SHUTDOWN_WAIT_MS = 2e3;
+var IMMUTABLE_CACHE_CONTROL = "public, max-age=31536000, immutable";
+var REMOTE_GIF_IMG_SRC_RE = /<img\b[^>]*?\bsrc\s*=\s*["'](https?:\/\/[^"']+\.gif(?:[?#][^"']*)?)["'][^>]*>/gi;
+async function loadStudioProducer() {
+  if (!isDevMode()) return await import("./src-6YQBJGWR.js");
+  if (!process.versions.bun) {
+    throw new Error(
+      "Studio dev-mode rendering requires bun (the producer is loaded from TypeScript source, which Node cannot resolve). Restart the studio with `bun run studio`."
+    );
+  }
+  return await import("./src-6YQBJGWR.js");
+}
+function resolveDistDir() {
+  return resolveStudioBundle().dir;
+}
+function resolveStudioBundle() {
+  const builtPath = resolve2(__dirname, "studio");
+  const builtIndex = resolve2(builtPath, "index.html");
+  if (existsSync2(builtIndex)) {
+    return { dir: builtPath, indexPath: builtIndex, available: true, checkedPaths: [builtIndex] };
+  }
+  const devPath = resolve2(__dirname, "..", "..", "..", "studio", "dist");
+  const devIndex = resolve2(devPath, "index.html");
+  if (existsSync2(devIndex)) {
+    return {
+      dir: devPath,
+      indexPath: devIndex,
+      available: true,
+      checkedPaths: [builtIndex, devIndex]
+    };
+  }
+  return {
+    dir: builtPath,
+    indexPath: builtIndex,
+    available: false,
+    checkedPaths: [builtIndex, devIndex]
+  };
+}
+function resolveRuntimePath() {
+  const builtPath = resolve2(__dirname, "hyperframe-runtime.js");
+  if (existsSync2(builtPath)) return builtPath;
+  const iifePath = resolve2(__dirname, "hyperframe.runtime.iife.js");
+  if (existsSync2(iifePath)) return iifePath;
+  const devPath = resolve2(
+    __dirname,
+    "..",
+    "..",
+    "..",
+    "core",
+    "dist",
+    "hyperframe.runtime.iife.js"
+  );
+  if (existsSync2(devPath)) return devPath;
+  return builtPath;
+}
+function readStudioManualEditManifestContent(projectDir) {
+  const manifestPath = join2(projectDir, STUDIO_MANUAL_EDITS_PATH);
+  if (!existsSync2(manifestPath)) return "";
+  try {
+    return readFileSync2(manifestPath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+async function applyStudioManualEditsToThumbnailPage(page, manifestContent, activeCompositionPath) {
+  const script = createStudioManualEditsRenderBodyScript(manifestContent, {
+    activeCompositionPath
+  });
+  if (!script) return;
+  await page.addScriptTag({ content: script });
+}
+async function reapplyStudioManualEditsToThumbnailPage(page) {
+  await page.evaluate(() => {
+    const apply = window.__hfStudioManualEditsApply;
+    if (typeof apply === "function") apply();
+  });
+}
+function collectRemoteGifImageSources(html) {
+  const urls = /* @__PURE__ */ new Set();
+  const re = new RegExp(REMOTE_GIF_IMG_SRC_RE.source, REMOTE_GIF_IMG_SRC_RE.flags);
+  let match;
+  while ((match = re.exec(html)) !== null) {
+    if (match[1]) urls.add(match[1]);
+  }
+  return [...urls];
+}
+async function downloadRemoteGifImageSources(html, downloadDir, downloadToTemp) {
+  const sourceAssets = /* @__PURE__ */ new Map();
+  await Promise.all(
+    collectRemoteGifImageSources(html).map(async (url) => {
+      try {
+        sourceAssets.set(url, await downloadToTemp(url, downloadDir));
+      } catch (err) {
+        console.warn(
+          "[Studio] Remote animated GIF prep skipped:",
+          err instanceof Error ? err.message : err
+        );
+      }
+    })
+  );
+  return sourceAssets;
+}
+var _thumbnailBrowserLease = null;
+var thumbnailPages = createThumbnailPages();
+var _thumbnailBrowserInitializing = null;
+var _thumbnailBrowserModes = null;
+async function getThumbnailBrowser(requestedGpuMode, isShuttingDown) {
+  if (isShuttingDown()) return null;
+  if (_thumbnailBrowserLease?.browser.connected && _thumbnailBrowserModes?.requested === requestedGpuMode) {
+    return {
+      browser: _thumbnailBrowserLease.browser,
+      requestedGpuMode: _thumbnailBrowserModes.requested,
+      resolvedGpuMode: _thumbnailBrowserModes.resolved
+    };
+  }
+  if (_thumbnailBrowserInitializing) {
+    const session = await _thumbnailBrowserInitializing;
+    if (session?.requestedGpuMode === requestedGpuMode) return session;
+  }
+  if (_thumbnailBrowserLease) await closeThumbnailBrowser();
+  _thumbnailBrowserInitializing = (async () => {
+    try {
+      if (isShuttingDown()) return null;
+      const { ensureBrowser } = await import("./manager-CT3D67CG.js");
+      const { acquireBrowser, buildChromeArgs } = await import("./src-PVYUYV3M.js");
+      let executablePath;
+      try {
+        const b = await ensureBrowser({ preferManagedChrome: true });
+        executablePath = b.executablePath;
+        if (b.executablePath && !process.env.PRODUCER_HEADLESS_SHELL_PATH) {
+          process.env.PRODUCER_HEADLESS_SHELL_PATH = b.executablePath;
+        }
+      } catch {
+      }
+      const resolvedGpuMode = await resolveCaptureBrowserGpuMode(requestedGpuMode, executablePath);
+      const acquired = await acquireBrowser(
+        buildChromeArgs(
+          { width: 1920, height: 1080, captureMode: "screenshot" },
+          { browserGpuMode: resolvedGpuMode }
+        ),
+        { forceScreenshot: true }
+      );
+      _thumbnailBrowserLease = acquired;
+      _thumbnailBrowserModes = { requested: requestedGpuMode, resolved: resolvedGpuMode };
+      acquired.browser.on("disconnected", () => {
+        if (_thumbnailBrowserLease !== acquired) return;
+        _thumbnailBrowserLease = null;
+        _thumbnailBrowserModes = null;
+        _thumbnailBrowserInitializing = null;
+      });
+      return { browser: acquired.browser, requestedGpuMode, resolvedGpuMode };
+    } catch (err) {
+      console.warn(
+        "[Studio] Failed to launch thumbnail browser:",
+        err instanceof Error ? err.message : err
+      );
+      _thumbnailBrowserInitializing = null;
+      return null;
+    }
+  })();
+  return _thumbnailBrowserInitializing;
+}
+async function closeThumbnailBrowser() {
+  thumbnailPages.closeAll();
+  if (_thumbnailBrowserInitializing) await _thumbnailBrowserInitializing.catch(() => {
+  });
+  if (!_thumbnailBrowserLease) return;
+  const lease = _thumbnailBrowserLease;
+  _thumbnailBrowserLease = null;
+  _thumbnailBrowserModes = null;
+  _thumbnailBrowserInitializing = null;
+  await lease.release().catch(() => {
+  });
+}
+async function loadPreviewServerBuildSignature() {
+  const runtimeSignature = await loadRuntimeSourceSignature();
+  const studioBundle = resolveStudioBundle();
+  const studioIndex = studioBundle.available ? readBundleFile(studioBundle.indexPath)?.toString("utf-8") ?? "" : "";
+  return hashSignatureParts([
+    VERSION,
+    runtimeSignature,
+    studioIndex,
+    createStudioServer.toString(),
+    createStudioApi.toString(),
+    createProjectSignature.toString(),
+    getMimeType.toString(),
+    getElementScreenshotClip.toString()
+  ]);
+}
+function rewriteWrittenToHostViewport(projectDir, written) {
+  const indexPath = join2(projectDir, "index.html");
+  if (!existsSync2(indexPath)) return;
+  const indexHtml = readFileSync2(indexPath, "utf-8");
+  const hostW = indexHtml.match(/data-width="(\d+)"/)?.[1];
+  const hostH = indexHtml.match(/data-height="(\d+)"/)?.[1];
+  if (!hostW || !hostH) return;
+  for (const absPath of written) {
+    if (!absPath.endsWith(".html")) continue;
+    let content = readFileSync2(absPath, "utf-8");
+    content = content.replace(
+      /(<meta\s+name="viewport"\s+content="width=)\d+(,\s*height=)\d+/i,
+      `$1${hostW}$2${hostH}`
+    );
+    content = content.replace(
+      /(\bwidth:\s*)\d+(px;\s*\n?\s*height:\s*)\d+(px;)/g,
+      (match, pre, mid, post) => {
+        if (match.includes("1920") || match.includes("1080")) {
+          return `${pre}${hostW}${mid}${hostH}${post}`;
+        }
+        return match;
+      }
+    );
+    replaceFileAtomically(absPath, content, statSync2(absPath).mode);
+  }
+}
+function createStudioServer(options) {
+  const { projectDir, projectName } = options;
+  const projectId = projectName || basename(projectDir);
+  const browserGpuMode = options.browserGpuMode ?? resolveLocalBrowserGpuMode();
+  const studioDir = resolveDistDir();
+  const runtimePath = resolveRuntimePath();
+  stampProjectHfIds(projectDir);
+  const watcher = createProjectWatcher(projectDir);
+  const project = { id: projectId, dir: projectDir, title: projectId };
+  let cachedProjectSignature = null;
+  watcher.addListener((changedPath) => {
+    if (affectsProjectSignature(projectDir, join2(projectDir, changedPath))) {
+      cachedProjectSignature = null;
+    }
+  });
+  const projectSignature = (dir) => {
+    if (resolve2(dir) !== resolve2(projectDir)) return createProjectSignature(dir);
+    cachedProjectSignature ??= createProjectSignature(projectDir);
+    return cachedProjectSignature;
+  };
+  let ownerWaitMs;
+  const histories = historyCache(
+    () => openProjectHistory({
+      projectDir,
+      historyRoot: options.historyRoot ?? DEFAULT_HISTORY_ROOT,
+      ownerWaitMs
+    }).then((history) => {
+      ownerWaitMs = void 0;
+      return history;
+    }).catch((error) => {
+      console.warn(`[studio] Project history is off: ${String(error)}`);
+      if (error instanceof HistoryBusyError) ownerWaitMs = 0;
+      if (error instanceof HistoryBusyError || error instanceof HistoryClosedError)
+        histories.forget(projectDir);
+      return null;
+    })
+  );
+  const projectHistory = () => histories.get(projectDir);
+  watcher.addListener((changedPath) => {
+    void histories.peek(projectDir)?.then((opened) => opened?.noteChange(changedPath));
+  });
+  const inFlightRenders = /* @__PURE__ */ new Map();
+  let shuttingDown = false;
+  const adapter = {
+    history: () => projectHistory(),
+    // Explicit option wins (preview's resolved --proxy/--no-proxy + config);
+    // otherwise honor the project's hyperframes.json media.autoProxy so every
+    // createStudioServer caller (e.g. the background preview child) gets the
+    // configured behavior without its own plumbing.
+    autoProxy: options.autoProxy ?? resolveAutoProxy(projectDir, void 0),
+    listProjects: () => [project],
+    // Salted with the running CLI file, so an upgraded CLI never serves an older build's document.
+    previewDocuments: createPreviewDocumentStore(
+      projectDir,
+      createHash2("sha256").update(readFileSync2(fileURLToPath(import.meta.url))).digest("hex")
+    ),
+    resolveProject: (id) => id === projectId ? project : null,
+    async bundle(dir, options2) {
+      try {
+        const { bundleToSingleHtml } = await import("./compiler-QO36EXLS.js");
+        let html = await bundleToSingleHtml(dir, { ...PREVIEW_BUNDLE_OPTIONS, ...options2 });
+        html = html.replace(
+          'data-hyperframes-preview-runtime="1" src=""',
+          'data-hyperframes-preview-runtime="1" src="/api/runtime.js"'
+        );
+        return html;
+      } catch (err) {
+        console.error("[studio] Bundle failed:", err);
+        return null;
+      }
+    },
+    async transformPreviewHtml({ html, project: project2 }) {
+      const { injectDeterministicFontFaces } = await import("./deterministicFonts-HAEMV4TM.js");
+      const { prepareAnimatedGifInputs } = await import("./animatedGifPrep-P2T6YM7Z.js");
+      const { downloadToTemp, writeUrlDownloadTelemetry } = await import("./urlDownloader-H6WRI2UE.js");
+      const gifOutputDir = join2(project2.dir, ".hyperframes", "prepared-assets", "gif");
+      const gifDownloadDir = join2(project2.dir, ".hyperframes", "prepared-assets", "downloads");
+      const prepared = await prepareAnimatedGifInputs(html, {
+        projectDir: project2.dir,
+        downloadDir: gifDownloadDir,
+        outputDir: gifOutputDir,
+        outputSrcPrefix: ".hyperframes/prepared-assets/gif",
+        cacheDir: gifOutputDir,
+        sourceAssets: await downloadRemoteGifImageSources(
+          html,
+          gifDownloadDir,
+          (url, destDir) => downloadToTemp(url, destDir, void 0, void 0, void 0, {
+            onTelemetry: writeUrlDownloadTelemetry
+          })
+        )
+      });
+      return injectDeterministicFontFaces(prepared.html);
+    },
+    getProjectSignature: projectSignature,
+    invalidateProjectSignature: (dir) => {
+      if (resolve2(dir) === resolve2(projectDir)) cachedProjectSignature = null;
+    },
+    async lint(html, opts) {
+      const { lintHyperframeHtml } = await import("./dist-FNNGCKFS.js");
+      return await lintHyperframeHtml(html, { ...opts, host: "studio" });
+    },
+    // Out of process: linting a large composition is seconds of synchronous parsing, and on
+    // this event loop it stalls every other Studio request, the preview included.
+    lintProject: (dir) => runRenderSetupWorker(
+      "lint",
+      { projectDir: dir, host: "studio" },
+      { maxBufferBytes: 8 * 1024 * 1024 }
+    ),
+    runtimeUrl: "/api/runtime.js",
+    rendersDir: () => join2(projectDir, "renders"),
+    startRender(opts) {
+      if (shuttingDown) {
+        return {
+          id: opts.jobId,
+          status: "failed",
+          progress: 0,
+          outputPath: opts.outputPath,
+          error: "Studio server is shutting down"
+        };
+      }
+      refreshTelemetryPosture();
+      const abortController = new AbortController();
+      const state = {
+        id: opts.jobId,
+        status: "rendering",
+        progress: 0,
+        outputPath: opts.outputPath,
+        cancel: () => abortController.abort()
+      };
+      const startTime = Date.now();
+      const run = (async () => {
+        let renderJob;
+        const removeCancelledOutput = () => {
+          state.status = "cancelled";
+          for (const suffix of ["", ".meta.json"]) {
+            const fp = suffix ? opts.outputPath.replace(/\.(mp4|webm|mov)$/, suffix) : opts.outputPath;
+            try {
+              if (existsSync2(fp)) unlinkSync(fp);
+            } catch {
+            }
+          }
+        };
+        try {
+          const { createRenderJob, executeRenderJob } = await loadStudioProducer();
+          const browser = await resolveRenderBrowser(abortController.signal);
+          if (!process.env.PRODUCER_HEADLESS_SHELL_PATH) {
+            process.env.PRODUCER_HEADLESS_SHELL_PATH = browser.executablePath;
+          }
+          const manifestContent = readStudioManualEditManifestContent(opts.project.dir);
+          const manualEditsRenderScript = createStudioManualEditsRenderBodyScript(manifestContent);
+          const job = createRenderJob({
+            // opts.fps is already an Fps rational — see vite-config-studio
+            // adapter for the same convention.
+            fps: opts.fps,
+            quality: opts.quality,
+            format: opts.format,
+            outputResolution: opts.outputResolution,
+            ...manualEditsRenderScript ? { renderBodyScripts: [manualEditsRenderScript] } : {},
+            ...opts.composition ? { entryFile: opts.composition } : {},
+            ...opts.variables ? { variables: opts.variables } : {}
+          });
+          renderJob = job;
+          const onProgress = (j) => {
+            state.progress = j.progress;
+            if (j.currentStage) state.stage = j.currentStage;
+          };
+          await executeRenderJob(
+            job,
+            opts.project.dir,
+            opts.outputPath,
+            onProgress,
+            abortController.signal
+          );
+          if (abortController.signal.aborted) {
+            removeCancelledOutput();
+            return;
+          }
+          if (job.audioLoweredDb !== void 0) state.audioLoweredDb = job.audioLoweredDb;
+          state.status = "complete";
+          state.progress = 100;
+          const metaPath = opts.outputPath.replace(/\.(mp4|webm|mov)$/, ".meta.json");
+          writeFileSync(
+            metaPath,
+            JSON.stringify({
+              status: "complete",
+              durationMs: Date.now() - startTime,
+              ...job.audioLoweredDb !== void 0 ? { audioLoweredDb: job.audioLoweredDb } : {}
+            })
+          );
+          refreshTelemetryPosture();
+          emitStudioRenderComplete(opts, Date.now() - startTime, job.perfSummary);
+        } catch (err) {
+          if (abortController.signal.aborted) {
+            removeCancelledOutput();
+            return;
+          }
+          state.status = "failed";
+          state.error = err instanceof Error ? err.message : String(err);
+          refreshTelemetryPosture();
+          emitStudioRenderError(opts, Date.now() - startTime, state.stage, err, renderJob);
+          try {
+            const metaPath = opts.outputPath.replace(/\.(mp4|webm|mov)$/, ".meta.json");
+            writeFileSync(metaPath, JSON.stringify({ status: "failed" }));
+          } catch {
+          }
+        }
+      })();
+      inFlightRenders.set(abortController, run);
+      const forget = () => void inFlightRenders.delete(abortController);
+      run.then(forget, forget);
+      return state;
+    },
+    startBackgroundRemoval(opts) {
+      return createBackgroundRemovalJob(opts, async (renderOpts) => {
+        const sourcePipelinePath = "../background-removal/pipeline.ts";
+        const pipeline = await import("./pipeline-TNGWUZQC.js").catch(
+          () => import(sourcePipelinePath)
+        );
+        return pipeline.render(renderOpts);
+      });
+    },
+    async generateThumbnail(opts) {
+      const session = await getThumbnailBrowser(browserGpuMode, () => shuttingDown);
+      if (!session) {
+        if (!shuttingDown) {
+          console.warn("[Studio] Thumbnail: no browser available \u2014 Chrome may not be installed");
+        }
+        return null;
+      }
+      const sourcePath = join2(opts.project.dir, opts.compPath);
+      const requiresWebGpu = existsSync2(sourcePath) ? compositionRequiresWebGpu(readFileSync2(sourcePath, "utf-8")) : false;
+      if (opts.signal.aborted) return null;
+      const width = opts.width || 1920;
+      const height = opts.height || 1080;
+      const viewport = { width, height, deviceScaleFactor: thumbnailDeviceScaleFactor(opts) };
+      try {
+        return await thumbnailPages.withPage(
+          session.browser,
+          opts.previewUrl,
+          projectSignature(opts.project.dir),
+          opts.seekTime,
+          async (page) => {
+            await page.setViewport(viewport);
+            await page.goto(opts.previewUrl, { waitUntil: "domcontentloaded", timeout: 1e4 });
+            await assertWebGpuAdapterAvailable(page, requiresWebGpu);
+            await page.waitForFunction(
+              () => {
+                const w = window;
+                return !!(w.__timelines && Object.keys(w.__timelines).length > 0);
+              },
+              { timeout: 5e3 }
+            ).catch(() => {
+            });
+          },
+          async (page) => {
+            if (opts.signal.aborted) return null;
+            await page.setViewport(viewport);
+            await seekCompositionTimeline(page, opts.seekTime, {
+              fallbackToBridgeAndTimelines: true,
+              waitForPreferredSeekTargetMs: 500,
+              animationFrameSettle: "double",
+              waitForFontsMs: 500
+            });
+            const manifestContent = readStudioManualEditManifestContent(opts.project.dir);
+            await applyStudioManualEditsToThumbnailPage(page, manifestContent, opts.compPath);
+            await page.evaluate(() => {
+              void document.fonts?.ready;
+              const body = document.body;
+              if (body && getComputedStyle(body).backgroundColor === "rgba(0, 0, 0, 0)") {
+                body.style.backgroundColor = "#1c2028";
+              }
+            });
+            await new Promise((r) => setTimeout(r, 200));
+            await reapplyStudioManualEditsToThumbnailPage(page);
+            if (opts.signal.aborted) return null;
+            try {
+              const clip = opts.selector ? await page.evaluate(getElementScreenshotClip, opts.selector, opts.selectorIndex) : void 0;
+              return await page.screenshot(
+                opts.format === "png" ? { type: "png", ...clip ? { clip } : {} } : { type: "jpeg", quality: 80, ...clip ? { clip } : {} }
+              );
+            } finally {
+              if (opts.selector) await page.evaluate(clearElementScreenshotIsolation);
+            }
+          }
+        );
+      } catch (err) {
+        if (!opts.signal.aborted) {
+          console.warn(
+            "[Studio] Thumbnail generation failed:",
+            err instanceof Error ? err.message : err
+          );
+        }
+        return null;
+      }
+    },
+    async listRegistryCatalog() {
+      const { listRegistryItems, loadAllItems } = await import("./resolver-IZ647GBZ.js");
+      const { loadProjectConfig } = await import("./projectConfig-HYJMJ5BY.js");
+      const registry = { baseUrl: loadProjectConfig(projectDir).registry };
+      const entries = await listRegistryItems(void 0, registry);
+      const blockAndComponentEntries = entries.filter(
+        (e) => e.type === "hyperframes:block" || e.type === "hyperframes:component"
+      );
+      return loadAllItems(blockAndComponentEntries, registry);
+    },
+    async installRegistryBlock(opts) {
+      const { addToProject, primaryInstalledTarget } = await import("./add-LR3ZR2A5.js");
+      const { recordRewrittenInstall } = await import("./installer-K6O5WF44.js");
+      const { registryTargetPath } = await import("./publication-HQ5Y3KBM.js");
+      const { result, item } = await addToProject({
+        name: opts.blockName,
+        projectDir: opts.project.dir,
+        skipClipboard: true,
+        source: "studio"
+      });
+      for (const warning of result.warnings) {
+        process.stderr.write(`hyperframes:registry ${warning}
+`);
+      }
+      const written = result.written;
+      rewriteWrittenToHostViewport(opts.project.dir, written);
+      recordRewrittenInstall(opts.project.dir, written);
+      const root = realpath(opts.project.dir);
+      const primary = primaryInstalledTarget(item);
+      const primaryPath = registryTargetPath(root, primary);
+      const others = written.filter((abs) => abs !== primaryPath).map((abs) => relative2(root, abs).split(sep2).join("/"));
+      return {
+        written: written.includes(primaryPath) ? [primary, ...others] : others,
+        block: item
+      };
+    }
+  };
+  const app = new Hono();
+  app.get("/__hyperframes_config", (c) => {
+    const serve = async () => {
+      const serverBuildSignature = await loadPreviewServerBuildSignature();
+      return c.json({
+        isHyperframes: true,
+        pid: process.pid,
+        projectName: projectId,
+        projectDir,
+        serverBuildSignature,
+        browserGpuMode,
+        version: VERSION
+      });
+    };
+    return serve();
+  });
+  app.get("/api/runtime.js", (c) => {
+    const serve = async () => {
+      const runtimeSource = await loadRuntimeSource() ?? readBundleFile(runtimePath)?.toString("utf-8") ?? null;
+      if (!runtimeSource) return c.text("runtime not available", 404);
+      return c.body(runtimeSource, 200, {
+        "Content-Type": "text/javascript",
+        "Cache-Control": "no-store"
+      });
+    };
+    return serve();
+  });
+  app.get("/api/telemetry-identity", (c) => {
+    if (!identityAllowed(c.req.header("host"))) {
+      return c.json({ error: "forbidden" }, 403);
+    }
+    refreshTelemetryPosture();
+    return c.json({ distinctId: resolveCliTelemetryDistinctId() });
+  });
+  app.get("/api/events", (c) => {
+    return streamSSE(c, async (stream) => {
+      const listener = (path) => {
+        const absPath = resolve2(projectDir, path);
+        let version = null;
+        try {
+          version = fileContentVersion(readFileSync2(absPath));
+        } catch {
+        }
+        const receipt = identifyFileWrite(absPath, version ?? DELETED_VERSION);
+        const reloads = affectsPreview(projectDir, path);
+        stream.writeSSE({
+          event: "file-change",
+          data: JSON.stringify({
+            path,
+            version,
+            projectId: project.id,
+            affectsPreview: reloads,
+            // Which thumbnails this write can change; null means all of them.
+            affectedCompositions: reloads ? compositionsAffectedBy(projectDir, path) : [],
+            ...receipt
+          })
+        }).catch(() => {
+        });
+      };
+      const wrappedListener = (changedPath) => {
+        if (shouldWatchProjectFile(changedPath)) listener(changedPath);
+      };
+      watcher.addListener(wrappedListener);
+      stream.onAbort(() => watcher.removeListener(wrappedListener));
+      try {
+        while (true) {
+          await stream.sleep(3e4);
+        }
+      } finally {
+        watcher.removeListener(wrappedListener);
+      }
+    });
+  });
+  let ffmpegReady = false;
+  app.get("/api/environment/ffmpeg", async (c) => {
+    if (ffmpegReady) return c.json({ ok: true });
+    const [{ runEnvironmentChecks }, { getFFmpegInstallCommand }] = await Promise.all([
+      import("./preflight-SMNV6RW2.js"),
+      import("./ffmpeg-QIUFEFTY.js")
+    ]);
+    const { outcomes } = await runEnvironmentChecks();
+    const failed = outcomes.find((outcome) => !outcome.ok);
+    if (!failed) {
+      ffmpegReady = true;
+      return c.json({ ok: true });
+    }
+    return c.json({
+      ok: false,
+      title: failed.title ?? `${failed.name} not found`,
+      detail: failed.detail,
+      hint: failed.hint,
+      command: getFFmpegInstallCommand()
+    });
+  });
+  mountDesktopRoutes(app, projectDir);
+  let cachedFFmpegPath;
+  app.post("/api/projects/:id/render", async (c, next) => {
+    const { findFFmpeg, getFFmpegInstallHint } = await import("./ffmpeg-QIUFEFTY.js");
+    if (!cachedFFmpegPath) {
+      cachedFFmpegPath = findFFmpeg();
+    }
+    if (!cachedFFmpegPath) {
+      return c.json({ error: "FFmpeg not found", hint: getFFmpegInstallHint() }, 503);
+    }
+    return next();
+  });
+  const api = createStudioApi(adapter);
+  app.all("/api/*", async (c) => {
+    const url = new URL(c.req.url);
+    url.pathname = url.pathname.slice(4);
+    const forwardReq = new Request(url.toString(), {
+      method: c.req.method,
+      headers: c.req.raw.headers,
+      body: c.req.raw.body,
+      // @ts-expect-error -- Node needs duplex for streaming bodies
+      duplex: "half"
+    });
+    return api.fetch(forwardReq);
+  });
+  const serveStudioStaticFile = (cacheControl) => (c) => {
+    const filePath = resolve2(studioDir, c.req.path.slice(1));
+    if (!isWithinProjectRoot(studioDir, filePath)) return c.text("not found", 404);
+    const content = readBundleFile(filePath);
+    if (content === null) return c.text("not found", 404);
+    return new Response(content, {
+      headers: { "Content-Type": getMimeType(filePath), "Cache-Control": cacheControl }
+    });
+  };
+  app.get("/assets/*", serveStudioStaticFile(IMMUTABLE_CACHE_CONTROL));
+  app.get("/icons/*", serveStudioStaticFile("no-store"));
+  app.get("/favicon.svg", serveStudioStaticFile("no-store"));
+  function buildRuntimeEnvScript() {
+    const overrides = {};
+    for (const [key, value] of Object.entries(process.env)) {
+      if (key.startsWith("VITE_STUDIO_") && value !== void 0) {
+        overrides[key] = value;
+      }
+    }
+    if (Object.keys(overrides).length === 0) return "";
+    return `<script>window.__HF_STUDIO_ENV__=${JSON.stringify(overrides)};</script>`;
+  }
+  app.get("*", (c) => {
+    const indexPath = resolve2(studioDir, "index.html");
+    const indexContent = readBundleFile(indexPath);
+    if (indexContent === null) {
+      return c.html(
+        `<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>HyperFrames Studio unavailable</title>
+    <style>
+      body {
+        margin: 0;
+        min-height: 100vh;
+        display: grid;
+        place-items: center;
+        background: #0d0f14;
+        color: #eef2f7;
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      }
+      main {
+        width: min(560px, calc(100vw - 48px));
+        border: 1px solid rgba(255, 255, 255, 0.14);
+        border-radius: 8px;
+        padding: 28px;
+        background: #151923;
+      }
+      h1 {
+        margin: 0 0 12px;
+        font-size: 22px;
+        line-height: 1.2;
+      }
+      p {
+        margin: 0 0 18px;
+        color: #aab3c2;
+        line-height: 1.5;
+      }
+      code {
+        display: block;
+        padding: 12px 14px;
+        border-radius: 6px;
+        background: #090b10;
+        color: #8ff0c2;
+        overflow-wrap: anywhere;
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>Studio bundle missing</h1>
+      <p>The preview server started, but this CLI build does not contain the Studio assets.</p>
+      <code>bun run build</code>
+    </main>
+  </body>
+</html>`,
+        500
+      );
+    }
+    let html = indexContent.toString("utf-8");
+    const headScript = buildStudioHeadScriptsForHost(buildRuntimeEnvScript(), c.req.header("host"));
+    if (headScript) {
+      html = html.replace("<head>", `<head>${headScript}`);
+    }
+    return c.html(html, 200, { "Cache-Control": "no-cache" });
+  });
+  const shutdown = async () => {
+    shuttingDown = true;
+    const closeHistory = histories.closeAll().catch(() => {
+    });
+    const renders = [...inFlightRenders];
+    for (const [abortController] of renders) abortController.abort();
+    const { killTrackedProcesses, closeBrowserPool } = await import("./src-PVYUYV3M.js");
+    killTrackedProcesses();
+    const closeBrowsers = Promise.allSettled([
+      closeThumbnailBrowser().catch(() => {
+      }),
+      closeBrowserPool().catch(() => {
+      })
+    ]);
+    await Promise.race([
+      Promise.allSettled([...renders.map(([, done]) => done), closeHistory]),
+      new Promise((resolve3) => setTimeout(resolve3, RENDER_SHUTDOWN_WAIT_MS).unref())
+    ]);
+    await closeBrowsers;
+  };
+  return { app, watcher, adapter, shutdown };
+}
+export {
+  createStudioServer,
+  loadPreviewServerBuildSignature,
+  resolveStudioBundle
+};