@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/render-batch-YH7CTWNY.js

@@ -0,0 +1,284 @@
+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 {
+  warnOnDimensionMismatch
+} from "./chunk-THXFSPLV.js";
+import {
+  requireStack
+} from "./chunk-H4YZZ2VQ.js";
+import {
+  loadProjectVariableSchema,
+  reportVariableIssues,
+  validateVariablesAgainstSchema
+} from "./chunk-6CTIGJY7.js";
+import "./chunk-5Z63TBTX.js";
+import {
+  errorBox
+} from "./chunk-IHFUKJOR.js";
+import "./chunk-PFCFR3KZ.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+import {
+  failCommand,
+  setCommandExitCode
+} from "./chunk-PBN6GBJE.js";
+import "./chunk-2YN64IN5.js";
+import "./chunk-AVUUN2XD.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-HWKCIWQT.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-TQFG7HTI.js";
+import "./chunk-GK4AIFIH.js";
+import "./chunk-2PSPARWP.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-KNU5COPB.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-PMRBLBUP.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/lambda/render-batch.ts
+import { existsSync, readFileSync } from "fs";
+import { join, resolve as resolvePath } from "path";
+async function loadSDK() {
+  return import("@hyperframes/aws-lambda/sdk");
+}
+var DEFAULT_MAX_CONCURRENT = 50;
+async function runRenderBatch(args) {
+  const projectDir = resolvePath(args.projectDir);
+  const stack = requireStack(args.stackName);
+  const batchPath = resolvePath(args.batch);
+  if (!existsSync(batchPath)) {
+    errorBox("Batch file not found", `No such file: ${batchPath}`);
+    failCommand();
+  }
+  const entries = parseBatchFile(batchPath);
+  if (entries.length === 0) {
+    errorBox("Empty batch", `${batchPath} contains zero entries (every line was blank).`);
+    failCommand();
+  }
+  warnOnDimensionMismatch({
+    projectDir,
+    cliWidth: args.width,
+    cliHeight: args.height,
+    outputResolution: args.outputResolution,
+    quiet: args.json
+  });
+  const schema = loadProjectVariableSchema(join(projectDir, "index.html"));
+  const strict = args.strictVariables ?? false;
+  let hadStrictIssue = false;
+  for (const { entry, lineNumber } of entries) {
+    if (!entry.variables || Object.keys(entry.variables).length === 0) continue;
+    const issues = validateVariablesAgainstSchema(entry.variables, schema);
+    if (issues.length === 0) continue;
+    if (!args.json) {
+      console.log("");
+      console.log(c.dim(`Batch entry on line ${lineNumber}:`));
+    }
+    reportVariableIssues(issues, { strict: false, quiet: args.json });
+    if (strict) hadStrictIssue = true;
+  }
+  if (hadStrictIssue) {
+    errorBox(
+      "Variable validation failed",
+      "Aborting batch due to variable issues in one or more entries (--strict-variables mode)."
+    );
+    failCommand();
+  }
+  const config = buildLambdaBatchRenderConfig(args);
+  let siteHandle;
+  if (args.siteId) {
+    siteHandle = makePlaceholderSiteHandle(args.siteId, stack.bucketName);
+  } else if (args.dryRun) {
+    siteHandle = makePlaceholderSiteHandle("dry-run-site", stack.bucketName);
+  } else {
+    const { deploySite } = await loadSDK();
+    siteHandle = await deploySite({
+      projectDir,
+      bucketName: stack.bucketName,
+      region: stack.region
+    });
+    if (!args.json) {
+      console.log(
+        c.success(
+          siteHandle.uploaded ? `Site uploaded once for the batch: ${siteHandle.siteId}` : `Site already up to date (skipped upload): ${siteHandle.siteId}`
+        )
+      );
+      console.log();
+    }
+  }
+  const maxConcurrent = args.maxConcurrent ?? DEFAULT_MAX_CONCURRENT;
+  const renderToLambda = args.dryRun ? void 0 : (await loadSDK()).renderToLambda;
+  const startEntry = async (item) => {
+    const { entry, lineNumber } = item;
+    if (args.dryRun) {
+      return {
+        inputLine: lineNumber,
+        outputKey: entry.outputKey,
+        executionArn: null,
+        status: "would-invoke"
+      };
+    }
+    if (!renderToLambda) {
+      throw new Error("[render-batch] renderToLambda is undefined outside --dry-run");
+    }
+    try {
+      const handle = await renderToLambda({
+        siteHandle,
+        bucketName: stack.bucketName,
+        stateMachineArn: stack.stateMachineArn,
+        region: stack.region,
+        config: { ...config, variables: entry.variables },
+        executionName: entry.executionName,
+        outputKey: entry.outputKey
+      });
+      return {
+        inputLine: lineNumber,
+        outputKey: entry.outputKey,
+        executionArn: handle.executionArn,
+        status: "started"
+      };
+    } catch (err) {
+      return {
+        inputLine: lineNumber,
+        outputKey: entry.outputKey,
+        executionArn: null,
+        status: "failed-to-start",
+        error: normalizeErrorMessage(err)
+      };
+    }
+  };
+  const manifest = await runWithConcurrencyLimit(entries, maxConcurrent, startEntry);
+  if (args.json) {
+    console.log(JSON.stringify(manifest, null, 2));
+    return;
+  }
+  const started = manifest.filter((m) => m.status === "started").length;
+  const failed = manifest.filter((m) => m.status === "failed-to-start").length;
+  const wouldInvoke = manifest.filter((m) => m.status === "would-invoke").length;
+  if (args.dryRun) {
+    console.log(c.success(`Dry-run complete: ${wouldInvoke} entries would invoke.`));
+  } else {
+    console.log(c.success(`Batch dispatched: ${started} started, ${failed} failed-to-start.`));
+  }
+  console.log();
+  for (const row of manifest) {
+    const tag = row.status === "started" ? c.success("\u2713") : row.status === "would-invoke" ? c.dim("\xB7") : c.error("\u2717");
+    const detail = row.status === "failed-to-start" ? c.error(row.error ?? "unknown error") : row.executionArn ?? c.dim("(no execution)");
+    console.log(`  ${tag} line ${row.inputLine}  ${c.dim(row.outputKey)}  ${detail}`);
+  }
+  if (failed > 0) setCommandExitCode(1);
+}
+function makePlaceholderSiteHandle(siteId, bucketName) {
+  return {
+    siteId,
+    bucketName,
+    projectS3Uri: `s3://${bucketName}/sites/${siteId}/project.tar.gz`,
+    bytes: 0,
+    uploadedAt: "",
+    uploaded: false
+  };
+}
+function buildLambdaBatchRenderConfig(args) {
+  const config = {
+    fps: args.fps,
+    width: args.width,
+    height: args.height,
+    outputResolution: args.outputResolution,
+    format: args.format,
+    codec: args.codec,
+    quality: args.quality,
+    chunkSize: args.chunkSize,
+    maxParallelChunks: args.maxParallelChunks,
+    targetChunkFrames: args.targetChunkFrames,
+    runtimeCap: "lambda"
+  };
+  if (args.outputResolutionAspectAgnostic) {
+    config.outputResolutionAspectAgnostic = true;
+  }
+  return config;
+}
+function parseBatchFile(path) {
+  const raw = readFileSync(path, "utf8");
+  const lines = raw.split(/\r?\n/);
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line === "") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch (err) {
+      errorBox(`Invalid JSON in batch file on line ${i + 1}`, normalizeErrorMessage(err));
+      failCommand();
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      errorBox(
+        `Invalid batch entry on line ${i + 1}`,
+        'Each line must be a JSON object with at least { "outputKey": "..." }.'
+      );
+      failCommand();
+    }
+    const obj = parsed;
+    const outputKey = obj.outputKey;
+    if (typeof outputKey !== "string" || outputKey.length === 0) {
+      errorBox(
+        `Missing outputKey on line ${i + 1}`,
+        'Each batch entry needs a non-empty "outputKey" string (e.g. "renders/alice.mp4").'
+      );
+      failCommand();
+    }
+    if (obj.variables !== void 0) {
+      if (obj.variables === null || typeof obj.variables !== "object" || Array.isArray(obj.variables)) {
+        errorBox(
+          `Invalid variables on line ${i + 1}`,
+          '"variables" must be a JSON object (or omitted).'
+        );
+        failCommand();
+      }
+    }
+    if (obj.executionName !== void 0 && typeof obj.executionName !== "string") {
+      errorBox(
+        `Invalid executionName on line ${i + 1}`,
+        '"executionName" must be a string (or omitted).'
+      );
+      failCommand();
+    }
+    out.push({
+      entry: {
+        outputKey,
+        variables: obj.variables,
+        executionName: obj.executionName
+      },
+      lineNumber: i + 1
+    });
+  }
+  return out;
+}
+async function runWithConcurrencyLimit(inputs, limit, worker) {
+  if (limit < 1) throw new Error(`runWithConcurrencyLimit: limit must be \u2265 1, got ${limit}`);
+  const results = new Array(inputs.length);
+  let cursor = 0;
+  const workerCount = Math.min(limit, inputs.length);
+  await Promise.all(
+    Array.from({ length: workerCount }, async () => {
+      while (cursor < inputs.length) {
+        const idx = cursor++;
+        results[idx] = await worker(inputs[idx], idx);
+      }
+    })
+  );
+  return results;
+}
+export {
+  buildLambdaBatchRenderConfig,
+  parseBatchFile,
+  runRenderBatch,
+  runWithConcurrencyLimit
+};

