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

package/node_modules/@higgsfield/higgsedit/dist/chunk-7PYXSJS7.mjs

@@ -0,0 +1,717 @@
+#!/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 {
+  SOURCE_FILE,
+  SyncError,
+  bundlePackages,
+  compileFile,
+  measureSync
+} from "./chunk-UDL5AHKO.mjs";
+import {
+  fontFiles,
+  inside,
+  readSources
+} from "./chunk-LTKMGZ6T.mjs";
+import {
+  FONT_CATEGORIES,
+  FONT_LIMIT,
+  cachedFonts,
+  listFonts
+} from "./chunk-NUXTKQNM.mjs";
+import {
+  GoogleFontsUnavailable,
+  googleFace,
+  googleFontsDir,
+  googleFontsOff
+} from "./chunk-2VKQHJMM.mjs";
+
+// src/assets.ts
+import { join } from "node:path";
+var PACKAGED = true;
+function packagedAsset(name) {
+  return globalThis.higgseditAssets?.[name] ?? join(import.meta.dirname, name);
+}
+
+// src/media-upload.ts
+import { randomUUID } from "node:crypto";
+import {
+  constants,
+  linkSync,
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  realpathSync,
+  readdirSync,
+  renameSync,
+  rmdirSync,
+  statSync
+} from "node:fs";
+import { open, rm } from "node:fs/promises";
+import { extname, join as join2 } from "node:path";
+var json = (res, status, body) => {
+  res.statusCode = status;
+  res.setHeader("content-type", "application/json");
+  res.end(JSON.stringify(body));
+};
+var MEDIA_UPLOAD_PART_BYTES = 2 << 20;
+var MEDIA_UPLOAD_TEMP_PREFIX = ".higgsedit-upload-";
+function isPrivateMediaUploadPath(path) {
+  return path.split(/[/\\]/).some((part) => part.toUpperCase().startsWith(MEDIA_UPLOAD_TEMP_PREFIX.toUpperCase()));
+}
+var defaults = {
+  maxBytes: 8 * 1024 ** 3,
+  idleMs: 6e4,
+  totalMs: 30 * 6e4,
+  maxConcurrent: 4
+};
+var envKeys = {
+  maxBytes: "HIGGSEDIT_MEDIA_MAX_BYTES",
+  idleMs: "HIGGSEDIT_MEDIA_IDLE_MS",
+  totalMs: "HIGGSEDIT_MEDIA_TOTAL_MS",
+  maxConcurrent: "HIGGSEDIT_MEDIA_MAX_CONCURRENT"
+};
+var UploadError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+var MediaUploads = class {
+  active = /* @__PURE__ */ new Map();
+  root;
+  rootIdentity;
+  closed = false;
+  limits;
+  constructor(dir, limits = {}) {
+    this.root = realpathSync(dir);
+    this.rootIdentity = lstatSync(this.root);
+    this.limits = { ...defaults };
+    for (const key of Object.keys(defaults)) {
+      const value = limits[key] ?? (process.env[envKeys[key]] ? Number(process.env[envKeys[key]]) : defaults[key]);
+      if (!Number.isSafeInteger(value) || value <= 0)
+        throw new Error(`${envKeys[key]} must be a positive safe integer`);
+      this.limits[key] = value;
+    }
+  }
+  get busy() {
+    return this.active.size > 0;
+  }
+  async close() {
+    this.closed = true;
+    await Promise.all(
+      [...this.active.values()].map((u) => this.dispose(u, new UploadError("editor closed", 503)))
+    );
+  }
+  checkMedia() {
+    const root = lstatSync(this.root);
+    if (root.isSymbolicLink() || root.dev !== this.rootIdentity.dev || root.ino !== this.rootIdentity.ino)
+      throw new UploadError("project directory changed during upload", 400);
+    const media = join2(this.root, "media");
+    mkdirSync(media, { recursive: true });
+    const st = lstatSync(media);
+    if (!st.isDirectory() || st.isSymbolicLink() || realpathSync(media) !== media)
+      throw new UploadError("media must be a real project directory, not a symlink", 400);
+    return media;
+  }
+  async begin(name) {
+    if (!name || name.startsWith(".") || /[/\\]/.test(name) || [...name].some((c) => c.charCodeAt(0) < 32 || c.charCodeAt(0) === 127) || Buffer.byteLength(name) > 240)
+      throw new UploadError("invalid media filename", 400);
+    if (this.closed) throw new UploadError("editor closed", 503);
+    if (this.active.size >= this.limits.maxConcurrent)
+      throw new UploadError("too many active media uploads; try again after one finishes", 429);
+    const directory = lstatSync(this.checkMedia());
+    const temp = mkdtempSync(join2(this.checkMedia(), MEDIA_UPLOAD_TEMP_PREFIX));
+    const u = {
+      id: randomUUID(),
+      name,
+      temp,
+      directory,
+      staging: lstatSync(temp),
+      bytes: 0,
+      busy: true,
+      abort: new AbortController()
+    };
+    this.active.set(u.id, u);
+    try {
+      u.file = await open(
+        join2(temp, "body"),
+        constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW,
+        384
+      );
+      if (u.abort.signal.aborted) {
+        await u.file.close();
+        u.abort.signal.throwIfAborted();
+      }
+      u.total = setTimeout(() => {
+        void this.dispose(u, new UploadError("media upload exceeded its total time limit", 408));
+      }, this.limits.totalMs);
+      u.total.unref();
+      u.busy = false;
+      this.touch(u);
+      return u;
+    } catch (error) {
+      await this.dispose(u, error);
+      throw error;
+    }
+  }
+  touch(u) {
+    clearTimeout(u.idle);
+    u.idle = setTimeout(() => {
+      void this.dispose(u, new UploadError("media upload stalled", 408));
+    }, this.limits.idleMs);
+    u.idle.unref();
+  }
+  dispose(u, reason = new UploadError("media upload cancelled", 499)) {
+    if (u.cleanup) return u.cleanup;
+    u.abort.abort(reason);
+    clearTimeout(u.idle);
+    clearTimeout(u.total);
+    u.cleanup = (async () => {
+      let failure;
+      try {
+        await u.file?.close();
+      } catch (error) {
+        failure = error;
+      }
+      try {
+        let current;
+        try {
+          current = lstatSync(u.temp);
+        } catch (error) {
+          if (error.code !== "ENOENT") throw error;
+        }
+        if (current?.isDirectory() && !current.isSymbolicLink() && current.dev === u.staging.dev && current.ino === u.staging.ino)
+          await rm(u.temp, { recursive: true, force: true });
+      } catch (error) {
+        failure ??= error;
+      }
+      this.active.delete(u.id);
+      if (failure) throw failure;
+    })();
+    void u.cleanup.catch(() => {
+    });
+    return u.cleanup;
+  }
+  declared(req, maximum) {
+    const length = req.headers["content-length"];
+    if (length !== void 0 && (!/^\d+$/.test(length) || !Number.isSafeInteger(Number(length)) || Number(length) > maximum)) {
+      throw new UploadError(`media upload exceeds the ${maximum} byte limit`, 413);
+    }
+  }
+  async append(u, req, maxPart) {
+    this.declared(req, Math.min(maxPart, this.limits.maxBytes - u.bytes));
+    let partBytes = 0;
+    const signal = u.abort.signal;
+    while (true) {
+      signal.throwIfAborted();
+      if (req.aborted || req.destroyed && !req.complete)
+        throw new UploadError("media upload disconnected", 499);
+      const bytes = req.read();
+      if (bytes === null) {
+        if (req.readableEnded) break;
+        await new Promise((resolve, reject) => {
+          const clean = () => {
+            req.off("readable", ready);
+            req.off("end", ready);
+            req.off("error", fail);
+            req.off("aborted", disconnected);
+            signal.removeEventListener("abort", aborted);
+          };
+          const ready = () => {
+            clean();
+            resolve();
+          };
+          const fail = (error) => {
+            clean();
+            reject(error);
+          };
+          const disconnected = () => fail(new UploadError("media upload disconnected", 499));
+          const aborted = () => fail(signal.reason);
+          req.once("readable", ready);
+          req.once("end", ready);
+          req.once("error", fail);
+          req.once("aborted", disconnected);
+          signal.addEventListener("abort", aborted, { once: true });
+          if (signal.aborted) aborted();
+        });
+        continue;
+      }
+      partBytes += bytes.byteLength;
+      if (partBytes > maxPart || u.bytes + bytes.byteLength > this.limits.maxBytes)
+        throw new UploadError(`media upload exceeds the ${this.limits.maxBytes} byte limit`, 413);
+      this.touch(u);
+      for (let offset = 0; offset < bytes.byteLength; ) {
+        signal.throwIfAborted();
+        const { bytesWritten } = await u.file.write(bytes, offset, bytes.byteLength - offset);
+        if (!bytesWritten) throw new Error("could not write media upload");
+        offset += bytesWritten;
+      }
+      u.bytes += bytes.byteLength;
+      this.touch(u);
+    }
+    signal.throwIfAborted();
+  }
+  async publish(u) {
+    await u.file.sync();
+    u.abort.signal.throwIfAborted();
+    const written = await u.file.stat();
+    u.abort.signal.throwIfAborted();
+    const media = this.checkMedia();
+    const directory = lstatSync(media);
+    const staging = lstatSync(u.temp);
+    const current = lstatSync(join2(u.temp, "body"));
+    if (directory.dev !== u.directory.dev || directory.ino !== u.directory.ino || staging.isSymbolicLink() || staging.dev !== u.staging.dev || staging.ino !== u.staging.ino || !current.isFile() || current.isSymbolicLink() || current.dev !== written.dev || current.ino !== written.ino || current.size !== u.bytes)
+      throw new UploadError("media upload destination changed", 409);
+    const ext = extname(u.name);
+    const stem = u.name.slice(0, u.name.length - ext.length);
+    for (let suffix = 1; suffix <= 1e4; suffix++) {
+      const name = suffix === 1 ? u.name : `${stem}-${suffix}${ext}`;
+      try {
+        linkSync(join2(u.temp, "body"), join2(media, name));
+      } catch (error) {
+        const code = error.code;
+        if (code === "EEXIST") continue;
+        if (!["ENOTSUP", "EOPNOTSUPP", "EPERM", "EXDEV", "ENOSYS"].includes(code ?? ""))
+          throw error;
+        const reserved = mkdtempSync(join2(media, "import-"));
+        try {
+          renameSync(join2(u.temp, "body"), join2(reserved, u.name));
+        } catch (failure) {
+          try {
+            rmdirSync(reserved);
+          } catch {
+          }
+          throw failure;
+        }
+        return { src: `./media/${reserved.slice(media.length + 1)}/${u.name}`, byteSize: u.bytes };
+      }
+      return { src: `./media/${name}`, byteSize: u.bytes };
+    }
+    throw new UploadError("too many media files with this name", 409);
+  }
+  async handle(req, res, url) {
+    if (isPrivateMediaUploadPath(decodeURIComponent(url.pathname))) {
+      json(res, 403, { error: "private upload" });
+      return true;
+    }
+    if (url.pathname === "/api/media/capabilities" && req.method === "GET") {
+      json(res, 200, {
+        streaming: true,
+        version: 1,
+        maxBytes: this.limits.maxBytes,
+        partBytes: MEDIA_UPLOAD_PART_BYTES,
+        maxConcurrent: this.limits.maxConcurrent
+      });
+      return true;
+    }
+    const direct = (url.pathname === "/api/media" || url.pathname === "/api/media/stream") && req.method === "POST";
+    const begin = url.pathname === "/api/media/uploads" && req.method === "POST";
+    const part = /^\/api\/media\/uploads\/([a-f0-9-]{36})$/.exec(url.pathname);
+    if (!direct && !begin && !part) return false;
+    let u;
+    let owns = false;
+    const disconnected = () => {
+      if (u && !res.writableFinished)
+        void this.dispose(u, new UploadError("media upload disconnected", 499));
+    };
+    res.once("close", disconnected);
+    try {
+      if (direct || begin) {
+        this.declared(req, direct ? this.limits.maxBytes : 0);
+        if (begin && req.headers["transfer-encoding"])
+          throw new UploadError("upload session creation takes no body", 400);
+        u = await this.begin(url.searchParams.get("name") ?? "");
+        if (res.destroyed) throw new UploadError("media upload disconnected", 499);
+        if (begin) {
+          json(res, 201, {
+            id: u.id,
+            maxBytes: this.limits.maxBytes,
+            partBytes: MEDIA_UPLOAD_PART_BYTES
+          });
+          return true;
+        }
+      } else {
+        u = this.active.get(part[1]);
+        if (req.method !== "PUT") {
+          this.declared(req, 0);
+          if (req.headers["transfer-encoding"])
+            throw new UploadError("upload finalization and cancellation take no body", 400);
+        }
+        if (!u) throw new UploadError("media upload not found or expired", 404);
+        if (req.method === "DELETE") {
+          await this.dispose(u);
+          json(res, 200, { ok: true });
+          return true;
+        }
+        if (u.busy) throw new UploadError("media upload already has a request in progress", 409);
+        if (req.method !== "PUT" && req.method !== "POST")
+          throw new UploadError("unsupported upload method", 405);
+        if (req.method === "PUT" && (!/^\d+$/.test(url.searchParams.get("offset") ?? "") || Number(url.searchParams.get("offset")) !== u.bytes))
+          throw new UploadError("media upload offset does not match", 409);
+      }
+      u.busy = true;
+      owns = true;
+      if (direct || req.method === "PUT")
+        await this.append(u, req, direct ? this.limits.maxBytes : MEDIA_UPLOAD_PART_BYTES);
+      if (direct || req.method === "POST") {
+        const result = await this.publish(u);
+        await this.dispose(u);
+        json(res, 200, result);
+      } else {
+        u.busy = false;
+        this.touch(u);
+        json(res, 200, { offset: u.bytes });
+      }
+    } catch (error) {
+      if (u && (owns || direct || begin)) await this.dispose(u, error);
+      if (!res.destroyed) {
+        if (!req.complete) {
+          res.setHeader("connection", "close");
+          res.once("finish", () => req.destroy());
+        }
+        json(res, error instanceof UploadError ? error.status : 500, {
+          error: error instanceof Error ? error.message : "media upload failed"
+        });
+      }
+    } finally {
+      res.off("close", disconnected);
+    }
+    return true;
+  }
+};
+function listMediaFiles(media) {
+  let entries;
+  try {
+    entries = readdirSync(media, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  const files = [];
+  for (const entry of entries) {
+    if (entry.isFile() && !entry.name.startsWith("."))
+      files.push({
+        src: `./media/${entry.name}`,
+        byteSize: statSync(join2(media, entry.name)).size
+      });
+    else if (entry.isDirectory() && /^import-[a-zA-Z0-9]{6}$/.test(entry.name)) {
+      for (const child of readdirSync(join2(media, entry.name), { withFileTypes: true })) {
+        if (child.isFile() && !child.name.startsWith("."))
+          files.push({
+            src: `./media/${entry.name}/${child.name}`,
+            byteSize: statSync(join2(media, entry.name, child.name)).size
+          });
+      }
+    }
+  }
+  return files.toSorted((a, b) => a.src.localeCompare(b.src));
+}
+
+// src/server.ts
+import { createHash } from "node:crypto";
+import { createReadStream, readFileSync, statSync as statSync2 } from "node:fs";
+import { createServer } from "node:http";
+import { extname as extname2 } from "node:path";
+
+// src/bundle.ts
+import { readFile } from "node:fs/promises";
+import { join as join3 } from "node:path";
+var PAGE_SRC = join3(import.meta.dirname, "../../../packages/editor-document/src");
+var cache = /* @__PURE__ */ new Map();
+function pageBundle(entry) {
+  let bundle = cache.get(entry);
+  if (!bundle) {
+    if (PACKAGED) {
+      bundle = readFile(packagedAsset("capture-page.js"), "utf8");
+      cache.set(entry, bundle);
+      return bundle;
+    }
+    bundle = import("esbuild").then(({ build }) => build({
+      entryPoints: [join3(PAGE_SRC, `${entry}.ts`)],
+      bundle: true,
+      write: false,
+      format: "esm",
+      platform: "browser",
+      target: "chrome120",
+      minify: false,
+      sourcemap: false,
+      logLevel: "silent",
+      define: { "process.env.NODE_ENV": '"production"', "process.env.BABEL_TYPES_8_BREAKING": "false" },
+      alias: { assert: join3(PAGE_SRC, "shims/assert.cjs") },
+      banner: { js: "globalThis.process ??= { env: {}, cwd: () => '/', platform: 'browser' };" }
+    })).then((r) => r.outputFiles[0].text);
+    cache.set(entry, bundle);
+  }
+  return bundle;
+}
+
+// src/fonts/route.ts
+import { relative, sep } from "node:path";
+var FILE = "/__higgsedit/fonts/file/";
+var MAX_LIMIT = 200;
+var count = (raw, fallback, max) => {
+  const n = Number.parseInt(raw ?? "", 10);
+  return Number.isFinite(n) ? Math.min(Math.max(n, 0), max) : fallback;
+};
+function json2(res, status, body) {
+  res.statusCode = status;
+  res.setHeader("content-type", "application/json");
+  res.end(JSON.stringify(body));
+}
+async function fontsRoute(req, res, path, url, sendFile2) {
+  if (path === "/__higgsedit/fonts/list") {
+    await listRoute(res, url);
+    return true;
+  }
+  if (path === "/__higgsedit/fonts/google") {
+    const family = url.searchParams.get("family") ?? "";
+    const weight = Number(url.searchParams.get("weight") ?? 400);
+    const style = url.searchParams.get("style") === "italic" ? "italic" : "normal";
+    try {
+      const face = family ? await googleFace(family, Number.isFinite(weight) ? weight : 400, style) : null;
+      if (!face) {
+        json2(res, 200, null);
+        return true;
+      }
+      const file = relative(googleFontsDir(), face.file).split(sep).map(encodeURIComponent).join("/");
+      const answer = { family: face.family, weight: face.weight, style: face.style, url: `${FILE}${file}` };
+      json2(res, 200, answer);
+    } catch (error) {
+      if (error instanceof GoogleFontsUnavailable) json2(res, 200, { unavailable: error.message });
+      else json2(res, 503, { error: error.message });
+    }
+    return true;
+  }
+  if (path.startsWith(FILE)) {
+    const file = inside(googleFontsDir(), path.slice(FILE.length));
+    if (!file) {
+      res.statusCode = 403;
+      res.end("outside the font cache");
+      return true;
+    }
+    sendFile2(req, res, file);
+    return true;
+  }
+  return false;
+}
+async function listRoute(res, url) {
+  const p = url.searchParams;
+  const category = p.get("category") || void 0;
+  if (category && !FONT_CATEGORIES.includes(category)) {
+    json2(res, 400, { error: `unknown category ${category}: ${FONT_CATEGORIES.join(", ")}` });
+    return;
+  }
+  const query = {
+    family: p.get("family") ?? "",
+    ...category ? { category } : {},
+    cached: p.get("cached") === "1" || p.get("cached") === "true",
+    limit: Math.max(1, count(p.get("limit"), FONT_LIMIT, MAX_LIMIT)),
+    offset: count(p.get("offset"), 0, Number.MAX_SAFE_INTEGER)
+  };
+  try {
+    const list = await listFonts(query);
+    const families = list.families.map((f) => ({ family: f.family, category: f.category, popularity: f.popularity, weights: f.weights, italics: f.italics, cached: f.cached }));
+    json2(res, 200, { families, total: list.total, offset: query.offset, catalogue: list.catalogue });
+  } catch (error) {
+    if (!(error instanceof GoogleFontsUnavailable)) throw error;
+    const cached = googleFontsOff() ? { families: [], total: 0 } : await cachedFonts(query);
+    json2(res, 200, { ...cached, offset: query.offset, unavailable: error.message });
+  }
+}
+
+// src/server.ts
+var TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".ttf": "font/ttf",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".json": "application/json",
+  ".srt": "application/x-subrip; charset=utf-8",
+  ".vtt": "text/vtt; charset=utf-8",
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".webm": "video/webm",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".svg": "image/svg+xml",
+  ".tsx": "text/plain; charset=utf-8",
+  ".ts": "text/plain; charset=utf-8"
+};
+function sendFile(req, res, file) {
+  let size;
+  let etag;
+  let modified;
+  try {
+    const st = statSync2(file, { bigint: true });
+    if (!st.isFile()) throw new Error("not a file");
+    size = Number(st.size);
+    etag = `"${createHash("sha256").update(`${st.dev}:${st.ino}:${st.size}:${st.mtimeNs}:${st.ctimeNs}`).digest("hex")}"`;
+    modified = Math.floor(Number(st.mtimeNs > st.ctimeNs ? st.mtimeNs : st.ctimeNs) / 1e9) * 1e3;
+  } catch {
+    res.statusCode = 404;
+    res.end("not found");
+    return;
+  }
+  res.setHeader("content-type", TYPES[extname2(file).toLowerCase()] ?? "application/octet-stream");
+  res.setHeader("accept-ranges", "bytes");
+  res.setHeader("cache-control", "no-cache");
+  res.setHeader("etag", etag);
+  res.setHeader("last-modified", new Date(modified).toUTCString());
+  const readable = req.method === "GET" || req.method === "HEAD";
+  const noneMatch = req.headers["if-none-match"];
+  const unmodified = noneMatch !== void 0 ? noneMatch.split(",").some((value) => value.trim() === "*" || value.trim().replace(/^W\//, "") === etag) : Date.parse(req.headers["if-modified-since"] ?? "") >= modified;
+  if (readable && unmodified) {
+    res.statusCode = 304;
+    res.end();
+    return;
+  }
+  const ifRange = req.headers["if-range"];
+  const sameRange = !ifRange || ifRange === etag || modified <= Date.now() - 6e4 && typeof ifRange === "string" && Date.parse(ifRange) === modified;
+  const range = req.method === "GET" && sameRange ? /^bytes=(\d*)-(\d*)$/.exec(req.headers.range ?? "") : null;
+  if (range) {
+    const start = range[1] ? Number(range[1]) : Math.max(0, size - Number(range[2]));
+    const end = range[1] && range[2] ? Math.min(Number(range[2]), size - 1) : size - 1;
+    if (!range[1] && !Number(range[2]) || !Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start > end || start >= size) {
+      res.statusCode = 416;
+      res.setHeader("content-range", `bytes */${size}`);
+      res.end();
+      return;
+    }
+    res.statusCode = 206;
+    res.setHeader("content-range", `bytes ${start}-${end}/${size}`);
+    res.setHeader("content-length", end - start + 1);
+    stream(file, res, { start, end });
+    return;
+  }
+  res.setHeader("content-length", size);
+  if (req.method === "HEAD") {
+    res.end();
+    return;
+  }
+  stream(file, res);
+}
+function stream(file, res, range) {
+  if (file.startsWith("/$bunfs/")) {
+    const bytes = readFileSync(file);
+    res.end(range ? bytes.subarray(range.start, range.end + 1) : bytes);
+    return;
+  }
+  createReadStream(file, range).on("error", () => res.destroy()).pipe(res);
+}
+var json3 = (res, status, body) => {
+  res.statusCode = status;
+  res.setHeader("content-type", "application/json");
+  res.end(JSON.stringify(body));
+};
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+var CAPTURE_HTML = `<!doctype html><meta charset="utf-8"><title>higgsedit capture</title><script type="module" src="/__higgsedit/capture-page.js"></script>`;
+async function startServer(dir, handlers = [], port = 0) {
+  const compiled = /* @__PURE__ */ new Map();
+  const compileSources = (files) => {
+    const modules = {};
+    try {
+      for (const [file, code] of Object.entries(files)) {
+        if (!SOURCE_FILE.test(file) || file.endsWith(".d.ts")) continue;
+        let hit = compiled.get(file);
+        if (hit?.code !== code) compiled.set(file, hit = { code, out: compileFile(file, code, { sourceMaps: false }) });
+        modules[file] = hit.out;
+      }
+    } catch (error) {
+      return { error: error.message };
+    }
+    return { modules };
+  };
+  const server = createServer((req, res) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    void (async () => {
+      for (const handler of handlers) if (await handler(req, res, url)) return;
+      const path = decodeURIComponent(url.pathname);
+      if (path === "/__higgsedit/capture.html") {
+        res.setHeader("content-type", TYPES[".html"]);
+        res.end(CAPTURE_HTML);
+        return;
+      }
+      if (path === "/__higgsedit/capture-page.js") {
+        res.setHeader("content-type", TYPES[".js"]);
+        res.end(await pageBundle("capture-page"));
+        return;
+      }
+      if (path.startsWith("/__higgsedit/fonts/") && await fontsRoute(req, res, path, url, sendFile)) return;
+      if (path === "/__higgsedit/sync") {
+        try {
+          json3(res, 200, await measureSync(dir, url.searchParams.get("src") ?? "", url.searchParams.get("target") ?? ""));
+        } catch (error) {
+          if (!(error instanceof SyncError)) throw error;
+          json3(res, 422, { error: error.message, kind: error.kind });
+        }
+        return;
+      }
+      if (path === "/api/files") {
+        const files = readSources(dir);
+        json3(res, 200, { files, ...compileSources(files), fonts: fontFiles(dir), packages: (await bundlePackages(dir)).code });
+        return;
+      }
+      if (path.startsWith("/project/")) {
+        if (isPrivateMediaUploadPath(path)) {
+          res.statusCode = 403;
+          res.end("private upload");
+          return;
+        }
+        const file = inside(dir, path.slice("/project/".length));
+        if (!file) {
+          res.statusCode = 403;
+          res.end("outside the project");
+          return;
+        }
+        sendFile(req, res, file);
+        return;
+      }
+      res.statusCode = 404;
+      res.end("not found");
+    })().catch((error) => {
+      if (!res.headersSent) json3(res, 500, { error: error instanceof Error ? error.message : String(error) });
+      else res.destroy();
+    });
+  });
+  await new Promise((resolve) => server.listen(port, "127.0.0.1", resolve));
+  const address = server.address();
+  const origin = `http://127.0.0.1:${typeof address === "object" && address ? address.port : port}`;
+  return {
+    server,
+    origin,
+    close: () => new Promise((resolve) => {
+      server.closeAllConnections();
+      server.close(() => resolve());
+    })
+  };
+}
+
+export {
+  PACKAGED,
+  packagedAsset,
+  pageBundle,
+  MEDIA_UPLOAD_TEMP_PREFIX,
+  MediaUploads,
+  listMediaFiles,
+  sendFile,
+  json3 as json,
+  readBody,
+  startServer
+};