@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/lambda-D7UMN4DJ.js

@@ -0,0 +1,451 @@
+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 {
+  parseOutputResolutionFlag
+} from "./chunk-PDAMK4Q5.js";
+import {
+  readAllowedCompositionFpsFromDir
+} from "./chunk-YEIFI443.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import {
+  failCommand
+} 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 "./chunk-RQVDTPGD.js";
+import "./chunk-PMRBLBUP.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/lambda.ts
+var examples = [
+  ["Deploy the Lambda render stack to AWS", "hyperframes lambda deploy"],
+  [
+    "Render a composition on the deployed stack",
+    "hyperframes lambda render ./my-project --width 1920 --height 1080"
+  ],
+  [
+    "Render and stream progress until done",
+    "hyperframes lambda render ./my-project --width 1920 --height 1080 --wait"
+  ],
+  [
+    "Supersample a 1080p composition to 4K via Chrome deviceScaleFactor",
+    "hyperframes lambda render ./my-project --width 1920 --height 1080 --output-resolution 4k --wait"
+  ],
+  [
+    "Render with composition variables (personalised template)",
+    `hyperframes lambda render ./my-template --site-id abc1234deadbeef0 --width 1920 --height 1080 --variables '{"title":"Hello Alice","accent":"#ff0000"}'`
+  ],
+  [
+    "Render with variables from a JSON file",
+    "hyperframes lambda render ./my-template --site-id abc1234deadbeef0 --width 1920 --height 1080 --variables-file ./alice.json"
+  ],
+  [
+    "Batch-render N personalised videos from a JSONL file (deploys the site once)",
+    "hyperframes lambda render-batch ./my-template --batch ./users.jsonl --width 1920 --height 1080 --max-concurrent 10"
+  ],
+  ["Check progress for a started render", "hyperframes lambda progress hf-render-abcd1234"],
+  [
+    "Pre-upload a project so multiple renders share the upload",
+    "hyperframes lambda sites create ./my-project"
+  ],
+  ["Tear the stack down", "hyperframes lambda destroy"],
+  ["Print the IAM policy the CLI needs", "hyperframes lambda policies user"],
+  [
+    "Validate a checked-in IAM policy still covers the CLI",
+    "hyperframes lambda policies validate ./infra/iam/hyperframes.json"
+  ]
+];
+var HELP = `
+${c.bold("hyperframes lambda")} ${c.dim("<subcommand> [args]")}
+
+Deploy + drive distributed video renders on AWS Lambda.
+
+${c.bold("SUBCOMMANDS:")}
+  ${c.accent("deploy")}            ${c.dim("Provision the Lambda + Step Functions + S3 stack via SAM")}
+  ${c.accent("sites create")}      ${c.dim("Tar + upload a project to S3 (reusable across renders)")}
+  ${c.accent("render")}            ${c.dim("Start a distributed render (returns a renderId)")}
+  ${c.accent("render-batch")}      ${c.dim("Fan out N personalised renders from a JSONL batch file")}
+  ${c.accent("progress")}          ${c.dim("Print progress + cost for an in-flight or finished render")}
+  ${c.accent("destroy")}           ${c.dim("Tear the stack down (S3 bucket is retained)")}
+  ${c.accent("policies")}          ${c.dim("Print or validate the IAM permissions the CLI needs")}
+
+${c.bold("FIRST RUN:")}
+  ${c.accent("hyperframes lambda deploy")}
+  ${c.accent("hyperframes lambda render ./my-project --width 1920 --height 1080 --wait")}
+
+${c.bold("REQUIREMENTS:")}
+  \u2022 AWS CLI configured (env vars, ~/.aws/credentials, or SSO)
+  \u2022 AWS SAM CLI installed (https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html)
+  \u2022 bun on PATH (used to build the handler ZIP)
+`;
+var lambda_default = defineCommand({
+  meta: { name: "lambda", description: "Deploy and drive renders on AWS Lambda" },
+  args: {
+    subcommand: {
+      type: "positional",
+      required: false,
+      description: "deploy | sites | render | progress | destroy | policies"
+    },
+    target: {
+      type: "positional",
+      required: false,
+      description: "Subcommand-specific positional (project dir, render id, policies verb, etc.)"
+    },
+    extra: {
+      type: "positional",
+      required: false,
+      description: "Extra positional (e.g. `sites create <projectDir>` or `policies validate <policy.json>`)"
+    },
+    // Stack identity
+    "stack-name": {
+      type: "string",
+      description: "CloudFormation stack name (default: hyperframes-default)"
+    },
+    region: { type: "string", description: "AWS region (default: AWS_REGION env or us-east-1)" },
+    profile: { type: "string", description: "AWS profile name (default: AWS_PROFILE env)" },
+    // deploy
+    concurrency: { type: "string", description: "Lambda reserved concurrency (default: 8)" },
+    "chrome-source": {
+      type: "string",
+      description: "sparticuz | chrome-headless-shell (default: sparticuz)"
+    },
+    memory: { type: "string", description: "Lambda memory MB (default: 10240)" },
+    "skip-build": { type: "boolean", description: "Reuse existing handler.zip (deploy)" },
+    // sites / render
+    "site-id": { type: "string", description: "Explicit site id (overrides content hash)" },
+    width: { type: "string", description: "Render width in pixels" },
+    height: { type: "string", description: "Render height in pixels" },
+    "output-resolution": {
+      type: "string",
+      description: "Output resolution preset that engages Chrome deviceScaleFactor supersampling. Accepts canonical names (landscape, landscape-4k, portrait, portrait-4k, square, square-4k) and aliases (1080p, 4k, uhd, hd). When set, the composition's authored data-width/data-height is supersampled to the target preset without changing the layout."
+    },
+    fps: { type: "string", description: "Render fps (24 | 30 | 60)" },
+    format: { type: "string", description: "mp4 | mov | png-sequence | webm (default: mp4)" },
+    codec: { type: "string", description: "h264 | h265 (mp4 only)" },
+    quality: { type: "string", description: "draft | standard | high" },
+    "chunk-size": { type: "string", description: "Frames per chunk (default: 240)" },
+    "max-parallel-chunks": { type: "string", description: "Max concurrent chunks (default: 16)" },
+    "target-chunk-frames": {
+      type: "string",
+      description: "Cap per-chunk frames; auto-adds chunks (up to --max-parallel-chunks) to keep each under this. Ignored if --chunk-size is set."
+    },
+    "execution-name": {
+      type: "string",
+      description: "Step Functions execution name (default: hf-render-<uuid>)"
+    },
+    "output-key": {
+      type: "string",
+      description: "Final output S3 key (default: renders/<exec>/output.<ext>)"
+    },
+    // Variables — mirrors the local `hyperframes render` UX. Inline JSON or
+    // file path, plus --strict-variables for type-checked validation against
+    // the composition's `data-composition-variables` declaration.
+    variables: {
+      type: "string",
+      description: `JSON object of variable values for the composition. Example: --variables '{"title":"Hello"}'. Values flow into window.__hfVariables on the Lambda chunk workers.`
+    },
+    "variables-file": {
+      type: "string",
+      description: "Path to a JSON file with variable values (alternative to --variables). The file must contain a single JSON object."
+    },
+    "strict-variables": {
+      type: "boolean",
+      description: "Fail the render command if any --variables key is undeclared or has a wrong type vs the composition's data-composition-variables. Without this flag, mismatches are warnings.",
+      default: false
+    },
+    // render-batch
+    batch: {
+      type: "string",
+      description: 'Path to a JSONL batch file for `render-batch`. Each line: {"outputKey":"...","variables":{...}}'
+    },
+    "max-concurrent": {
+      type: "string",
+      description: "Max in-flight Step Functions executions for `render-batch` (default: 50). Distinct from --max-parallel-chunks (which caps chunks per render)."
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "For `render-batch`: parse the batch file and print the manifest without invoking AWS. Every entry's status becomes `would-invoke`.",
+      default: false
+    },
+    wait: { type: "boolean", description: "Block until the render finishes" },
+    "wait-interval-ms": {
+      type: "string",
+      description: "Poll cadence in ms when --wait is set (default: 5000)"
+    },
+    // shared
+    json: { type: "boolean", description: "Emit machine-readable JSON" }
+  },
+  async run({ args }) {
+    const subcommand = args.subcommand;
+    if (!subcommand) {
+      console.log(HELP);
+      return;
+    }
+    const stackName = args["stack-name"] ?? // Lazy-imported so the dispatcher doesn't pull state.ts (and its
+    // node:fs deps) on every CLI invocation — only on lambda runs.
+    (await import("./state-KAXGHF77.js")).DEFAULT_STACK_NAME;
+    const profileFlag = args.profile;
+    if (profileFlag) process.env.AWS_PROFILE = profileFlag;
+    const regionFlag = args.region;
+    if (regionFlag) process.env.AWS_REGION = regionFlag;
+    const verbsNeedingSDK = /* @__PURE__ */ new Set([
+      "deploy",
+      "sites",
+      "render",
+      "render-batch",
+      "progress",
+      "destroy"
+    ]);
+    if (verbsNeedingSDK.has(subcommand)) {
+      try {
+        await import("@hyperframes/aws-lambda/sdk");
+      } catch (err) {
+        if (err.code === "ERR_MODULE_NOT_FOUND") {
+          console.error(
+            `${c.error("@hyperframes/aws-lambda is not installed.")} The ${c.accent(`hyperframes lambda ${subcommand}`)} command needs it at runtime.
+Install it alongside the CLI:
+  ${c.accent("npm install -g @hyperframes/aws-lambda")}
+Or, for an opt-in dev setup:
+  ${c.accent("npm install @hyperframes/aws-lambda")}`
+          );
+          failCommand();
+        }
+        throw err;
+      }
+    }
+    switch (subcommand) {
+      case "deploy": {
+        const { runDeploy } = await import("./deploy-MX76RZ36.js");
+        await runDeploy({
+          stackName,
+          region: args.region,
+          awsProfile: args.profile,
+          reservedConcurrency: parsePositiveInt(args.concurrency, "--concurrency"),
+          chromeSource: parseChromeSource(args["chrome-source"]),
+          lambdaMemoryMb: parsePositiveInt(args.memory, "--memory"),
+          skipBuild: Boolean(args["skip-build"])
+        });
+        return;
+      }
+      case "sites": {
+        if (args.target !== "create") {
+          console.error(
+            `[lambda sites] unknown verb "${String(args.target)}". Only "create" is supported.`
+          );
+          failCommand();
+        }
+        const projectDir = args.extra;
+        if (!projectDir) {
+          console.error(
+            "[lambda sites create] usage: hyperframes lambda sites create <projectDir>"
+          );
+          failCommand();
+        }
+        const { runSitesCreate } = await import("./sites-TNVKZS73.js");
+        await runSitesCreate({
+          projectDir,
+          stackName,
+          siteId: args["site-id"],
+          json: Boolean(args.json)
+        });
+        return;
+      }
+      case "render": {
+        const projectDir = args.target;
+        if (!projectDir) {
+          console.error(
+            "[lambda render] usage: hyperframes lambda render <projectDir> --width <px> --height <px>"
+          );
+          failCommand();
+        }
+        const width = parsePositiveInt(args.width, "--width");
+        const height = parsePositiveInt(args.height, "--height");
+        if (width === void 0 || height === void 0) {
+          console.error("[lambda render] --width and --height are required.");
+          failCommand();
+        }
+        const fpsRaw = parseIntFlag(args.fps) ?? readAllowedCompositionFpsFromDir(projectDir, [24, 30, 60]) ?? 30;
+        if (fpsRaw !== 24 && fpsRaw !== 30 && fpsRaw !== 60) {
+          console.error(`[lambda render] --fps must be 24, 30, or 60; got ${fpsRaw}.`);
+          failCommand();
+        }
+        const { runRender } = await import("./render-AO5VX3YI.js");
+        const renderResolution = parseOutputResolution(args["output-resolution"]);
+        await runRender({
+          projectDir,
+          stackName,
+          siteId: args["site-id"],
+          fps: fpsRaw,
+          width,
+          height,
+          outputResolution: renderResolution.outputResolution,
+          outputResolutionAspectAgnostic: renderResolution.outputResolutionAspectAgnostic,
+          format: parseFormat(args.format),
+          codec: parseCodec(args.codec),
+          quality: parseQuality(args.quality),
+          chunkSize: parsePositiveInt(args["chunk-size"], "--chunk-size"),
+          maxParallelChunks: parsePositiveInt(args["max-parallel-chunks"], "--max-parallel-chunks"),
+          targetChunkFrames: parsePositiveInt(args["target-chunk-frames"], "--target-chunk-frames"),
+          executionName: args["execution-name"],
+          outputKey: args["output-key"],
+          variables: args.variables,
+          variablesFile: args["variables-file"],
+          strictVariables: Boolean(args["strict-variables"]),
+          json: Boolean(args.json),
+          wait: Boolean(args.wait),
+          waitIntervalMs: parsePositiveInt(args["wait-interval-ms"], "--wait-interval-ms") ?? 5e3
+        });
+        return;
+      }
+      case "render-batch": {
+        const projectDir = args.target;
+        if (!projectDir) {
+          console.error(
+            "[lambda render-batch] usage: hyperframes lambda render-batch <projectDir> --batch <path.jsonl> --width <px> --height <px>"
+          );
+          failCommand();
+        }
+        const batch = args.batch;
+        if (!batch) {
+          console.error(
+            "[lambda render-batch] --batch <path.jsonl> is required. Each line is a JSON object with at least { outputKey: '...' }."
+          );
+          failCommand();
+        }
+        const width = parsePositiveInt(args.width, "--width");
+        const height = parsePositiveInt(args.height, "--height");
+        if (width === void 0 || height === void 0) {
+          console.error("[lambda render-batch] --width and --height are required.");
+          failCommand();
+        }
+        const fpsRaw = parseIntFlag(args.fps) ?? readAllowedCompositionFpsFromDir(projectDir, [24, 30, 60]) ?? 30;
+        if (fpsRaw !== 24 && fpsRaw !== 30 && fpsRaw !== 60) {
+          console.error(`[lambda render-batch] --fps must be 24, 30, or 60; got ${fpsRaw}.`);
+          failCommand();
+        }
+        const { runRenderBatch } = await import("./render-batch-YH7CTWNY.js");
+        const batchResolution = parseOutputResolution(args["output-resolution"]);
+        await runRenderBatch({
+          projectDir,
+          stackName,
+          batch,
+          siteId: args["site-id"],
+          fps: fpsRaw,
+          width,
+          height,
+          outputResolution: batchResolution.outputResolution,
+          outputResolutionAspectAgnostic: batchResolution.outputResolutionAspectAgnostic,
+          format: parseFormat(args.format),
+          codec: parseCodec(args.codec),
+          quality: parseQuality(args.quality),
+          chunkSize: parsePositiveInt(args["chunk-size"], "--chunk-size"),
+          maxParallelChunks: parsePositiveInt(args["max-parallel-chunks"], "--max-parallel-chunks"),
+          targetChunkFrames: parsePositiveInt(args["target-chunk-frames"], "--target-chunk-frames"),
+          maxConcurrent: parsePositiveInt(args["max-concurrent"], "--max-concurrent"),
+          strictVariables: Boolean(args["strict-variables"]),
+          dryRun: Boolean(args["dry-run"]),
+          json: Boolean(args.json)
+        });
+        return;
+      }
+      case "progress": {
+        const target = args.target;
+        if (!target) {
+          console.error(
+            "[lambda progress] usage: hyperframes lambda progress <renderId | executionArn>"
+          );
+          failCommand();
+        }
+        const { runProgress } = await import("./progress-FBIEEB7Y.js");
+        await runProgress({ target, stackName, json: Boolean(args.json) });
+        return;
+      }
+      case "destroy": {
+        const { runDestroy } = await import("./destroy-H2TZBYHH.js");
+        await runDestroy({ stackName, awsProfile: args.profile });
+        return;
+      }
+      case "policies": {
+        const verb = args.target;
+        if (verb !== "role" && verb !== "user" && verb !== "validate") {
+          console.error(
+            `[lambda policies] usage: hyperframes lambda policies <role|user|validate> [args]`
+          );
+          failCommand();
+        }
+        const { runPolicies } = await import("./policies-FSDZVS2E.js");
+        await runPolicies({
+          verb,
+          inputPath: args.extra,
+          json: Boolean(args.json)
+        });
+        return;
+      }
+      default:
+        console.error(`${c.error("Unknown subcommand:")} ${subcommand}
+${HELP}`);
+        failCommand();
+    }
+  }
+});
+function parseIntFlag(raw) {
+  if (raw === void 0 || raw === null || raw === "") return void 0;
+  const n = Number.parseInt(String(raw), 10);
+  return Number.isFinite(n) ? n : void 0;
+}
+function parsePositiveInt(raw, flagName) {
+  const n = parseIntFlag(raw);
+  if (n === void 0) return void 0;
+  if (!Number.isInteger(n) || n < 1) {
+    throw new Error(`[lambda] ${flagName} must be a positive integer; got ${n}`);
+  }
+  return n;
+}
+function parseEnum(raw, allowed, errorPrefix, defaultValue) {
+  if (raw === void 0 || raw === null || raw === "") return defaultValue;
+  const s = String(raw);
+  if (allowed.includes(s)) return s;
+  throw new Error(`${errorPrefix} must be ${allowed.join("|")}; got ${s}`);
+}
+var FORMATS = [
+  "mp4",
+  "mov",
+  "png-sequence",
+  "webm"
+];
+var CODECS = ["h264", "h265"];
+var QUALITIES = ["draft", "standard", "high"];
+var CHROME_SOURCES = ["sparticuz", "chrome-headless-shell"];
+var parseFormat = (raw) => parseEnum(raw, FORMATS, "[lambda render] --format", "mp4");
+var parseCodec = (raw) => parseEnum(raw, CODECS, "[lambda render] --codec", void 0);
+var parseQuality = (raw) => parseEnum(raw, QUALITIES, "[lambda render] --quality", void 0);
+var parseChromeSource = (raw) => parseEnum(raw, CHROME_SOURCES, "[lambda deploy] --chrome-source", "sparticuz");
+function parseOutputResolution(raw) {
+  return parseOutputResolutionFlag(raw, {
+    surfaceLabel: "[lambda render]",
+    // The Lambda `--output-resolution` help text advertises the full alias
+    // list (tier-only + orientation-suffixed) — keep the error message
+    // faithful to that surface's docs.
+    aliasHint: "1080p, 4k, uhd, hd, 1080p-portrait, portrait-1080p, 4k-portrait, 1080p-square, square-1080p, 4k-square"
+  });
+}
+export {
+  lambda_default as default,
+  examples
+};

