@bendyline/squisq 2.11.7 → 2.11.8

package/dist/mediaEdit/index.js

@@ -0,0 +1,990 @@
+import {
+  createBiquadCascade,
+  highpassCoeffs,
+  lowpassCoeffs
+} from "../chunk-NEWNNLWN.js";
+import {
+  createMediaTimeMap
+} from "../chunk-JSGIWW35.js";
+import {
+  MEDIA_EDIT_PARAMS,
+  MEDIA_FX_ORDER,
+  MEDIA_FX_SPECS,
+  formatMediaNumber,
+  hasRenderableFx,
+  mediaEditHtmlAttribute,
+  mediaEditValuesFromAttributes,
+  mediaEditValuesFromParams,
+  mediaRenderKey,
+  normalizeMediaCrop,
+  normalizeMediaCuts,
+  parseMediaCrop,
+  parseMediaCuts,
+  parseMediaEdits,
+  parseMediaFx,
+  serializeMediaCrop,
+  serializeMediaCuts,
+  serializeMediaEdits,
+  serializeMediaFx
+} from "../chunk-L7QZORLB.js";
+
+// src/mediaEdit/renderStore.ts
+var MEDIA_RENDER_DIR = ".mediaEdits";
+var MEDIA_RENDER_MANIFEST_VERSION = 1;
+var MEDIA_RENDER_GC_AGE_DAYS = 7;
+var RENDER_EXTENSIONS = /* @__PURE__ */ new Set(["webm", "wav", "ogg", "m4a"]);
+function mediaRenderStem(src) {
+  const base = src.split(/[?#]/, 1)[0].split("/").pop() ?? "media";
+  const stem = base.replace(/\.[^.]+$/, "").replace(/[^A-Za-z0-9_-]+/g, "_");
+  return stem.slice(0, 80) || "media";
+}
+function mediaRenderFilePath(src, key, extension) {
+  return `${MEDIA_RENDER_DIR}/${mediaRenderStem(src)}.${key}.${extension}`;
+}
+function mediaRenderManifestPath(src, key) {
+  return `${MEDIA_RENDER_DIR}/${mediaRenderStem(src)}.${key}.json`;
+}
+function parseMediaRenderPath(path) {
+  const segments = path.split("/");
+  const dirIndex = segments.length - 2;
+  if (dirIndex < 0 || segments[dirIndex] !== MEDIA_RENDER_DIR) return null;
+  const match = segments[segments.length - 1].match(/^(.+)\.([0-9a-f]{12})\.([a-z0-9]+)$/);
+  if (!match) return null;
+  const extension = match[3];
+  const isManifest = extension === "json";
+  if (!isManifest && !RENDER_EXTENSIONS.has(extension)) return null;
+  return { stem: match[1], key: match[2], extension, isManifest };
+}
+function isMediaRenderPath(path) {
+  return parseMediaRenderPath(path) != null;
+}
+function buildMediaRenderIndex(entries) {
+  const manifests = /* @__PURE__ */ new Map();
+  const renders = [];
+  for (const entry of entries) {
+    const parsed = parseMediaRenderPath(entry.name);
+    if (!parsed) continue;
+    if (parsed.isManifest) manifests.set(parsed.key, entry.name);
+    else renders.push({ key: parsed.key, path: entry.name, size: entry.size });
+  }
+  const index = /* @__PURE__ */ new Map();
+  for (const render of renders) {
+    index.set(render.key, { ...render, manifestPath: manifests.get(render.key) ?? null });
+  }
+  return index;
+}
+function parseMediaRenderManifest(text) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!raw || typeof raw !== "object") return null;
+  const m = raw;
+  const str = (v) => typeof v === "string";
+  const numOrNull = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+  if (m.version !== MEDIA_RENDER_MANIFEST_VERSION) return null;
+  if (!str(m.src) || !str(m.key) || !str(m.fx) || !str(m.file) || !str(m.mimeType)) return null;
+  if (!str(m.engine) || !str(m.createdAt)) return null;
+  const ignoredOps2 = Array.isArray(m.ignoredOps) ? m.ignoredOps.filter(str) : [];
+  const manifest = {
+    version: MEDIA_RENDER_MANIFEST_VERSION,
+    src: m.src,
+    key: m.key,
+    fx: m.fx,
+    ignoredOps: ignoredOps2,
+    file: m.file,
+    mimeType: m.mimeType,
+    sourceSize: numOrNull(m.sourceSize),
+    sourceDuration: numOrNull(m.sourceDuration),
+    engine: m.engine,
+    createdAt: m.createdAt
+  };
+  if (m.analysis && typeof m.analysis === "object") {
+    const a = m.analysis;
+    const analysis = {};
+    const lufs = numOrNull(a.integratedLufs);
+    const gain = numOrNull(a.appliedGainDb);
+    const breaths = numOrNull(a.breathCount);
+    if (lufs != null) analysis.integratedLufs = lufs;
+    if (gain != null) analysis.appliedGainDb = gain;
+    if (breaths != null) analysis.breathCount = breaths;
+    manifest.analysis = analysis;
+  }
+  return manifest;
+}
+function serializeMediaRenderManifest(manifest) {
+  return `${JSON.stringify(manifest, null, 2)}
+`;
+}
+function mediaRenderStaleness(manifest, current) {
+  if (current.sourceSize != null && manifest.sourceSize != null && current.sourceSize !== manifest.sourceSize) {
+    return "source-changed";
+  }
+  const known = new Set(current.knownOps ?? MEDIA_FX_ORDER);
+  const nowKnown = manifest.ignoredOps.some(
+    (token) => known.has(token.split(":", 1)[0].toLowerCase())
+  );
+  return nowKnown ? "engine-upgraded" : null;
+}
+function flattenBlocks(blocks, out = []) {
+  for (const block of blocks) {
+    out.push(block);
+    if (block.children && block.children.length > 0) flattenBlocks(block.children, out);
+  }
+  return out;
+}
+function collectDocMediaClips(doc) {
+  const clips = [];
+  for (const block of flattenBlocks(doc.blocks)) clips.push(...block.media ?? []);
+  clips.push(...doc.documentMedia ?? []);
+  return clips;
+}
+function mediaClipRenderKey(clip) {
+  const fx = clip.edits?.fx;
+  return hasRenderableFx(fx) ? mediaRenderKey(clip.src, fx) : null;
+}
+function referencedMediaRenderKeys(doc) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const clip of collectDocMediaClips(doc)) {
+    const key = mediaClipRenderKey(clip);
+    if (key) keys.add(key);
+  }
+  return keys;
+}
+function mediaRenderKeyFor(src, fx) {
+  const chain = parseMediaFx(fx) ?? void 0;
+  return hasRenderableFx(chain) ? mediaRenderKey(src, chain) : null;
+}
+function selectMediaRendersForGc(index, referencedKeys, manifests, now = /* @__PURE__ */ new Date(), olderThanDays = MEDIA_RENDER_GC_AGE_DAYS) {
+  const cutoff = now.getTime() - olderThanDays * 24 * 60 * 60 * 1e3;
+  const paths = [];
+  for (const [key, entry] of index) {
+    if (referencedKeys.has(key)) continue;
+    const manifest = manifests.get(key);
+    if (manifest) {
+      const created = Date.parse(manifest.createdAt);
+      if (Number.isFinite(created) && created > cutoff) continue;
+    }
+    paths.push(entry.path);
+    if (entry.manifestPath) paths.push(entry.manifestPath);
+  }
+  return paths;
+}
+
+// src/mediaEdit/dsp/breath.ts
+var HOP_SEC = 0.01;
+var FRAME_SEC = 0.02;
+var PITCH_WINDOW_SEC = 0.04;
+var PITCH_MIN_HZ = 70;
+var PITCH_MAX_HZ = 400;
+var DECIMATED_RATE = 6e3;
+var SILENT_DB = -120;
+function createBreathAnalyzer(sampleRate) {
+  const hop = Math.round(HOP_SEC * sampleRate);
+  const frameLen = Math.round(FRAME_SEC * sampleRate);
+  const decimation = Math.max(1, Math.round(sampleRate / DECIMATED_RATE));
+  const lowRate = sampleRate / decimation;
+  const pitchLen = Math.round(PITCH_WINDOW_SEC * lowRate);
+  const minLag = Math.max(1, Math.floor(lowRate / PITCH_MAX_HZ));
+  const maxLag = Math.min(pitchLen - 1, Math.ceil(lowRate / PITCH_MIN_HZ));
+  const levelBand = createBiquadCascade([highpassCoeffs(sampleRate, 60)]);
+  const pitchBand = createBiquadCascade([
+    highpassCoeffs(sampleRate, 60),
+    lowpassCoeffs(sampleRate, 900),
+    lowpassCoeffs(sampleRate, 900)
+  ]);
+  const keepFull = frameLen + hop;
+  let full = new Float32Array(0);
+  let fullStart = 0;
+  let low = [];
+  let lowStart = 0;
+  let decimPhase = 0;
+  let nextFrameStart = 0;
+  const out = [];
+  const window = new Float64Array(pitchLen);
+  const voicingAt = (centerLow) => {
+    const begin = Math.round(centerLow - pitchLen / 2) - lowStart;
+    if (begin < 0 || begin + pitchLen > low.length) return 0;
+    let mean = 0;
+    for (let i = 0; i < pitchLen; i++) mean += low[begin + i];
+    mean /= pitchLen;
+    for (let i = 0; i < pitchLen; i++) window[i] = low[begin + i] - mean;
+    let energy = 0;
+    for (let i = 0; i < pitchLen; i++) energy += window[i] * window[i];
+    if (energy <= 1e-12) return 0;
+    let best = 0;
+    for (let lag = minLag; lag <= maxLag; lag++) {
+      let acc = 0;
+      let e1 = 0;
+      let e2 = 0;
+      for (let i = 0; i + lag < pitchLen; i++) {
+        const a = window[i];
+        const b = window[i + lag];
+        acc += a * b;
+        e1 += a * a;
+        e2 += b * b;
+      }
+      const norm = Math.sqrt(e1 * e2);
+      if (norm > 0 && acc / norm > best) best = acc / norm;
+    }
+    return best;
+  };
+  return {
+    push(mono) {
+      const filtered = mono.slice();
+      pitchBand.process(filtered);
+      for (let i = 0; i < filtered.length; i++) {
+        if (decimPhase === 0) low.push(filtered[i]);
+        decimPhase = (decimPhase + 1) % decimation;
+      }
+      const leveled = mono.slice();
+      levelBand.process(leveled);
+      const merged = new Float32Array(full.length + leveled.length);
+      merged.set(full, 0);
+      merged.set(leveled, full.length);
+      full = merged;
+      const lowEnd = lowStart + low.length;
+      while (nextFrameStart + frameLen <= fullStart + full.length) {
+        const centerFull = nextFrameStart + frameLen / 2;
+        const centerLow = centerFull / decimation;
+        if (centerLow + pitchLen / 2 > lowEnd) break;
+        const s = nextFrameStart - fullStart;
+        let sumSq = 0;
+        let crossings = 0;
+        for (let i = 0; i < frameLen; i++) {
+          const v = full[s + i];
+          sumSq += v * v;
+          if (i > 0 && v >= 0 !== full[s + i - 1] >= 0) crossings++;
+        }
+        const rms = Math.sqrt(sumSq / frameLen);
+        out.push({
+          t: centerFull / sampleRate,
+          rmsDb: rms > 0 ? 20 * Math.log10(rms) : SILENT_DB,
+          voicing: voicingAt(centerLow),
+          zcr: crossings / (frameLen - 1)
+        });
+        nextFrameStart += hop;
+      }
+      const dropFull = Math.max(0, nextFrameStart - fullStart - keepFull);
+      if (dropFull > 0) {
+        full = full.slice(dropFull);
+        fullStart += dropFull;
+      }
+      const neededLow = Math.floor(nextFrameStart / decimation - pitchLen) - lowStart;
+      if (neededLow > 0) {
+        low = low.slice(neededLow);
+        lowStart += neededLow;
+      }
+    },
+    frames: () => out
+  };
+}
+function percentile(values, p) {
+  if (values.length === 0) return SILENT_DB;
+  const sorted = [...values].sort((a, b) => a - b);
+  return sorted[Math.min(sorted.length - 1, Math.max(0, Math.floor(p * (sorted.length - 1))))];
+}
+function detectBreaths(frames, options = {}) {
+  if (frames.length === 0) return [];
+  const sensitivity = Math.min(1, Math.max(0, options.sensitivity ?? 0.5));
+  const minDur = options.minDurationSec ?? 0.12;
+  const maxDur = options.maxDurationSec ?? 1;
+  const voicedThreshold = 0.6;
+  const levels = frames.map((f) => f.rmsDb);
+  const floor = percentile(levels, 0.1);
+  const voicedLevels = frames.filter((f) => f.voicing >= voicedThreshold).map((f) => f.rmsDb);
+  const speech = percentile(voicedLevels.length > 0 ? voicedLevels : levels, 0.9);
+  if (speech - floor < 12) return [];
+  const aboveFloor = 6 - 3 * sensitivity;
+  const belowSpeech = 10 - 6 * sensitivity;
+  const maxVoicing = 0.35 + 0.15 * sensitivity;
+  const maxZcr = 0.2 + 0.05 * sensitivity;
+  const isCandidate = (f) => f.voicing < maxVoicing && f.rmsDb > floor + aboveFloor && f.rmsDb < speech - belowSpeech && f.zcr < maxZcr;
+  const isVoiced = (f) => f.voicing >= voicedThreshold && f.rmsDb > floor + 10;
+  const runs = [];
+  let current = null;
+  for (let i = 0; i < frames.length; i++) {
+    if (isCandidate(frames[i])) {
+      if (current && i - current.last <= 2) current.last = i;
+      else {
+        current = { first: i, last: i };
+        runs.push(current);
+      }
+    }
+  }
+  const contextFrames = Math.round(0.06 / HOP_SEC);
+  const voicedNear = (from, to) => {
+    for (let i = Math.max(0, from); i <= Math.min(frames.length - 1, to); i++) {
+      if (isVoiced(frames[i])) return true;
+    }
+    return false;
+  };
+  const regions = [];
+  for (const run of runs) {
+    const start = frames[run.first].t - HOP_SEC / 2;
+    const end = frames[run.last].t + HOP_SEC / 2;
+    const duration = end - start;
+    if (duration < minDur || duration > maxDur) continue;
+    const voicedBefore = voicedNear(run.first - contextFrames, run.first - 1);
+    const voicedAfter = voicedNear(run.last + 1, run.last + contextFrames);
+    if (voicedBefore && voicedAfter && duration < 0.25) continue;
+    regions.push({ start, end });
+  }
+  return regions;
+}
+function breathGainAt(regions, reductionDb, t, rampSec = 0.015) {
+  const floorGain = Math.pow(10, Math.min(0, reductionDb) / 20);
+  for (const r of regions) {
+    if (t < r.start || t >= r.end) continue;
+    const ramp = Math.min(rampSec, (r.end - r.start) / 2);
+    const edge = Math.min(t - r.start, r.end - t);
+    const depth = ramp > 0 ? Math.min(1, edge / ramp) : 1;
+    return 1 - (1 - floorGain) * depth;
+  }
+  return 1;
+}
+function applyBreathEnvelope(channels, sampleRate, startSec, regions, reductionDb) {
+  const length = channels[0]?.length ?? 0;
+  if (length === 0 || regions.length === 0) return;
+  const endSec = startSec + length / sampleRate;
+  const touching = regions.filter((r) => r.end > startSec && r.start < endSec);
+  if (touching.length === 0) return;
+  for (let i = 0; i < length; i++) {
+    const g = breathGainAt(touching, reductionDb, startSec + i / sampleRate);
+    if (g === 1) continue;
+    for (const ch of channels) ch[i] *= g;
+  }
+}
+
+// src/mediaEdit/dsp/denoiser.ts
+var SampleFifo = class {
+  constructor(capacity) {
+    this.start = 0;
+    this.end = 0;
+    this.buffer = new Float32Array(Math.max(16, capacity));
+  }
+  get length() {
+    return this.end - this.start;
+  }
+  push(samples) {
+    if (this.end + samples.length > this.buffer.length) {
+      const live = this.buffer.subarray(this.start, this.end);
+      const next = live.length + samples.length > this.buffer.length ? new Float32Array((live.length + samples.length) * 2) : this.buffer;
+      next.set(live, 0);
+      this.buffer = next;
+      this.end = live.length;
+      this.start = 0;
+    }
+    this.buffer.set(samples, this.end);
+    this.end += samples.length;
+  }
+  pushZeros(count) {
+    this.push(new Float32Array(count));
+  }
+  shift(count) {
+    const out = this.buffer.slice(this.start, this.start + count);
+    this.start += count;
+    return out;
+  }
+};
+function createDenoiseStage(denoiser, strength) {
+  const frameSize = denoiser.frameSize;
+  const latency = frameSize + denoiser.latency;
+  const wet = Math.min(1, Math.max(0, strength));
+  const input = new SampleFifo(frameSize * 4);
+  const output = new SampleFifo(frameSize * 4);
+  const dry = new SampleFifo(frameSize * 4);
+  output.pushZeros(frameSize);
+  dry.pushZeros(latency);
+  const frame = new Float32Array(frameSize);
+  return {
+    latency,
+    process(block) {
+      input.push(block);
+      dry.push(block);
+      while (input.length >= frameSize) {
+        frame.set(input.shift(frameSize));
+        denoiser.processFrame(frame);
+        output.push(frame);
+      }
+      const out = output.shift(block.length);
+      const delayedDry = dry.shift(block.length);
+      if (wet < 1) {
+        for (let i = 0; i < out.length; i++) out[i] = wet * out[i] + (1 - wet) * delayedDry[i];
+      }
+      return out;
+    },
+    dispose: () => denoiser.dispose()
+  };
+}
+
+// src/mediaEdit/dsp/limiter.ts
+var OVERSAMPLE = 4;
+var TAPS_PER_PHASE = 8;
+function interpolationKernels() {
+  const kernels = [];
+  const half = TAPS_PER_PHASE / 2;
+  for (let phase = 1; phase < OVERSAMPLE; phase++) {
+    const frac = phase / OVERSAMPLE;
+    const k = new Float32Array(TAPS_PER_PHASE);
+    let sum = 0;
+    for (let t = 0; t < TAPS_PER_PHASE; t++) {
+      const x = t - (half - 1) - frac;
+      const sinc = x === 0 ? 1 : Math.sin(Math.PI * x) / (Math.PI * x);
+      const w = 0.5 * (1 + Math.cos(Math.PI * x / half));
+      k[t] = sinc * w;
+      sum += k[t];
+    }
+    for (let t = 0; t < TAPS_PER_PHASE; t++) k[t] /= sum;
+    kernels.push(k);
+  }
+  return kernels;
+}
+function createLimiter(options) {
+  const channelCount = options.channels;
+  const ceiling = Math.pow(10, (options.ceilingDb ?? -1) / 20);
+  const lookahead = Math.max(
+    1,
+    Math.round((options.lookaheadMs ?? 5) / 1e3 * options.sampleRate)
+  );
+  const releaseCoeff = Math.exp(-1 / ((options.releaseMs ?? 80) / 1e3 * options.sampleRate));
+  const kernels = interpolationKernels();
+  const half = TAPS_PER_PHASE / 2;
+  const history = Array.from({ length: channelCount }, () => new Float32Array(TAPS_PER_PHASE));
+  const delaySize = lookahead + half;
+  const delay = Array.from({ length: channelCount }, () => new Float32Array(delaySize));
+  const required = new Float64Array(lookahead);
+  const dequeIdx = new Int32Array(lookahead + 1);
+  let dqHead = 0;
+  let dqTail = 0;
+  const minRing = new Float64Array(lookahead).fill(1);
+  let minSum = lookahead;
+  let n = 0;
+  let gain = 1;
+  let smallest = 1;
+  const truePeak = (sample, c) => {
+    const h = history[c];
+    h.copyWithin(0, 1);
+    h[TAPS_PER_PHASE - 1] = sample;
+    let peak = Math.max(Math.abs(h[half - 1]), Math.abs(h[half]));
+    for (const k of kernels) {
+      let v = 0;
+      for (let t = 0; t < TAPS_PER_PHASE; t++) v += k[t] * h[t];
+      peak = Math.max(peak, Math.abs(v));
+    }
+    return peak;
+  };
+  const step = (input, out, i) => {
+    let peak = 0;
+    for (let c = 0; c < channelCount; c++) peak = Math.max(peak, truePeak(input[c], c));
+    const r = peak > ceiling ? ceiling / peak : 1;
+    const slot = n % lookahead;
+    const cap = lookahead + 1;
+    while (dqTail > dqHead && dequeIdx[dqHead % cap] <= n - lookahead) dqHead++;
+    required[slot] = r;
+    while (dqTail > dqHead && required[dequeIdx[(dqTail - 1) % cap] % lookahead] >= r) dqTail--;
+    dequeIdx[dqTail % cap] = n;
+    dqTail++;
+    const windowMin = required[dequeIdx[dqHead % cap] % lookahead];
+    minSum += windowMin - minRing[slot];
+    minRing[slot] = windowMin;
+    const smoothed = Math.min(1, minSum / lookahead);
+    gain = smoothed < gain ? smoothed : smoothed + (gain - smoothed) * releaseCoeff;
+    if (gain < smallest) smallest = gain;
+    const writeSlot = n % delaySize;
+    const readSlot = (n + 1) % delaySize;
+    for (let c = 0; c < channelCount; c++) {
+      const d = delay[c];
+      d[writeSlot] = input[c];
+      out[c][i] = d[readSlot] * gain;
+    }
+    n++;
+  };
+  const run = (channels, length) => {
+    const out = Array.from({ length: channelCount }, () => new Float32Array(length));
+    const frame = new Array(channelCount).fill(0);
+    for (let i = 0; i < length; i++) {
+      for (let c = 0; c < channelCount; c++) frame[c] = channels[c]?.[i] ?? 0;
+      step(frame, out, i);
+    }
+    return out;
+  };
+  return {
+    latency: lookahead - 1 + half,
+    process: (channels) => run(channels, channels[0]?.length ?? 0),
+    flush: () => run([], lookahead - 1 + half),
+    minGain: () => smallest
+  };
+}
+
+// src/mediaEdit/dsp/loudness.ts
+var ABSOLUTE_GATE = -70;
+var RELATIVE_GATE = -10;
+var STEPS_PER_BLOCK = 4;
+function kWeightingCoeffs(sampleRate) {
+  let f0 = 1681.974450955533;
+  let q = 0.7071752369554196;
+  let k = Math.tan(Math.PI * f0 / sampleRate);
+  const vh = Math.pow(10, 3.999843853973347 / 20);
+  const vb = Math.pow(vh, 0.4996667741545416);
+  let a0 = 1 + k / q + k * k;
+  const shelf = {
+    b0: (vh + vb * k / q + k * k) / a0,
+    b1: 2 * (k * k - vh) / a0,
+    b2: (vh - vb * k / q + k * k) / a0,
+    a1: 2 * (k * k - 1) / a0,
+    a2: (1 - k / q + k * k) / a0
+  };
+  f0 = 38.13547087602444;
+  q = 0.5003270373238773;
+  k = Math.tan(Math.PI * f0 / sampleRate);
+  a0 = 1 + k / q + k * k;
+  const rlb = {
+    b0: 1,
+    b1: -2,
+    b2: 1,
+    a1: 2 * (k * k - 1) / a0,
+    a2: (1 - k / q + k * k) / a0
+  };
+  return [shelf, rlb];
+}
+function kWeighting(sampleRate) {
+  return createBiquadCascade(kWeightingCoeffs(sampleRate));
+}
+function blockLoudness(meanSquareSum) {
+  return meanSquareSum > 0 ? -0.691 + 10 * Math.log10(meanSquareSum) : Number.NEGATIVE_INFINITY;
+}
+function createLoudnessMeter(sampleRate, channelCount) {
+  const filters = Array.from({ length: channelCount }, () => kWeighting(sampleRate));
+  const stepSamples = Math.round(sampleRate / 10);
+  const steps = [];
+  let stepSum = 0;
+  let stepFill = 0;
+  let scratch = new Float32Array(0);
+  return {
+    push(channels) {
+      const length = channels[0]?.length ?? 0;
+      if (length === 0) return;
+      if (scratch.length < length * channelCount) scratch = new Float32Array(length * channelCount);
+      const weighted = [];
+      for (let c = 0; c < channelCount; c++) {
+        const view = scratch.subarray(c * length, (c + 1) * length);
+        view.set(channels[c] ?? channels[0]);
+        filters[c].process(view);
+        weighted.push(view);
+      }
+      for (let i = 0; i < length; i++) {
+        let sum = 0;
+        for (let c = 0; c < channelCount; c++) sum += weighted[c][i] * weighted[c][i];
+        stepSum += sum;
+        stepFill++;
+        if (stepFill === stepSamples) {
+          steps.push(stepSum / stepSamples);
+          stepSum = 0;
+          stepFill = 0;
+        }
+      }
+    },
+    stepPowers: () => steps,
+    integrated: () => integratedLoudnessFromSteps(steps)
+  };
+}
+function integratedLoudnessFromSteps(steps) {
+  const blocks = [];
+  for (let i = 0; i + STEPS_PER_BLOCK <= steps.length; i++) {
+    let sum = 0;
+    for (let k = 0; k < STEPS_PER_BLOCK; k++) sum += steps[i + k];
+    blocks.push(sum / STEPS_PER_BLOCK);
+  }
+  const absolute = blocks.filter((z) => blockLoudness(z) > ABSOLUTE_GATE);
+  if (absolute.length === 0) return Number.NEGATIVE_INFINITY;
+  const absoluteMean = absolute.reduce((a, b) => a + b, 0) / absolute.length;
+  const threshold = blockLoudness(absoluteMean) + RELATIVE_GATE;
+  const relative = absolute.filter((z) => blockLoudness(z) > threshold);
+  if (relative.length === 0) return Number.NEGATIVE_INFINITY;
+  return blockLoudness(relative.reduce((a, b) => a + b, 0) / relative.length);
+}
+
+// src/mediaEdit/dsp/chain.ts
+var MEDIA_FX_SAMPLE_RATE = 48e3;
+var MEDIA_FX_ENGINE = "squisq-media-edit/1";
+var LOUDNESS_GAIN_RANGE = { min: -20, max: 24 };
+var MEDIA_FX_TRUE_PEAK_CEILING_DB = -1;
+function opValues(fx) {
+  const values = {};
+  for (const op of fx.ops) values[op.id] = op.value;
+  return values;
+}
+function ignoredOps(fx, hasDenoiser) {
+  const ignored = [...fx.unknown];
+  const denoise = fx.ops.find((op) => op.id === "denoise");
+  if (denoise && !hasDenoiser) ignored.push(`denoise:${denoise.value}`);
+  return ignored;
+}
+function assertRate(source) {
+  if (source.sampleRate !== MEDIA_FX_SAMPLE_RATE) {
+    throw new Error(
+      `Media-edit chain runs at ${MEDIA_FX_SAMPLE_RATE} Hz; resample the source first (got ${source.sampleRate}).`
+    );
+  }
+}
+async function* frontStages(options, onFrames) {
+  const { source, signal } = options;
+  const ops = opValues(options.fx);
+  const channels = source.channels;
+  const highpass = ops.highpass != null ? Array.from(
+    { length: channels },
+    () => createBiquadCascade([highpassCoeffs(source.sampleRate, ops.highpass)])
+  ) : null;
+  let denoise = null;
+  if (ops.denoise != null && options.denoiser) {
+    const factory = options.denoiser;
+    denoise = await Promise.all(
+      Array.from(
+        { length: channels },
+        async () => createDenoiseStage(await factory(), ops.denoise)
+      )
+    );
+  }
+  const latency = denoise?.[0]?.latency ?? 0;
+  let inFrames = 0;
+  let outFrames = 0;
+  let toSkip = latency;
+  const run = (block) => {
+    const copies = block.map((ch) => ch.slice());
+    if (highpass) copies.forEach((ch, c) => highpass[c].process(ch));
+    let processed = denoise ? copies.map((ch, c) => denoise[c].process(ch)) : copies;
+    const length = processed[0]?.length ?? 0;
+    const skip = Math.min(toSkip, length);
+    toSkip -= skip;
+    const room = inFrames - outFrames;
+    const take = Math.min(length - skip, room);
+    if (take <= 0) return null;
+    processed = processed.map((ch) => ch.subarray(skip, skip + take));
+    outFrames += take;
+    return processed;
+  };
+  try {
+    for await (const block of source.open()) {
+      signal?.throwIfAborted();
+      const length = block[0]?.length ?? 0;
+      if (length === 0) continue;
+      inFrames += length;
+      onFrames(length);
+      const out = run(block);
+      if (out) yield out;
+    }
+    if (latency > 0) {
+      const out = run(Array.from({ length: channels }, () => new Float32Array(latency)));
+      if (out) yield out;
+    }
+  } finally {
+    denoise?.forEach((stage) => stage.dispose());
+  }
+}
+function monoMix(block) {
+  if (block.length === 1) return block[0];
+  const mono = new Float32Array(block[0].length);
+  for (const ch of block) for (let i = 0; i < mono.length; i++) mono[i] += ch[i] / block.length;
+  return mono;
+}
+async function analyzeMediaFx(options) {
+  assertRate(options.source);
+  const ops = opValues(options.fx);
+  const { source } = options;
+  const startSec = options.startSec ?? 0;
+  const breath = ops.debreath != null ? createBreathAnalyzer(source.sampleRate) : null;
+  const meter = ops.loudness != null ? createLoudnessMeter(source.sampleRate, source.channels) : null;
+  let seen = 0;
+  const total = source.frames ?? 0;
+  for await (const block of frontStages(options, (n) => {
+    seen += n;
+    if (total > 0) options.onProgress?.(Math.min(1, seen / total));
+  })) {
+    breath?.push(monoMix(block));
+    meter?.push(block);
+  }
+  const breaths = breath ? detectBreaths(breath.frames()).map((r) => ({
+    start: r.start + startSec,
+    end: r.end + startSec
+  })) : [];
+  let integratedLufs = null;
+  let loudnessGainDb = 0;
+  if (meter && ops.loudness != null) {
+    const reduction = ops.debreath ?? 0;
+    const steps = meter.stepPowers().map((power, k) => {
+      if (breaths.length === 0) return power;
+      let sum = 0;
+      for (let i = 0; i < 100; i++) {
+        const g = breathGainAt(breaths, reduction, startSec + k * 0.1 + (i + 0.5) * 1e-3);
+        sum += g * g;
+      }
+      return power * (sum / 100);
+    });
+    const measured = integratedLoudnessFromSteps(steps);
+    if (Number.isFinite(measured)) {
+      integratedLufs = measured;
+      loudnessGainDb = Math.min(
+        LOUDNESS_GAIN_RANGE.max,
+        Math.max(LOUDNESS_GAIN_RANGE.min, ops.loudness - measured)
+      );
+    }
+  }
+  return { integratedLufs, loudnessGainDb, breaths };
+}
+async function renderMediaFx(options) {
+  assertRate(options.source);
+  const ops = opValues(options.fx);
+  const needsAnalysis = ops.debreath != null || ops.loudness != null;
+  const analysisShare = needsAnalysis && !options.analysis ? 0.5 : 0;
+  const analysis = options.analysis ?? (needsAnalysis ? await analyzeMediaFx({
+    ...options,
+    onProgress: (f) => options.onProgress?.(f * analysisShare)
+  }) : { integratedLufs: null, loudnessGainDb: 0, breaths: [] });
+  const { source } = options;
+  const startSec = options.startSec ?? 0;
+  const gain = Math.pow(10, analysis.loudnessGainDb / 20);
+  const limiter = ops.loudness != null ? createLimiter({
+    sampleRate: source.sampleRate,
+    channels: source.channels,
+    ceilingDb: MEDIA_FX_TRUE_PEAK_CEILING_DB
+  }) : null;
+  let limiterSkip = limiter?.latency ?? 0;
+  const outputMeter = ops.loudness != null ? createLoudnessMeter(source.sampleRate, source.channels) : null;
+  let processed = 0;
+  let written = 0;
+  let seen = 0;
+  const total = source.frames ?? 0;
+  const emit = async (block) => {
+    const skip = Math.min(limiterSkip, block[0]?.length ?? 0);
+    limiterSkip -= skip;
+    const out = skip > 0 ? block.map((ch) => ch.subarray(skip)) : block;
+    if ((out[0]?.length ?? 0) === 0) return;
+    written += out[0].length;
+    outputMeter?.push(out);
+    await options.write(out);
+  };
+  for await (const block of frontStages(options, (n) => {
+    seen += n;
+    if (total > 0) {
+      options.onProgress?.(analysisShare + (1 - analysisShare) * Math.min(1, seen / total));
+    }
+  })) {
+    const blockStartSec = startSec + processed / source.sampleRate;
+    processed += block[0].length;
+    if (ops.debreath != null && analysis.breaths.length > 0) {
+      applyBreathEnvelope(block, source.sampleRate, blockStartSec, analysis.breaths, ops.debreath);
+    }
+    if (gain !== 1) for (const ch of block) for (let i = 0; i < ch.length; i++) ch[i] *= gain;
+    await emit(limiter ? limiter.process(block) : block);
+  }
+  if (limiter) await emit(limiter.flush());
+  return {
+    analysis,
+    frames: written,
+    ignoredOps: ignoredOps(options.fx, options.denoiser != null),
+    limiterMinGain: limiter?.minGain() ?? 1,
+    outputLufs: outputMeter ? finiteOrNull(outputMeter.integrated()) : null
+  };
+}
+function finiteOrNull(value) {
+  return Number.isFinite(value) ? value : null;
+}
+var MEDIA_FX_LOUDNESS_TOLERANCE = 0.5;
+function correctedLoudnessAnalysis(fx, result) {
+  const target = opValues(fx).loudness;
+  if (target == null || result.outputLufs == null) return null;
+  const miss = target - result.outputLufs;
+  if (Math.abs(miss) <= MEDIA_FX_LOUDNESS_TOLERANCE) return null;
+  const loudnessGainDb = Math.min(
+    LOUDNESS_GAIN_RANGE.max,
+    Math.max(LOUDNESS_GAIN_RANGE.min, result.analysis.loudnessGainDb + miss)
+  );
+  if (loudnessGainDb === result.analysis.loudnessGainDb) return null;
+  return { ...result.analysis, loudnessGainDb };
+}
+
+// src/mediaEdit/dsp/resample.ts
+var TABLE_RESOLUTION = 512;
+function createResampler(inRate, outRate, halfTaps = 16) {
+  const ratio = inRate / outRate;
+  const cutoff = Math.min(1, outRate / inRate);
+  const half = Math.ceil(halfTaps / cutoff);
+  const table = new Float32Array(half * TABLE_RESOLUTION + 2);
+  for (let i = 0; i < table.length; i++) {
+    const x = i / TABLE_RESOLUTION;
+    const sinc = x === 0 ? 1 : Math.sin(Math.PI * cutoff * x) / (Math.PI * cutoff * x);
+    const w = x >= half ? 0 : 0.42 + 0.5 * Math.cos(Math.PI * x / half) + 0.08 * Math.cos(2 * Math.PI * x / half);
+    table[i] = cutoff * sinc * w;
+  }
+  const kernel = (distance) => {
+    const pos = Math.abs(distance) * TABLE_RESOLUTION;
+    const i = Math.floor(pos);
+    if (i + 1 >= table.length) return 0;
+    const frac = pos - i;
+    return table[i] + (table[i + 1] - table[i]) * frac;
+  };
+  let buffer = new Float32Array(0);
+  let bufferStart = 0;
+  let totalIn = 0;
+  let nextOut = 0;
+  let flushed = false;
+  const produce = (final) => {
+    const out = [];
+    const limit = final ? Math.ceil(totalIn * outRate / inRate) : Number.POSITIVE_INFINITY;
+    for (; ; ) {
+      if (nextOut >= limit) break;
+      const p = nextOut * ratio;
+      const center = Math.floor(p);
+      if (!final && center + half >= totalIn) break;
+      let acc = 0;
+      for (let k = center - half + 1; k <= center + half; k++) {
+        const idx = k - bufferStart;
+        if (idx < 0 || idx >= buffer.length) continue;
+        acc += buffer[idx] * kernel(p - k);
+      }
+      out.push(acc);
+      nextOut++;
+    }
+    const keepFrom = Math.floor(nextOut * ratio) - half;
+    const drop = keepFrom - bufferStart;
+    if (drop > 0) {
+      const count = Math.min(drop, buffer.length);
+      buffer = buffer.slice(count);
+      bufferStart += count;
+    }
+    return Float32Array.from(out);
+  };
+  if (inRate === outRate) {
+    return {
+      inRate,
+      outRate,
+      process: (input) => input.slice(),
+      flush: () => new Float32Array(0)
+    };
+  }
+  return {
+    inRate,
+    outRate,
+    process(input) {
+      const merged = new Float32Array(buffer.length + input.length);
+      merged.set(buffer, 0);
+      merged.set(input, buffer.length);
+      buffer = merged;
+      totalIn += input.length;
+      return produce(false);
+    },
+    flush() {
+      if (flushed) return new Float32Array(0);
+      flushed = true;
+      return produce(true);
+    }
+  };
+}
+
+// src/mediaEdit/dsp/pauses.ts
+var PAUSE_TIGHTEN_DEFAULTS = Object.freeze({
+  maxPauseSec: 0.8,
+  keepSec: 0.4,
+  minCutSec: 0.25
+});
+var HOP_SEC2 = 0.01;
+var SILENT_DB2 = -120;
+function percentile2(values, p) {
+  if (values.length === 0) return SILENT_DB2;
+  const sorted = [...values].sort((a, b) => a - b);
+  return sorted[Math.min(sorted.length - 1, Math.floor(p * (sorted.length - 1)))];
+}
+function detectPauseCuts(frames, options = {}) {
+  if (frames.length === 0) return [];
+  const maxPause = options.maxPauseSec ?? PAUSE_TIGHTEN_DEFAULTS.maxPauseSec;
+  const keep = Math.min(options.keepSec ?? PAUSE_TIGHTEN_DEFAULTS.keepSec, maxPause);
+  const minCut = options.minCutSec ?? PAUSE_TIGHTEN_DEFAULTS.minCutSec;
+  const levels = frames.map((f) => f.rmsDb);
+  const floor = percentile2(levels, 0.1);
+  const voiced = frames.filter((f) => f.voicing >= 0.6).map((f) => f.rmsDb);
+  const speech = percentile2(voiced.length > 0 ? voiced : levels, 0.9);
+  if (speech - floor < 12) return [];
+  const quietCeiling = Math.min(floor + 10, speech - 20);
+  const isQuiet = (f) => f.voicing < 0.5 && f.rmsDb < quietCeiling;
+  const cuts = [];
+  let runStart = -1;
+  const closeRun = (endIndex) => {
+    if (runStart < 0) return;
+    const start = frames[runStart].t - HOP_SEC2 / 2;
+    const end = frames[endIndex].t + HOP_SEC2 / 2;
+    runStart = -1;
+    if (end - start <= maxPause) return;
+    const cutStart = start + keep / 2;
+    const cutEnd = end - keep / 2;
+    if (cutEnd - cutStart >= minCut) cuts.push({ start: cutStart, end: cutEnd });
+  };
+  for (let i = 0; i < frames.length; i++) {
+    if (isQuiet(frames[i])) {
+      if (runStart < 0) runStart = i;
+    } else {
+      closeRun(i - 1);
+    }
+  }
+  closeRun(frames.length - 1);
+  return cuts;
+}
+export {
+  MEDIA_EDIT_PARAMS,
+  MEDIA_FX_ENGINE,
+  MEDIA_FX_LOUDNESS_TOLERANCE,
+  MEDIA_FX_ORDER,
+  MEDIA_FX_SAMPLE_RATE,
+  MEDIA_FX_SPECS,
+  MEDIA_FX_TRUE_PEAK_CEILING_DB,
+  MEDIA_RENDER_DIR,
+  MEDIA_RENDER_GC_AGE_DAYS,
+  MEDIA_RENDER_MANIFEST_VERSION,
+  PAUSE_TIGHTEN_DEFAULTS,
+  analyzeMediaFx,
+  applyBreathEnvelope,
+  breathGainAt,
+  buildMediaRenderIndex,
+  collectDocMediaClips,
+  correctedLoudnessAnalysis,
+  createBreathAnalyzer,
+  createDenoiseStage,
+  createLimiter,
+  createLoudnessMeter,
+  createMediaTimeMap,
+  createResampler,
+  detectBreaths,
+  detectPauseCuts,
+  formatMediaNumber,
+  hasRenderableFx,
+  integratedLoudnessFromSteps,
+  isMediaRenderPath,
+  mediaClipRenderKey,
+  mediaEditHtmlAttribute,
+  mediaEditValuesFromAttributes,
+  mediaEditValuesFromParams,
+  mediaRenderFilePath,
+  mediaRenderKey,
+  mediaRenderKeyFor,
+  mediaRenderManifestPath,
+  mediaRenderStaleness,
+  mediaRenderStem,
+  normalizeMediaCrop,
+  normalizeMediaCuts,
+  parseMediaCrop,
+  parseMediaCuts,
+  parseMediaEdits,
+  parseMediaFx,
+  parseMediaRenderManifest,
+  parseMediaRenderPath,
+  referencedMediaRenderKeys,
+  renderMediaFx,
+  selectMediaRendersForGc,
+  serializeMediaCrop,
+  serializeMediaCuts,
+  serializeMediaEdits,
+  serializeMediaFx,
+  serializeMediaRenderManifest
+};