@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

package/vendor/framey/dist/chunk-K4WKGXRC.js

@@ -0,0 +1,18 @@
+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);
+
+// src/utils/textFile.ts
+import { existsSync } from "fs";
+import { extname, resolve } from "path";
+function isTextFile(input) {
+  const path = resolve(input);
+  return existsSync(path) && extname(path).toLowerCase() === ".txt";
+}
+
+export {
+  isTextFile
+};

package/vendor/framey/dist/chunk-KGPLIH7B.js

@@ -0,0 +1,127 @@
+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);
+
+// src/utils/processTree.ts
+import { execFileSync, spawn } from "child_process";
+import { readdirSync, readFileSync } from "fs";
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code !== "ESRCH";
+  }
+}
+function processGroupIsAlive(pid) {
+  if (process.platform === "linux") {
+    try {
+      return readdirSync("/proc").some((entry) => {
+        if (!/^\d+$/.test(entry)) return false;
+        try {
+          const stat = readFileSync(`/proc/${entry}/stat`, "utf8");
+          const fields = stat.slice(stat.lastIndexOf(") ") + 2).split(/\s+/);
+          return fields[2] === String(pid) && fields[0] !== "Z" && fields[0] !== "X";
+        } catch {
+          return false;
+        }
+      });
+    } catch {
+    }
+  }
+  return processIsAlive(-pid);
+}
+function waitForDelay(delayMs) {
+  return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+async function waitForProcessGroupExit(pid) {
+  while (processGroupIsAlive(pid)) await waitForDelay(20);
+}
+function windowsProcessTreeKillArgs(pid) {
+  return ["/PID", String(pid), "/T", "/F"];
+}
+function terminateWindowsProcessTree(pid, spawnProcess = (command, args, options) => spawn(command, [...args], options)) {
+  return new Promise((resolve, reject) => {
+    const killer = spawnProcess("taskkill", windowsProcessTreeKillArgs(pid), {
+      stdio: "ignore",
+      windowsHide: true
+    });
+    killer.once("error", reject);
+    killer.once("close", (status) => {
+      if (status === 0) resolve();
+      else reject(new Error(`taskkill exited with status ${status ?? "unknown"}`));
+    });
+  });
+}
+function signalProcessGroup(pid, signal) {
+  try {
+    process.kill(-pid, signal);
+  } catch {
+  }
+}
+function getDescendants(pid) {
+  let children;
+  try {
+    const raw = execFileSync("pgrep", ["-P", String(pid)], {
+      encoding: "utf8",
+      timeout: 2e3
+    }).trim();
+    children = raw.split(/\r?\n/).map(Number).filter((childPid) => Number.isInteger(childPid) && childPid > 0);
+  } catch {
+    return [];
+  }
+  return children.flatMap((childPid) => [childPid, ...getDescendants(childPid)]);
+}
+function signalProcesses(pids, signal) {
+  for (const pid of pids) {
+    try {
+      process.kill(pid, signal);
+    } catch {
+    }
+  }
+}
+async function terminatePidTree(pid, signal) {
+  const pids = [...getDescendants(pid).reverse(), pid];
+  signalProcesses(pids, signal);
+  if (signal === "SIGKILL") return "SIGKILL";
+  await waitForDelay(500);
+  const survivors = pids.filter(processIsAlive);
+  signalProcesses(survivors, "SIGKILL");
+  return survivors.length > 0 ? "SIGKILL" : "SIGTERM";
+}
+async function terminateProcessGroup(pid, signal) {
+  signalProcessGroup(pid, signal);
+  if (signal === "SIGKILL") {
+    await waitForProcessGroupExit(pid);
+    return "SIGKILL";
+  }
+  await Promise.race([waitForProcessGroupExit(pid), waitForDelay(250)]);
+  if (!processGroupIsAlive(pid)) return "SIGTERM";
+  signalProcessGroup(pid, "SIGKILL");
+  await waitForProcessGroupExit(pid);
+  return "SIGKILL";
+}
+async function terminateProcessTree(pid, options = {}) {
+  if (process.platform === "win32") {
+    try {
+      await terminateWindowsProcessTree(pid, options.spawnProcess);
+    } catch (error) {
+      try {
+        options.child?.kill("SIGKILL");
+      } catch {
+      }
+      if (options.child) throw error;
+    }
+    return "SIGKILL";
+  }
+  const signal = options.signal ?? "SIGTERM";
+  return options.processGroup ? terminateProcessGroup(pid, signal) : terminatePidTree(pid, signal);
+}
+
+export {
+  processIsAlive,
+  terminateProcessTree
+};

package/vendor/framey/dist/chunk-KLIKCX6Q.js

@@ -0,0 +1,63 @@
+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);
+
+// ../studio-server/dist/chunk-GR4TX52A.js
+var CRF_MAX_BY_FORMAT = { mp4: 51, webm: 63 };
+var VIDEO_BITRATE = /^\d+(\.\d+)?[kKmMgG]?$/;
+var VIDEO_FRAME_FORMATS = ["auto", "jpg", "png"];
+var HDR_MODES = ["auto", "force-hdr", "force-sdr"];
+var isSet = (value) => value !== void 0 && value !== null;
+function oneOf(value, allowed) {
+  return typeof value === "string" && allowed.includes(value);
+}
+function parseCrf(crf, format, max) {
+  if (typeof crf !== "number" || !Number.isInteger(crf) || crf < 0 || crf > max) {
+    return { ok: false, error: `crf must be an integer from 0 to ${max} for ${format}` };
+  }
+  return { ok: true, options: { crf } };
+}
+function parseVideoBitrate(videoBitrate) {
+  if (typeof videoBitrate !== "string" || !VIDEO_BITRATE.test(videoBitrate)) {
+    return { ok: false, error: 'videoBitrate must look like "10M", "2500k" or "8000000"' };
+  }
+  return { ok: true, options: { videoBitrate } };
+}
+function parseRateControl(body, format) {
+  const max = CRF_MAX_BY_FORMAT[format];
+  if (max === void 0) return { ok: true, options: {} };
+  if (isSet(body.crf) && isSet(body.videoBitrate)) {
+    return { ok: false, error: "use either crf or videoBitrate, not both" };
+  }
+  if (isSet(body.crf)) return parseCrf(body.crf, format, max);
+  if (isSet(body.videoBitrate)) return parseVideoBitrate(body.videoBitrate);
+  return { ok: true, options: {} };
+}
+function parseEncoderOptions(body, format) {
+  const rate = parseRateControl(body, format);
+  if (!rate.ok) return rate;
+  const options = { ...rate.options };
+  if (isSet(body.videoFrameFormat)) {
+    if (!oneOf(body.videoFrameFormat, VIDEO_FRAME_FORMATS)) {
+      return {
+        ok: false,
+        error: `videoFrameFormat must be one of ${VIDEO_FRAME_FORMATS.join(", ")}`
+      };
+    }
+    options.videoFrameFormat = body.videoFrameFormat;
+  }
+  if (isSet(body.hdrMode)) {
+    if (!oneOf(body.hdrMode, HDR_MODES)) {
+      return { ok: false, error: `hdrMode must be one of ${HDR_MODES.join(", ")}` };
+    }
+    options.hdrMode = body.hdrMode;
+  }
+  return { ok: true, options };
+}
+
+export {
+  parseEncoderOptions
+};