package/vendor/hyperframes/dist/layout-XSPPDHOO.js

@@ -0,0 +1,86 @@
+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 {
+  createInspectCommand,
+  examples,
+  layout_default,
+  loadBrowserScript,
+  parseAt
+} from "./chunk-2EGFTPWD.js";
+import "./chunk-KBJUXVOJ.js";
+import "./chunk-XUHOIDKG.js";
+import "./chunk-UEZXMWG3.js";
+import "./chunk-X7MTZ4T2.js";
+import "./chunk-YQZNILVH.js";
+import "./chunk-5Z63TBTX.js";
+import "./chunk-7HG4BFIN.js";
+import "./chunk-HRUGC23L.js";
+import "./chunk-YEIFI443.js";
+import "./chunk-S7NPLFWV.js";
+import "./chunk-RMHUQGRK.js";
+import "./chunk-EOVYQ3IG.js";
+import "./chunk-QC4FJVLM.js";
+import "./chunk-TCLGPL65.js";
+import "./chunk-S3D6GE5W.js";
+import "./chunk-IHFUKJOR.js";
+import "./chunk-XS4EJSKU.js";
+import "./chunk-PFCFR3KZ.js";
+import "./chunk-CFKU7HTK.js";
+import "./chunk-XT7X6QCP.js";
+import "./chunk-4YYJOFKS.js";
+import "./chunk-HVW7ABXD.js";
+import "./chunk-LYNI3FOL.js";
+import "./chunk-CWPVM2QV.js";
+import "./chunk-A2Z4Z4VL.js";
+import "./chunk-AWDFDFI3.js";
+import "./chunk-P6LJ4Y32.js";
+import "./chunk-GMECXFAN.js";
+import "./chunk-4NWOGZZS.js";
+import "./chunk-JTHMTOMQ.js";
+import "./chunk-EISRN4E6.js";
+import "./chunk-VWG7OQKU.js";
+import "./chunk-ZTZA4UWZ.js";
+import "./chunk-IUZFXWSV.js";
+import "./chunk-AMKC3AXA.js";
+import "./chunk-S3S4TGEH.js";
+import "./chunk-54HJ63Q2.js";
+import "./chunk-PBN6GBJE.js";
+import "./chunk-KC5XXX3X.js";
+import "./chunk-TJSTGSAW.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-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";
+export {
+  createInspectCommand,
+  layout_default as default,
+  examples,
+  loadBrowserScript,
+  parseAt
+};

