@ignix-social/editor 0.1.0

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

@@ -0,0 +1,108 @@
+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/commandResult.ts
+var SUCCESS_RESULT = { exitCode: 0, kind: "success" };
+var pendingResult = SUCCESS_RESULT;
+var rootExitRequester;
+var rootExitCodeSanitizer;
+var CliUsageError = class extends Error {
+  result;
+  constructor(message = "Invalid command usage", options = {}) {
+    super(message);
+    this.name = "CliUsageError";
+    this.result = {
+      exitCode: options.exitCode ?? 1,
+      kind: "usage_error",
+      presented: options.presented
+    };
+  }
+};
+var CliRuntimeError = class extends Error {
+  result;
+  constructor(message = "Command failed", options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "CliRuntimeError";
+    this.result = {
+      exitCode: options.exitCode ?? 1,
+      kind: "runtime_error",
+      presented: options.presented
+    };
+  }
+};
+var CliResultSignal = class extends Error {
+  result;
+  constructor(result) {
+    super(`CLI result ${result.exitCode}`);
+    this.name = "CliResultSignal";
+    this.result = result;
+  }
+};
+function failCommand(exitCode = 1, cause) {
+  throw new CliRuntimeError("Command failed", { exitCode, presented: true, cause });
+}
+function failUsage(exitCode = 1) {
+  throw new CliUsageError("Invalid command usage", { exitCode, presented: true });
+}
+function finishCommand(exitCode = 0) {
+  throw new CliResultSignal({
+    exitCode,
+    kind: exitCode === 0 ? "success" : "runtime_error",
+    presented: true
+  });
+}
+function setCommandResult(result) {
+  if (pendingResult.exitCode !== 0 && result.exitCode === 0) return;
+  pendingResult = result;
+}
+function setCommandExitCode(exitCode) {
+  setCommandResult({
+    exitCode,
+    kind: exitCode === 0 ? "success" : "runtime_error",
+    presented: true
+  });
+}
+function consumeCommandResult() {
+  const result = pendingResult;
+  pendingResult = SUCCESS_RESULT;
+  return result;
+}
+function registerRootExitRequester(requester) {
+  rootExitRequester = requester;
+}
+function registerRootExitCodeSanitizer(sanitizer) {
+  rootExitCodeSanitizer = sanitizer;
+}
+function sanitizeSuccessfulExitCode() {
+  rootExitCodeSanitizer?.();
+}
+function requestCliExit(exitCode = 0) {
+  if (!rootExitRequester) {
+    setCommandResult({
+      exitCode,
+      kind: exitCode === 0 ? "success" : "runtime_error",
+      presented: true
+    });
+    return;
+  }
+  rootExitRequester(exitCode);
+}
+
+export {
+  CliUsageError,
+  CliRuntimeError,
+  CliResultSignal,
+  failCommand,
+  failUsage,
+  finishCommand,
+  setCommandExitCode,
+  consumeCommandResult,
+  registerRootExitRequester,
+  registerRootExitCodeSanitizer,
+  sanitizeSuccessfulExitCode,
+  requestCliExit
+};

package/vendor/hyperframes/dist/chunk-PDAMK4Q5.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);
+import {
+  VALID_CANVAS_RESOLUTIONS,
+  resolveResolutionFlagPair
+} from "./chunk-AVUUN2XD.js";
+
+// src/utils/parseOutputResolution.ts
+function parseOutputResolutionFlag(raw, options) {
+  if (raw == null || raw === "") {
+    return { outputResolution: void 0, outputResolutionAspectAgnostic: false };
+  }
+  const asString = String(raw);
+  const { outputResolution, outputResolutionAspectAgnostic } = resolveResolutionFlagPair(asString);
+  if (outputResolution) return { outputResolution, outputResolutionAspectAgnostic };
+  const aliasHint = options.aliasHint ?? "1080p, 4k, uhd, hd, \u2026";
+  throw new Error(
+    `${options.surfaceLabel} --output-resolution must be one of ${VALID_CANVAS_RESOLUTIONS.join("|")} (or an alias: ${aliasHint}); got ${asString}`
+  );
+}
+
+export {
+  parseOutputResolutionFlag
+};

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

