@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/tokens-OBGTYE4Z.js

@@ -0,0 +1,92 @@
+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 {
+  FigmaClientError,
+  createFigmaClient,
+  parseFigmaRef,
+  tokensToVariables,
+  upsertBindings,
+  withFigmaErrors
+} from "./chunk-QNYYOUU3.js";
+import "./chunk-IHFUKJOR.js";
+import "./chunk-ZTZA4UWZ.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import "./chunk-PBN6GBJE.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-GK4AIFIH.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/figma/tokens.ts
+import { writeFileSync } from "fs";
+import { join } from "path";
+async function runTokensImport(refInput, deps) {
+  const { fileKey } = parseFigmaRef(refInput);
+  const { version } = await deps.client.fileVersion(fileKey);
+  const sidecarPath = join(deps.projectDir, "figma-tokens.json");
+  let vars = null;
+  try {
+    vars = await deps.client.variables(fileKey);
+  } catch (err) {
+    if (!(err instanceof FigmaClientError) || err.code !== "REQUIRES_ENTERPRISE") throw err;
+  }
+  if (vars !== null) {
+    const out = tokensToVariables(vars, { fileKey, version });
+    upsertBindings(deps.projectDir, out.bindings);
+    writeFileSync(sidecarPath, JSON.stringify(out.sidecar, null, 2) + "\n");
+    return { mode: "variables", entries: out.entries, sidecarPath };
+  }
+  const styles = await deps.client.styles(fileKey);
+  const sidecar = {
+    source: { fileKey, version },
+    tokens: styles.map((s) => ({
+      name: s.name,
+      type: `style:${s.style_type}`,
+      figmaId: s.node_id ?? s.key,
+      key: s.key,
+      value: null
+    }))
+  };
+  writeFileSync(sidecarPath, JSON.stringify(sidecar, null, 2) + "\n");
+  return { mode: "styles", entries: [], sidecarPath, styleCount: styles.length };
+}
+var tokens_default = defineCommand({
+  meta: { name: "tokens", description: "Import figma variables/styles as brand tokens" },
+  args: {
+    ref: { type: "positional", description: "figma fileKey or URL", required: true },
+    dir: { type: "string", description: "project directory", default: "." }
+  },
+  async run({ args }) {
+    await withFigmaErrors("figma:tokens", async () => {
+      const t0 = Date.now();
+      const client = createFigmaClient({ token: process.env.FIGMA_TOKEN ?? "" });
+      const result = await runTokensImport(args.ref, { projectDir: args.dir, client });
+      if (result.mode === "styles") {
+        console.log(
+          (result.styleCount ?? 0) > 0 ? `variables are Enterprise-gated on this plan \u2014 recorded ${result.styleCount} published style(s) instead (style values resolve at component-import time)` : "variables are Enterprise-gated on this plan, and this file has no published library styles to fall back to \u2014 nothing recorded. Publish the file's styles to a team library, or read variables via the Figma MCP connector's get_variable_defs instead (works on any plan, rate-limited)."
+        );
+      }
+      console.log(`wrote ${result.sidecarPath} (${result.mode})`);
+      if (result.entries.length > 0) {
+        console.log("add to data-composition-variables:");
+        console.log(JSON.stringify(result.entries, null, 2));
+      }
+      const { trackFigmaImport } = await import("./telemetry-QMYM4WME.js");
+      trackFigmaImport({
+        phase: "tokens",
+        tokensMode: result.mode,
+        entryCount: result.entries.length,
+        durationMs: Date.now() - t0
+      });
+    });
+  }
+});
+export {
+  tokens_default as default,
+  runTokensImport
+};

package/vendor/hyperframes/dist/transcribe-7NVFHCGA.js