package/vendor/hyperframes/dist/renderCancellation-JPIHE47X.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 {
+  createRenderCancellationScope,
+  stoppedByCancelSignal
+} from "./chunk-7JZ4FXP2.js";
+import "./chunk-K2FTXJYH.js";
+import "./chunk-2YN64IN5.js";
+import "./chunk-AVUUN2XD.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-Z6B37SNM.js";
+import "./chunk-HWKCIWQT.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-LAOCA3MQ.js";
+import "./chunk-LCSMOLGX.js";
+import "./chunk-TWWSYAKJ.js";
+import "./chunk-ZJUKFZ2P.js";
+import "./chunk-HBBJFK6I.js";
+import "./chunk-PJ3HDUCY.js";
+import "./chunk-TQFG7HTI.js";
+import "./chunk-GK4AIFIH.js";
+import "./chunk-2PSPARWP.js";
+import "./chunk-3GXQPCJC.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-PMRBLBUP.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  createRenderCancellationScope,
+  stoppedByCancelSignal
+};

package/vendor/hyperframes/dist/renderSetupWorker.js

@@ -0,0 +1,79 @@
+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 "./chunk-Q5X2B5WT.js";
+import {
+  ensureBrowser,
+  releaseOwnedBrowserInstallLock
+} from "./chunk-4PFZPP2N.js";
+import {
+  killOrphanedProcesses
+} from "./chunk-LAOCA3MQ.js";
+import "./chunk-LCSMOLGX.js";
+import "./chunk-TWWSYAKJ.js";
+import {
+  lintProject
+} 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 "./chunk-KNU5COPB.js";
+import "./chunk-PMRBLBUP.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/renderSetupWorker.ts
+import { constants, setPriority } from "os";
+
+// src/renderSetupWorkerLifecycle.ts
+var RENDER_SETUP_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+function installRenderSetupSignalHandlers(signalTarget, releaseLock, resendSignal, handleHangup = true) {
+  const handlers = /* @__PURE__ */ new Map();
+  const handledSignals = handleHangup ? RENDER_SETUP_SIGNALS : RENDER_SETUP_SIGNALS.filter((signal) => signal !== "SIGHUP");
+  for (const signal of handledSignals) {
+    const handler = () => {
+      releaseLock();
+      signalTarget.off(signal, handler);
+      resendSignal(signal);
+    };
+    handlers.set(signal, handler);
+    signalTarget.on(signal, handler);
+  }
+  return () => {
+    for (const [signal, handler] of handlers) signalTarget.off(signal, handler);
+  };
+}
+
+// src/renderSetupWorker.ts
+var RESULT_PREFIX = "HYPERFRAMES_RENDER_SETUP_RESULT:";
+var mode = process.argv[2];
+var input = JSON.parse(process.env.HYPERFRAMES_RENDER_SETUP_INPUT ?? "{}");
+var disposeSignalHandlers = installRenderSetupSignalHandlers(
+  process,
+  releaseOwnedBrowserInstallLock,
+  (signal) => process.kill(process.pid, signal),
+  process.env.HYPERFRAMES_RENDER_DETACHED !== "1"
+);
+var result;
+if (mode === "browser") {
+  result = await ensureBrowser(input);
+} else if (mode === "lint") {
+  setPriority(constants.priority.PRIORITY_LOW);
+  result = await lintProject(
+    input.projectDir,
+    input.entryFile,
+    input.host ? { host: input.host } : void 0
+  );
+} else if (mode === "orphan-cleanup") {
+  const killed = killOrphanedProcesses();
+  result = killed;
+  if (killed > 0) await new Promise((resolve) => setTimeout(resolve, 600));
+} else {
+  throw new Error(`Unknown render setup mode: ${mode}`);
+}
+disposeSignalHandlers();
+process.stdout.write(RESULT_PREFIX + JSON.stringify(result) + "\n");

