@vfrey/vfrey 0.0.1 → 1.0.0-beta.1

package/vendor/framey/dist/render-batch-ZAMFPCLL.js

@@ -0,0 +1,274 @@
+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-H6IEMZEV.js";
+import {
+  requireStack
+} from "./chunk-3FYD4YEK.js";
+import {
+  loadProjectVariableSchema,
+  reportVariableIssues,
+  validateVariablesAgainstSchema
+} from "./chunk-EAMLBAHA.js";
+import {
+  errorBox
+} from "./chunk-P5ZBLXJ6.js";
+import "./chunk-LEKZNRKI.js";
+import "./chunk-442JNXRM.js";
+import {
+  runWithConcurrencyLimit
+} from "./chunk-JHOCK3DG.js";
+import {
+  c
+} from "./chunk-VORQIH64.js";
+import {
+  failCommand,
+  setCommandExitCode
+} from "./chunk-JVBRJMOP.js";
+import "./chunk-DLA44CMS.js";
+import "./chunk-UJZREAV6.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-X7HBSTCZ.js";
+import "./chunk-B7RJV74O.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-634HSJ3J.js";
+import "./chunk-FXMKHHPO.js";
+import "./chunk-RQVDTPGD.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-T2EUWCJE.js";
+import "./chunk-MMQ52NIZ.js";
+import "./chunk-BSQ7XANM.js";
+import "./chunk-SDYDNHEE.js";
+import "./chunk-RXATE6FZ.js";
+import "./chunk-3422KMTD.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("@framey/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,
+    stack.reservedConcurrency
+  );
+  let siteHandle;
+  const { assertStackReadsSites, deploySite, siteHandleFromId } = await loadSDK();
+  if (!args.dryRun) {
+    await assertStackReadsSites({ stateMachineArn: stack.stateMachineArn, region: stack.region });
+  }
+  if (args.siteId) {
+    siteHandle = siteHandleFromId(stack.bucketName, args.siteId);
+  } else if (args.dryRun) {
+    siteHandle = siteHandleFromId(stack.bucketName, "dry-run-site");
+  } else {
+    siteHandle = await deploySite({
+      projectDir,
+      bucketName: stack.bucketName,
+      region: stack.region,
+      onNotice: (message) => console.error(c.dim(message))
+    });
+    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({
+        projectDir,
+        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 buildLambdaBatchRenderConfig(args, workerConcurrency) {
+  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,
+    workerConcurrency,
+    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;
+}
+export {
+  buildLambdaBatchRenderConfig,
+  parseBatchFile,
+  runRenderBatch
+};

package/vendor/framey/dist/renderSetupWorker.js

@@ -0,0 +1,120 @@
+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 {
+  ensureBrowser,
+  installLogLine,
+  installProgressLine,
+  releaseOwnedBrowserInstallLock
+} from "./chunk-ND46XKK3.js";
+import {
+  killOrphanedProcesses
+} from "./chunk-LTGTN2TH.js";
+import {
+  installRenderSetupSignalHandlers,
+  renderSetupErrorLine,
+  renderSetupResultLine
+} from "./chunk-BL4U6U52.js";
+import "./chunk-Q5X2B5WT.js";
+import "./chunk-T2EUWCJE.js";
+import "./chunk-T6AGUTZJ.js";
+import "./chunk-XT6MXC7A.js";
+import "./chunk-K4MJX7SR.js";
+import "./chunk-4UMPIPCQ.js";
+import {
+  lintProject
+} from "./chunk-4P7NX5BM.js";
+import "./chunk-VAS6HQX3.js";
+import "./chunk-6BNTGNGD.js";
+import "./chunk-CZGHFATT.js";
+import "./chunk-PKZ7RK5N.js";
+import "./chunk-W2LGJSEN.js";
+import "./chunk-MMQ52NIZ.js";
+import "./chunk-BSQ7XANM.js";
+import "./chunk-SDYDNHEE.js";
+import "./chunk-RXATE6FZ.js";
+import "./chunk-3422KMTD.js";
+import "./chunk-KGPLIH7B.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/renderSetupWorker.ts
+import { constants, setPriority } from "os";
+
+// src/browser/installRun.ts
+import { debuglog } from "util";
+var PROGRESS_EVERY_MS = 100;
+async function runBrowserInstall(input2) {
+  const { install } = await import("@puppeteer/browsers");
+  let lastReport = 0;
+  process.stdout.write(installProgressLine(0, 0));
+  const { unpack, ...rest } = input2;
+  const options = {
+    ...rest,
+    downloadProgressCallback: (downloaded, total) => {
+      const now = Date.now();
+      if (now - lastReport < PROGRESS_EVERY_MS && downloaded < total) return;
+      lastReport = now;
+      process.stdout.write(installProgressLine(downloaded, total));
+    },
+    logger: (prefix) => {
+      const debug = debuglog(prefix);
+      const isUnzip = prefix === "puppeteer:browsers:fileUtil";
+      if (!isUnzip && !debug.enabled) return void 0;
+      return (...args) => {
+        const line = args.join(" ");
+        if (isUnzip) process.stdout.write(installLogLine(line));
+        if (debug.enabled) debug(line);
+      };
+    }
+  };
+  if (unpack === false) return install({ ...options, unpack: false });
+  const { path, executablePath } = await install(options);
+  return { path, executablePath };
+}
+
+// src/renderSetupWorker.ts
+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"
+);
+function lowerPriority() {
+  try {
+    setPriority(constants.priority.PRIORITY_LOW);
+  } catch (error) {
+    process.stderr.write(`Lint runs at normal priority: ${error.message}
+`);
+  }
+}
+async function runMode() {
+  if (mode === "browser") return ensureBrowser(input);
+  if (mode === "browser-install") return runBrowserInstall(input);
+  if (mode === "lint") {
+    lowerPriority();
+    return lintProject(
+      input.projectDir,
+      input.entryFile,
+      input.host ? { host: input.host } : void 0
+    );
+  }
+  if (mode === "orphan-cleanup") {
+    const killed = killOrphanedProcesses();
+    if (killed > 0) await new Promise((resolve) => setTimeout(resolve, 600));
+    return killed;
+  }
+  throw new Error(`Unknown render setup mode: ${mode}`);
+}
+try {
+  const result = await runMode().finally(disposeSignalHandlers);
+  process.stdout.write(renderSetupResultLine(result));
+} catch (error) {
+  process.stderr.write(renderSetupErrorLine(error), () => {
+    throw error;
+  });
+}

package/vendor/framey/dist/resolver-D5BIPSEW.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 {
+  listRegistryItems,
+  loadAllItems,
+  resolveItem,
+  resolveItemWithDependencies,
+  resolveItemsByTag,
+  unreachableRegistryMessage
+} from "./chunk-XX7LTW5Y.js";
+import "./chunk-JHOCK3DG.js";
+import "./chunk-RGLQURIX.js";
+import "./chunk-P6LJ4Y32.js";
+import "./chunk-GMECXFAN.js";
+import "./chunk-DLA44CMS.js";
+import "./chunk-UJZREAV6.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-X7HBSTCZ.js";
+import "./chunk-B7RJV74O.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-634HSJ3J.js";
+import "./chunk-FXMKHHPO.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-MMQ52NIZ.js";
+import "./chunk-BSQ7XANM.js";
+import "./chunk-SDYDNHEE.js";
+import "./chunk-RXATE6FZ.js";
+import "./chunk-3422KMTD.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  listRegistryItems,
+  loadAllItems,
+  resolveItem,
+  resolveItemWithDependencies,
+  resolveItemsByTag,
+  unreachableRegistryMessage
+};

package/vendor/framey/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 `Framey requires Node.js >= ${MINIMUM_NODE_MAJOR} (current: ${version}). Switch Node versions and retry.`;
+}
+export {
+  runtimeVersionError
+};