package/vendor/hyperframes/dist/lib-TPG2ZMAX.js

@@ -0,0 +1,128 @@
+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 {
+  __commonJS
+} from "./chunk-M2WBOQ2Q.js";
+
+// ../../node_modules/.bun/bpm-detective@2.0.5/node_modules/bpm-detective/lib/detect.js
+var require_detect = __commonJS({
+  "../../node_modules/.bun/bpm-detective@2.0.5/node_modules/bpm-detective/lib/detect.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = detect;
+    var OfflineContext = window.OfflineAudioContext || window.webkitOfflineAudioContext;
+    function detect(buffer) {
+      var source = getLowPassSource(buffer);
+      source.start(0);
+      return [findPeaks, identifyIntervals, groupByTempo(buffer.sampleRate), getTopCandidate].reduce(function(state, fn) {
+        return fn(state);
+      }, source.buffer.getChannelData(0));
+    }
+    function getTopCandidate(candidates) {
+      return candidates.sort(function(a, b) {
+        return b.count - a.count;
+      }).splice(0, 5)[0].tempo;
+    }
+    function getLowPassSource(buffer) {
+      var length = buffer.length, numberOfChannels = buffer.numberOfChannels, sampleRate = buffer.sampleRate;
+      var context = new OfflineContext(numberOfChannels, length, sampleRate);
+      var source = context.createBufferSource();
+      source.buffer = buffer;
+      var filter = context.createBiquadFilter();
+      filter.type = "lowpass";
+      source.connect(filter);
+      filter.connect(context.destination);
+      return source;
+    }
+    function findPeaks(data) {
+      var peaks = [];
+      var threshold = 0.9;
+      var minThresold = 0.3;
+      var minPeaks = 15;
+      while (peaks.length < minPeaks && threshold >= minThresold) {
+        peaks = findPeaksAtThreshold(data, threshold);
+        threshold -= 0.05;
+      }
+      if (peaks.length < minPeaks) {
+        throw new Error("Could not find enough samples for a reliable detection.");
+      }
+      return peaks;
+    }
+    function findPeaksAtThreshold(data, threshold) {
+      var peaks = [];
+      for (var i = 0, l = data.length; i < l; i += 1) {
+        if (data[i] > threshold) {
+          peaks.push(i);
+          i += 1e4;
+        }
+      }
+      return peaks;
+    }
+    function identifyIntervals(peaks) {
+      var intervals = [];
+      peaks.forEach(function(peak, index) {
+        var _loop = function _loop2(i2) {
+          var interval = peaks[index + i2] - peak;
+          var foundInterval = intervals.some(function(intervalCount) {
+            if (intervalCount.interval === interval) {
+              return intervalCount.count += 1;
+            }
+          });
+          if (!foundInterval) {
+            intervals.push({
+              interval,
+              count: 1
+            });
+          }
+        };
+        for (var i = 0; i < 10; i += 1) {
+          _loop(i);
+        }
+      });
+      return intervals;
+    }
+    function groupByTempo(sampleRate) {
+      return function(intervalCounts) {
+        var tempoCounts = [];
+        intervalCounts.forEach(function(intervalCount) {
+          if (intervalCount.interval !== 0) {
+            var theoreticalTempo = 60 / (intervalCount.interval / sampleRate);
+            while (theoreticalTempo < 90) {
+              theoreticalTempo *= 2;
+            }
+            while (theoreticalTempo > 180) {
+              theoreticalTempo /= 2;
+            }
+            theoreticalTempo = Math.round(theoreticalTempo);
+            var foundTempo = tempoCounts.some(function(tempoCount) {
+              if (tempoCount.tempo === theoreticalTempo) {
+                return tempoCount.count += intervalCount.count;
+              }
+            });
+            if (!foundTempo) {
+              tempoCounts.push({
+                tempo: theoreticalTempo,
+                count: intervalCount.count
+              });
+            }
+          }
+        });
+        return tempoCounts;
+      };
+    }
+  }
+});
+
+// ../../node_modules/.bun/bpm-detective@2.0.5/node_modules/bpm-detective/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/.bun/bpm-detective@2.0.5/node_modules/bpm-detective/lib/index.js"(exports, module) {
+    module.exports = require_detect().default;
+  }
+});
+export default require_lib();