package/vendor/hyperframes/dist/resolver-IZ647GBZ.js

@@ -0,0 +1,38 @@
+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 {
+  listRegistryItems,
+  loadAllItems,
+  resolveItem,
+  resolveItemWithDependencies,
+  resolveItemsByTag,
+  unreachableRegistryMessage
+} from "./chunk-LYNI3FOL.js";
+import "./chunk-A2Z4Z4VL.js";
+import "./chunk-AWDFDFI3.js";
+import "./chunk-P6LJ4Y32.js";
+import "./chunk-GMECXFAN.js";
+import "./chunk-2YN64IN5.js";
+import "./chunk-AVUUN2XD.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-HWKCIWQT.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-TQFG7HTI.js";
+import "./chunk-GK4AIFIH.js";
+import "./chunk-2PSPARWP.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-PMRBLBUP.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  listRegistryItems,
+  loadAllItems,
+  resolveItem,
+  resolveItemWithDependencies,
+  resolveItemsByTag,
+  unreachableRegistryMessage
+};

package/vendor/hyperframes/dist/runtimeVersion.js

@@ -0,0 +1,18 @@
+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 "./chunk-M2WBOQ2Q.js";
+
+// src/runtimeVersion.ts
+var MINIMUM_NODE_MAJOR = 22;
+function runtimeVersionError(version) {
+  const major = Number.parseInt(version.split(".", 1)[0] ?? "", 10);
+  if (Number.isFinite(major) && major >= MINIMUM_NODE_MAJOR) return null;
+  return `HyperFrames requires Node.js >= ${MINIMUM_NODE_MAJOR} (current: ${version}). Switch Node versions and retry.`;
+}
+export {
+  runtimeVersionError
+};

