@ignix-social/editor 0.1.0

package/vendor/hyperframes/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/hyperframes/dist/chunk-L3YOGIPG.js

@@ -0,0 +1,48 @@
+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 {
+  sanitizeSuccessfulExitCode
+} from "./chunk-PBN6GBJE.js";
+
+// src/utils/render-success-state.ts
+var renderSucceeded = false;
+function markRenderSucceeded() {
+  renderSucceeded = true;
+}
+function isRenderSucceeded() {
+  return renderSucceeded;
+}
+var defaultErrorSink = (message) => {
+  process.stderr.write(`${message}
+`);
+};
+function runPostRenderStep(label, fn, sink = defaultErrorSink) {
+  try {
+    fn();
+  } catch (err) {
+    reportPostRenderStepFailure(label, err, sink);
+  }
+}
+async function runPostRenderStepAsync(label, fn, sink = defaultErrorSink) {
+  try {
+    await fn();
+  } catch (err) {
+    reportPostRenderStepFailure(label, err, sink);
+  }
+}
+function reportPostRenderStepFailure(label, err, sink) {
+  const message = err instanceof Error ? err.message : String(err);
+  sink(`  [hyperframes] Post-render step '${label}' failed (render already succeeded): ${message}`);
+  sanitizeSuccessfulExitCode();
+}
+
+export {
+  markRenderSucceeded,
+  isRenderSucceeded,
+  runPostRenderStep,
+  runPostRenderStepAsync
+};

package/vendor/hyperframes/dist/chunk-LAOCA3MQ.js