package/vendor/framey/dist/sam-WFZXI4F7.js

@@ -0,0 +1,23 @@
+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 {
+  deleteEcrRepository,
+  fetchStackOutputs,
+  locateSamTemplate,
+  parseReservedConcurrency,
+  samDelete,
+  samDeploy
+} from "./chunk-HEFQCIXR.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  deleteEcrRepository,
+  fetchStackOutputs,
+  locateSamTemplate,
+  parseReservedConcurrency,
+  samDelete,
+  samDeploy
+};

package/vendor/framey/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]);
+    }
+  });
+}

package/vendor/framey/dist/sherpa-RQWLV7I3.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 {
+  DecodeCancelled,
+  PARAKEET_MODEL_DIR,
+  SHERPA_RUNTIME_DIR,
+  decodeTimeoutMs,
+  ensureParakeetModel,
+  installSherpaRuntime,
+  prepareSherpaWav,
+  sherpaParakeetInstalled,
+  sherpaPlatformPackage,
+  sherpaRuntimeLoadError,
+  sherpaUnsupportedReason,
+  transcribeWithSherpa
+} from "./chunk-R6YBK4XX.js";
+import "./chunk-VMC4WSH5.js";
+import "./chunk-6BEFEWFB.js";
+import "./chunk-HTUHQKDB.js";
+import "./chunk-HFQ4CWHA.js";
+import "./chunk-HPDTCOKE.js";
+import "./chunk-WQ6ZXHFQ.js";
+import "./chunk-UMD3V7CU.js";
+import "./chunk-EOVYQ3IG.js";
+import "./chunk-TIQB63MX.js";
+import "./chunk-IZCW2NKT.js";
+import "./chunk-RNV3DM4S.js";
+import "./chunk-DLA44CMS.js";
+import "./chunk-UJZREAV6.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-X7HBSTCZ.js";
+import "./chunk-B7RJV74O.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-634HSJ3J.js";
+import "./chunk-FXMKHHPO.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-LTGTN2TH.js";
+import "./chunk-BL4U6U52.js";
+import "./chunk-T2EUWCJE.js";
+import "./chunk-XT6MXC7A.js";
+import "./chunk-K4MJX7SR.js";
+import "./chunk-4UMPIPCQ.js";
+import "./chunk-4P7NX5BM.js";
+import "./chunk-VAS6HQX3.js";
+import "./chunk-6BNTGNGD.js";
+import "./chunk-CZGHFATT.js";
+import "./chunk-PKZ7RK5N.js";
+import "./chunk-W2LGJSEN.js";
+import "./chunk-MMQ52NIZ.js";
+import "./chunk-BSQ7XANM.js";
+import "./chunk-SDYDNHEE.js";
+import "./chunk-RXATE6FZ.js";
+import "./chunk-3422KMTD.js";
+import "./chunk-II3J3WXK.js";
+import "./chunk-UOFAE5RF.js";
+import "./chunk-IR35BCLK.js";
+import "./chunk-HU2SPFNG.js";
+import "./chunk-KGPLIH7B.js";
+import "./chunk-3GXQPCJC.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  DecodeCancelled,
+  PARAKEET_MODEL_DIR,
+  SHERPA_RUNTIME_DIR,
+  decodeTimeoutMs,
+  ensureParakeetModel,
+  installSherpaRuntime,
+  prepareSherpaWav,
+  sherpaParakeetInstalled,
+  sherpaPlatformPackage,
+  sherpaRuntimeLoadError,
+  sherpaUnsupportedReason,
+  transcribeWithSherpa
+};

