@ignix-social/editor 0.1.0

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

@@ -0,0 +1,273 @@
+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 {
+  parse,
+  simple
+} from "./chunk-2PSPARWP.js";
+
+// ../parsers/dist/composition.js
+var CANVAS_DIMENSIONS = {
+  landscape: { width: 1920, height: 1080 },
+  portrait: { width: 1080, height: 1920 },
+  "landscape-4k": { width: 3840, height: 2160 },
+  "portrait-4k": { width: 2160, height: 3840 },
+  square: { width: 1080, height: 1080 },
+  "square-4k": { width: 2160, height: 2160 }
+};
+var VALID_CANVAS_RESOLUTIONS = Object.keys(
+  CANVAS_DIMENSIONS
+);
+var COMPOSITION_VARIABLE_TYPES = [
+  "string",
+  "number",
+  "color",
+  "boolean",
+  "enum",
+  "font",
+  "image"
+];
+var FONT_ALIAS_MAP = {
+  // ── Canonical bundled fonts (self-referencing) ────────────────────────
+  inter: "inter",
+  montserrat: "montserrat",
+  outfit: "outfit",
+  nunito: "nunito",
+  oswald: "oswald",
+  "league gothic": "league-gothic",
+  "archivo black": "archivo-black",
+  "space mono": "space-mono",
+  "ibm plex mono": "ibm-plex-mono",
+  "jetbrains mono": "jetbrains-mono",
+  "eb garamond": "eb-garamond",
+  "playfair display": "playfair-display",
+  "source code pro": "source-code-pro",
+  "noto sans jp": "noto-sans-jp",
+  roboto: "roboto",
+  "open sans": "open-sans",
+  lato: "lato",
+  poppins: "poppins",
+  // ── Common aliases → nearest canonical ────────────────────────────────
+  "helvetica neue": "inter",
+  helvetica: "inter",
+  arial: "inter",
+  "helvetica bold": "inter",
+  futura: "montserrat",
+  "din alternate": "montserrat",
+  "arial black": "montserrat",
+  "bebas neue": "league-gothic",
+  "courier new": "jetbrains-mono",
+  courier: "jetbrains-mono",
+  garamond: "eb-garamond",
+  "noto sans japanese": "noto-sans-jp",
+  "segoe ui": "roboto",
+  // ── macOS sans-serif system fonts → inter ─────────────────────────────
+  "sf pro": "inter",
+  "sf pro display": "inter",
+  "sf pro text": "inter",
+  "sf pro rounded": "inter",
+  avenir: "inter",
+  "avenir next": "inter",
+  "lucida grande": "inter",
+  geneva: "inter",
+  optima: "inter",
+  // ── Windows sans-serif system fonts → inter ───────────────────────────
+  verdana: "inter",
+  tahoma: "inter",
+  "trebuchet ms": "inter",
+  calibri: "inter",
+  candara: "inter",
+  corbel: "inter",
+  "lucida sans": "inter",
+  "lucida sans unicode": "inter",
+  // ── Linux sans-serif system fonts → inter ─────────────────────────────
+  "noto sans": "inter",
+  "dejavu sans": "inter",
+  "liberation sans": "inter",
+  // ── Monospace system fonts → jetbrains-mono ───────────────────────────
+  "sf mono": "jetbrains-mono",
+  menlo: "jetbrains-mono",
+  monaco: "jetbrains-mono",
+  consolas: "jetbrains-mono",
+  "lucida console": "jetbrains-mono",
+  "lucida sans typewriter": "jetbrains-mono",
+  "andale mono": "jetbrains-mono",
+  "dejavu sans mono": "jetbrains-mono",
+  "liberation mono": "jetbrains-mono",
+  // ── Serif system fonts → eb-garamond ──────────────────────────────────
+  georgia: "eb-garamond",
+  palatino: "eb-garamond",
+  "palatino linotype": "eb-garamond",
+  "book antiqua": "eb-garamond",
+  cambria: "eb-garamond",
+  times: "eb-garamond",
+  "times new roman": "eb-garamond",
+  "dejavu serif": "eb-garamond",
+  "liberation serif": "eb-garamond"
+};
+var FONT_ALIAS_KEYS = new Set(Object.keys(FONT_ALIAS_MAP));
+var CANONICAL_FONT_DISPLAY_NAMES = {
+  inter: "Inter",
+  montserrat: "Montserrat",
+  outfit: "Outfit",
+  nunito: "Nunito",
+  oswald: "Oswald",
+  "league-gothic": "League Gothic",
+  "archivo-black": "Archivo Black",
+  "space-mono": "Space Mono",
+  "ibm-plex-mono": "IBM Plex Mono",
+  "jetbrains-mono": "JetBrains Mono",
+  "eb-garamond": "EB Garamond",
+  "playfair-display": "Playfair Display",
+  "source-code-pro": "Source Code Pro",
+  "noto-sans-jp": "Noto Sans JP",
+  roboto: "Roboto",
+  "open-sans": "Open Sans",
+  lato: "Lato",
+  poppins: "Poppins"
+};
+function resolveAliasDisplayName(alias) {
+  const slug = FONT_ALIAS_MAP[alias.toLowerCase()];
+  if (!slug) return void 0;
+  return CANONICAL_FONT_DISPLAY_NAMES[slug];
+}
+var DEFAULT_TYPEOF = {
+  string: "string",
+  number: "number",
+  color: "string",
+  boolean: "boolean",
+  enum: "string",
+  font: "string",
+  image: "string"
+};
+function isRecord(v) {
+  return typeof v === "object" && v !== null;
+}
+function isVariableType(t) {
+  return typeof t === "string" && t in DEFAULT_TYPEOF;
+}
+function isCompositionVariable(v) {
+  if (!isRecord(v)) return false;
+  if (typeof v.id !== "string" || typeof v.label !== "string") return false;
+  if (!isVariableType(v.type)) return false;
+  if (typeof v.default !== DEFAULT_TYPEOF[v.type]) return false;
+  if (v.type === "enum" && !Array.isArray(v.options)) return false;
+  return true;
+}
+function isSafeMediaUrl(url) {
+  const normalized = url.replace(/[\u0000-\u0020]/g, "");
+  const scheme = /^([a-z][a-z0-9+.-]*):/i.exec(normalized);
+  if (!scheme) return true;
+  const proto = scheme[1]?.toLowerCase();
+  if (!proto) return false;
+  if (proto === "https" || proto === "http" || proto === "blob") return true;
+  if (proto === "data") return /^data:image\//i.test(normalized);
+  return false;
+}
+var COMPOSITION_ATTRIBUTES = Object.freeze({
+  start: "data-start",
+  duration: "data-duration",
+  trackIndex: "data-track-index",
+  derivedEnd: "data-end",
+  legacyTrack: "data-layer"
+});
+var CANONICAL_AUTHORED_TIMING_ATTRIBUTES = Object.freeze([
+  COMPOSITION_ATTRIBUTES.start,
+  COMPOSITION_ATTRIBUTES.duration,
+  COMPOSITION_ATTRIBUTES.trackIndex
+]);
+var DERIVED_TIMING_ATTRIBUTES = Object.freeze([
+  COMPOSITION_ATTRIBUTES.derivedEnd
+]);
+var LEGACY_TIMING_ATTRIBUTES = Object.freeze([
+  COMPOSITION_ATTRIBUTES.derivedEnd,
+  COMPOSITION_ATTRIBUTES.legacyTrack
+]);
+var HTML_BODY_CSS_WIDTH_FIRST_RE = /(html\s*,\s*body\s*\{[^}]*?width:\s*)(\d+)px([^}]*?height:\s*)(\d+)px/i;
+var HTML_BODY_CSS_HEIGHT_FIRST_RE = /(html\s*,\s*body\s*\{[^}]*?height:\s*)(\d+)px([^}]*?width:\s*)(\d+)px/i;
+var VIEWPORT_META_SIZE_RE = /(<meta[^>]*name=["']viewport["'][^>]*content=["']width=)(\d+)(,\s*height=)(\d+)/i;
+function parseProgram(script) {
+  try {
+    return parse(script, { ecmaVersion: "latest", sourceType: "script" });
+  } catch {
+    return parse(script, { ecmaVersion: "latest", sourceType: "module" });
+  }
+}
+function literalString(node) {
+  if (node?.type === "Literal" && typeof node.value === "string") return node.value;
+  if (node?.type === "TemplateLiteral" && node.expressions?.length === 0) {
+    return node.quasis?.[0]?.value?.cooked;
+  }
+  return void 0;
+}
+function memberName(node) {
+  if (node?.type !== "MemberExpression") return void 0;
+  if (!node.computed && node.property?.type === "Identifier") return node.property.name;
+  return literalString(node.property);
+}
+function lookupSelector(node, bindings) {
+  if (node?.type === "Identifier") return bindings.get(node.name);
+  if (node?.type !== "CallExpression" || node.callee?.type !== "MemberExpression") {
+    return void 0;
+  }
+  const method = memberName(node.callee);
+  if (method !== "getElementById" && method !== "querySelector") return void 0;
+  const value = literalString(node.arguments?.[0]);
+  if (!value) return void 0;
+  return method === "getElementById" ? `#${value}` : value;
+}
+function extractMediaSrcMutations(script) {
+  try {
+    const ast = parseProgram(script);
+    const bindings = /* @__PURE__ */ new Map();
+    simple(ast, {
+      VariableDeclarator(node) {
+        if (node.id?.type !== "Identifier") return;
+        const selector = lookupSelector(node.init, bindings);
+        if (selector) bindings.set(node.id.name, selector);
+      }
+    });
+    const mutations = [];
+    simple(ast, {
+      AssignmentExpression(node) {
+        if (node.operator !== "=" || memberName(node.left) !== "src") return;
+        const selector = lookupSelector(node.left.object, bindings);
+        if (!selector) return;
+        mutations.push({
+          selector,
+          operation: "src_assignment",
+          raw: script.slice(node.start, node.end)
+        });
+      },
+      CallExpression(node) {
+        if (memberName(node.callee) !== "setAttribute") return;
+        if (literalString(node.arguments?.[0])?.toLowerCase() !== "src") return;
+        const selector = lookupSelector(node.callee.object, bindings);
+        if (!selector) return;
+        mutations.push({
+          selector,
+          operation: "set_attribute",
+          raw: script.slice(node.start, node.end)
+        });
+      }
+    });
+    return mutations;
+  } catch {
+    return [];
+  }
+}
+
+export {
+  COMPOSITION_VARIABLE_TYPES,
+  FONT_ALIAS_KEYS,
+  resolveAliasDisplayName,
+  isCompositionVariable,
+  isSafeMediaUrl,
+  HTML_BODY_CSS_WIDTH_FIRST_RE,
+  HTML_BODY_CSS_HEIGHT_FIRST_RE,
+  VIEWPORT_META_SIZE_RE,
+  extractMediaSrcMutations
+};

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