package/vendor/framey/dist/chunk-KXTKKBOC.js

@@ -0,0 +1,61 @@
+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 {
+  c
+} from "./chunk-VORQIH64.js";
+import {
+  DISTRIBUTED_FPS,
+  isDistributedFps
+} from "./chunk-DLA44CMS.js";
+import {
+  parseHTML
+} from "./chunk-SDYDNHEE.js";
+
+// src/utils/compositionFps.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+function getHtmlAttribute(element, name) {
+  return Array.from(element.attributes).find((attribute) => attribute.name.toLowerCase() === name)?.value ?? null;
+}
+function readCompositionFps(html) {
+  let doc;
+  try {
+    doc = parseHTML(html).document;
+  } catch {
+    return null;
+  }
+  const compositions = Array.from(doc.querySelectorAll("*")).filter(
+    (element) => getHtmlAttribute(element, "data-composition-id") !== null
+  );
+  const root = compositions.find((element) => getHtmlAttribute(element, "data-root") === "true") ?? compositions[0];
+  const raw = root ? getHtmlAttribute(root, "data-fps")?.trim() : void 0;
+  return raw ? raw : null;
+}
+var DEFAULT_CLOUD_FPS = 30;
+function defaultCloudFps(projectDir) {
+  let html;
+  try {
+    html = readFileSync(join(projectDir, "index.html"), "utf8");
+  } catch {
+    return DEFAULT_CLOUD_FPS;
+  }
+  const raw = readCompositionFps(html);
+  if (raw == null) return DEFAULT_CLOUD_FPS;
+  const n = Number(raw);
+  if (isDistributedFps(n)) return n;
+  console.warn(
+    c.warn(
+      `The composition declares data-fps="${raw}", which cloud renders do not support (${DISTRIBUTED_FPS.join(", ")}). Rendering at ${DEFAULT_CLOUD_FPS} fps; pass --fps to choose.`
+    )
+  );
+  return DEFAULT_CLOUD_FPS;
+}
+
+export {
+  readCompositionFps,
+  defaultCloudFps
+};