package/vendor/hyperframes/dist/screenshotCapture-ECBTLCU6.js

@@ -0,0 +1,179 @@
+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 {
+  isDegradableEvaluateTimeoutError
+} from "./chunk-AWNBM3MZ.js";
+import {
+  ensureCaptureDirSync,
+  writeCaptureFileSync
+} from "./chunk-MRF4AMKD.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/capture/screenshotCapture.ts
+import { join } from "path";
+var MAX_PLATE_HEIGHT_PX = 16384;
+function pngHeight(buf) {
+  if (buf.length < 24) return null;
+  if (buf[12] !== 73 || buf[13] !== 72 || buf[14] !== 68 || buf[15] !== 82) return null;
+  return (buf[20] << 24 | buf[21] << 16 | buf[22] << 8 | buf[23]) >>> 0;
+}
+async function captureFullPagePlate(page, screenshotsDir, budget = {}) {
+  await page.evaluate(
+    `document.querySelectorAll('*').forEach((el) => {
+      const p = getComputedStyle(el).position;
+      if (p === 'fixed' || p === 'sticky') {
+        el.setAttribute('data-hf-plate-position', el.style.position || '');
+        el.style.position = 'static';
+      }
+    })`
+  );
+  try {
+    const docHeight = await page.evaluate(
+      `Math.max(document.body.scrollHeight, document.documentElement.scrollHeight)`
+    );
+    if (docHeight > MAX_PLATE_HEIGHT_PX) return null;
+    if ((budget.remainingMs?.() ?? 1) <= 0) return null;
+    const buffer = await page.screenshot({ type: "png", fullPage: true });
+    const produced = pngHeight(buffer);
+    if (produced != null && produced > MAX_PLATE_HEIGHT_PX) return null;
+    writeCaptureFileSync(join(screenshotsDir, "full-page.png"), buffer);
+    return "screenshots/full-page.png";
+  } finally {
+    try {
+      await page.evaluate(
+        `document.querySelectorAll('[data-hf-plate-position]').forEach((el) => {
+          el.style.position = el.getAttribute('data-hf-plate-position');
+          el.removeAttribute('data-hf-plate-position');
+        })`
+      );
+    } catch {
+    }
+  }
+}
+async function captureScrollScreenshots(page, outputDir, budget = {}) {
+  const screenshotsDir = join(outputDir, "screenshots");
+  ensureCaptureDirSync(outputDir, screenshotsDir);
+  const MAX_SCREENSHOTS = 20;
+  const filePaths = [];
+  if ((budget.remainingMs?.() ?? 1) <= 0) return filePaths;
+  try {
+    await page.evaluate(() => {
+      const selectors = [
+        // Cookie consent
+        '[id*="cookie"] button[class*="accept"]',
+        '[id*="cookie"] button[class*="agree"]',
+        '[id*="cookie"] button[class*="allow"]',
+        '[class*="cookie"] button[class*="accept"]',
+        '[class*="consent"] button',
+        // Generic close buttons on overlays/modals
+        '[class*="banner"] [class*="close"]',
+        '[class*="banner"] [class*="dismiss"]',
+        '[class*="popup"] [class*="close"]',
+        '[class*="modal"] [class*="close"]',
+        '[class*="overlay"] [class*="close"]',
+        // Common GDPR patterns — scoped under a cookie/consent/gdpr ancestor
+        // so we don't click "Accept invitation" / "Accept terms" / etc. on
+        // unrelated buttons elsewhere on the page.
+        '[id*="cookie" i] button[id*="accept" i]',
+        '[id*="consent" i] button[id*="accept" i]',
+        '[id*="gdpr" i] button[id*="accept" i]',
+        '[class*="cookie" i] button[class*="accept-all" i]',
+        '[class*="cookie" i] button[class*="acceptAll" i]',
+        '[class*="consent" i] button[class*="accept-all" i]',
+        // Notification prompts
+        'button[class*="decline"]',
+        'button[class*="not-now"]',
+        'button[class*="no-thanks"]'
+      ];
+      for (const sel of selectors) {
+        try {
+          const el = document.querySelector(sel);
+          if (el) el.click();
+        } catch {
+        }
+      }
+      const SCAN_CAP = 5e3;
+      const minWidth = window.innerWidth * 0.3;
+      const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT);
+      let visited = 0;
+      let node = walker.nextNode();
+      while (node && visited < SCAN_CAP) {
+        visited++;
+        const el = node;
+        const rect = el.getBoundingClientRect();
+        if (rect.height > 80 && rect.width > minWidth) {
+          const tag = el.tagName;
+          if (tag !== "HEADER" && tag !== "NAV" && !el.closest("header") && !el.closest("nav")) {
+            const style = window.getComputedStyle(el);
+            if ((style.position === "fixed" || style.position === "sticky") && style.zIndex !== "auto" && parseInt(style.zIndex) > 100) {
+              el.style.display = "none";
+            }
+          }
+        }
+        node = walker.nextNode();
+      }
+    }).catch((err) => {
+      if (isDegradableEvaluateTimeoutError(err)) {
+        throw err;
+      }
+    });
+    await new Promise((r) => setTimeout(r, 400));
+    const scrollHeight = await page.evaluate(
+      `Math.max(document.body.scrollHeight, document.documentElement.scrollHeight)`
+    );
+    const viewportHeight = await page.evaluate(`window.innerHeight`);
+    const step = Math.floor(viewportHeight * 0.7);
+    const positions = [0];
+    for (let y = step; y < scrollHeight - viewportHeight; y += step) {
+      positions.push(y);
+    }
+    const lastPos = Math.max(0, scrollHeight - viewportHeight);
+    if (positions[positions.length - 1] !== lastPos) {
+      positions.push(lastPos);
+    }
+    let finalPositions = positions;
+    if (positions.length > MAX_SCREENSHOTS) {
+      finalPositions = [positions[0]];
+      const stride = (positions.length - 1) / (MAX_SCREENSHOTS - 1);
+      for (let i = 1; i < MAX_SCREENSHOTS - 1; i++) {
+        finalPositions.push(positions[Math.round(i * stride)]);
+      }
+      finalPositions.push(positions[positions.length - 1]);
+    }
+    for (let i = 0; i < finalPositions.length; i++) {
+      if ((budget.remainingMs?.() ?? 1) <= 0) break;
+      await page.evaluate(`window.scrollTo(0, ${finalPositions[i]})`);
+      await new Promise((r) => setTimeout(r, 400));
+      const pct = Math.round(
+        finalPositions[i] / Math.max(1, scrollHeight - viewportHeight) * 100
+      );
+      const filename = `scroll-${String(Math.min(pct, 100)).padStart(3, "0")}.png`;
+      const filePath = join(screenshotsDir, filename);
+      if ((budget.remainingMs?.() ?? 1) <= 0) break;
+      const buffer = await page.screenshot({ type: "png" });
+      writeCaptureFileSync(filePath, buffer);
+      filePaths.push(`screenshots/${filename}`);
+    }
+    await page.evaluate(`window.scrollTo(0, 0)`);
+    await new Promise((r) => setTimeout(r, 200));
+    if ((budget.remainingMs?.() ?? 1) > 0) {
+      const plate = await captureFullPagePlate(page, screenshotsDir, budget);
+      if (plate) filePaths.push(plate);
+    }
+  } catch (err) {
+    if (isDegradableEvaluateTimeoutError(err)) {
+      throw err;
+    }
+  }
+  return filePaths;
+}
+export {
+  MAX_PLATE_HEIGHT_PX,
+  captureFullPagePlate,
+  captureScrollScreenshots,
+  pngHeight
+};

