@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/component-VFFR2O7T.js

@@ -0,0 +1,176 @@
+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 {
+  downloadRender,
+  runAssetImport
+} from "./chunk-PPQUYWTW.js";
+import {
+  FigmaClientError,
+  createFigmaClient,
+  nodeToHtml,
+  parseFigmaRef,
+  readBindings,
+  resolveBindings,
+  withFigmaErrors
+} from "./chunk-QNYYOUU3.js";
+import "./chunk-IHFUKJOR.js";
+import "./chunk-ZTZA4UWZ.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import "./chunk-PBN6GBJE.js";
+import {
+  slugify
+} from "./chunk-VC76R6W2.js";
+import "./chunk-GK4AIFIH.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/figma/component.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join, relative } from "path";
+function escapeAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+async function runComponentImport(refInput, deps) {
+  const ref = parseFigmaRef(refInput);
+  if (!ref.nodeId) throw new Error(`ref "${refInput}" has no node id`);
+  const tree = await deps.client.nodeTree(ref);
+  const bindings = resolveBindings(tree, readBindings(deps.projectDir));
+  const mapped = nodeToHtml(tree, bindings, { rootName: deps.name });
+  const name = slugify(deps.name ?? tree.name);
+  const componentDir = join(deps.projectDir, "compositions", "components", name);
+  if (existsSync(componentDir))
+    console.warn(
+      `component dir compositions/components/${name} already exists \u2014 overwriting (rename the figma frame for a separate import)`
+    );
+  mkdirSync(componentDir, { recursive: true });
+  const { html, frozenAssets, failedRasterize } = await rasterizeFallback(
+    mapped,
+    ref.fileKey,
+    componentDir,
+    deps
+  );
+  const htmlFile = join(componentDir, `${name}.html`);
+  writeFileSync(htmlFile, html + "\n");
+  const registryItem = {
+    name,
+    type: "hyperframes:component",
+    description: `Imported from figma ${ref.fileKey}/${ref.nodeId}`,
+    files: [
+      {
+        path: `${name}.html`,
+        target: `compositions/components/${name}/${name}.html`,
+        type: "hyperframes:snippet"
+      },
+      // The paths the frozen files ACTUALLY landed at (image_NNN.svg), which
+      // is also what the emitted HTML references — not the slug names.
+      ...frozenAssets.map((p) => ({
+        path: p.split("/").pop() ?? p,
+        target: p.replaceAll("\\", "/"),
+        type: "hyperframes:asset"
+      }))
+    ]
+  };
+  writeFileSync(
+    join(componentDir, "registry-item.json"),
+    JSON.stringify(registryItem, null, 2) + "\n"
+  );
+  return {
+    name,
+    htmlPath: relative(deps.projectDir, htmlFile),
+    unresolved: bindings.unresolved,
+    rasterized: mapped.rasterize,
+    failedRasterize
+  };
+}
+async function rasterizeFallback(mapped, fileKey, componentDir, deps) {
+  let html = mapped.html;
+  const frozenAssets = [];
+  const failedRasterize = [];
+  for (const req of mapped.rasterize) {
+    const asset = await renderWithPngRetry(fileKey, req, deps);
+    if (asset === null) {
+      failedRasterize.push(req.nodeId);
+      console.warn(
+        `could not render node ${req.nodeId} ("${req.name}") as svg or png \u2014 leaving its placeholder without src`
+      );
+      continue;
+    }
+    frozenAssets.push(asset.record.path);
+    const srcRel = relative(componentDir, join(deps.projectDir, asset.record.path)).replaceAll(
+      "\\",
+      "/"
+    );
+    const emittedId = escapeAttr(req.nodeId);
+    html = html.replaceAll(
+      `data-figma-rasterize="${emittedId}" `,
+      `data-figma-rasterize="${emittedId}" src="${escapeAttr(srcRel)}" `
+    );
+  }
+  return { html, frozenAssets, failedRasterize };
+}
+async function renderWithPngRetry(fileKey, req, deps) {
+  for (const format of ["svg", "png"]) {
+    try {
+      return await runAssetImport(
+        `${fileKey}:${req.nodeId}`,
+        { format, description: req.name },
+        { projectDir: deps.projectDir, client: deps.client, download: deps.download }
+      );
+    } catch (err) {
+      if (!(err instanceof FigmaClientError) || err.code !== "RENDER_FAILED") throw err;
+    }
+  }
+  return null;
+}
+var component_default = defineCommand({
+  meta: { name: "component", description: "Import a figma frame as an editable HTML component" },
+  args: {
+    ref: { type: "positional", description: "figma URL or fileKey:nodeId", required: true },
+    name: {
+      type: "string",
+      description: "component name override (variant frames often share a name and would collide)"
+    },
+    dir: { type: "string", description: "project directory", default: "." }
+  },
+  async run({ args }) {
+    await withFigmaErrors("figma:component", async () => {
+      const t0 = Date.now();
+      const client = createFigmaClient({ token: process.env.FIGMA_TOKEN ?? "" });
+      const result = await runComponentImport(args.ref, {
+        projectDir: args.dir,
+        client,
+        download: downloadRender,
+        name: args.name
+      });
+      console.log(`imported component "${result.name}" \u2192 ${result.htmlPath}`);
+      if (result.rasterized.length > 0) {
+        const ok = result.rasterized.length - result.failedRasterize.length;
+        console.log(
+          result.failedRasterize.length > 0 ? `rasterized ${ok}/${result.rasterized.length} node(s) via asset export \u2014 ${result.failedRasterize.length} skipped (unrenderable; placeholders have no src)` : `rasterized ${result.rasterized.length} node(s) via asset export`
+        );
+      }
+      if (result.unresolved.length > 0) {
+        console.log(
+          `${result.unresolved.length} binding(s) reference tokens not yet imported \u2014 colors baked as literals (flagged data-figma-unresolved). Run \`hyperframes figma tokens\` on the source/library file, then re-import to link them.`
+        );
+      }
+      const { trackFigmaImport } = await import("./telemetry-QMYM4WME.js");
+      trackFigmaImport({
+        phase: "component",
+        unresolvedBindings: result.unresolved.length,
+        rasterizedNodes: result.rasterized.length,
+        rasterizeFailures: result.failedRasterize.length,
+        durationMs: Date.now() - t0
+      });
+    });
+  }
+});
+export {
+  component_default as default,
+  runComponentImport
+};