@@ -0,0 +1,387 @@
+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 {
+  ft
+} from "./chunk-WMQNIQDJ.js";
+import {
+  DEFAULT_MODEL,
+  isWhisperUnavailable
+} from "./chunk-OAF4XJOW.js";
+import "./chunk-X5HWXQPU.js";
+import "./chunk-TVCRUG2S.js";
+import {
+  trackTranscribeUnavailable
+} from "./chunk-JTHMTOMQ.js";
+import "./chunk-EISRN4E6.js";
+import "./chunk-VWG7OQKU.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+import "./chunk-IUZFXWSV.js";
+import "./chunk-AMKC3AXA.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import "./chunk-54HJ63Q2.js";
+import {
+  failCommand,
+  setCommandExitCode
+} from "./chunk-PBN6GBJE.js";
+import "./chunk-K2FTXJYH.js";
+import "./chunk-2YN64IN5.js";
+import "./chunk-AVUUN2XD.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-Z6B37SNM.js";
+import "./chunk-HWKCIWQT.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-LCSMOLGX.js";
+import "./chunk-TWWSYAKJ.js";
+import "./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 "./chunk-XUXGIA7H.js";
+import "./chunk-WERLJGIC.js";
+import "./chunk-ISN5GRYI.js";
+import "./chunk-FLWXXDNS.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-KNU5COPB.js";
+import {
+  PARAKEET_LANGUAGES,
+  PARAKEET_MODEL_LABEL,
+  findParakeet,
+  parakeetSpeaks,
+  transcribeWithParakeet
+} from "./chunk-IQ3OUQ5Z.js";
+import "./chunk-3GXQPCJC.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-PMRBLBUP.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/transcribe.ts
+import { existsSync, rmSync, writeFileSync } from "fs";
+import { resolve, join, extname, dirname } from "path";
+var examples = [
+  ["Transcribe an audio file", "hyperframes transcribe audio.mp3"],
+  ["Transcribe a video file", "hyperframes transcribe video.mp4"],
+  ["Use a larger model for better accuracy", "hyperframes transcribe audio.mp3 --model medium.en"],
+  ["Set language to filter non-target speech", "hyperframes transcribe audio.mp3 --language en"],
+  ["Import an existing SRT file", "hyperframes transcribe subtitles.srt"],
+  ["Import an OpenAI Whisper JSON response", "hyperframes transcribe response.json"],
+  ["Export captions to SRT", "hyperframes transcribe transcript.json --to srt"],
+  [
+    "Export single-word/CJK captions without re-grouping",
+    "hyperframes transcribe transcript.json --to vtt --preserve-cues"
+  ]
+];
+var CLI_TIMEOUT_MIN_MS = 5e3;
+var transcribe_default = defineCommand({
+  meta: {
+    name: "transcribe",
+    description: "Transcribe audio/video to word-level timestamps, or import an existing transcript"
+  },
+  args: {
+    input: {
+      type: "positional",
+      description: "Audio/video file to transcribe, or transcript file to import (.json, .srt, .vtt)",
+      required: true
+    },
+    dir: {
+      type: "string",
+      description: "Project directory (default: current directory)",
+      alias: "d"
+    },
+    engine: {
+      type: "string",
+      description: "ASR engine: auto (Parakeet if installed and it covers --language, else whisper), parakeet, or whisper. Default: auto. Parakeet is more accurate and faster; install it with `hyperframes models install parakeet`.",
+      alias: "e"
+    },
+    model: {
+      type: "string",
+      description: `Whisper model (default: ${DEFAULT_MODEL}). Options: tiny.en, base.en, small.en, medium.en, large-v3`,
+      alias: "m"
+    },
+    language: {
+      type: "string",
+      description: "Language code (e.g. en, es, ja). Filters out non-target language speech.",
+      alias: "l"
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON",
+      default: false
+    },
+    to: {
+      type: "string",
+      description: "Export transcript sidecar format: srt or vtt"
+    },
+    output: {
+      type: "string",
+      alias: "o",
+      description: "Output path for exported SRT/VTT sidecar"
+    },
+    "preserve-cues": {
+      type: "boolean",
+      description: "Keep each transcript entry as its own caption cue (skip word-level grouping). Use when exporting an already-cued transcript whose entries have no internal spaces, e.g. single-word or CJK captions.",
+      default: false
+    },
+    optional: {
+      type: "boolean",
+      description: "Treat captions as optional: if whisper-cpp is unavailable, skip and exit 0 instead of failing. For pipelines that continue without captions.",
+      default: false
+    },
+    timeout: {
+      type: "string",
+      description: "Whisper spawn timeout in ms. Overrides the duration+model auto-scaled default. Increase on slow CPUs (e.g. emulated arm64/x64, low-power laptops) where whisper.cpp takes many seconds per audio second on medium/large models. Applies to the whisper engine only; Parakeet has a separate fixed timeout. Minimum 5000 (5 s). Env: HYPERFRAMES_TRANSCRIBE_TIMEOUT_MS."
+    }
+  },
+  async run({ args }) {
+    const inputPath = resolve(args.input);
+    if (!existsSync(inputPath)) {
+      const message = `File not found: ${args.input}`;
+      console.error(c.error(message));
+      failCommand(1, message);
+    }
+    const dir = resolve(args.dir ?? dirname(inputPath));
+    const ext = extname(inputPath).toLowerCase();
+    const isImport = ext === ".json" || ext === ".srt" || ext === ".vtt";
+    const to = parseExportFormat(args.to, args.json);
+    if (to) {
+      if (!isImport) {
+        failWith(
+          "--to can only export from transcript files (.json, .srt, .vtt). Run transcribe first.",
+          args.json
+        );
+      }
+      return exportTranscript(inputPath, dir, to, args.output, args.json, args["preserve-cues"]);
+    }
+    if (isImport) {
+      return importTranscript(inputPath, dir, args.json);
+    }
+    const timeoutMs = parseTimeoutMs(args.timeout, args.json);
+    return transcribeAudio(inputPath, dir, {
+      engine: args.engine,
+      model: args.model,
+      language: args.language,
+      json: args.json,
+      optional: args.optional,
+      timeoutMs
+    });
+  }
+});
+function parseTimeoutMs(raw, json) {
+  const source = raw ?? process.env["HYPERFRAMES_TRANSCRIBE_TIMEOUT_MS"];
+  if (source == null || source === "") return void 0;
+  const parsed = Number.parseInt(source, 10);
+  if (!Number.isFinite(parsed) || parsed < CLI_TIMEOUT_MIN_MS) {
+    const origin = raw != null ? "--timeout" : "HYPERFRAMES_TRANSCRIBE_TIMEOUT_MS";
+    failWith(
+      `Invalid ${origin}: "${source}". Must be an integer >= ${CLI_TIMEOUT_MIN_MS} (ms).`,
+      json
+    );
+  }
+  return parsed;
+}
+function failWith(message, json) {
+  if (json) {
+    console.log(JSON.stringify({ ok: false, error: message }));
+  } else {
+    console.error(c.error(message));
+  }
+  failCommand(1, message);
+}
+function parseExportFormat(value, json) {
+  if (!value) return void 0;
+  const normalized = value.toLowerCase();
+  if (normalized === "srt" || normalized === "vtt") return normalized;
+  failWith(`Unsupported caption export format: ${value}. Use srt or vtt.`, json);
+}
+function exitNoWords(json) {
+  failWith("No words found in transcript.", json);
+}
+async function importTranscript(inputPath, dir, json) {
+  const { loadTranscript, patchCaptionHtml } = await import("./normalize-O76AC4HE.js");
+  const { words, format } = loadTranscript(inputPath);
+  if (words.length === 0) exitNoWords(json);
+  const outPath = join(dir, "transcript.json");
+  writeFileSync(outPath, JSON.stringify(words, null, 2));
+  patchCaptionHtml(dir, words);
+  if (json) {
+    console.log(
+      JSON.stringify({ ok: true, format, wordCount: words.length, transcriptPath: outPath })
+    );
+  } else {
+    console.log(
+      `${c.success("\u25C7")}  Imported ${c.accent(String(words.length))} words from ${c.accent(format)} format \u2192 ${c.accent("transcript.json")}`
+    );
+  }
+}
+async function exportTranscript(inputPath, dir, to, output, json, preserveCues) {
+  const { loadTranscript, formatSrt, formatVtt } = await import("./normalize-O76AC4HE.js");
+  const { words, format } = loadTranscript(inputPath);
+  if (words.length === 0) exitNoWords(json);
+  const preGrouped = preserveCues || format === "srt" || format === "vtt" || void 0;
+  const outPath = resolve(output ?? join(dir, `transcript.${to}`));
+  const content = to === "srt" ? formatSrt(words, { preGrouped }) : formatVtt(words, { preGrouped });
+  writeFileSync(outPath, content);
+  if (json) {
+    console.log(
+      JSON.stringify({ ok: true, format: to, wordCount: words.length, outputPath: outPath })
+    );
+  } else {
+    console.log(
+      `${c.success("\u25C7")}  Exported ${c.accent(String(words.length))} words to ${c.accent(to.toUpperCase())} \u2192 ${c.accent(outPath)}`
+    );
+  }
+}
+function pickRunner(engine, sherpaUsable, language) {
+  if (engine === "whisper" || !parakeetSpeaks(language)) return "whisper";
+  if (sherpaUsable()) return "sherpa";
+  return findParakeet() ? "parakeet-mlx" : "whisper";
+}
+var parakeetFallsBack = (engine) => engine === "auto";
+async function transcribeAudio(inputPath, dir, opts) {
+  const { transcribe } = await import("./transcribe-BNSJRR4M.js");
+  const { loadTranscript, patchCaptionHtml, stripBeforeOnset } = await import("./normalize-O76AC4HE.js");
+  const {
+    DecodeCancelled,
+    prepareSherpaWav,
+    sherpaParakeetInstalled,
+    sherpaUnsupportedReason,
+    transcribeWithSherpa
+  } = await import("./sherpa-KKLNW6U2.js");
+  const { createRenderCancellationScope, stoppedByCancelSignal } = await import("./renderCancellation-JPIHE47X.js");
+  const engine = (opts.engine ?? "auto").toLowerCase();
+  if (engine !== "auto" && engine !== "parakeet" && engine !== "whisper") {
+    failWith(`Unknown --engine: ${opts.engine}. Use auto, parakeet, or whisper.`, !!opts.json);
+  }
+  const unsupported = sherpaUnsupportedReason();
+  const sherpaUsable = () => !unsupported && sherpaParakeetInstalled();
+  let runner = pickRunner(engine, sherpaUsable, opts.language);
+  if (engine === "parakeet" && runner === "whisper") {
+    failWith(
+      !parakeetSpeaks(opts.language) ? `Parakeet does not transcribe --language ${opts.language}; it covers ${PARAKEET_LANGUAGES.split(" ").join(", ")}. Use --engine whisper.` : unsupported ?? "Parakeet is not installed. Install it with: hyperframes models install parakeet (or use --engine whisper)",
+      !!opts.json
+    );
+  }
+  const model = opts.model ?? DEFAULT_MODEL;
+  if (runner !== "whisper" && opts.model && !opts.json) {
+    console.error(
+      c.dim(`  Note: --model applies to the whisper engine only; ignored under Parakeet.`)
+    );
+  }
+  const label = (r) => c.accent(r === "whisper" ? model : "Parakeet");
+  const spin = opts.json ? null : ft();
+  spin?.start(`Transcribing with ${label(runner)}...`);
+  const onProgress = spin ? (msg) => spin.message(msg) : void 0;
+  let wavPath = inputPath;
+  const cancellation = runner === "sherpa" ? createRenderCancellationScope() : null;
+  const run = (r) => r === "sherpa" ? transcribeWithSherpa(wavPath, dir, { onProgress, signal: cancellation.signal }) : r === "parakeet-mlx" ? transcribeWithParakeet(wavPath, dir, { language: opts.language, onProgress }) : transcribe(wavPath, dir, {
+    model,
+    language: opts.language,
+    onProgress,
+    timeoutMs: opts.timeoutMs
+  });
+  try {
+    if (runner === "sherpa") wavPath = prepareSherpaWav(inputPath, onProgress);
+    let result;
+    try {
+      result = await run(runner);
+    } catch (err) {
+      if (runner !== "sherpa" || err instanceof DecodeCancelled) throw err;
+      const reason = normalizeErrorMessage(err).replace(/\.+$/, "");
+      const parakeetError = `Parakeet failed: ${reason}. To repair it, run: hyperframes models install parakeet`;
+      if (!parakeetFallsBack(engine)) throw new Error(parakeetError);
+      runner = pickRunner(engine, () => false, opts.language);
+      spin?.clear();
+      console.error(c.warn(`${parakeetError}. Using ${runner} for this run.`));
+      spin?.start(`Transcribing with ${label(runner)}...`);
+      try {
+        result = await run(runner);
+      } catch (fallbackErr) {
+        if (stoppedByCancelSignal(fallbackErr)) {
+          throw new DecodeCancelled("Transcription cancelled");
+        }
+        const why = normalizeErrorMessage(fallbackErr);
+        throw new Error(`${parakeetError}. The ${runner} fallback failed too: ${why}`);
+      }
+    }
+    let { words } = loadTranscript(result.transcriptPath);
+    if (result.speechOnsetSeconds != null) {
+      const before = words.length;
+      words = stripBeforeOnset(words, result.speechOnsetSeconds);
+      const stripped = before - words.length;
+      if (stripped > 0 && !opts.json) {
+        spin?.message(
+          `Stripped ${stripped} words before speech onset at ${result.speechOnsetSeconds.toFixed(1)}s`
+        );
+      }
+    }
+    writeFileSync(result.transcriptPath, JSON.stringify(words, null, 2));
+    patchCaptionHtml(dir, words);
+    if (opts.json) {
+      console.log(
+        JSON.stringify({
+          ok: true,
+          engine: runner === "whisper" ? "whisper" : "parakeet",
+          model: runner === "whisper" ? model : PARAKEET_MODEL_LABEL,
+          wordCount: words.length,
+          durationSeconds: result.durationSeconds,
+          speechOnsetSeconds: result.speechOnsetSeconds,
+          transcriptPath: result.transcriptPath
+        })
+      );
+    } else {
+      const onsetNote = result.speechOnsetSeconds != null ? ` \u2014 speech detected at ${result.speechOnsetSeconds.toFixed(1)}s` : "";
+      spin?.stop(
+        c.success(
+          `Transcribed ${c.accent(String(words.length))} words (${result.durationSeconds.toFixed(1)}s${onsetNote})`
+        )
+      );
+    }
+  } catch (err) {
+    if (err instanceof DecodeCancelled || cancellation?.signal.aborted) {
+      const message2 = "Transcription cancelled";
+      if (opts.json) console.log(JSON.stringify({ ok: false, error: message2 }));
+      else spin?.stop(c.warn(message2));
+      setCommandExitCode(130);
+      return;
+    }
+    const base = err instanceof Error ? err.message : String(err);
+    const stderr = err && typeof err === "object" && "stderr" in err && err.stderr ? String(err.stderr).trim().split("\n").slice(-3).filter((line) => !base.includes(line)).join("\n") : "";
+    const message = stderr ? `${base}
+${stderr}` : base;
+    if (isWhisperUnavailable(err)) {
+      trackTranscribeUnavailable({ optional: opts.optional === true });
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, skipped: true, reason: "whisper_unavailable" }));
+      } else {
+        spin?.stop(c.warn(`Captions skipped \u2014 ${message}`));
+      }
+      setCommandExitCode(opts.optional ? 0 : 1);
+      return;
+    }
+    if (opts.json) {
+      console.log(JSON.stringify({ ok: false, error: message }));
+    } else {
+      spin?.stop(c.error(`Transcription failed: ${message}`));
+    }
+    failCommand(1, err);
+  } finally {
+    cancellation?.dispose();
+    if (wavPath !== inputPath) rmSync(wavPath, { force: true });
+  }
+}
+export {
+  transcribe_default as default,
+  examples
+};