package/vendor/framey/dist/chunk-KZI44OPA.js

@@ -0,0 +1,185 @@
+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);
+
+// src/commands/motionShotLayout.ts
+var ANGLE_PRESETS = {
+  front: [0, 0],
+  iso: [30, -22],
+  top: [0, -68],
+  side: [78, 0],
+  "rear-iso": [205, -22]
+};
+function parseAngle(a) {
+  if (!a) return { yaw: 0, pitch: 0 };
+  const preset = ANGLE_PRESETS[a];
+  if (preset) return { yaw: preset[0], pitch: preset[1] };
+  const [y, p] = a.split(",").map((n) => Number.parseFloat(n));
+  return { yaw: Number.isFinite(y) ? y : 0, pitch: Number.isFinite(p) ? p : 0 };
+}
+function resolveShotSelectors(scope, animated, isDescendant) {
+  if (animated.includes(scope)) return [scope];
+  return animated.filter((target) => isDescendant(scope, target));
+}
+function sampleTimes(dur, n, from, to) {
+  const t0 = from != null ? Math.max(0, Math.min(from, dur)) : 0;
+  const t1 = to != null ? Math.max(0, Math.min(to, dur)) : dur;
+  const count = Math.max(1, Math.floor(n));
+  if (count === 1) return [t0];
+  return Array.from({ length: count }, (_, i) => {
+    const t = t0 + i / (count - 1) * (t1 - t0);
+    return Math.round(t * 1e3) / 1e3;
+  });
+}
+function stripCaptureTimeCandidates(time) {
+  return time > 0 ? [time, Math.max(0, time - 1 / 30)] : [time];
+}
+function ghostAlphas(n) {
+  if (n <= 0) return [];
+  if (n === 1) return [1];
+  const lo = 0.14;
+  return Array.from(
+    { length: n },
+    (_, i) => Math.round((lo + (1 - lo) * (i / (n - 1))) * 1e3) / 1e3
+  );
+}
+function fitTransform(pts, width, height) {
+  if (pts.length === 0) return { k: 1, cx: width / 2, cy: height / 2 };
+  const xs = pts.map((p) => p.x);
+  const ys = pts.map((p) => p.y);
+  const minX = Math.min(...xs);
+  const maxX = Math.max(...xs);
+  const minY = Math.min(...ys);
+  const maxY = Math.max(...ys);
+  const cx = (minX + maxX) / 2;
+  const cy = (minY + maxY) / 2;
+  const span = Math.max(maxX - minX, maxY - minY, 1);
+  const k = Math.max(0.3, Math.min(7, Math.min(width, height) * 0.8 / span));
+  return { k, cx, cy };
+}
+function stripCells(n, width, height) {
+  const cols = n <= 5 ? Math.max(1, n) : Math.ceil(Math.sqrt(n));
+  const rows = Math.ceil(n / cols);
+  return { cols, rows, cellW: width / cols, cellH: height / rows };
+}
+var timeColor = (f) => `hsl(${190 + f * 150} 90% 65%)`;
+var attrs = (o) => Object.entries(o).map(([k, v]) => `${k}="${v}"`).join(" ");
+var polygon = (corners, fill, fillOpacity, stroke) => `<polygon ${attrs({
+  points: corners.map((p) => `${round(p.x)},${round(p.y)}`).join(" "),
+  fill,
+  "fill-opacity": fillOpacity.toFixed(2),
+  stroke,
+  "stroke-width": 2.5,
+  "stroke-linejoin": "round"
+})}/>`;
+var line = (a, b, stroke, w, o) => `<line ${attrs({ x1: round(a.x), y1: round(a.y), x2: round(b.x), y2: round(b.y), stroke, "stroke-width": w, opacity: o, "stroke-linecap": "round" })}/>`;
+var circle = (p, r, fill) => `<circle ${attrs({ cx: round(p.x), cy: round(p.y), r, fill })}/>`;
+var text = (p, s, fill, size = 15) => `<text ${attrs({ x: round(p.x), y: round(p.y), fill, "font-family": "ui-monospace,monospace", "font-size": size, "font-weight": 600 })}>${escapeXml(s)}</text>`;
+var round = (n) => Math.round(n * 100) / 100;
+var escapeXml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var ghost = (corners, center, color, opacity, f) => {
+  const tickEnd = {
+    x: (corners[0].x + corners[1].x) / 2,
+    y: (corners[0].y + corners[1].y) / 2
+  };
+  return polygon(corners, color, Math.max(0.08, opacity * 0.42), timeColor(f)) + line(center, tickEnd, timeColor(f), 3, 0.9);
+};
+function buildOnionSvg(elements, opt) {
+  const { width: W, height: H } = opt;
+  let body = "";
+  if (opt.layout === "strip") {
+    body = stripBody(elements[0]?.samples ?? [], W, H);
+  } else {
+    body = pathBody(elements, opt.fit, W, H);
+  }
+  if (opt.label) body += text({ x: 28, y: 40 }, opt.label, timeColor(0), 18);
+  return `<svg ${attrs({
+    xmlns: "http://www.w3.org/2000/svg",
+    style: "position:fixed;inset:0;width:100vw;height:100vh;pointer-events:none;z-index:2147483647",
+    viewBox: `0 0 ${W} ${H}`
+  })}>${body}</svg>`;
+}
+function buildRenderedStripSvg(frames, opt) {
+  const { width: W, height: H } = opt;
+  const { cols, cellW, cellH } = stripCells(frames.length, W, H);
+  let body = `<rect ${attrs({ x: 0, y: 0, width: W, height: H, fill: "#0b1320" })}/>`;
+  frames.forEach((frame, index) => {
+    const col = index % cols;
+    const row = Math.floor(index / cols);
+    const cellX = col * cellW;
+    const cellY = row * cellH;
+    const availableW = Math.max(1, cellW - 20);
+    const availableH = Math.max(1, cellH - 38);
+    const scale = Math.min(availableW / frame.width, availableH / frame.height);
+    const imageW = frame.width * scale;
+    const imageH = frame.height * scale;
+    const imageX = cellX + (cellW - imageW) / 2;
+    const imageY = cellY + 30 + (availableH - imageH) / 2;
+    const f = frames.length <= 1 ? 0 : index / (frames.length - 1);
+    body += `<rect ${attrs({ x: round(cellX + 3), y: round(cellY + 3), width: round(cellW - 6), height: round(cellH - 6), fill: "none", stroke: "#1c2531", "stroke-width": 1, rx: 8 })}/>`;
+    body += `<image ${attrs({ x: round(imageX), y: round(imageY), width: round(imageW), height: round(imageH), href: frame.dataUrl, preserveAspectRatio: "xMidYMid meet" })}/>`;
+    body += text({ x: cellX + 12, y: cellY + 24 }, `${frame.t}s`, timeColor(f), 16);
+  });
+  if (opt.label) body += text({ x: 28, y: 40 }, opt.label, timeColor(0), 18);
+  return `<svg ${attrs({
+    xmlns: "http://www.w3.org/2000/svg",
+    style: "position:fixed;inset:0;width:100vw;height:100vh;pointer-events:none;z-index:2147483647",
+    viewBox: `0 0 ${W} ${H}`
+  })}>${body}</svg>`;
+}
+function pathBody(elements, fit, W, H) {
+  const all = elements.flatMap((e) => e.samples.flatMap((s) => [...s.q, s.c]));
+  const { k, cx, cy } = fit ? fitTransform(all, W, H) : { k: 1, cx: W / 2, cy: H / 2 };
+  const M = (p) => ({ x: (p.x - cx) * k + W / 2, y: (p.y - cy) * k + H / 2 });
+  let out = "";
+  for (const el of elements) {
+    const last = el.samples.length - 1;
+    const fOf = (i) => last <= 0 ? 0 : i / last;
+    el.samples.forEach((s, i) => out += ghost(s.q.map(M), M(s.c), s.color, s.opacity, fOf(i)));
+    for (let i = 0; i < last; i++)
+      out += line(M(el.samples[i].c), M(el.samples[i + 1].c), timeColor(fOf(i)), 3.5, 0.85);
+    el.samples.forEach((s, i) => {
+      const c = M(s.c);
+      out += circle(c, 4, timeColor(fOf(i)));
+      out += text({ x: c.x + 10, y: c.y + (i % 2 === 0 ? -10 : 18) }, `${s.t}s`, timeColor(fOf(i)));
+    });
+  }
+  return out;
+}
+function stripBody(samples, W, H) {
+  if (samples.length === 0) return "";
+  const { cols, cellW, cellH } = stripCells(samples.length, W, H);
+  let maxExt = 1;
+  for (const s of samples)
+    for (const p of s.q) maxExt = Math.max(maxExt, Math.hypot(p.x - s.c.x, p.y - s.c.y));
+  const cellScale = Math.min(cellW, cellH) * 0.62 / maxExt;
+  const last = samples.length - 1;
+  let out = "";
+  samples.forEach((s, i) => {
+    const col = i % cols;
+    const row = Math.floor(i / cols);
+    const cc = { x: cellW * (col + 0.5), y: cellH * (row + 0.5) };
+    const f = last <= 0 ? 0 : i / last;
+    out += `<rect ${attrs({ x: round(col * cellW + 3), y: round(row * cellH + 3), width: round(cellW - 6), height: round(cellH - 6), fill: "none", stroke: "#1c2531", "stroke-width": 1, rx: 8 })}/>`;
+    const corners = s.q.map((p) => ({
+      x: cc.x + (p.x - s.c.x) * cellScale,
+      y: cc.y + (p.y - s.c.y) * cellScale
+    }));
+    out += ghost(corners, cc, s.color, s.opacity, f);
+    out += text({ x: col * cellW + 12, y: row * cellH + 24 }, `${s.t}s`, timeColor(f), 16);
+  });
+  return out;
+}
+
+export {
+  parseAngle,
+  resolveShotSelectors,
+  sampleTimes,
+  stripCaptureTimeCandidates,
+  ghostAlphas,
+  buildOnionSvg,
+  buildRenderedStripSvg
+};

