@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/feedback-WCMDMSTK.js

@@ -0,0 +1,472 @@
+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 {
+  getDoctorSummary
+} from "./chunk-4THIAPBL.js";
+import {
+  getPublishApiBaseUrl,
+  publishProjectArchive
+} from "./chunk-JH556Q42.js";
+import "./chunk-ZTZ7NCJT.js";
+import "./chunk-SHB5VDMH.js";
+import "./chunk-I465DBM6.js";
+import {
+  feedbackEmail,
+  parseFeedbackSource
+} from "./chunk-IGLEPPTN.js";
+import {
+  ft,
+  q,
+  ue
+} from "./chunk-WMQNIQDJ.js";
+import {
+  FEEDBACK_RATING_SCALE,
+  parseFeedbackRating,
+  trackCatalogSearchMiss,
+  trackRenderFeedback
+} from "./chunk-JTHMTOMQ.js";
+import {
+  shouldTrack
+} from "./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
+} 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-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 {
+  readConfig
+} from "./chunk-XUXGIA7H.js";
+import "./chunk-WERLJGIC.js";
+import "./chunk-ISN5GRYI.js";
+import {
+  VERSION
+} from "./chunk-FLWXXDNS.js";
+import "./chunk-KNU5COPB.js";
+import "./chunk-3GXQPCJC.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-PMRBLBUP.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/feedback.ts
+import { randomUUID } from "crypto";
+import { resolve } from "path";
+import open from "open";
+
+// src/utils/submitFeedback.ts
+var MAX_COMMENT = 2e3;
+var MAX_CLI_VERSION = 100;
+var MAX_ENV = 500;
+var MAX_EMAIL = 254;
+function cap(value, max) {
+  if (value === void 0) return void 0;
+  return value.length > max ? value.slice(0, max) : value;
+}
+async function submitFeedback(input) {
+  try {
+    const apiBaseUrl = getPublishApiBaseUrl();
+    await fetch(`${apiBaseUrl}/v1/hyperframes/feedback`, {
+      method: "POST",
+      body: JSON.stringify({
+        rating: input.rating,
+        rating_scale: FEEDBACK_RATING_SCALE,
+        comment: cap(input.comment, MAX_COMMENT),
+        cli_version: cap(input.cliVersion, MAX_CLI_VERSION),
+        env: cap(input.env, MAX_ENV),
+        source: input.source,
+        email: cap(input.email, MAX_EMAIL)
+      }),
+      headers: {
+        "content-type": "application/json"
+      },
+      signal: AbortSignal.timeout(5e3)
+    });
+  } catch {
+  }
+}
+var MAX_QUERY = 500;
+var MAX_WANTED = 500;
+var MAX_TIER = 50;
+async function submitCatalogSearchMiss(input) {
+  try {
+    const apiBaseUrl = getPublishApiBaseUrl();
+    await fetch(`${apiBaseUrl}/v1/hyperframes/catalog_search_miss`, {
+      method: "POST",
+      body: JSON.stringify({
+        query: cap(input.query, MAX_QUERY),
+        wanted: cap(input.wanted, MAX_WANTED),
+        tier: cap(input.tier, MAX_TIER),
+        cli_version: cap(input.cliVersion, MAX_CLI_VERSION)
+      }),
+      headers: {
+        "content-type": "application/json",
+        heygen_route: "canary"
+      },
+      signal: AbortSignal.timeout(5e3)
+    });
+  } catch {
+  }
+}
+
+// src/utils/feedbackIssue.ts
+var HYPERFRAMES_REPO_URL = "https://github.com/heygen-com/hyperframes";
+var TITLE_MAX = 80;
+var COMMENT_MAX = 4e3;
+function normalizeRepoUrl(repoUrl) {
+  const trimmed = repoUrl.trim().replace(/\/$/, "").replace(/\.git$/, "");
+  return trimmed || HYPERFRAMES_REPO_URL;
+}
+function truncate(value, max) {
+  return value.length > max ? `${value.slice(0, max - 1)}\u2026` : value;
+}
+function buildIssueTitle(rating, comment) {
+  const firstLine = comment?.split("\n")[0]?.trim();
+  if (!firstLine) return `Render feedback (rating ${rating}/${FEEDBACK_RATING_SCALE})`;
+  return `[feedback] ${truncate(firstLine, TITLE_MAX)}`;
+}
+function buildIssueBody(input) {
+  const comment = input.comment?.trim();
+  const repro = input.repoPublicUrl ? `Published minimal repro: ${input.repoPublicUrl}` : "_Publishing the repro failed, no public link available._";
+  return [
+    `**Rating:** ${input.rating}/${FEEDBACK_RATING_SCALE}`,
+    "",
+    "## Comment",
+    comment ? truncate(comment, COMMENT_MAX) : "_No comment provided._",
+    "",
+    "## Minimal repro",
+    repro,
+    "",
+    "## Environment",
+    "```",
+    input.environment || "(unavailable)",
+    `cli=${input.cliVersion}`,
+    "```",
+    "",
+    "---",
+    "_Filed via `hyperframes feedback --file-issue`._"
+  ].join("\n");
+}
+function buildIssueUrl(input) {
+  const repo = normalizeRepoUrl(input.repoUrl);
+  const title = encodeURIComponent(buildIssueTitle(input.rating, input.comment));
+  const body = encodeURIComponent(buildIssueBody(input));
+  return `${repo}/issues/new?title=${title}&body=${body}&labels=bug`;
+}
+
+// src/utils/feedbackLint.ts
+var VISUAL_DEFECT_KEYWORDS = [
+  "black",
+  "flicker",
+  "corrupt",
+  "wrong frame",
+  "blank",
+  "visual"
+];
+var COMPOSITION_STRUCTURE_RATING_CEILING = 7;
+var REPRO_MARKER = "REPRO COMMAND:";
+var STRUCTURE_MARKER = "COMPOSITION_STRUCTURE:";
+var FEEDBACK_PACKET_MARKERS = [
+  REPRO_MARKER,
+  "EXPECTED / ACTUAL:",
+  "EXACT ERROR:",
+  "OUTCOME:",
+  "WORKAROUND:",
+  STRUCTURE_MARKER
+];
+function lintFeedbackComment(input) {
+  const { rating, comment } = input;
+  if (rating === FEEDBACK_RATING_SCALE) return [];
+  const trimmed = comment?.trim();
+  if (!trimmed) return [];
+  const upperTrimmed = trimmed.toUpperCase();
+  const warnings = [];
+  if (!hasReproCommandBody(trimmed)) {
+    warnings.push({
+      code: "missing-repro-command",
+      message: [
+        `Comment on a ${rating}/${FEEDBACK_RATING_SCALE} report is missing a non-empty "${REPRO_MARKER}" block \u2014`,
+        "maintainers can't rerun the failure from a symptom summary alone.",
+        "See `references/preview-render.md` \u2192 feedback for the required packet shape."
+      ].join(" ")
+    });
+  }
+  if (rating <= COMPOSITION_STRUCTURE_RATING_CEILING && mentionsVisualDefect(trimmed) && !upperTrimmed.includes(STRUCTURE_MARKER)) {
+    warnings.push({
+      code: "missing-composition-structure",
+      message: [
+        `Comment describes a visual defect at ${rating}/${FEEDBACK_RATING_SCALE} but omits a`,
+        `"${STRUCTURE_MARKER}" block. Agents can auto-fill this via the composition-census helper`,
+        "(`buildCompositionCensus`/`renderCompositionCensusBlock` in `packages/cli/src/utils/compositionCensus.ts`)",
+        "so maintainers can pattern-match against known bug families without the composition ZIP."
+      ].join(" ")
+    });
+  }
+  return warnings;
+}
+function hasReproCommandBody(comment) {
+  const lines = comment.split(/\r?\n/);
+  return lines.some((line, index) => {
+    const markerIndex = line.toUpperCase().indexOf(REPRO_MARKER);
+    if (markerIndex === -1) return false;
+    const inlineBody = line.slice(markerIndex + REPRO_MARKER.length).trim();
+    if (inlineBody) return !startsWithFeedbackPacketMarker(inlineBody);
+    const nextContentLine = lines.slice(index + 1).find((candidate) => candidate.trim());
+    if (!nextContentLine) return false;
+    return !startsWithFeedbackPacketMarker(nextContentLine.trimStart());
+  });
+}
+function startsWithFeedbackPacketMarker(value) {
+  const upperValue = value.toUpperCase();
+  return FEEDBACK_PACKET_MARKERS.some((marker) => upperValue.startsWith(marker));
+}
+function escapeRegex(input) {
+  return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var VISUAL_DEFECT_REGEX = new RegExp(
+  `(^|[^A-Za-z0-9_])(?:${VISUAL_DEFECT_KEYWORDS.map(escapeRegex).join("|")})(?![A-Za-z0-9_])`,
+  "i"
+);
+function mentionsVisualDefect(comment) {
+  return VISUAL_DEFECT_REGEX.test(comment);
+}
+
+// src/commands/feedback.ts
+var examples = [
+  ["Submit render feedback", 'hyperframes feedback --rating 8 --comment "fast but font missing"'],
+  ["Quick rating only", "hyperframes feedback --rating 10"],
+  [
+    "Report a catalog gap after a fruitless search",
+    'hyperframes feedback --search-miss "typewriter that deletes" --wanted "text that types then backspaces"'
+  ],
+  [
+    "Also file a GitHub issue with a published repro",
+    'hyperframes feedback --rating 3 --comment "GSAP timeline froze" --file-issue'
+  ]
+];
+function normalizeComment(raw) {
+  return raw || void 0;
+}
+function buildTelemetryJoinKeys(input) {
+  const parts = [`fid=${input.feedbackId}`, `tid=${input.anonymousId}`];
+  if (input.recentRenders?.length) {
+    parts.push(`renders=${input.recentRenders.map((r) => `${r.id}${r.ok ? "" : "!"}`).join(",")}`);
+  }
+  return parts.join(" ");
+}
+function printIssueConsent(dir) {
+  console.log();
+  console.log(
+    `  ${c.bold("Filing an issue will publish this project publicly and open a GitHub issue draft.")}`
+  );
+  console.log(`  ${c.dim(`Project at ${dir} will be uploaded to a public URL.`)}`);
+  console.log(
+    `  ${c.dim("The issue draft will contain that public link plus your feedback; you review and submit it.")}`
+  );
+  console.log();
+}
+async function promptConfirm() {
+  const approved = await ue({ message: "Publish this project and draft the issue?" });
+  return !q(approved) && approved === true;
+}
+async function confirmFileIssue(dir, yes) {
+  printIssueConsent(dir);
+  if (yes) return true;
+  if (!process.stdout.isTTY) {
+    console.log(`  ${c.dim("Re-run with --yes to publish the repro and file the issue.")}
+`);
+    return false;
+  }
+  if (await promptConfirm()) return true;
+  console.log(`
+  ${c.dim("Aborted. Feedback was still sent.")}
+`);
+  return false;
+}
+async function publishRepro(dir) {
+  const spinner = ft();
+  spinner.start("Publishing minimal repro...");
+  try {
+    const published = await publishProjectArchive(dir);
+    spinner.stop(c.success("Repro published"));
+    return published.url;
+  } catch (err) {
+    spinner.stop(c.error("Publish failed"));
+    console.error(`  ${err.message}`);
+    console.log(`  ${c.dim("Filing the issue without a repro link.")}`);
+    return void 0;
+  }
+}
+function printFeedbackLintWarnings(input) {
+  for (const warning of lintFeedbackComment(input)) {
+    console.log(c.warn(`\u26A0 ${warning.message}`));
+  }
+}
+async function openAndPrintIssue(url) {
+  if (process.stdout.isTTY) {
+    try {
+      await open(url);
+    } catch {
+    }
+  }
+  console.log();
+  console.log(`  ${c.dim("Review and submit the pre-filled issue (it is not auto-submitted):")}`);
+  console.log(`  ${c.accent(url)}`);
+  console.log();
+}
+async function fileGithubIssue(opts) {
+  const dir = resolve(opts.rawDir ?? ".");
+  if (!await confirmFileIssue(dir, opts.yes)) return;
+  const repoPublicUrl = await publishRepro(dir);
+  const url = buildIssueUrl({
+    repoUrl: HYPERFRAMES_REPO_URL,
+    rating: opts.rating,
+    comment: opts.comment,
+    repoPublicUrl,
+    environment: opts.doctorSummary,
+    cliVersion: VERSION
+  });
+  await openAndPrintIssue(url);
+}
+var feedback_default = defineCommand({
+  meta: { name: "feedback", description: "Submit feedback about your experience" },
+  args: {
+    rating: {
+      type: "string",
+      // Required for a rating report, but --search-miss is a different report
+      // with no rating to give, so the check moved into the run body.
+      description: "Likelihood to recommend (0=not likely, 10=extremely likely)"
+    },
+    comment: {
+      type: "string",
+      description: "Optional details about your experience"
+    },
+    source: {
+      type: "string",
+      description: 'Who wrote the report: "person" or "agent"'
+    },
+    "search-miss": {
+      type: "string",
+      description: "Report a catalog search that found nothing useful; pass the query you ran"
+    },
+    wanted: {
+      type: "string",
+      description: "What you needed the catalog to have (used with --search-miss)"
+    },
+    tier: {
+      type: "string",
+      description: 'Which search tier answered: "on-device" or "words"'
+    },
+    "file-issue": {
+      type: "boolean",
+      description: "Also open a pre-filled GitHub issue with a published minimal repro",
+      default: false
+    },
+    dir: {
+      type: "string",
+      description: "Project directory to publish as the repro (default: current directory)"
+    },
+    yes: {
+      type: "boolean",
+      alias: "y",
+      description: "Skip the publish + file-issue consent prompt",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const searchMiss = normalizeComment(args["search-miss"]);
+    if (searchMiss) {
+      if (!shouldTrack()) {
+        console.log(c.dim("Telemetry is disabled. Nothing sent."));
+        return;
+      }
+      const wanted = normalizeComment(args.wanted);
+      const tier = normalizeComment(args.tier);
+      trackCatalogSearchMiss({ query: searchMiss, wanted, tier });
+      console.log(c.dim("Logged the gap. Thanks \u2014 that is how the catalog grows."));
+      await submitCatalogSearchMiss({ query: searchMiss, wanted, tier, cliVersion: VERSION });
+      return;
+    }
+    const rating = args.rating === void 0 ? null : parseFeedbackRating(args.rating);
+    if (rating === null) {
+      console.error(c.error("Rating must be an integer between 0 and 10"));
+      failCommand();
+    }
+    const source = parseFeedbackSource(args.source);
+    if (source === null) {
+      console.error(c.error('Source must be "person" or "agent"'));
+      failCommand();
+    }
+    if (!shouldTrack()) {
+      console.log(c.dim("Telemetry is disabled. Feedback not sent."));
+      return;
+    }
+    const comment = normalizeComment(args.comment);
+    const doctorSummary = await getDoctorSummary();
+    const feedbackId = randomUUID();
+    const config = readConfig();
+    const joinKeys = buildTelemetryJoinKeys({
+      feedbackId,
+      anonymousId: config.anonymousId,
+      recentRenders: config.recentRenders
+    });
+    const envWithJoinKeys = doctorSummary ? `${doctorSummary} ${joinKeys}` : joinKeys;
+    printFeedbackLintWarnings({ rating, comment });
+    trackRenderFeedback({
+      rating,
+      comment,
+      doctorSummary,
+      feedbackId,
+      recentRenderIds: config.recentRenders?.map((r) => r.id)
+    });
+    console.log(c.dim("Thanks for the feedback!"));
+    await submitFeedback({
+      rating,
+      comment,
+      cliVersion: VERSION,
+      env: envWithJoinKeys,
+      source,
+      email: feedbackEmail()
+    });
+    if (args["file-issue"] === true) {
+      await fileGithubIssue({
+        rating,
+        comment,
+        rawDir: args.dir,
+        yes: args.yes === true,
+        doctorSummary
+      });
+    }
+  }
+});
+export {
+  buildTelemetryJoinKeys,
+  feedback_default as default,
+  examples
+};

package/vendor/hyperframes/dist/ffmpeg-QIUFEFTY.js

@@ -0,0 +1,35 @@
+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 {
+  H264EncoderUnavailableError,
+  detectH264EncoderMode,
+  detectH264EncoderModeForRender,
+  findFFmpeg,
+  findFFprobe,
+  getFFmpegInstallCommand,
+  getFFmpegInstallHint,
+  resolveH264EncoderMode
+} from "./chunk-TVCRUG2S.js";
+import "./chunk-AMKC3AXA.js";
+import "./chunk-LCSMOLGX.js";
+import {
+  FFMPEG_PATH_ENV,
+  FFPROBE_PATH_ENV
+} from "./chunk-PJ3HDUCY.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  FFMPEG_PATH_ENV,
+  FFPROBE_PATH_ENV,
+  H264EncoderUnavailableError,
+  detectH264EncoderMode,
+  detectH264EncoderModeForRender,
+  findFFmpeg,
+  findFFprobe,
+  getFFmpegInstallCommand,
+  getFFmpegInstallHint,
+  resolveH264EncoderMode
+};

package/vendor/hyperframes/dist/figma-64WY462P.js

@@ -0,0 +1,63 @@
+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";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/figma.ts
+var examples = [
+  [
+    "Import a frame as a frozen SVG asset",
+    "hyperframes figma asset 'https://www.figma.com/design/KEY/T?node-id=1-2'"
+  ],
+  ["Import as PNG at 2x", "hyperframes figma asset KEY:1-2 --format png --scale 2"],
+  ["Pull brand tokens into the composition", "hyperframes figma tokens KEY"],
+  ["Import a frame as an editable HTML component", "hyperframes figma component KEY:10-20"]
+];
+var HELP = `
+${c.bold("hyperframes figma")} ${c.dim("<subcommand> [args]")}
+
+Import figma content over the REST API. Requires ${c.accent("FIGMA_TOKEN")}.
+
+${c.bold("SUBCOMMANDS:")}
+  ${c.accent("asset")}      ${c.dim("Render a node (png/svg/jpg/pdf), freeze under .media/, print a snippet.")}
+  ${c.accent("tokens")}     ${c.dim("Import variables/styles as composition brand variables.")}
+  ${c.accent("component")}  ${c.dim("Import a frame as an editable HTML component (brand-linked colors).")}
+
+${c.bold("FIRST-TIME SETUP:")}
+  1. ${c.dim("Mint a token:")} figma.com/settings \u2192 Security \u2192 Personal access tokens
+  2. ${c.dim("Scopes (read-only only \u2014 this integration never writes to figma):")}
+       File content: Read-only \xB7 File metadata: Read-only
+       Variables: Read-only ${c.dim("(optional \u2014 Enterprise-only brand variables)")}
+  3. ${c.accent('export FIGMA_TOKEN="figd_\u2026"')} ${c.dim("\u2014 persist in your shell profile or project .env")}
+
+${c.bold("WHAT TO EXPECT:")}
+  ${c.dim("Every import freezes files locally under .media/ and records figma provenance \u2014")}
+  ${c.dim("renders never touch figma. Re-running a command re-imports only what changed.")}
+
+${c.dim("Motion and shader import are agent-only (figma exposes no REST endpoint for")}
+${c.dim("either) \u2014 use the /figma skill in a Claude session for those.")}
+`;
+var figma_default = defineCommand({
+  meta: { name: "figma", description: "Import figma assets, tokens, and components (REST)" },
+  subCommands: {
+    asset: () => import("./asset-BE2DOV72.js").then((m) => m.default),
+    tokens: () => import("./tokens-OBGTYE4Z.js").then((m) => m.default),
+    component: () => import("./component-VFFR2O7T.js").then((m) => m.default)
+  },
+  async run({ args }) {
+    if (!args._?.[0]) console.log(HELP);
+  }
+});
+export {
+  figma_default as default,
+  examples
+};

package/vendor/hyperframes/dist/fontData.generated-NXAOI4GH.js

@@ -0,0 +1,13 @@
+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 {
+  EMBEDDED_FONT_DATA
+} from "./chunk-FI4I7CME.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  EMBEDDED_FONT_DATA
+};