package/vendor/hyperframes/dist/compositions-QTVN3U2A.js

@@ -0,0 +1,228 @@
+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 {
+  resolveProject
+} from "./chunk-S3D6GE5W.js";
+import "./chunk-IHFUKJOR.js";
+import {
+  ensureDOMParser
+} from "./chunk-PFCFR3KZ.js";
+import "./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 "./chunk-PBN6GBJE.js";
+import {
+  resolveReferencedStart
+} from "./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 {
+  readProjectFile
+} from "./chunk-ZJUKFZ2P.js";
+import "./chunk-HBBJFK6I.js";
+import "./chunk-PJ3HDUCY.js";
+import "./chunk-TQFG7HTI.js";
+import "./chunk-GK4AIFIH.js";
+import "./chunk-2PSPARWP.js";
+import {
+  withMeta
+} from "./chunk-HW6OYASV.js";
+import "./chunk-K4WIOZFP.js";
+import "./chunk-XUXGIA7H.js";
+import "./chunk-WERLJGIC.js";
+import "./chunk-ISN5GRYI.js";
+import "./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/compositions.ts
+import { readFileSync } from "fs";
+import { resolve, dirname } from "path";
+var examples = [
+  ["List compositions in the current project", "hyperframes compositions"],
+  ["Output as JSON", "hyperframes compositions --json"]
+];
+var NON_RENDERED_TAGS = /* @__PURE__ */ new Set(["script", "style", "link", "meta", "template"]);
+function countRenderableDescendants(root) {
+  return Array.from(root.querySelectorAll("*")).filter(
+    (el) => !NON_RENDERED_TAGS.has(el.tagName.toLowerCase())
+  ).length;
+}
+function estimateDurationFromScripts(root) {
+  let duration = 0;
+  for (const script of Array.from(root.querySelectorAll("script"))) {
+    const content = script.textContent ?? "";
+    const durationPattern = /\bduration\s*:\s*(\d+(?:\.\d+)?)/g;
+    let match;
+    while ((match = durationPattern.exec(content)) !== null) {
+      const value = Number.parseFloat(match[1] ?? "");
+      if (Number.isFinite(value) && value > duration) {
+        duration = value;
+      }
+    }
+  }
+  return duration;
+}
+function parseCompositions(html, baseDir) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, "text/html");
+  const compositionDivs = doc.querySelectorAll("[data-composition-id]");
+  const compositions = [];
+  const startCache = /* @__PURE__ */ new Map();
+  const visiting = /* @__PURE__ */ new Set();
+  compositionDivs.forEach((div) => {
+    const id = div.getAttribute("data-composition-id") ?? "unknown";
+    const width = parseInt(div.getAttribute("data-width") ?? "1920", 10);
+    const height = parseInt(div.getAttribute("data-height") ?? "1080", 10);
+    const compositionSrc = div.getAttribute("data-composition-src");
+    if (compositionSrc) {
+      const subPath = resolve(baseDir, compositionSrc);
+      const sub = readProjectFile(subPath);
+      if (sub.kind === "file") {
+        const subInfo = parseSubComposition(sub.text, id, width, height);
+        compositions.push({ ...subInfo, source: compositionSrc });
+        return;
+      }
+    }
+    const timedChildren = div.querySelectorAll("[data-start]");
+    let maxEnd = 0;
+    let elementCount = 0;
+    timedChildren.forEach((el) => {
+      elementCount++;
+      const start = resolveReferencedStart(doc, el, startCache, visiting);
+      const endAttr = el.getAttribute("data-end");
+      const durationAttr = el.getAttribute("data-duration");
+      let end;
+      if (endAttr) {
+        end = parseFloat(endAttr);
+      } else if (durationAttr) {
+        end = start + parseFloat(durationAttr);
+      } else {
+        end = start + 5;
+      }
+      if (end > maxEnd) {
+        maxEnd = end;
+      }
+    });
+    compositions.push({
+      id,
+      duration: maxEnd,
+      width,
+      height,
+      elementCount
+    });
+  });
+  return compositions;
+}
+function parseSubComposition(html, fallbackId, fallbackWidth, fallbackHeight) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, "text/html");
+  const template = doc.querySelector("template");
+  const searchDocument = template?.content ?? doc;
+  const compDiv = searchDocument.querySelector("[data-composition-id]");
+  const id = compDiv?.getAttribute("data-composition-id") ?? fallbackId;
+  const width = parseInt(compDiv?.getAttribute("data-width") ?? String(fallbackWidth), 10);
+  const height = parseInt(compDiv?.getAttribute("data-height") ?? String(fallbackHeight), 10);
+  const searchRoot = compDiv ?? searchDocument;
+  const timedChildren = searchRoot.querySelectorAll("[data-start], .clip, .caption-group");
+  let elementCount = timedChildren.length;
+  if (elementCount === 0 && compDiv) {
+    elementCount = countRenderableDescendants(compDiv);
+  }
+  let duration = 0;
+  const durationAttr = compDiv?.getAttribute("data-duration");
+  if (durationAttr && !durationAttr.startsWith("__")) {
+    duration = parseFloat(durationAttr) || 0;
+  }
+  if (compDiv) {
+    const timedEls = compDiv.querySelectorAll("[data-start]");
+    const startCache = /* @__PURE__ */ new Map();
+    const visiting = /* @__PURE__ */ new Set();
+    timedEls.forEach((el) => {
+      elementCount = Math.max(elementCount, timedEls.length);
+      const start = resolveReferencedStart(doc, el, startCache, visiting);
+      const endAttr = el.getAttribute("data-end");
+      const durAttr = el.getAttribute("data-duration");
+      let end;
+      if (endAttr) {
+        end = parseFloat(endAttr);
+      } else if (durAttr) {
+        end = start + parseFloat(durAttr);
+      } else {
+        end = start + 5;
+      }
+      if (end > duration) {
+        duration = end;
+      }
+    });
+  }
+  if (duration <= 0) {
+    duration = estimateDurationFromScripts(searchRoot);
+  }
+  return { id, duration, width, height, elementCount };
+}
+var compositions_default = defineCommand({
+  meta: { name: "compositions", description: "List all compositions in a project" },
+  args: {
+    dir: { type: "positional", description: "Project directory", required: false },
+    json: { type: "boolean", description: "Output as JSON", default: false }
+  },
+  async run({ args }) {
+    const project = resolveProject(args.dir);
+    const html = readFileSync(project.indexPath, "utf-8");
+    ensureDOMParser();
+    const compositions = parseCompositions(html, dirname(project.indexPath));
+    if (args.json) {
+      console.log(JSON.stringify(withMeta({ compositions }), null, 2));
+      return;
+    }
+    if (compositions.length === 0) {
+      console.log(`${c.success("\u25C7")}  ${c.accent(project.name)} \u2014 no compositions found`);
+      return;
+    }
+    const compositionLabel = compositions.length === 1 ? "1 composition" : `${compositions.length} compositions`;
+    console.log(
+      `${c.success("\u25C7")}  ${c.accent(project.name)} ${c.dim("\u2014")} ${c.dim(compositionLabel)}`
+    );
+    console.log();
+    const maxIdLen = compositions.reduce((max, comp) => Math.max(max, comp.id.length), 0);
+    for (const comp of compositions) {
+      const id = c.accent(comp.id.padEnd(maxIdLen));
+      const duration = c.bold(`${comp.duration.toFixed(1)}s`);
+      const resolution = c.dim(`${comp.width}\xD7${comp.height}`);
+      const elements = c.dim(
+        `${comp.elementCount} ${comp.elementCount === 1 ? "element" : "elements"}`
+      );
+      const source = comp.source ? c.dim(` \u2190 ${comp.source}`) : "";
+      console.log(`   ${id}   ${duration}   ${resolution}   ${elements}${source}`);
+    }
+  }
+});
+export {
+  compositions_default as default,
+  examples,
+  parseCompositions,
+  parseSubComposition
+};