package/vendor/hyperframes/dist/transcribe-BNSJRR4M.js

@@ -0,0 +1,62 @@
+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 {
+  detectSpeechOnset,
+  dtwPresetForModel,
+  getMediaDurationSeconds,
+  getPreparedWavDurationSeconds,
+  initialModelForLanguage,
+  isPcm16kMono,
+  isWhisperTimeoutError,
+  prepareWav,
+  resolveAudioPreparationTimeoutMs,
+  resolveWhisperTimeoutMs,
+  transcribe,
+  whisperModelSlowdownFactor,
+  wrapWhisperTimeoutError
+} from "./chunk-K2EQN4VU.js";
+import "./chunk-7JZ4FXP2.js";
+import "./chunk-OAF4XJOW.js";
+import "./chunk-X5HWXQPU.js";
+import "./chunk-TVCRUG2S.js";
+import "./chunk-AMKC3AXA.js";
+import "./chunk-K2FTXJYH.js";
+import "./chunk-2YN64IN5.js";
+import "./chunk-AVUUN2XD.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-Z6B37SNM.js";
+import "./chunk-HWKCIWQT.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-LAOCA3MQ.js";
+import "./chunk-LCSMOLGX.js";
+import "./chunk-TWWSYAKJ.js";
+import "./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-3GXQPCJC.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-PMRBLBUP.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  detectSpeechOnset,
+  dtwPresetForModel,
+  getMediaDurationSeconds,
+  getPreparedWavDurationSeconds,
+  initialModelForLanguage,
+  isPcm16kMono,
+  isWhisperTimeoutError,
+  prepareWav,
+  resolveAudioPreparationTimeoutMs,
+  resolveWhisperTimeoutMs,
+  transcribe,
+  whisperModelSlowdownFactor,
+  wrapWhisperTimeoutError
+};