package/vendor/framey/dist/chunk-LEKZNRKI.js

@@ -0,0 +1,45 @@
+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 {
+  ensureDOMParser
+} from "./chunk-442JNXRM.js";
+import {
+  quantizePreviewProxyBox
+} from "./chunk-DLA44CMS.js";
+
+// src/utils/compositionViewport.ts
+var DEFAULT_VIEWPORT = { width: 1920, height: 1080 };
+var MAX_VIEWPORT_DIMENSION = 4096;
+function parseViewportDimension(value) {
+  if (!value) return null;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return null;
+  return Math.min(parsed, MAX_VIEWPORT_DIMENSION);
+}
+function findCompositionDimensions(html) {
+  ensureDOMParser();
+  const doc = new DOMParser().parseFromString(html, "text/html");
+  const root = doc.querySelector("[data-composition-id][data-width][data-height]");
+  if (!root) return null;
+  const width = parseViewportDimension(root.getAttribute("data-width"));
+  const height = parseViewportDimension(root.getAttribute("data-height"));
+  if (width === null || height === null) return null;
+  return { width, height };
+}
+function findStageProxyBox(html) {
+  const stage = findCompositionDimensions(html);
+  return stage && quantizePreviewProxyBox(stage.width, stage.height) || void 0;
+}
+function resolveCompositionViewportFromHtml(html) {
+  return findCompositionDimensions(html) ?? DEFAULT_VIEWPORT;
+}
+
+export {
+  findCompositionDimensions,
+  findStageProxyBox,
+  resolveCompositionViewportFromHtml
+};