@@ -0,0 +1,189 @@
+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 {
+  runRenderSetupWorker,
+  terminateProcessTree
+} from "./chunk-LCSMOLGX.js";
+
+// src/utils/orphanCleanup.ts
+import { execFileSync } from "child_process";
+import { readFileSync } from "fs";
+function killOrphanedProcesses() {
+  if (process.platform === "win32") return 0;
+  return killOrphansMatching([
+    "chrome-headless-shell",
+    "chrome_headless_shell",
+    "puppeteer_dev_chrome_profile"
+  ]);
+}
+async function killOrphanedProcessesForRender(signal) {
+  return runRenderSetupWorker("orphan-cleanup", {}, { signal, timeoutMs: 15e3 });
+}
+function killProcessTree(pid, signal = "SIGTERM") {
+  void terminateProcessTree(pid, { signal }).catch(() => void 0);
+}
+function processIdentity(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return null;
+  try {
+    if (process.platform === "win32") {
+      const created = execFileSync(
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          `$p = Get-CimInstance Win32_Process -Filter 'ProcessId = ${pid}' -ErrorAction SilentlyContinue; if ($p) { $p.CreationDate.ToFileTimeUtc() }`
+        ],
+        {
+          encoding: "utf8",
+          timeout: 2e3,
+          stdio: ["pipe", "pipe", "ignore"],
+          windowsHide: true
+        }
+      ).trim();
+      return created ? `windows:${created}` : null;
+    }
+    if (process.platform === "linux") {
+      const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+      const fields = stat.slice(stat.lastIndexOf(") ") + 2).trim().split(/\s+/);
+      const startTicks = fields[19];
+      return startTicks ? `linux:${startTicks}` : null;
+    }
+    const started = execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
+      encoding: "utf8",
+      timeout: 2e3
+    }).trim();
+    return started ? `posix:${started}` : null;
+  } catch {
+    return null;
+  }
+}
+function recordsToAncestors(pid, records) {
+  const byPid = new Map(records.map((record) => [record.pid, record]));
+  const ancestors = [];
+  const visited = /* @__PURE__ */ new Set([pid]);
+  let current = pid;
+  for (let depth = 0; depth < 64; depth++) {
+    const parent = byPid.get(current)?.parentPid;
+    if (parent === void 0 || parent <= 1 || visited.has(parent)) break;
+    visited.add(parent);
+    const ancestor = byPid.get(parent);
+    if (!ancestor) break;
+    ancestors.push({ pid: ancestor.pid, identity: ancestor.identity });
+    current = parent;
+  }
+  return ancestors;
+}
+function processAncestorSnapshot(pid) {
+  if (!Number.isInteger(pid) || pid <= 0 || process.platform === "linux") return [];
+  try {
+    if (process.platform === "win32") {
+      const output2 = execFileSync(
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          'Get-CimInstance Win32_Process | ForEach-Object { "$($_.ProcessId) $($_.ParentProcessId) $($_.CreationDate.ToFileTimeUtc())" }'
+        ],
+        { encoding: "utf8", timeout: 2e3, stdio: ["pipe", "pipe", "ignore"], windowsHide: true }
+      );
+      const records2 = output2.split(/\r?\n/).map((line) => line.trim().split(/\s+/)).map(([processId, parentProcessId, creationDate]) => ({
+        pid: Number(processId),
+        parentPid: Number(parentProcessId),
+        identity: creationDate ? `windows:${creationDate}` : ""
+      })).filter(
+        (record) => Number.isInteger(record.pid) && record.pid > 0 && Number.isInteger(record.parentPid) && record.parentPid > 0 && record.identity !== ""
+      );
+      return recordsToAncestors(pid, records2);
+    }
+    const output = execFileSync("ps", ["-axo", "pid=,ppid=,lstart="], {
+      encoding: "utf8",
+      timeout: 2e3
+    });
+    const records = output.split(/\r?\n/).map((line) => line.match(/^\s*(\d+)\s+(\d+)\s+(.+)$/)).filter((match) => match !== null).map(([, processId, parentProcessId, started]) => ({
+      pid: Number(processId),
+      parentPid: Number(parentProcessId),
+      identity: `posix:${started?.trim() ?? ""}`
+    }));
+    return recordsToAncestors(pid, records);
+  } catch {
+    return [];
+  }
+}
+function processParentPid(pid) {
+  try {
+    const output = process.platform === "win32" ? execFileSync(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `$p = Get-CimInstance Win32_Process -Filter 'ProcessId = ${pid}' -ErrorAction SilentlyContinue; if ($p) { $p.ParentProcessId }`
+      ],
+      {
+        encoding: "utf8",
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      }
+    ) : execFileSync("ps", ["-o", "ppid=", "-p", String(pid)], {
+      encoding: "utf8",
+      timeout: 2e3
+    });
+    const parentPid = Number(output.trim());
+    return Number.isInteger(parentPid) && parentPid > 0 ? parentPid : null;
+  } catch {
+    return null;
+  }
+}
+function isProcessDescendant(childPid, ancestorPid, parentPid = processParentPid) {
+  if (childPid <= 0 || ancestorPid <= 0 || childPid === ancestorPid) return false;
+  const visited = /* @__PURE__ */ new Set();
+  let current = childPid;
+  for (let depth = 0; depth < 64; depth++) {
+    if (visited.has(current)) return false;
+    visited.add(current);
+    const parent = parentPid(current);
+    if (parent === ancestorPid) return true;
+    if (parent === null || parent <= 1) return false;
+    current = parent;
+  }
+  return false;
+}
+function killOrphansMatching(markers) {
+  const uid = process.getuid?.();
+  const owner = uid === void 0 ? ["-A"] : ["-U", String(uid)];
+  let table;
+  try {
+    table = execFileSync("ps", [...owner, "-ww", "-o", "pid=,ppid=,args="], {
+      encoding: "utf-8",
+      timeout: 3e3
+    });
+  } catch {
+    return 0;
+  }
+  let killed = 0;
+  for (const line of table.split("\n")) {
+    const match = line.match(/^\s*(\d+)\s+(\d+)\s+(.*)$/);
+    if (!match || match[2] !== "1") continue;
+    if (!markers.some((marker) => match[3].includes(marker))) continue;
+    killProcessTree(Number(match[1]));
+    killed++;
+  }
+  return killed;
+}
+
+export {
+  killOrphanedProcesses,
+  killOrphanedProcessesForRender,
+  killProcessTree,
+  processIdentity,
+  processAncestorSnapshot,
+  processParentPid,
+  isProcessDescendant
+};