package/vendor/framey/dist/sherpaWorker.js

@@ -0,0 +1,84 @@
+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 {
+  SHERPA_ERROR_PREFIX,
+  SHERPA_RESULT_PREFIX,
+  SHERPA_WINDOW_PREFIX,
+  droppedSpeechGaps,
+  silenceCuts,
+  spliceGap
+} from "./chunk-II3J3WXK.js";
+import {
+  readWav
+} from "./chunk-UOFAE5RF.js";
+import "./chunk-IR35BCLK.js";
+import "./chunk-HU2SPFNG.js";
+import "./chunk-KGPLIH7B.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/whisper/sherpaWorker.ts
+import { createRequire } from "module";
+var { wavPath, runtimePath, config } = JSON.parse(process.env.HYPERFRAMES_PARAKEET_INPUT ?? "{}");
+var parentPid = process.ppid;
+var RETRY_PAD_SECONDS = 0.5;
+var GAP_MARGIN_SECONDS = 0.5;
+function decodeWindow(recognizer, wave, padSeconds = 0) {
+  const pad = Math.round(padSeconds * wave.sampleRate);
+  const samples = new Float32Array(pad + wave.samples.length);
+  samples.set(wave.samples, pad);
+  const stream = recognizer.createStream();
+  stream.acceptWaveform({ sampleRate: wave.sampleRate, samples });
+  recognizer.decode(stream);
+  const { tokens, timestamps, durations } = recognizer.getResult(stream);
+  return { tokens, timestamps: timestamps.map((t) => Math.max(0, t - padSeconds)), durations };
+}
+try {
+  const sherpa = createRequire(import.meta.url)(runtimePath);
+  const recognizer = new sherpa.OfflineRecognizer(config);
+  const wave = readWav(wavPath);
+  const cuts = silenceCuts(wave.samples, wave.sampleRate);
+  const windows = [];
+  for (let k = 0; k + 1 < cuts.length; k++) {
+    if (process.ppid !== parentPid) throw new Error("the CLI exited, so the decode stopped");
+    const slice = {
+      sampleRate: wave.sampleRate,
+      samples: wave.samples.subarray(cuts[k], cuts[k + 1])
+    };
+    let decoded = decodeWindow(recognizer, slice);
+    const gaps = droppedSpeechGaps(slice.samples, slice.sampleRate, decoded);
+    let spliced = decoded;
+    for (const [from, to] of gaps) {
+      const lo = Math.max(0, from - GAP_MARGIN_SECONDS);
+      const at = (seconds) => Math.round(seconds * slice.sampleRate);
+      const samples = slice.samples.subarray(at(lo), at(to + GAP_MARGIN_SECONDS));
+      const patch = decodeWindow(
+        recognizer,
+        { sampleRate: slice.sampleRate, samples },
+        RETRY_PAD_SECONDS
+      );
+      spliced = spliceGap(spliced, patch, lo, [from, to]);
+    }
+    if (spliced.tokens.length > decoded.tokens.length) decoded = spliced;
+    else if (gaps.length > 0) {
+      const retry = decodeWindow(recognizer, slice, RETRY_PAD_SECONDS);
+      if (retry.tokens.length > decoded.tokens.length) decoded = retry;
+    }
+    const window = { offset: cuts[k] / wave.sampleRate, ...decoded };
+    windows.push(window);
+    const through = cuts[k + 1] / wave.sampleRate;
+    process.stdout.write(`${SHERPA_WINDOW_PREFIX}${JSON.stringify({ window, through })}
+`);
+  }
+  process.stdout.write(`${SHERPA_RESULT_PREFIX}${JSON.stringify(windows)}
+`);
+} catch (err) {
+  const message = (err instanceof Error ? err.message : String(err)).replace(/\s+/g, " ").trim();
+  process.stderr.write(`${SHERPA_ERROR_PREFIX}${message}
+`, () => {
+    throw err;
+  });
+}