package/vendor/hyperframes/dist/contactSheet-27SRU7A4.js

@@ -0,0 +1,22 @@
+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 {
+  createAssetContactSheet,
+  createContactSheet,
+  createScrollContactSheet,
+  createSnapshotContactSheet,
+  createSvgContactSheet
+} from "./chunk-E6RPWJVC.js";
+import "./chunk-MRF4AMKD.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  createAssetContactSheet,
+  createContactSheet,
+  createScrollContactSheet,
+  createSnapshotContactSheet,
+  createSvgContactSheet
+};

package/vendor/hyperframes/dist/delete-ZAKYCB7I.js

@@ -0,0 +1,114 @@
+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 {
+  createCloudClient,
+  reportApiError
+} from "./chunk-Y6W4DVPS.js";
+import "./chunk-BXCMXMJQ.js";
+import "./chunk-SHB5VDMH.js";
+import "./chunk-I465DBM6.js";
+import "./chunk-EOVYQ3IG.js";
+import {
+  errorBox
+} from "./chunk-IHFUKJOR.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import {
+  failCommand
+} from "./chunk-PBN6GBJE.js";
+import "./chunk-OFQWTKPW.js";
+import {
+  withMeta
+} from "./chunk-HW6OYASV.js";
+import "./chunk-K4WIOZFP.js";
+import "./chunk-XUXGIA7H.js";
+import "./chunk-WERLJGIC.js";
+import "./chunk-ISN5GRYI.js";
+import "./chunk-FLWXXDNS.js";
+import "./chunk-KNU5COPB.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/cloud/delete.ts
+var delete_default = defineCommand({
+  meta: { name: "delete", description: "Soft-delete a cloud render" },
+  args: {
+    id: {
+      type: "positional",
+      required: true,
+      description: "Render ID to delete"
+    },
+    json: {
+      type: "boolean",
+      description: "Emit machine-readable JSON",
+      default: false
+    },
+    // Citty intercepts the `--no-` prefix as a negation of the base
+    // flag, so a flag literally named "no-confirm" gets parsed as
+    // `--confirm=false` and the `args["no-confirm"]` lookup never
+    // sees `true`. Naming the flag `confirm` with `default: true` lets
+    // citty's negation handle `--no-confirm` correctly — same
+    // user-facing flag (`--no-confirm` to skip the prompt), correct
+    // runtime semantics.
+    confirm: {
+      type: "boolean",
+      description: "Prompt before deleting (default: true). Pass `--no-confirm` to skip \u2014 required for scripts and --json.",
+      default: true
+    }
+  },
+  // fallow-ignore-next-line complexity
+  async run({ args }) {
+    if (args.confirm) {
+      if (args.json || !process.stdin.isTTY) {
+        errorBox(
+          "Confirmation required",
+          "delete cannot prompt for confirmation here \u2014 stdin isn't a TTY or --json was passed.",
+          "Re-run with --no-confirm to acknowledge the irreversible delete."
+        );
+        failCommand();
+      }
+      const ok = await confirmDelete(args.id);
+      if (!ok) {
+        console.log(c.dim("Aborted."));
+        failCommand(2);
+      }
+    }
+    const client = await createCloudClient();
+    try {
+      const response = await client.deleteRender({ render_id: args.id });
+      if (args.json) {
+        console.log(
+          JSON.stringify(
+            withMeta({ render: { render_id: response.render_id }, deleted: true }),
+            null,
+            2
+          )
+        );
+        return;
+      }
+      console.log(`${c.success("\u2713")}  Deleted ${c.accent(response.render_id)}`);
+    } catch (err) {
+      reportApiError("Could not delete render", err, {
+        notFound: `No render found with id "${args.id}".`
+      });
+    }
+  }
+});
+async function confirmDelete(id) {
+  const clack = await import("./dist-EWXJGN63.js");
+  const answer = await clack.confirm({
+    message: `Delete render ${id}? This is irreversible.`,
+    initialValue: false
+  });
+  return answer === true;
+}
+export {
+  delete_default as default
+};