package/vendor/hyperframes/dist/shaderTransitionWorker.js

@@ -0,0 +1,44 @@
+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 {
+  TRANSITIONS,
+  crossfade
+} from "./chunk-3GXQPCJC.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// ../producer/src/services/shaderTransitionWorker.ts
+import { parentPort } from "worker_threads";
+if (!parentPort) {
+  console.warn("[shaderTransitionWorker] no parentPort; module loaded on main thread");
+} else {
+  parentPort.on("message", (msg) => {
+    const { shader, bufferA, bufferB, output, width, height, progress } = msg;
+    const bufA = Buffer.from(bufferA);
+    const bufB = Buffer.from(bufferB);
+    const out = Buffer.from(output);
+    try {
+      const fn = TRANSITIONS[shader] ?? crossfade;
+      fn(bufA, bufB, out, width, height, progress);
+      const reply = {
+        ok: true,
+        bufferA,
+        bufferB,
+        output
+      };
+      parentPort.postMessage(reply, [bufferA, bufferB, output]);
+    } catch (err) {
+      const reply = {
+        ok: false,
+        error: err instanceof Error ? err.message : String(err),
+        bufferA,
+        bufferB,
+        output
+      };
+      parentPort.postMessage(reply, [bufferA, bufferB, output]);
+    }
+  });
+}