@@ -0,0 +1,212 @@
+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 {
+  readCompositionFps
+} from "./chunk-YEIFI443.js";
+import {
+  errorBox
+} from "./chunk-IHFUKJOR.js";
+import {
+  failUsage
+} from "./chunk-PBN6GBJE.js";
+import {
+  parseFps
+} from "./chunk-2YN64IN5.js";
+
+// src/browser/windowsCrash.ts
+var STATUS_STACK_BUFFER_OVERRUN_DEC = "3221225595";
+var STATUS_STACK_BUFFER_OVERRUN_HEX = /0x[cC]0000409/;
+var STATUS_STACK_BUFFER_OVERRUN_NAME = /STATUS_STACK_BUFFER_OVERRUN/i;
+function isWindowsChromeCrashError(errorMessage) {
+  if (!/Failed to launch the browser process/i.test(errorMessage)) return false;
+  return errorMessage.includes(STATUS_STACK_BUFFER_OVERRUN_DEC) || STATUS_STACK_BUFFER_OVERRUN_HEX.test(errorMessage) || STATUS_STACK_BUFFER_OVERRUN_NAME.test(errorMessage);
+}
+function windowsChromeCrashRemediation(errorMessage) {
+  if (process.platform !== "win32") return void 0;
+  if (!isWindowsChromeCrashError(errorMessage)) return void 0;
+  return [
+    "chrome-headless-shell crashed at launch (Windows STATUS_STACK_BUFFER_OVERRUN, exit 0xC0000409 / 3221225595).",
+    "The pinned Chromium build is not stable on this Windows host; point hyperframes at your installed Chrome instead:",
+    "",
+    '  set HYPERFRAMES_BROWSER_PATH="C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe"',
+    "",
+    "Then re-run your command. Any Chrome build works for the screenshot capture path; install a real chrome-headless-shell later if you need the perf-optimized BeginFrame path."
+  ].join("\n");
+}
+
+// src/utils/renderArgs.ts
+import { readFileSync } from "fs";
+import { resolve, sep } from "path";
+var MIN_PAGE_NAVIGATION_TIMEOUT_MS = 1;
+var MAX_PAGE_NAVIGATION_TIMEOUT_SECONDS = 86400;
+function parseBrowserTimeoutMsArg(raw) {
+  if (raw == null) return { ok: true, value: void 0 };
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) {
+    return { ok: false, error: { kind: "not-a-number", raw } };
+  }
+  if (parsed <= 0) {
+    return { ok: false, error: { kind: "not-positive", raw } };
+  }
+  if (parsed > MAX_PAGE_NAVIGATION_TIMEOUT_SECONDS) {
+    return { ok: false, error: { kind: "too-large", raw } };
+  }
+  const ms = Math.round(parsed * 1e3);
+  if (ms < MIN_PAGE_NAVIGATION_TIMEOUT_MS) {
+    return { ok: false, error: { kind: "too-small", raw } };
+  }
+  return { ok: true, value: ms };
+}
+function browserTimeoutErrorMessage(error) {
+  const title = "Invalid browser-timeout";
+  switch (error.kind) {
+    case "not-a-number":
+      return {
+        title,
+        message: `Got "${error.raw}", which is not a number. Pass a positive number of seconds (e.g. 180).`
+      };
+    case "not-positive":
+      return {
+        title,
+        message: `Got "${error.raw}" seconds, which is not positive. Pass a positive number of seconds (e.g. 180).`
+      };
+    case "too-small":
+      return {
+        title,
+        message: `Got "${error.raw}" seconds, which rounds to 0 ms. Puppeteer treats 0 as 'no timeout' \u2014 pass a value that rounds to at least 1 ms.`
+      };
+    case "too-large":
+      return {
+        title,
+        message: `Got "${error.raw}" seconds, which exceeds the ${MAX_PAGE_NAVIGATION_TIMEOUT_SECONDS}s (24h) cap. Node's setTimeout overflows for larger values.`
+      };
+  }
+}
+function resolveBrowserTimeoutMsArg(raw) {
+  const result = parseBrowserTimeoutMsArg(raw);
+  if (!result.ok) {
+    const { title, message, hint } = browserTimeoutErrorMessage(result.error);
+    errorBox(title, message, hint);
+    failUsage();
+  }
+  return result.value;
+}
+function resolveDiagnosticNavigationTimeoutMs(env = process.env, minimumTimeoutMs = 0) {
+  const parsed = Number(env.PRODUCER_PAGE_NAVIGATION_TIMEOUT_MS);
+  const configured = Number.isFinite(parsed) && parsed > 0 ? parsed : 1e4;
+  return Math.max(configured, minimumTimeoutMs);
+}
+function normalizeCompositionEntryArg(raw) {
+  const trimmed = raw?.trim().replace(/^\.\//, "") || void 0;
+  return !trimmed || trimmed === "." ? void 0 : trimmed;
+}
+function hasExplicitCompositionArg(raw) {
+  return normalizeCompositionEntryArg(raw) !== void 0;
+}
+function parseCompositionEntryArg(raw, projectDir, stat) {
+  const trimmed = normalizeCompositionEntryArg(raw);
+  if (!trimmed) return { ok: true, value: void 0 };
+  const absProjectDir = resolve(projectDir);
+  const entryPath = resolve(absProjectDir, trimmed);
+  if (entryPath !== absProjectDir && !entryPath.startsWith(absProjectDir + sep)) {
+    return { ok: false, error: { kind: "outside-project", entryFile: trimmed } };
+  }
+  let entryStat;
+  try {
+    entryStat = stat(entryPath);
+  } catch {
+    return { ok: false, error: { kind: "not-found", entryFile: trimmed } };
+  }
+  if (!entryStat.isFile()) {
+    return { ok: false, error: { kind: "not-a-file", entryFile: trimmed } };
+  }
+  return { ok: true, value: trimmed };
+}
+function compositionEntryErrorMessage(error) {
+  switch (error.kind) {
+    case "outside-project":
+      return {
+        title: "Invalid composition path",
+        message: `Entry file must stay inside the project directory: ${error.entryFile}`
+      };
+    case "not-found":
+      return {
+        title: "Composition not found",
+        message: `"${error.entryFile}" does not exist in the project directory.`,
+        hint: "Pass a path to a .html file relative to the project root (e.g. compositions/intro.html)."
+      };
+    case "not-a-file":
+      return {
+        title: "Invalid composition path",
+        message: `"${error.entryFile}" is a directory, not an .html file.`,
+        hint: "Pass a path to a .html file (e.g. compositions/intro.html), or omit --composition to render index.html."
+      };
+  }
+}
+function resolveCompositionEntryArg(raw, projectDir, stat) {
+  const result = parseCompositionEntryArg(raw, projectDir, stat);
+  if (!result.ok) {
+    const { title, message, hint } = compositionEntryErrorMessage(result.error);
+    errorBox(title, message, hint);
+    failUsage();
+  }
+  return result.value;
+}
+function resolveDefaultFpsArg(explicitFps, projectDir, indexPath, entryFile) {
+  if (explicitFps != null) return explicitFps;
+  try {
+    const fpsSourcePath = entryFile ? resolve(projectDir, entryFile) : indexPath;
+    const declared = readCompositionFps(readFileSync(fpsSourcePath, "utf8"));
+    if (declared != null && parseFps(declared).ok) {
+      return declared;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function parseGifLoopArg(raw) {
+  if (raw === void 0) return { ok: true, value: void 0 };
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) {
+    return { ok: false, message: "GIF loop count must not be empty." };
+  }
+  const parsed = Number(trimmed);
+  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
+    return {
+      ok: false,
+      message: `Got "${raw}". GIF loop count must be an integer between 0 and 65535.`
+    };
+  }
+  return { ok: true, value: parsed };
+}
+var MAX_HLS_SEGMENT_SECONDS = 60;
+function parseHlsSegmentSecondsArg(raw) {
+  if (raw === void 0) return { ok: true, value: void 0 };
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) {
+    return { ok: false, message: "HLS segment length must not be empty." };
+  }
+  const parsed = Number(trimmed);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > MAX_HLS_SEGMENT_SECONDS) {
+    return {
+      ok: false,
+      message: `Got "${raw}". HLS segment length must be a whole number of seconds between 1 and ${MAX_HLS_SEGMENT_SECONDS}.`
+    };
+  }
+  return { ok: true, value: parsed };
+}
+
+export {
+  windowsChromeCrashRemediation,
+  resolveBrowserTimeoutMsArg,
+  resolveDiagnosticNavigationTimeoutMs,
+  hasExplicitCompositionArg,
+  resolveCompositionEntryArg,
+  resolveDefaultFpsArg,
+  parseGifLoopArg,
+  parseHlsSegmentSecondsArg
+};

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

@@ -0,0 +1,19 @@
+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/telemetry/skill.ts
+var SKILL_SLUG = /^[a-z0-9][a-z0-9-]{0,63}$/;
+function normalizeSkillSlug(raw) {
+  if (typeof raw !== "string") return void 0;
+  const slug = raw.trim();
+  return SKILL_SLUG.test(slug) ? slug : void 0;
+}
+
+export {
+  SKILL_SLUG,
+  normalizeSkillSlug
+};