package/vendor/framey/dist/chunk-LFGJWOVA.js

@@ -0,0 +1,61 @@
+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);
+
+// src/utils/openBrowser.ts
+import { spawn } from "child_process";
+function parseRemoteDebuggingPort(value) {
+  if (value === void 0 || value === "") return void 0;
+  if (!/^\d+$/.test(value)) {
+    throw new Error("--remote-debugging-port must be an integer between 1 and 65535");
+  }
+  const port = Number(value);
+  if (port < 1 || port > 65535) {
+    throw new Error("--remote-debugging-port must be an integer between 1 and 65535");
+  }
+  return port;
+}
+function validateRemoteDebuggingPortDeps(deps) {
+  if (!deps.remoteDebuggingPort) return null;
+  if (!deps.browserPath) return "--remote-debugging-port requires --browser-path";
+  if (!deps.userDataDir) return "--remote-debugging-port requires --user-data-dir";
+  return null;
+}
+function buildBrowserArgs(url, options) {
+  const args = [];
+  if (options.userDataDir) {
+    args.push(`--user-data-dir=${options.userDataDir}`);
+  }
+  if (options.remoteDebuggingPort !== void 0 && options.userDataDir) {
+    args.push(`--remote-debugging-port=${options.remoteDebuggingPort}`);
+  }
+  if (options.disableGpu) {
+    args.push("--disable-gpu");
+  }
+  args.push(url);
+  return args;
+}
+function openBrowser(url, options = {}) {
+  if (options.browserPath) {
+    const args = buildBrowserArgs(url, options);
+    const child = spawn(options.browserPath, args, {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.on("error", () => {
+    });
+    child.unref();
+    return;
+  }
+  import("open").then((mod) => mod.default(url)).catch(() => {
+  });
+}
+
+export {
+  parseRemoteDebuggingPort,
+  validateRemoteDebuggingPortDeps,
+  openBrowser
+};

package/vendor/framey/dist/chunk-LLMSX6V6.js

@@ -0,0 +1,17 @@
+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);
+
+// src/timeline/domStructure.ts
+function toDomNode(el) {
+  const attrs = {};
+  for (const { name, value } of Array.from(el.attributes)) attrs[name] = value;
+  return { tag: el.tagName, attrs, children: Array.from(el.children).map(toDomNode), el };
+}
+
+export {
+  toDomNode
+};