@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/chunk-4YYJOFKS.js

@@ -0,0 +1,28 @@
+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/writeNewFile.ts
+import { linkSync, mkdtempSync, rmSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+function writeNewFileSync(filePath, content) {
+  const stagingDir = mkdtempSync(join(dirname(filePath), ".hf-create-"));
+  try {
+    const stagedPath = join(stagingDir, "content");
+    writeFileSync(stagedPath, content, { encoding: "utf-8", flag: "wx" });
+    try {
+      linkSync(stagedPath, filePath);
+    } catch (err) {
+      if (!(err instanceof Error && "code" in err && err.code === "EEXIST")) throw err;
+    }
+  } finally {
+    rmSync(stagingDir, { recursive: true, force: true });
+  }
+}
+
+export {
+  writeNewFileSync
+};

package/vendor/hyperframes/dist/chunk-54HJ63Q2.js

@@ -0,0 +1,29 @@
+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/runId.ts
+import { randomUUID } from "crypto";
+var resolved = false;
+var runId;
+function getRunId() {
+  if (!resolved) {
+    const value = process.env["HYPERFRAMES_RUN_ID"]?.trim().slice(0, 128);
+    runId = value ? value : void 0;
+    resolved = true;
+  }
+  return runId;
+}
+var invocationId;
+function getInvocationId() {
+  invocationId ??= randomUUID();
+  return invocationId;
+}
+
+export {
+  getRunId,
+  getInvocationId
+};

package/vendor/hyperframes/dist/chunk-5ETJX6WM.js

@@ -0,0 +1,89 @@
+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/tts/python.ts
+import { execFileSync } from "child_process";
+function validatePythonOverride(override) {
+  try {
+    const version = execFileSync(override, ["--version"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5e3
+    });
+    if (/Python 3/.test(version)) return { ok: true };
+    return {
+      ok: false,
+      reason: `did not report a Python 3 version (got ${JSON.stringify(version.trim())})`
+    };
+  } catch (error) {
+    return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+  }
+}
+function findPython() {
+  const override = process.env.HYPERFRAMES_PYTHON;
+  if (override && validatePythonOverride(override).ok) return override;
+  for (const name of ["python3", "python"]) {
+    try {
+      const cmd = process.platform === "win32" ? "where" : "which";
+      const output = execFileSync(cmd, [name], {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 5e3
+      });
+      const first = output.split(/\r?\n/).map((s) => s.trim()).find(Boolean);
+      if (!first) continue;
+      const version = execFileSync(first, ["--version"], {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 5e3
+      }).trim();
+      if (version.includes("Python 3")) return first;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function describeRejectedPythonOverride() {
+  const override = process.env.HYPERFRAMES_PYTHON;
+  if (!override) return null;
+  const validation = validatePythonOverride(override);
+  if (validation.ok) return null;
+  return `HYPERFRAMES_PYTHON="${override}" was rejected: ${validation.reason}`;
+}
+function hasPythonPackage(python, pkg) {
+  try {
+    execFileSync(python, ["-c", `import ${pkg}`], {
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 1e4
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasPythonModules(modules) {
+  const python = findPython();
+  if (!python) return false;
+  const list = JSON.stringify(modules);
+  const probe = `import importlib.util,sys; sys.exit(0 if all(importlib.util.find_spec(m) for m in ${list}) else 1)`;
+  try {
+    execFileSync(python, ["-c", probe], {
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 1e4
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  findPython,
+  describeRejectedPythonOverride,
+  hasPythonPackage,
+  hasPythonModules
+};

package/vendor/hyperframes/dist/chunk-5IAKAQA7.js

@@ -0,0 +1,389 @@
+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 {
+  KOKORO_MODULES,
+  KOKORO_PIP,
+  MUSICGEN_MODULES,
+  MUSICGEN_PIP
+} from "./chunk-Z27A7NUB.js";
+import {
+  describeRejectedPythonOverride,
+  hasPythonModules
+} from "./chunk-5ETJX6WM.js";
+import {
+  runEnvironmentChecks
+} from "./chunk-FCSIGXXP.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+import {
+  getAvailableMemoryMb,
+  getFreeDiskMb,
+  getShmSizeMb,
+  getSystemMeta
+} from "./chunk-IUZFXWSV.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import {
+  resolveExtractCacheDir
+} from "./chunk-K2FTXJYH.js";
+import {
+  getUpdateMeta,
+  withMeta
+} from "./chunk-HW6OYASV.js";
+import {
+  CONFIG_PATH,
+  withFileLock
+} from "./chunk-XUXGIA7H.js";
+import {
+  VERSION
+} from "./chunk-FLWXXDNS.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-KNU5COPB.js";
+import {
+  OPTIONAL_PACKAGES,
+  installedOptionalPackageVersion
+} from "./chunk-XT5P4QMO.js";
+
+// src/commands/doctor.ts
+import { execFileSync, execSync } from "child_process";
+import * as fs from "fs";
+import { existsSync } from "fs";
+import { platform } from "os";
+import { dirname } from "path";
+var examples = [
+  ["Check system dependencies", "hyperframes doctor"],
+  ["Output as JSON for CI / agents", "hyperframes doctor --json"]
+];
+function checkDocker() {
+  try {
+    const version = execSync("docker --version", { encoding: "utf-8", timeout: 5e3 }).trim();
+    return { ok: true, detail: version };
+  } catch {
+    return {
+      ok: false,
+      detail: "Not found",
+      hint: "https://docs.docker.com/get-docker/"
+    };
+  }
+}
+function checkDockerRunning() {
+  try {
+    execSync("docker info", { stdio: "pipe", timeout: 5e3 });
+    return { ok: true, detail: "Running" };
+  } catch {
+    return {
+      ok: false,
+      detail: "Not running",
+      hint: "Start Docker Desktop or run: sudo systemctl start docker"
+    };
+  }
+}
+function checkVersion() {
+  const meta = getUpdateMeta();
+  if (meta.updateAvailable && meta.latestVersion) {
+    return {
+      ok: false,
+      detail: `${VERSION} \u2192 ${meta.latestVersion} available`,
+      hint: "Run: hyperframes upgrade"
+    };
+  }
+  return { ok: true, detail: `${VERSION} (latest)` };
+}
+function checkNode() {
+  return { ok: true, detail: `${process.version} (${process.platform} ${process.arch})` };
+}
+function checkCPU() {
+  const sys = getSystemMeta();
+  const model = sys.cpu_model ?? "Unknown";
+  const speedStr = sys.cpu_speed ? ` @ ${sys.cpu_speed}MHz` : "";
+  return { ok: true, detail: `${sys.cpu_count} cores \xB7 ${model}${speedStr}` };
+}
+function checkMemory() {
+  const sys = getSystemMeta();
+  const availMb = getAvailableMemoryMb();
+  const totalGb = (sys.memory_total_mb / 1024).toFixed(1);
+  const availGb = (availMb / 1024).toFixed(1);
+  if (availMb < 2048) {
+    return {
+      ok: false,
+      detail: `${totalGb} GB total \xB7 ${availGb} GB available`,
+      hint: "Low memory \u2014 renders may fail. Close other apps or increase RAM."
+    };
+  }
+  return { ok: true, detail: `${totalGb} GB total \xB7 ${availGb} GB available` };
+}
+function checkShm() {
+  const shmMb = getShmSizeMb();
+  if (shmMb === null) {
+    return { ok: true, detail: "N/A (non-Linux)" };
+  }
+  if (shmMb < 256) {
+    return {
+      ok: false,
+      detail: `${shmMb} MB`,
+      hint: "Chrome needs \u2265256 MB. Use: docker run --shm-size=512m"
+    };
+  }
+  return { ok: true, detail: `${shmMb} MB` };
+}
+function checkDisk() {
+  const freeMb = getFreeDiskMb(".");
+  if (freeMb === null) {
+    return { ok: true, detail: "Unable to check" };
+  }
+  const freeGb = (freeMb / 1024).toFixed(1);
+  if (freeMb < 1024) {
+    return {
+      ok: false,
+      detail: `${freeGb} GB free`,
+      hint: "Low disk space \u2014 renders produce large temp files."
+    };
+  }
+  return { ok: true, detail: `${freeGb} GB free` };
+}
+function checkFramesCache(env = process.env, freeDiskMb = getFreeDiskMb, fileExists = existsSync) {
+  const resolution = resolveExtractCacheDir(env);
+  if (resolution.disabled) {
+    return {
+      ok: true,
+      detail: `Disabled (${resolution.rawValue}) \u2014 frames extract into per-render workDir`
+    };
+  }
+  const dir = resolution.dir;
+  const probePath = firstExistingAncestor(dir, fileExists) ?? dir;
+  const freeMb = freeDiskMb(probePath);
+  if (freeMb === null) {
+    return {
+      ok: true,
+      detail: `${dir} (free space unknown; ${sourceLabel(resolution.source)})`
+    };
+  }
+  const freeGb = (freeMb / 1024).toFixed(1);
+  const suffix = `${freeGb} GB free at ${probePath} \xB7 ${sourceLabel(resolution.source)}`;
+  if (freeMb < 2048) {
+    return {
+      ok: false,
+      detail: `${dir} \xB7 ${suffix}`,
+      hint: "Low free space at the extract cache location \u2014 long renders can exhaust the drive. Relocate via HYPERFRAMES_EXTRACT_CACHE_DIR=<path> or `hyperframes render --frames-cache-dir <path>`."
+    };
+  }
+  return { ok: true, detail: `${dir} \xB7 ${suffix}` };
+}
+function firstExistingAncestor(path, fileExists) {
+  let current = path;
+  for (let i = 0; i < 64; i += 1) {
+    if (fileExists(current)) return current;
+    const parent = dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+  return null;
+}
+function sourceLabel(source) {
+  return source === "env" ? "HYPERFRAMES_EXTRACT_CACHE_DIR" : "default";
+}
+function commandExists(command) {
+  try {
+    execFileSync("which", [command], { stdio: "ignore", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkArchiveExtractor(hostPlatform = platform(), exists = commandExists) {
+  if (hostPlatform === "win32") {
+    return { ok: true, detail: "Built into Windows" };
+  }
+  if (exists("unzip")) {
+    return { ok: true, detail: "unzip" };
+  }
+  return {
+    ok: false,
+    detail: "Not found",
+    hint: "Install unzip so HyperFrames can extract its managed Chrome download."
+  };
+}
+function checkSettingsLock(lockPath = `${CONFIG_PATH}.lock`) {
+  if (!existsSync(lockPath)) return { ok: true, detail: "Not locked" };
+  try {
+    withFileLock(lockPath, fs, () => void 0);
+    return { ok: true, detail: "Not locked" };
+  } catch (error) {
+    return { ok: false, detail: "Locked", hint: normalizeErrorMessage(error) };
+  }
+}
+function checkEnvironment() {
+  const sys = getSystemMeta();
+  const parts = [];
+  if (sys.is_docker) parts.push("Docker");
+  if (sys.is_wsl) parts.push("WSL");
+  if (sys.is_ci) parts.push(`CI (${sys.ci_name ?? "detected"})`);
+  if (!sys.is_tty) parts.push("non-TTY");
+  if (parts.length === 0) {
+    return { ok: true, detail: "Native terminal" };
+  }
+  return { ok: true, detail: parts.join(" \xB7 ") };
+}
+async function checkWhisper() {
+  const { findWhisper, getInstallInstructions } = await import("./manager-67P2XFXQ.js");
+  const result = findWhisper();
+  if (result) {
+    return { ok: true, detail: result.executablePath };
+  }
+  return {
+    ok: false,
+    detail: "Not found (optional \u2014 needed for transcription)",
+    hint: getInstallInstructions()
+  };
+}
+function notInstalledDetail(base) {
+  const overrideRejection = describeRejectedPythonOverride();
+  return overrideRejection ? `${base}. ${overrideRejection}` : base;
+}
+function checkLocalVoice() {
+  if (hasPythonModules(KOKORO_MODULES)) return { ok: true, detail: "Kokoro deps installed" };
+  return {
+    ok: false,
+    detail: notInstalledDetail("Not installed (optional \u2014 local voice fallback)"),
+    hint: KOKORO_PIP
+  };
+}
+function checkLocalMusic() {
+  if (hasPythonModules(MUSICGEN_MODULES)) return { ok: true, detail: "MusicGen deps installed" };
+  return {
+    ok: false,
+    detail: notInstalledDetail("Not installed (optional \u2014 local music fallback)"),
+    hint: MUSICGEN_PIP
+  };
+}
+function checkOptionalPackage(name, cacheDir, cliUrl) {
+  const version = installedOptionalPackageVersion(name, cacheDir, cliUrl);
+  return {
+    ok: true,
+    detail: version ? `${version} installed` : "Not installed (installs on first use)"
+  };
+}
+function redactHome(s) {
+  const home = process.env["HOME"] || process.env["USERPROFILE"];
+  if (!home) return s;
+  return s.split(home).join("$HOME");
+}
+function redactOutcome(o) {
+  return {
+    name: o.name,
+    ok: o.ok,
+    detail: redactHome(o.detail),
+    ...o.hint ? { hint: redactHome(o.hint) } : {}
+  };
+}
+function buildDoctorReport(outcomes, options = {}) {
+  const checks = options.redact ? outcomes.map(redactOutcome) : outcomes;
+  return withMeta({
+    ok: checks.every((o) => o.ok),
+    platform: process.platform,
+    arch: process.arch,
+    checks
+  });
+}
+var doctor_default = defineCommand({
+  meta: { name: "doctor", description: "Check system dependencies and environment" },
+  args: {
+    json: { type: "boolean", description: "Output as JSON", default: false }
+  },
+  async run({ args }) {
+    const environment = await runEnvironmentChecks({ includeBrowser: true });
+    const checks = [
+      { name: "Version", run: checkVersion },
+      { name: "Node.js", run: checkNode },
+      { name: "CPU", run: checkCPU },
+      { name: "Memory", run: checkMemory },
+      { name: "Disk", run: checkDisk },
+      { name: "Frames cache", run: () => checkFramesCache() },
+      { name: "Archive extractor", run: checkArchiveExtractor },
+      { name: "Settings lock", run: () => checkSettingsLock() }
+    ];
+    if (platform() === "linux") {
+      checks.push({ name: "/dev/shm", run: checkShm });
+    }
+    checks.push({ name: "Environment", run: checkEnvironment });
+    checks.push({ name: "whisper-cpp", run: checkWhisper });
+    checks.push({ name: "TTS (Kokoro)", run: checkLocalVoice });
+    checks.push({ name: "BGM (MusicGen)", run: checkLocalMusic });
+    for (const name of Object.keys(OPTIONAL_PACKAGES)) {
+      checks.push({ name, run: () => checkOptionalPackage(name) });
+    }
+    const outcomes = [];
+    for (const check of checks) {
+      const result = await check.run();
+      outcomes.push({
+        name: check.name,
+        ok: result.ok,
+        detail: result.detail,
+        ...result.hint ? { hint: result.hint } : {}
+      });
+    }
+    for (const result of environment.outcomes) {
+      outcomes.push({
+        name: result.name,
+        ok: result.ok,
+        detail: result.detail,
+        ...result.hint ? { hint: result.hint } : {}
+      });
+    }
+    for (const check of [
+      { name: "Docker", run: checkDocker },
+      { name: "Docker running", run: checkDockerRunning }
+    ]) {
+      const result = await check.run();
+      outcomes.push({
+        name: check.name,
+        ok: result.ok,
+        detail: result.detail,
+        ...result.hint ? { hint: result.hint } : {}
+      });
+    }
+    const allOk = outcomes.every((o) => o.ok);
+    if (args.json) {
+      console.log(JSON.stringify(buildDoctorReport(outcomes, { redact: true }), null, 2));
+      return;
+    }
+    console.log();
+    console.log(c.bold("hyperframes doctor"));
+    console.log();
+    for (const outcome of outcomes) {
+      const icon = outcome.ok ? c.success("\u2713") : c.error("\u2717");
+      const name = outcome.name.padEnd(16);
+      console.log(
+        `  ${icon} ${c.bold(name)} ${outcome.ok ? c.dim(outcome.detail) : c.error(outcome.detail)}`
+      );
+      if (!outcome.ok && outcome.hint) {
+        console.log(`  ${" ".repeat(19)}${c.accent(outcome.hint)}`);
+      }
+    }
+    console.log();
+    if (allOk) {
+      console.log(`  ${c.success("\u25C7")}  ${c.success("All checks passed")}`);
+    } else {
+      console.log(`  ${c.warn("\u25C7")}  ${c.warn("Some checks failed \u2014 see hints above")}`);
+    }
+    console.log();
+  }
+});
+
+export {
+  examples,
+  checkFramesCache,
+  checkArchiveExtractor,
+  checkSettingsLock,
+  checkOptionalPackage,
+  redactHome,
+  buildDoctorReport,
+  doctor_default
+};

package/vendor/hyperframes/dist/chunk-5Z63TBTX.js

@@ -0,0 +1,37 @@
+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-PFCFR3KZ.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 resolveCompositionViewportFromHtml(html) {
+  return findCompositionDimensions(html) ?? DEFAULT_VIEWPORT;
+}
+
+export {
+  findCompositionDimensions,
+  resolveCompositionViewportFromHtml
+};

package/vendor/hyperframes/dist/chunk-6BEFEWFB.js

@@ -0,0 +1,25 @@
+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/npxCommand.ts
+function buildCmdShimCommand(name, args, platform) {
+  if (platform === "win32") {
+    return { command: "cmd.exe", args: ["/d", "/s", "/c", `${name}.cmd`, ...args] };
+  }
+  return { command: name, args: [...args] };
+}
+function buildNpxCommand(args, platform = process.platform) {
+  return buildCmdShimCommand("npx", args, platform);
+}
+function buildNpmCommand(args, platform = process.platform) {
+  return buildCmdShimCommand("npm", args, platform);
+}
+
+export {
+  buildNpxCommand,
+  buildNpmCommand
+};

package/vendor/hyperframes/dist/chunk-6CSYCFQV.js

@@ -0,0 +1,68 @@
+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-ZTZA4UWZ.js";
+
+// src/utils/lintFormat.ts
+function formatLintFindings({ results, totalErrors, totalWarnings, totalInfos }, options = {}) {
+  const {
+    showElementId = true,
+    showSummary = false,
+    errorsFirst = false,
+    verbose = false
+  } = options;
+  const lines = [];
+  const multiFile = results.length > 1;
+  for (const { file, result } of results) {
+    if (result.findings.length === 0) continue;
+    const format = (finding) => {
+      if (!verbose && finding.severity === "info") return;
+      const prefix = finding.severity === "error" ? c.error("\u2717") : finding.severity === "warning" ? c.warn("\u26A0") : c.dim("\u2139");
+      const fileLabel = findingFileLabel(file, finding, multiFile);
+      const loc = showElementId && finding.elementId ? ` ${c.accent(`[${finding.elementId}]`)}` : "";
+      lines.push(`  ${prefix} ${fileLabel}${c.bold(finding.code)}${loc}: ${finding.message}`);
+      if (finding.fixHint) lines.push(`    ${c.dim(`Fix: ${finding.fixHint}`)}`);
+    };
+    if (errorsFirst) {
+      for (const f of result.findings) if (f.severity === "error") format(f);
+      for (const f of result.findings) if (f.severity === "warning") format(f);
+      if (verbose) {
+        for (const f of result.findings) if (f.severity === "info") format(f);
+      }
+    } else {
+      for (const f of result.findings) format(f);
+    }
+  }
+  if (showSummary) {
+    const icon = totalErrors > 0 ? c.error("\u25C7") : c.success("\u25C7");
+    lines.push("");
+    lines.push(`${icon}  ${formatLintCounts(totalErrors, totalWarnings, totalInfos, verbose)}`);
+  }
+  return lines;
+}
+function formatLintCounts(totalErrors, totalWarnings, totalInfos, verbose) {
+  const parts = [`${totalErrors} error(s)`, `${totalWarnings} warning(s)`];
+  if (verbose && totalInfos > 0) parts.push(`${totalInfos} info(s)`);
+  return parts.join(", ");
+}
+function formatLintStartupMessage(lintResult, mode) {
+  if (mode.kind === "verbose") return formatLintFindings(lintResult, mode.options);
+  const counts = formatLintCounts(lintResult.totalErrors, lintResult.totalWarnings, 0, false);
+  const hint = mode.pointer === "studio" ? "see the Lint badge in Studio, or run `hyperframes lint` for full output" : "run with --lint-verbose for full output";
+  return [`  Lint: ${counts} \u2014 ${hint}.`];
+}
+function findingFileLabel(file, finding, multiFile) {
+  if (finding.line === void 0) return multiFile ? c.dim(`[${file}] `) : "";
+  const column = finding.column === void 0 ? "" : `:${finding.column}`;
+  return c.dim(`[${finding.file ?? file}:${finding.line}${column}] `);
+}
+
+export {
+  formatLintFindings,
+  formatLintStartupMessage
+};