@@ -0,0 +1,20 @@
+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 {
+  DOMParser
+} from "./chunk-GK4AIFIH.js";
+
+// src/utils/dom.ts
+function ensureDOMParser() {
+  if (typeof globalThis.DOMParser === "undefined") {
+    globalThis.DOMParser = DOMParser;
+  }
+}
+
+export {
+  ensureDOMParser
+};

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

@@ -0,0 +1,108 @@
+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);
+
+// ../parsers/dist/ffBinaries.js
+import { execFileSync } from "child_process";
+import { accessSync, constants, existsSync } from "fs";
+import { delimiter, join, resolve } from "path";
+var FFMPEG_PATH_ENV = "HYPERFRAMES_FFMPEG_PATH";
+var FFPROBE_PATH_ENV = "HYPERFRAMES_FFPROBE_PATH";
+var ENV_BY_NAME = {
+  ffmpeg: FFMPEG_PATH_ENV,
+  ffprobe: FFPROBE_PATH_ENV
+};
+var pathLookupCache = /* @__PURE__ */ new Map();
+function candidateFileName(candidate) {
+  return candidate.split(/[\\/]/).at(-1)?.toLowerCase() ?? candidate.toLowerCase();
+}
+function chooseBestPathCandidate(name, candidates) {
+  const normalized = candidates.map((candidate) => candidate.trim()).filter(Boolean);
+  return normalized.find((candidate) => candidateFileName(candidate) === `${name}.exe`) ?? normalized.find((candidate) => candidateFileName(candidate) === name) ?? normalized.find((candidate) => !candidateFileName(candidate).match(/\.(cmd|bat)$/i)) ?? normalized[0];
+}
+function isExecutablePathCandidate(candidate) {
+  if (process.platform === "win32") return existsSync(candidate);
+  try {
+    accessSync(candidate, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function scanPath(name) {
+  const pathValue = process.env.PATH;
+  const searchDirs = [
+    ...process.platform === "win32" ? [process.cwd()] : [],
+    ...pathValue ? pathValue.split(delimiter) : []
+  ].filter(Boolean);
+  if (searchDirs.length === 0) return void 0;
+  const extensions = process.platform === "win32" ? [
+    ".exe",
+    ...new Set(
+      (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").map((ext) => ext.trim().toLowerCase()).filter(Boolean)
+    ),
+    ""
+  ] : [""];
+  const candidates = [];
+  for (const dir of new Set(searchDirs)) {
+    for (const ext of extensions) {
+      const candidate = join(dir, `${name}${ext}`);
+      if (isExecutablePathCandidate(candidate)) candidates.push(candidate);
+    }
+  }
+  return chooseBestPathCandidate(name, candidates);
+}
+var COMMON_BIN_DIRS = process.platform === "win32" ? [] : ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin", "/snap/bin"];
+function findInCommonDirs(name) {
+  for (const dir of COMMON_BIN_DIRS) {
+    const candidate = `${dir}/${name}`;
+    if (existsSync(candidate)) return candidate;
+  }
+  return void 0;
+}
+function findInProjectLocalBin(name) {
+  const extension = process.platform === "win32" ? ".exe" : "";
+  const candidate = resolve(".hyperframes", "bin", `${name}${extension}`);
+  return existsSync(candidate) ? candidate : void 0;
+}
+function lookupOnSystem(name) {
+  if (pathLookupCache.has(name)) return pathLookupCache.get(name);
+  let found;
+  if (process.platform === "win32") {
+    found = scanPath(name);
+  } else {
+    try {
+      const output = execFileSync("which", [name], {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 5e3
+      });
+      const candidate = chooseBestPathCandidate(name, output.split(/\r?\n/));
+      found = candidate && isExecutablePathCandidate(candidate) ? candidate : scanPath(name);
+    } catch {
+      found = scanPath(name);
+    }
+  }
+  found ??= findInProjectLocalBin(name);
+  found ??= findInCommonDirs(name);
+  const resolved = found ? resolve(found) : void 0;
+  pathLookupCache.set(name, resolved);
+  return resolved;
+}
+function findFfBinary(name, options = {}) {
+  const configured = process.env[ENV_BY_NAME[name]]?.trim();
+  if (configured) {
+    if (options.configuredMustExist && !existsSync(configured)) return void 0;
+    return resolve(configured);
+  }
+  return lookupOnSystem(name);
+}
+
+export {
+  FFMPEG_PATH_ENV,
+  FFPROBE_PATH_ENV,
+  findFfBinary
+};

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

@@ -0,0 +1,152 @@
+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);
+
+// ../parsers/dist/slideshow.js
+var SLIDESHOW_MANIFEST_VERSION = 1;
+var SLIDESHOW_ISLAND_TYPE = "application/hyperframes-slideshow+json";
+function slideshowIslandRegex(flags = "i") {
+  const escaped = SLIDESHOW_ISLAND_TYPE.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`<script[^>]*type=["']${escaped}["'][^>]*>([\\s\\S]*?)<\\/script>`, flags);
+}
+function parseSlideshowManifest(html) {
+  const re = slideshowIslandRegex("i");
+  const match = re.exec(html);
+  if (!match || match[1] === void 0) return null;
+  const raw = match[1].trim();
+  if (raw.length === 0) return null;
+  const parsed = JSON.parse(raw);
+  if (!isManifest(parsed)) {
+    throw new Error("slideshow island is not a valid SlideshowManifest");
+  }
+  return parsed;
+}
+function isOptionalNumberArray(v) {
+  return v === void 0 || Array.isArray(v) && v.every((n) => typeof n === "number");
+}
+function isOptionalBoolean(v) {
+  return v === void 0 || typeof v === "boolean";
+}
+function isSlideRef(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const r = v;
+  if (typeof r["sceneId"] !== "string") return false;
+  if (!isOptionalNumberArray(r["fragments"])) return false;
+  if (r["hotspots"] !== void 0 && !Array.isArray(r["hotspots"])) return false;
+  if (!isOptionalBoolean(r["autoplay"])) return false;
+  return true;
+}
+function isSlideSequence(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const s = v;
+  return typeof s["id"] === "string" && typeof s["label"] === "string" && Array.isArray(s["slides"]) && s["slides"].every(isSlideRef);
+}
+function isManifest(v) {
+  if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
+  const o = v;
+  if (!Array.isArray(o["slides"]) || !o["slides"].every(isSlideRef)) return false;
+  if (o["slideSequences"] !== void 0) {
+    if (!Array.isArray(o["slideSequences"]) || !o["slideSequences"].every(isSlideSequence))
+      return false;
+  }
+  return true;
+}
+function missingBoundError(sceneId, missing) {
+  const present = missing === "startTime" ? "endTime" : "startTime";
+  return `slide "${sceneId}" sets ${present} but ${missing} cannot be resolved (no scene "${sceneId}")`;
+}
+function resolveTimeRange(ref, scene, errors) {
+  const { startTime, endTime, sceneId } = ref;
+  if (startTime !== void 0 && endTime !== void 0) {
+    return { start: startTime, end: endTime };
+  }
+  if (startTime === void 0 && endTime === void 0) {
+    if (!scene) {
+      errors.push(`slide references unresolved sceneId "${sceneId}"`);
+      return { start: 0, end: 0 };
+    }
+    return { start: scene.start, end: scene.start + scene.duration };
+  }
+  if (!scene) {
+    const missing = startTime === void 0 ? "startTime" : "endTime";
+    errors.push(missingBoundError(sceneId, missing));
+    const bound = startTime ?? endTime ?? 0;
+    return { start: bound, end: bound };
+  }
+  return {
+    start: startTime ?? scene.start,
+    end: endTime ?? scene.start + scene.duration
+  };
+}
+function validateFragments(sceneId, fragments, start, end, errors) {
+  for (const f of fragments) {
+    if (f < start || f > end) {
+      errors.push(`slide "${sceneId}" fragment ${f} is outside range [${start}, ${end}]`);
+    }
+  }
+}
+function resolveSlide(ref, sceneById, errors) {
+  const scene = sceneById.get(ref.sceneId);
+  const { start, end } = resolveTimeRange(ref, scene, errors);
+  if (ref.startTime !== void 0 && ref.endTime !== void 0 && end <= start) {
+    errors.push(`slide "${ref.sceneId}" has endTime (${end}) <= startTime (${start})`);
+  }
+  const fragments = [...new Set(ref.fragments ?? [])].sort((a, b) => a - b);
+  validateFragments(ref.sceneId, fragments, start, end, errors);
+  return { ...ref, start, end, fragments, hotspots: ref.hotspots ?? [] };
+}
+function resolveSlideshow(manifest, scenes) {
+  const errors = [];
+  const sceneById = new Map(scenes.map((s) => [s.id, s]));
+  const sequences = {};
+  for (const seq of manifest.slideSequences ?? []) {
+    if (Object.prototype.hasOwnProperty.call(sequences, seq.id)) {
+      errors.push(`duplicate slideSequence id "${seq.id}" \u2014 only the last definition is kept`);
+    }
+    sequences[seq.id] = {
+      id: seq.id,
+      label: seq.label,
+      slides: seq.slides.map((s) => resolveSlide(s, sceneById, errors))
+    };
+  }
+  const slides = manifest.slides.map((s) => resolveSlide(s, sceneById, errors));
+  const allSlides = [...slides, ...Object.values(sequences).flatMap((s) => s.slides)];
+  for (const slide of allSlides) {
+    for (const h of slide.hotspots) {
+      const seq = sequences[h.target];
+      if (!seq) {
+        errors.push(`hotspot "${h.id}" targets unknown sequence "${h.target}"`);
+      } else if (seq.slides.length === 0) {
+        errors.push(`hotspot "${h.id}" targets empty sequence "${h.target}"`);
+      }
+    }
+  }
+  const ordered = [...slides].sort((a, b) => a.start - b.start);
+  for (let i = 1; i < ordered.length; i++) {
+    const prev = ordered[i - 1];
+    const curr = ordered[i];
+    if (prev !== void 0 && curr !== void 0 && curr.start < prev.end) {
+      errors.push(`main-line slides "${prev.sceneId}" and "${curr.sceneId}" overlap`);
+    }
+  }
+  return { resolved: { slides, sequences }, errors };
+}
+function isSceneLikeCompositionId(compositionId) {
+  const normalized = compositionId.trim().toLowerCase();
+  if (!normalized || normalized === "main") return false;
+  if (normalized.includes("caption")) return false;
+  if (normalized.includes("ambient")) return false;
+  return true;
+}
+
+export {
+  SLIDESHOW_MANIFEST_VERSION,
+  SLIDESHOW_ISLAND_TYPE,
+  slideshowIslandRegex,
+  parseSlideshowManifest,
+  resolveSlideshow,
+  isSceneLikeCompositionId
+};

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

@@ -0,0 +1,240 @@
+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,
+  MAX_FREEZE_BYTES,
+  appendRecord,
+  buildAssetSnippet,
+  createFigmaClient,
+  exceedsFreezeCap,
+  findAllByFigmaNode,
+  freezeBytes,
+  nextId,
+  parseFigmaRef,
+  regenerateIndex,
+  sanitizeSvg,
+  typeDirPath,
+  updateRecord,
+  withFigmaErrors
+} from "./chunk-QNYYOUU3.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+
+// src/commands/figma/asset.ts
+import { existsSync } from "fs";
+import { join, relative } from "path";
+
+// src/commands/figma/download.ts
+async function downloadRender(url) {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`figma render download failed: HTTP ${res.status}`);
+  const declared = Number(res.headers.get("content-length") ?? 0);
+  if (exceedsFreezeCap(declared))
+    throw new Error(
+      `figma render download failed: content-length ${declared} exceeds ${MAX_FREEZE_BYTES} cap`
+    );
+  return new Uint8Array(await res.arrayBuffer());
+}
+
+// src/commands/figma/asset.ts
+function gatherAssetRefs(positionals) {
+  return positionals.flatMap((r) => /^https?:/i.test(r.trim()) ? [r] : r.split(",")).map((r) => r.trim()).filter((r) => r.length > 0);
+}
+function requireNodeRef(refInput) {
+  const ref = parseFigmaRef(refInput);
+  if (!ref.nodeId)
+    throw new Error(
+      `ref "${refInput}" has no node id \u2014 share a link with ?node-id=\u2026 or use fileKey:nodeId`
+    );
+  return { fileKey: ref.fileKey, nodeId: ref.nodeId };
+}
+function reuseExisting(fileKey, nodeId, opts, version, deps, description, entity) {
+  const existing = findAllByFigmaNode(deps.projectDir, fileKey, nodeId).find(
+    (r) => r.provenance.format === opts.format && (r.provenance.scale ?? 1) === (opts.scale ?? 1) && r.provenance.version === version && existsSync(join(deps.projectDir, r.path))
+  );
+  if (!existing) return null;
+  let record = existing;
+  if (description !== void 0 && description !== existing.description || entity !== void 0 && entity !== existing.entity) {
+    record = {
+      ...existing,
+      ...description !== void 0 && { description },
+      ...entity !== void 0 && { entity }
+    };
+    updateRecord(deps.projectDir, record);
+  }
+  return { record, snippet: buildAssetSnippet(record), reused: true };
+}
+async function freezeAndRecord(fileKey, nodeId, url, ext, opts, version, deps, description, entity) {
+  let bytes = await deps.download(url);
+  if (ext === "svg") {
+    const b0 = bytes[0];
+    if (b0 !== 60 && b0 !== 63 && b0 !== 239)
+      throw new Error("figma render returned non-SVG bytes for an svg export \u2014 retry the import");
+    bytes = new TextEncoder().encode(sanitizeSvg(new TextDecoder().decode(bytes)));
+  }
+  const id = nextId(deps.projectDir, "image");
+  const destAbs = join(typeDirPath(deps.projectDir, "image"), `${id}.${ext}`);
+  freezeBytes(bytes, destAbs);
+  const record = {
+    id,
+    type: "image",
+    path: relative(deps.projectDir, destAbs),
+    source: `figma:${fileKey}/${nodeId}`,
+    ...description !== void 0 && { description },
+    ...entity !== void 0 && { entity },
+    provenance: {
+      source: "figma",
+      fileKey,
+      nodeId,
+      version,
+      format: opts.format,
+      scale: opts.scale
+    }
+  };
+  appendRecord(deps.projectDir, record);
+  return { record, snippet: buildAssetSnippet(record), reused: false };
+}
+async function runAssetImport(refInput, opts, deps) {
+  const [result] = await runAssetImportMany([refInput], opts, deps);
+  if (!result) throw new Error(`figma asset import produced no result for "${refInput}"`);
+  return result;
+}
+async function runAssetImportMany(refInputs, opts, deps) {
+  if (refInputs.length === 0) return [];
+  const refs = refInputs.map(requireNodeRef);
+  const fileKey = refs[0].fileKey;
+  const mixed = refs.find((r) => r.fileKey !== fileKey);
+  if (mixed)
+    throw new Error(
+      `all refs in one import must share a fileKey (batch is per-file) \u2014 got ${fileKey} and ${mixed.fileKey}; run separate commands per file`
+    );
+  const { version } = await deps.client.fileVersion(fileKey);
+  const description = normalizeMeta(opts.description);
+  const entity = normalizeMeta(opts.entity);
+  const slots = refs.map(
+    (r) => reuseExisting(fileKey, r.nodeId, opts, version, deps, description, entity)
+  );
+  const missIndexes = slots.flatMap((s, i) => s === null ? [i] : []);
+  try {
+    if (missIndexes.length > 0) {
+      const missNodeIds = missIndexes.map((i) => refs[i].nodeId);
+      const rendered = await deps.client.renderNodes(fileKey, missNodeIds, opts);
+      const byNode = new Map(rendered.map((r) => [r.nodeId, r]));
+      for (const i of missIndexes) {
+        const nodeId = refs[i].nodeId;
+        const r = byNode.get(nodeId);
+        if (!r || r.url === null)
+          throw new FigmaClientError(
+            "RENDER_FAILED",
+            `figma could not render node ${nodeId} as ${opts.format}`,
+            void 0,
+            "images"
+          );
+        slots[i] = await freezeAndRecord(
+          fileKey,
+          nodeId,
+          r.url,
+          r.ext,
+          opts,
+          version,
+          deps,
+          description,
+          entity
+        );
+      }
+    }
+  } finally {
+    safeRegenerateIndex(deps.projectDir);
+  }
+  return slots.map((s, i) => {
+    if (!s) throw new Error(`figma asset import produced no result for "${refInputs[i]}"`);
+    return s;
+  });
+}
+function normalizeMeta(value) {
+  if (value === void 0) return void 0;
+  const cleaned = value.replace(/\s+/g, " ").trim();
+  return cleaned.length > 0 ? cleaned : void 0;
+}
+function safeRegenerateIndex(projectDir) {
+  try {
+    regenerateIndex(projectDir);
+  } catch (err) {
+    console.warn(`index.md regeneration failed: ${err instanceof Error ? err.message : err}`);
+  }
+}
+var FORMATS = ["png", "svg", "jpg", "pdf"];
+function parseFormat(raw) {
+  for (const f of FORMATS) if (f === raw) return f;
+  throw new Error(`unsupported format "${raw}" \u2014 use one of ${FORMATS.join(", ")}`);
+}
+var asset_default = defineCommand({
+  meta: { name: "asset", description: "Import one or more figma nodes as frozen local assets" },
+  args: {
+    ref: {
+      type: "positional",
+      description: "figma URL, fileKey:nodeId, or fileKey (pass several, or comma-separate ids, to batch)",
+      required: true
+    },
+    format: { type: "string", description: "png | svg | jpg | pdf", default: "svg" },
+    scale: { type: "string", description: "export scale (e.g. 2)" },
+    description: {
+      type: "string",
+      description: "what this asset is (index.md + <img alt>); e.g. the layer's purpose"
+    },
+    entity: {
+      type: "string",
+      description: 'entity name for media-use cache lookups (e.g. "Acme logo")'
+    },
+    dir: { type: "string", description: "project directory", default: "." }
+  },
+  async run({ args }) {
+    await withFigmaErrors("figma:asset", async () => {
+      const t0 = Date.now();
+      const token = process.env.FIGMA_TOKEN ?? "";
+      const client = createFigmaClient({ token });
+      const positionals = (Array.isArray(args._) && args._.length > 0 ? args._ : [args.ref]).map(String);
+      const refs = gatherAssetRefs(positionals);
+      const results = await runAssetImportMany(
+        refs,
+        {
+          format: parseFormat(args.format),
+          scale: args.scale !== void 0 ? Number(args.scale) : void 0,
+          description: args.description,
+          entity: args.entity
+        },
+        { projectDir: args.dir, client, download: downloadRender }
+      );
+      for (const result of results) {
+        const verb = result.reused ? "reused" : "imported";
+        console.log(`${verb} ${result.record.id} \u2192 ${result.record.path}`);
+        console.log(result.snippet.html);
+      }
+      if (results.length > 1) {
+        const rendered = results.filter((r) => !r.reused).length;
+        console.log(
+          rendered > 0 ? `(${results.length} nodes, ${rendered} rendered in 1 figma request)` : `(${results.length} nodes, all reused from cache \u2014 no figma request)`
+        );
+      }
+      const { trackFigmaImport } = await import("./telemetry-QMYM4WME.js");
+      trackFigmaImport({
+        phase: "asset",
+        reused: results.every((r) => r.reused),
+        durationMs: Date.now() - t0
+      });
+    });
+  }
+});
+
+export {
+  downloadRender,
+  gatherAssetRefs,
+  runAssetImport,
+  runAssetImportMany,
+  asset_default
+};

package/vendor/hyperframes/dist/chunk-Q5X2B5WT.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/utils/lintProject.ts
+function hasDefinitiveEntryMismatch(result) {
+  return result.results.some(
+    (entry) => entry.result.findings.some(
+      (finding) => finding.code === "blank_root_with_standalone_composition"
+    )
+  );
+}
+function definitiveEntryMismatchComposition(result) {
+  for (const entry of result.results) {
+    const finding = entry.result.findings.find(
+      (candidate) => candidate.code === "blank_root_with_standalone_composition"
+    );
+    if (finding) return finding.suggestedComposition;
+  }
+  return void 0;
+}
+
+export {
+  hasDefinitiveEntryMismatch,
+  definitiveEntryMismatchComposition
+};