package/vendor/hyperframes/dist/deploy-MX76RZ36.js

@@ -0,0 +1,101 @@
+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 {
+  fetchStackOutputs,
+  locateSamTemplate,
+  repoRoot,
+  samDeploy
+} from "./chunk-VFCKXTBB.js";
+import {
+  DEFAULT_STACK_NAME,
+  writeStackOutputs
+} from "./chunk-H4YZZ2VQ.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+import "./chunk-PBN6GBJE.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/lambda/deploy.ts
+import { spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { join, resolve } from "path";
+var DEFAULT_REGION = "us-east-1";
+var DEFAULT_MEMORY_MB = 10240;
+var DEFAULT_CONCURRENCY = 8;
+async function runDeploy(args = {}) {
+  const resolved = {
+    stackName: args.stackName ?? DEFAULT_STACK_NAME,
+    region: args.region ?? process.env.AWS_REGION ?? DEFAULT_REGION,
+    awsProfile: args.awsProfile ?? process.env.AWS_PROFILE,
+    reservedConcurrency: args.reservedConcurrency ?? DEFAULT_CONCURRENCY,
+    chromeSource: args.chromeSource ?? "sparticuz",
+    lambdaMemoryMb: args.lambdaMemoryMb ?? DEFAULT_MEMORY_MB,
+    skipBuild: args.skipBuild ?? false
+  };
+  const root = repoRoot();
+  locateSamTemplate(root);
+  if (!resolved.skipBuild) {
+    console.log(c.dim("\u2192 Building handler ZIP"));
+    buildHandlerZip(root);
+  } else {
+    const zip = join(root, "packages", "aws-lambda", "dist", "handler.zip");
+    if (!existsSync(zip)) {
+      throw new Error(
+        `--skip-build set but ${zip} does not exist. Run \`bun run --cwd packages/aws-lambda build:zip\` first or drop --skip-build.`
+      );
+    }
+  }
+  console.log(c.dim(`\u2192 sam deploy (stack=${resolved.stackName} region=${resolved.region})`));
+  samDeploy({
+    repoRoot: root,
+    stackName: resolved.stackName,
+    region: resolved.region,
+    awsProfile: resolved.awsProfile,
+    reservedConcurrency: resolved.reservedConcurrency,
+    lambdaMemoryMb: resolved.lambdaMemoryMb,
+    chromeSource: resolved.chromeSource
+  });
+  console.log(c.dim("\u2192 Reading stack outputs"));
+  const outputs = fetchStackOutputs({
+    stackName: resolved.stackName,
+    region: resolved.region,
+    awsProfile: resolved.awsProfile
+  });
+  const statePath = writeStackOutputs({
+    stackName: resolved.stackName,
+    region: resolved.region,
+    bucketName: outputs.bucketName,
+    stateMachineArn: outputs.stateMachineArn,
+    functionName: outputs.functionName,
+    lambdaMemoryMb: resolved.lambdaMemoryMb,
+    deployedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  console.log();
+  console.log(c.success("Stack deployed."));
+  console.log(`  ${c.dim("Bucket:")}         ${outputs.bucketName}`);
+  console.log(`  ${c.dim("State machine:")}  ${outputs.stateMachineArn}`);
+  console.log(`  ${c.dim("Function:")}       ${outputs.functionName}`);
+  console.log(`  ${c.dim("State file:")}     ${resolve(statePath)}`);
+  console.log();
+  console.log(c.dim(`Render with: hyperframes lambda render <project-dir>`));
+}
+function buildHandlerZip(root) {
+  const result = spawnSync(
+    "bun",
+    ["run", "--cwd", join(root, "packages", "aws-lambda"), "build:zip"],
+    { stdio: "inherit" }
+  );
+  if (result.status !== 0) {
+    throw new Error(
+      `[lambda deploy] handler ZIP build exited with code ${result.status ?? "unknown"}`
+    );
+  }
+}
+export {
+  runDeploy
+};

package/vendor/hyperframes/dist/destroy-H2TZBYHH.js

@@ -0,0 +1,42 @@
+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 {
+  repoRoot,
+  samDelete
+} from "./chunk-VFCKXTBB.js";
+import {
+  deleteStackOutputs,
+  requireStack
+} from "./chunk-H4YZZ2VQ.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+import "./chunk-PBN6GBJE.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/lambda/destroy.ts
+async function runDestroy(args) {
+  const stack = requireStack(args.stackName);
+  console.log(c.dim(`\u2192 sam delete (stack=${stack.stackName} region=${stack.region})`));
+  samDelete({
+    repoRoot: repoRoot(),
+    stackName: stack.stackName,
+    region: stack.region,
+    awsProfile: args.awsProfile ?? process.env.AWS_PROFILE
+  });
+  deleteStackOutputs(args.stackName);
+  console.log();
+  console.log(c.success("Stack torn down."));
+  console.log(
+    c.dim(
+      `Note: the render bucket "${stack.bucketName}" was deployed with Retain \u2014 empty + delete it via the AWS console or CLI if you want to fully reclaim storage.`
+    )
+  );
+}
+export {
+  runDestroy
+};