reelkit-cli 0.5.0 → 0.8.0

package/src/project/loudness.ts

@@ -0,0 +1,68 @@
+import { audioDuration, tool } from "./refmeasure";
+
+// How loud a sound is, measured on this machine, and how much to turn it up or down so that the same `volume` number sounds equally loud
+// for every file.
+//   A one-shot (a sound effect under 3 s) is levelled by its loudest moment: its peak is brought to -3 dBFS.
+//   A longer sound (music, a long effect) is levelled by how loud it is overall: about -18 LUFS, integrated.
+// The gain is limited to 18 dB either way, so a nearly silent or a broken file is not blown up into noise.
+export const ONE_SHOT_SECONDS = 3;
+export const ONE_SHOT_PEAK_DB = -3;
+export const LONG_TARGET_LUFS = -18;
+export const MAX_GAIN_DB = 18;
+
+export type SoundLevel = { durationSec: number; peakDb?: number; lufs?: number };
+
+const round = (n: number, digits: number) => Math.round(n * 10 ** digits) / 10 ** digits;
+
+// The gain in dB that brings a measured sound to its target, or 0 when it could not be measured (silence).
+export function gainDbFor(level: SoundLevel): number {
+  const oneShot = level.durationSec < ONE_SHOT_SECONDS;
+  const measured = oneShot ? level.peakDb : level.lufs ?? level.peakDb;
+  if (measured === undefined || !Number.isFinite(measured)) return 0;
+  const target = oneShot || level.lufs === undefined ? ONE_SHOT_PEAK_DB : LONG_TARGET_LUFS;
+  return round(Math.max(-MAX_GAIN_DB, Math.min(MAX_GAIN_DB, target - measured)), 1);
+}
+
+export const dbToLinear = (db: number) => round(10 ** (db / 20), 4);
+
+// ffmpeg's volumedetect: the loudest sample, in dBFS. Undefined for digital silence.
+export async function peakOf(path: string): Promise<number | undefined> {
+  const { stderr } = await tool("ffmpeg", ["-hide_banner", "-nostats", "-i", path, "-vn", "-af", "volumedetect", "-f", "null", "-"]);
+  const peak = Number(/max_volume:\s*(-?[0-9.]+)\s*dB/.exec(stderr)?.[1]);
+  return Number.isFinite(peak) ? peak : undefined;
+}
+
+// What loudnorm's first pass reports; its numbers are text in the JSON it prints, and "-inf" for silence.
+export type LoudnormReport = { input_i: string; input_tp: string; input_lra: string; input_thresh: string; target_offset: string };
+
+export function parseLoudnorm(stderr: string): LoudnormReport | undefined {
+  const end = stderr.lastIndexOf("}");
+  const start = stderr.lastIndexOf("{", end);
+  if (start < 0 || end < start) return undefined;
+  try {
+    const r = JSON.parse(stderr.slice(start, end + 1)) as LoudnormReport;
+    return typeof r.input_i === "string" ? r : undefined;
+  } catch { return undefined; }
+}
+
+export async function measureLoudnorm(path: string, target: { i: number; tp: number }): Promise<LoudnormReport | undefined> {
+  const { stderr } = await tool("ffmpeg", ["-hide_banner", "-nostats", "-i", path, "-vn", "-af", `loudnorm=I=${target.i}:TP=${target.tp}:LRA=11:print_format=json`, "-f", "null", "-"]);
+  return parseLoudnorm(stderr);
+}
+
+// Measures a sound for levelling. A failure to measure is not the caller's failure: it returns undefined and the sound is used as it is.
+export async function levelOf(path: string): Promise<(SoundLevel & { gainDb: number }) | undefined> {
+  try {
+    const durationSec = await audioDuration(path);
+    if (!(durationSec > 0)) return undefined;
+    const peakDb = await peakOf(path);
+    let lufs: number | undefined;
+    if (durationSec >= ONE_SHOT_SECONDS) {
+      const r = await measureLoudnorm(path, { i: LONG_TARGET_LUFS, tp: -1.5 });
+      const v = Number(r?.input_i);
+      if (Number.isFinite(v)) lufs = round(v, 1);
+    }
+    const level: SoundLevel = { durationSec, ...(peakDb !== undefined ? { peakDb } : {}), ...(lufs !== undefined ? { lufs } : {}) };
+    return { ...level, gainDb: gainDbFor(level) };
+  } catch { return undefined; }
+}

package/src/project/manifest.ts

@@ -1,6 +1,9 @@
-import { PACE_SPEED, type AssetManifest, type ScenePlan, type WordTiming } from "../pipeline/schema";
-import { extendBeats, snapToBeats, toBeatFrames } from "../pipeline/beatsnap";
-import { dimensionsFor, FPS, layoutScenes } from "../pipeline/timing";
+import { gapSec, isVoiceless, PACE_SPEED, type AssetManifest, type ScenePlan, type WordTiming } from "../pipeline/schema";
+import { extendBeats, MIN_TAIL_SEC, snapNarrated, snapToBeats, toBeatFrames } from "../pipeline/beatsnap";
+import { dimensionsFor, FPS, lastWordEndSec, layoutNarrated, layoutScenes, secondsToFrames } from "../pipeline/timing";
+import { readBackground } from "./background";
+import { toImageLayers, type LayerEntry } from "./layers";
+import { dbToLinear } from "./loudness";
 import type { MusicRecord } from "./music";
 import { FILES, type Project } from "./project";
 
@@ -16,26 +19,48 @@ export function voiceoverStale(vo: Voiceover, scene: ScenePlan["scenes"][number]
   return vo.text !== scene.narration || vo.voiceId !== plan.voiceId || vo.speed !== PACE_SPEED[plan.pace ?? "normal"];
 }
 
+// What the length of a film with no voice comes to once its cuts are on the beat of the pulled track, in seconds. Undefined without a track
+// whose tempo can be trusted. Used by `plan check`, which has no manifest yet.
+export function snappedSeconds(project: Project, plan: ScenePlan): number | undefined {
+  if (!isVoiceless(plan)) return undefined;
+  const music = project.readJsonOr<MusicRecord | undefined>(FILES.music, undefined);
+  if (!music?.bpm || !music.beats.length) return undefined;
+  const layout = layoutScenes(plan.scenes.map((s) => s.seconds ?? 0), FPS, 0);
+  const beatFrames = toBeatFrames(extendBeats(music.beats, music.bpm, layout.totalFrames / FPS + 10), FPS);
+  const lengths = snapToBeats({ naturalFrames: layout.scenes.map((s) => s.durationFrames), lastWordEndFrame: 0, beatFrames, fps: FPS, grid: "nearest" });
+  return lengths.reduce((a, b) => a + b, 0) / FPS;
+}
+
 // Lays the scenes out on the timeline from the real voiceover lengths. Paths are relative to the project folder.
 // Returns undefined, and writes nothing, until every scene has its voiceover.
 export function buildManifest(project: Project, plan: ScenePlan): AssetManifest | undefined {
-  const voiceovers = project.readJsonOr<Record<string, Voiceover>>(FILES.voiceovers, {});
-  if (plan.scenes.some((s) => !voiceovers[s.id])) return undefined;
+  const voiceless = isVoiceless(plan);
+  const voiceovers = voiceless ? {} : project.readJsonOr<Record<string, Voiceover>>(FILES.voiceovers, {});
+  if (!voiceless && plan.scenes.some((s) => !voiceovers[s.id])) return undefined;
   const images = project.readJsonOr<Record<string, string>>(FILES.images, {});
   const clips = project.readJsonOr<Record<string, ClipRecord>>(FILES.clips, {});
   const footage = project.footage();
   const byId = new Map(project.assets().map((a) => [a.id, a]));
 
-  let layout = layoutScenes(plan.scenes.map((s) => voiceovers[s.id].durationSec));
+  // With no voice the plan's own seconds are the lengths, with no padding after them: the plan already says how long each scene holds.
+  // With a voice each scene lasts until its last word has ended plus the plan's gap (the silence before the next sentence); the last keeps a longer tail.
+  let layout = voiceless ? layoutScenes(plan.scenes.map((s) => s.seconds ?? 0), FPS, 0) : layoutNarrated(plan.scenes.map((s) => voiceovers[s.id]!), gapSec(plan), FPS);
   const music = project.readJsonOr<MusicRecord | undefined>(FILES.music, undefined);
   let beatFrames: number[] = [];
   if (music) {
     beatFrames = toBeatFrames(extendBeats(music.beats, music.bpm ?? 120, layout.totalFrames / FPS + 10), FPS);
     // Scene changes land on beats only when the track has a trusted tempo. Footage has a fixed length that a longer scene must not overrun.
     if (music.bpm && music.beats.length) {
-      const last = voiceovers[plan.scenes[plan.scenes.length - 1].id];
-      const lastWords = last.words.length ? Math.max(...last.words.map((w) => w.endSec)) : last.durationSec;
-      const lengths = snapToBeats({ naturalFrames: layout.scenes.map((s) => s.durationFrames), lastWordEndFrame: Math.ceil(lastWords * FPS), beatFrames, fps: FPS });
+      const naturalFrames = layout.scenes.map((s) => s.durationFrames);
+      let lengths: number[];
+      if (voiceless) {
+        // No word to leave a tail after: the last scene is as long as the plan says, so the tail rule must not stretch it.
+        const lastWordEndFrame = Math.max(0, naturalFrames[naturalFrames.length - 1]! - Math.ceil(MIN_TAIL_SEC * FPS));
+        lengths = snapToBeats({ naturalFrames, lastWordEndFrame, beatFrames, fps: FPS, grid: "nearest" });
+      } else {
+        // The voice is the clock: a change moves to a beat only when that is a few frames away and cuts into no word.
+        lengths = snapNarrated({ naturalFrames, lastWordEndFrames: plan.scenes.map((s) => Math.ceil(lastWordEndSec(voiceovers[s.id]!) * FPS - 1e-9)), beatFrames }).frames;
+      }
       let cursor = 0;
       const snapped = { scenes: lengths.map((durationFrames) => { const r = { startFrame: cursor, durationFrames }; cursor += durationFrames; return r; }), totalFrames: 0 };
       snapped.totalFrames = cursor;
@@ -46,26 +71,41 @@ export function buildManifest(project: Project, plan: ScenePlan): AssetManifest
   if (footage) {
     const footageFrames = Math.floor((footage.durationSec ?? 0) * FPS);
     if (layout.totalFrames > footageFrames) {
-      throw new Error(`The voiceover (${(layout.totalFrames / FPS).toFixed(1)}s) is longer than the footage (${(footageFrames / FPS).toFixed(1)}s). Use a longer clip or shorten the script.`);
+      throw new Error(voiceless
+        ? `The scenes (${(layout.totalFrames / FPS).toFixed(1)}s) are longer than the footage (${(footageFrames / FPS).toFixed(1)}s). Use a longer clip or shorten the scenes' seconds.`
+        : `The voiceover (${(layout.totalFrames / FPS).toFixed(1)}s) is longer than the footage (${(footageFrames / FPS).toFixed(1)}s). Use a longer clip or shorten the script.`);
     }
     totalFrames = footageFrames;
   }
 
+  // The levelling of every sound that was measured when it was pulled, as linear gains by path.
+  const soundGain: Record<string, number> = {};
+  for (const e of Object.values(project.readJsonOr<Record<string, { path: string; kind: string; gainDb?: number }>>(FILES.library, {}))) {
+    if ((e.kind === "sfx" || e.kind === "music") && typeof e.gainDb === "number") soundGain[e.path] = dbToLinear(e.gainDb);
+  }
+  if (music) soundGain[music.key] = dbToLinear(music.gainDb);
+
+  const background = readBackground(project);
+  const layerEntries = project.readJsonOr<Record<string, LayerEntry>>(FILES.layers, {});
   const manifest: AssetManifest = {
     fps: FPS,
     ...dimensionsFor(plan.aspect, footage),
     totalFrames,
-    captions: plan.captions ?? "phrase",
+    captions: plan.captions ?? (voiceless ? "none" : "phrase"),
+    ...(Object.keys(soundGain).length ? { soundGain } : {}),
     ...(footage ? { footageKey: footage.key } : {}),
+    ...(background.film ? { background: { key: background.film.key, ...(background.film.durationSec ? { durationSec: background.film.durationSec } : {}) } } : {}),
     ...(music ? { music: { key: music.key, ...(music.bpm ? { bpm: music.bpm } : {}), beatFrames: music.bpm ? beatFrames.filter((f) => f < totalFrames) : [] } } : {}),
     scenes: plan.scenes.map((scene, i) => ({
       id: scene.id,
       startFrame: layout.scenes[i].startFrame,
       durationFrames: layout.scenes[i].durationFrames,
-      voiceoverKey: voiceovers[scene.id].key,
-      words: voiceovers[scene.id].words,
+      ...(voiceless ? {} : { voiceoverKey: voiceovers[scene.id]!.key }),
+      words: voiceless ? [] : voiceovers[scene.id]!.words,
       ...(scene.treatment === "illustration" && images[scene.id] ? { imageKey: images[scene.id] } : {}),
+      ...(scene.treatment === "illustration" && images[scene.id] && layerEntries[images[scene.id]!] ? { imageLayers: toImageLayers(images[scene.id]!, layerEntries[images[scene.id]!]!) } : {}),
       ...(scene.treatment === "clip" && clips[scene.id] ? { clipKey: clips[scene.id].key, ...(clips[scene.id].keyedKey ? { clipKeyedKey: clips[scene.id].keyedKey } : {}) } : {}),
+      ...(background.scenes[scene.id] ? { background: { key: background.scenes[scene.id]!.key } } : {}),
       userAssetKeys: scene.userAssetIds.map((id) => {
         const a = byId.get(id);
         if (!a) throw new Error(`Scene ${scene.id} references unknown asset ${id}. Add it with \`reelkit assets upload\`.`);
@@ -83,10 +123,12 @@ export function missingAssets(project: Project, plan: ScenePlan): string[] {
   const images = project.readJsonOr<Record<string, string>>(FILES.images, {});
   const clips = project.readJsonOr<Record<string, ClipRecord>>(FILES.clips, {});
   const problems: string[] = [];
+  const voiceless = isVoiceless(plan);
   const music = project.readJsonOr<MusicRecord | undefined>(FILES.music, undefined);
   if (music && !project.exists(music.key)) problems.push(`Missing file: ${music.key}. Pull the track again with \`reelkit assets pull ${music.id} --music\`.`);
   for (const s of plan.scenes) {
-    if (!voiceovers[s.id]) problems.push(`Scene ${s.id} has no voiceover.`);
+    if (voiceless) { /* nothing is recorded for a video with no voice */ }
+    else if (!voiceovers[s.id]) problems.push(`Scene ${s.id} has no voiceover.`);
     else if (voiceoverStale(voiceovers[s.id], s, plan)) problems.push(`Scene ${s.id}'s voiceover is out of date. Run \`reelkit assets voiceover --all\`.`);
     else if (!project.exists(voiceovers[s.id].key)) problems.push(`Missing file: ${voiceovers[s.id].key}`);
     // Only an illustration scene uses an image; one left over from an earlier plan is not needed.
@@ -102,3 +144,15 @@ export function missingAssets(project: Project, plan: ScenePlan): string[] {
   }
   return problems;
 }
+
+// The silence between each scene's last word and the next scene's first word, in seconds, as the manifest lays them out. This is what a listener hears
+// between two sentences, and it is what the plan's `gap` sets (the beat can move a change by a few frames).
+export function sentenceGaps(manifest: AssetManifest): number[] {
+  return manifest.scenes.slice(0, -1).map((s, i) => {
+    const next = manifest.scenes[i + 1]!;
+    if (!s.words.length || !next.words.length) return Math.max(0, (next.startFrame - s.startFrame) / manifest.fps);
+    const end = s.startFrame / manifest.fps + Math.max(...s.words.map((w) => w.endSec));
+    const start = next.startFrame / manifest.fps + Math.min(...next.words.map((w) => w.startSec));
+    return Math.round((start - end) * 100) / 100;
+  });
+}

package/src/project/music.ts

@@ -1,4 +1,5 @@
 import type { AssetManifest } from "../pipeline/schema";
+import { gridPoints } from "../pipeline/beatsnap";
 import { analyzeBeats } from "./beats";
 import { audioDuration, decodeMono } from "./refmeasure";
 
@@ -14,12 +15,25 @@ export async function measureMusic(path: string): Promise<Pick<MusicRecord, "dur
   return { durationSec, beatConfidence: r.confidence, beats: r.tempoBpm !== undefined && r.beats ? r.beats : [], ...(r.tempoBpm !== undefined ? { bpm: r.tempoBpm } : {}) };
 }
 
-// How many scene changes fall on a beat, for the preview.
-export function beatReport(manifest: AssetManifest): { bpm: number; boundariesOnBeat: number; boundaries: number; line: string } | undefined {
+// How many scene changes fall on a beat, for the preview. A film with no voice puts its cuts on a finer grid, so there a change on a half or
+// a quarter beat counts too, and the line says which grid was needed.
+export function beatReport(manifest: AssetManifest, opts: { finer?: boolean } = {}): { bpm: number; boundariesOnBeat: number; boundaries: number; line: string } | undefined {
   const m = manifest.music;
   if (!m?.bpm || manifest.scenes.length < 2) return undefined;
-  const beats = new Set(m.beatFrames);
   const starts = manifest.scenes.slice(1).map((s) => s.startFrame);
-  const on = starts.filter((f) => beats.has(f)).length;
-  return { bpm: m.bpm, boundariesOnBeat: on, boundaries: starts.length, line: `${on} of ${starts.length} scene changes land on the beat at ${Math.round(m.bpm)} BPM` };
+  const beats = new Set(m.beatFrames);
+  const bpm = Math.round(m.bpm);
+  if (!opts.finer) {
+    const on = starts.filter((f) => beats.has(f)).length;
+    // With a narrator the voice sets where a scene ends: a change is moved to a beat only when that is a few frames away, so say honestly how many are.
+    const rest = starts.length - on;
+    return { bpm: m.bpm, boundariesOnBeat: on, boundaries: starts.length, line: `${on} of ${starts.length} scene changes land on the beat at ${bpm} BPM${rest ? `; the other${rest === 1 ? "" : "s"} follow${rest === 1 ? "s" : ""} the voice` : ""}` };
+  }
+  const halves = new Set(gridPoints(m.beatFrames, 2)), quarters = new Set(gridPoints(m.beatFrames, 4));
+  const onBeat = starts.filter((f) => beats.has(f)).length;
+  const onHalf = starts.filter((f) => !beats.has(f) && halves.has(f)).length;
+  const onQuarter = starts.filter((f) => !beats.has(f) && !halves.has(f) && quarters.has(f)).length;
+  const on = onBeat + onHalf + onQuarter;
+  const grid = onQuarter ? "the beat, a half beat or a quarter beat" : onHalf ? "the beat or a half beat" : "the beat";
+  return { bpm: m.bpm, boundariesOnBeat: on, boundaries: starts.length, line: `${on} of ${starts.length} scene changes land on ${grid} at ${bpm} BPM` };
 }

package/src/project/project.ts

@@ -5,16 +5,21 @@ import { AspectSchema, type AssetRecord } from "../pipeline/schema";
 
 export const FILES = {
   config: "reelkit.json", plan: "plan.json", manifest: "manifest.json",
-  assetIndex: "assets/index.json", voiceovers: "assets/voiceovers.json", images: "assets/images.json", clips: "assets/clips.json", library: "assets/library.json", music: "assets/music.json",
+  assetIndex: "assets/index.json", voiceovers: "assets/voiceovers.json", images: "assets/images.json", clips: "assets/clips.json", library: "assets/library.json", music: "assets/music.json", background: "assets/background.json", layers: "assets/layers.json", searches: "assets/searches.json", shared: "assets/shared.json",
 } as const;
 
 // "path: message", or just the message for a problem at the root of the file.
 export const issueLines = (e: { issues: { path: PropertyKey[]; message: string }[] }) =>
   e.issues.map((i) => (i.path.length ? `${i.path.map(String).join(".")}: ${i.message}` : i.message));
 
-export const ProjectConfigSchema = z.object({ aspect: AspectSchema, name: z.string().optional(), footage: z.string().optional() });
+export const ProjectConfigSchema = z.object({ aspect: AspectSchema, name: z.string().optional(), footage: z.string().optional(),
+  // false when the project was made with --private: nothing is shared with the library automatically.
+  shareComponents: z.boolean().optional() });
 export type ProjectConfig = z.infer<typeof ProjectConfigSchema>;
 
+// True for a project made with `reelkit init --private` (shareComponents: false): nothing in it is sent to the library, whatever the plan or a flag says.
+export const isPrivateProject = (project: { config(): ProjectConfig }): boolean => project.config().shareComponents === false;
+
 // One video's working folder. Every command reads and writes its state here.
 export class Project {
   constructor(readonly dir: string) {}

package/src/project/refmeasure.ts

@@ -9,7 +9,7 @@ const exec = promisify(execFile);
 export const REF_ASPECTS = ["9:16", "16:9", "1:1", "4:5"] as const;
 export type RefAspect = (typeof REF_ASPECTS)[number];
 
-async function tool(cmd: "ffmpeg" | "ffprobe", args: string[]): Promise<{ stdout: Buffer; stderr: string }> {
+export async function tool(cmd: "ffmpeg" | "ffprobe", args: string[]): Promise<{ stdout: Buffer; stderr: string }> {
   try {
     const r = await exec(cmd, args, { maxBuffer: 256 * 1024 * 1024, encoding: "buffer" });
     return { stdout: r.stdout, stderr: r.stderr.toString("utf8") };

package/src/project/soundreport.ts

@@ -0,0 +1,347 @@
+// Measures how a finished film sounds against what it shows: how often something hits, how often a swell rises, and how many of the big
+// changes in the picture have a hit beside them. Everything but the two decoders is a pure function over arrays.
+import { loudnessLufs, meanAbsDiffs, probeVideo, tool } from "./refmeasure";
+
+export const AUDIO_RATE = 22050;
+export const PICTURE_FPS = 30;
+export const PICTURE_WIDTH = 64;
+const WINDOW_SEC = 0.046, HOP_SEC = 0.012;
+// A hit this close to a picture change belongs to it.
+export const HIT_NEAR_SEC = 0.1;
+// Nothing quieter than about -50 dBFS counts as sound, so a track that is only dither does not start the film.
+const AUDIBLE_RMS = 0.003;
+// A swell lives in the 0.5 to 10 kHz band, the air of a whoosh or a riser. Measured on the library's own sounds, whooshes keep their energy between
+// 0.2 and 5 kHz (the Cinematic and Quantum Motion ones put 40 to 90 percent of it between 0.5 and 5 kHz, risers 40 to 95 percent between 2 and 10 kHz)
+// and only a riser has a real share above 5 kHz, so a 5 to 10 kHz band could not hear a whoosh at all. Bass and kicks stay below it.
+export const SWELL_BAND: [number, number] = [500, 10000];
+// The band must be at least this loud (about -50 dBFS) to count as a swell, so that silence and dither are not counted.
+const BAND_FLOOR = 0.003;
+// A swell is a rise of the band above its own local level: the level is the median of the band over about 1.5 s around it, the rise must reach
+// SWELL_RISE_DB above it, stay above SWELL_EDGE_DB for at least SWELL_MIN_SEC, and take at least SWELL_RAMP_SEC to build (a click or a hit does not).
+const FLOOR_SEC = 1.5, SWELL_EDGE_DB = 2, SWELL_RISE_DB = 4, SWELL_MIN_SEC = 0.12, SWELL_RAMP_SEC = 0.08;
+
+const mean = (a: ArrayLike<number>) => { let s = 0; for (let i = 0; i < a.length; i++) s += a[i]!; return a.length ? s / a.length : 0; };
+const sd = (a: ArrayLike<number>, m = mean(a)) => { let s = 0; for (let i = 0; i < a.length; i++) s += (a[i]! - m) ** 2; return a.length ? Math.sqrt(s / a.length) : 0; };
+
+// The root-mean-square level of each ~46 ms window, every ~12 ms.
+export function envelope(samples: ArrayLike<number>, rate: number): { values: Float64Array; hopSec: number } {
+  const win = Math.max(1, Math.round(WINDOW_SEC * rate)), hop = Math.max(1, Math.round(HOP_SEC * rate));
+  const n = samples.length >= win ? Math.floor((samples.length - win) / hop) + 1 : 0;
+  const values = new Float64Array(n);
+  for (let f = 0; f < n; f++) {
+    let s = 0;
+    for (let i = f * hop, end = i + win; i < end; i++) s += samples[i]! * samples[i]!;
+    values[f] = Math.sqrt(s / win);
+  }
+  return { values, hopSec: hop / rate };
+}
+
+// Peaks of a series that rise above `threshold`, at least `gap` entries apart (the higher of two close ones is kept).
+function pickPeaks(series: ArrayLike<number>, threshold: number, gap: number): number[] {
+  const peaks: number[] = [];
+  for (let i = 0; i < series.length; i++) {
+    const v = series[i]!;
+    if (!(v > threshold) || v < (series[i - 1] ?? -Infinity) || v < (series[i + 1] ?? -Infinity)) continue;
+    const last = peaks[peaks.length - 1];
+    if (last !== undefined && i - last < gap) { if (v > series[last]!) peaks[peaks.length - 1] = i; } else peaks.push(i);
+  }
+  return peaks;
+}
+
+// The times in seconds of the hits: sudden rises of the full-band level. A hit is where the level of an ~46 ms window jumps by at least HIT_JUMP_DB
+// over what it was 48 ms before and ends up audible, at least 90 ms apart. The jump is relative to the sound just before it, so a quiet tap is a hit
+// whatever else the film holds: a loud drop does not raise the bar for the rest (a threshold taken from the whole film's statistics did).
+const HIT_JUMP_DB = 8, HIT_LOOKBACK = 4, HIT_FLOOR = 0.001;
+export function hitTimes(samples: ArrayLike<number>, rate: number): number[] {
+  const { values, hopSec } = envelope(samples, rate);
+  const jump = new Float64Array(values.length);
+  for (let i = HIT_LOOKBACK; i < values.length; i++) {
+    if (values[i]! < HIT_FLOOR) continue;
+    jump[i] = 20 * Math.log10(values[i]! / Math.max(values[i - HIT_LOOKBACK]!, 1e-5));
+  }
+  return pickPeaks(jump, HIT_JUMP_DB, Math.max(1, Math.round(0.09 / hopSec))).map((i) => (i * hopSec) + WINDOW_SEC / 2);
+}
+
+// One second-order section (RBJ cookbook). Two of them in a row make each edge of the band steeper.
+function biquad(x: ArrayLike<number>, type: "high" | "low", freq: number, rate: number): Float64Array {
+  const w0 = (2 * Math.PI * freq) / rate, cos = Math.cos(w0), alpha = Math.sin(w0) / (2 * Math.SQRT1_2);
+  const [b0, b1, b2] = type === "high" ? [(1 + cos) / 2, -(1 + cos), (1 + cos) / 2] : [(1 - cos) / 2, 1 - cos, (1 - cos) / 2];
+  const a0 = 1 + alpha, a1 = -2 * cos, a2 = 1 - alpha;
+  const y = new Float64Array(x.length);
+  let x1 = 0, x2 = 0, y1 = 0, y2 = 0;
+  for (let i = 0; i < x.length; i++) {
+    const v = (b0 * x[i]! + b1 * x1 + b2 * x2 - a1 * y1 - a2 * y2) / a0;
+    x2 = x1; x1 = x[i]!; y2 = y1; y1 = v; y[i] = v;
+  }
+  return y;
+}
+
+export type Swell = { start: number; peak: number; length: number };
+
+// The swells of a sound: where the 0.5 to 10 kHz band rises ramping up above its own local level (see the constants above). Each is a start (where it
+// leaves the local level), a peak (its loudest moment) and a length, all in seconds. The level is local, so one loud riser does not hide the quiet
+// whooshes around it, and a steady bed of music, which is its own level everywhere, gives none.
+export function swells(samples: ArrayLike<number>, rate: number): Swell[] {
+  if (samples.length < rate / 10) return [];
+  const [lo, hi] = [SWELL_BAND[0], Math.min(SWELL_BAND[1], rate * 0.45)];
+  const band = biquad(biquad(biquad(biquad(samples, "high", lo, rate), "high", lo, rate), "low", hi, rate), "low", hi, rate);
+  const fine = envelope(band, rate);
+  // One value every four hops (about 48 ms) is enough resolution and keeps the median cheap.
+  const step = 4, hopSec = fine.hopSec * step, n = Math.floor(fine.values.length / step);
+  const level = new Float64Array(n), db = new Float64Array(n);
+  for (let i = 0; i < n; i++) { level[i] = fine.values[i * step]!; db[i] = 20 * Math.log10(Math.max(level[i]!, 1e-6)); }
+  const half = Math.max(1, Math.round(FLOOR_SEC / 2 / hopSec));
+  const excess = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    const win = Array.from(db.subarray(Math.max(0, i - half), Math.min(n, i + half + 1))).sort((x, y) => x - y);
+    excess[i] = db[i]! - win[win.length >> 1]!;
+  }
+  const out: Swell[] = [];
+  for (let i = 0; i < n;) {
+    if (!(excess[i]! > SWELL_EDGE_DB)) { i++; continue; }
+    let j = i;
+    while (j < n && excess[j]! > SWELL_EDGE_DB) j++;
+    let top = i, loudest = i;
+    for (let k = i; k < j; k++) { if (excess[k]! > excess[top]!) top = k; if (level[k]! > level[loudest]!) loudest = k; }
+    // How long the rise took: from leaving the local level to coming within 3 dB of the run's own top.
+    let near = i;
+    while (near < top && excess[near]! < excess[top]! - 3) near++;
+    const loud = level[loudest]! >= BAND_FLOOR;
+    if (loud && excess[top]! >= SWELL_RISE_DB && (j - i) * hopSec >= SWELL_MIN_SEC && (near - i + 1) * hopSec >= SWELL_RAMP_SEC) {
+      out.push({ start: i * hopSec, peak: loudest * hopSec, length: (j - i) * hopSec });
+    }
+    i = j;
+  }
+  return out;
+}
+
+// The start times in seconds of the swells.
+export const swellTimes = (samples: ArrayLike<number>, rate: number): number[] => swells(samples, rate).map((w) => w.start);
+
+// A big change of the picture. A transition is a span of frames with a high difference, not a single frame: `start` and `end` (seconds) bound the
+// run of frames above the change threshold around the peak, `time` and `frame` are the peak itself, and `strength` is the peak's mean difference
+// between neighbouring frames (0 to 255, on a small grey picture).
+export type PictureChange = { time: number; frame: number; strength: number; start: number; end: number };
+
+// The big picture changes: peaks of the mean absolute difference between neighbouring frames above its mean plus 1.5 standard deviations, at least
+// 0.2 s apart, each with the contiguous run of frames above that same threshold around it. `diffs[i]` is the change from frame i to frame i + 1.
+export function pictureChanges(diffs: ArrayLike<number>, fps: number): PictureChange[] {
+  const m = mean(diffs);
+  const threshold = Math.max(0.5, m + 1.5 * sd(diffs, m));
+  return pickPeaks(diffs, threshold, Math.max(1, Math.round(0.2 * fps))).map((i) => {
+    let a = i, b = i;
+    while (a > 0 && diffs[a - 1]! > threshold) a--;
+    while (b < diffs.length - 1 && diffs[b + 1]! > threshold) b++;
+    return { time: (i + 1) / fps, frame: i + 1, strength: Math.round(diffs[i]! * 10) / 10, start: (a + 1) / fps, end: (b + 1) / fps };
+  });
+}
+
+export const pictureChangeTimes = (diffs: ArrayLike<number>, fps: number): number[] => pictureChanges(diffs, fps).map((c) => c.time);
+
+// The hit nearest to a change, measured to the nearest point of the change's own span: 0 when the hit lies inside it. `side` says which way it is.
+export type HitMatch = { hit: number; distance: number; side: "inside" | "before" | "after" };
+export function nearestHit(change: PictureChange | number, hits: readonly number[]): HitMatch | undefined {
+  const [a, b] = typeof change === "number" ? [change, change] : [change.start, change.end];
+  let best: HitMatch | undefined;
+  for (const h of hits) {
+    const d = h < a ? a - h : h > b ? h - b : 0;
+    if (!best || d < best.distance) best = { hit: h, distance: d, side: h < a ? "before" : h > b ? "after" : "inside" };
+  }
+  return best;
+}
+
+// How many changes have a hit within `near` seconds of their span.
+export const countWithHit = (changes: readonly (PictureChange | number)[], hits: readonly number[], near = HIT_NEAR_SEC): number =>
+  changes.filter((c) => (nearestHit(c, hits)?.distance ?? Infinity) <= near + 1e-9).length;
+
+// The first moment the full-band level reaches audible, or null for a film that is silent.
+export function firstSoundSec(samples: ArrayLike<number>, rate: number): number | null {
+  const { values, hopSec } = envelope(samples, rate);
+  const i = values.findIndex((v) => v > AUDIBLE_RMS);
+  return i < 0 ? null : Math.round(i * hopSec * 100) / 100;
+}
+
+export type SoundDetail = {
+  changes: (PictureChange & { hit: number | null; distance: number | null; side: HitMatch["side"] | null; matched: boolean })[];
+  swells: Swell[];
+  hits: number[];
+  firstSoundSec: number | null;
+};
+export type SoundReport = { hitsPerSecond: number; swellsPerSecond: number; pictureChanges: number; changesWithHit: number; firstSoundSec: number | null; loudnessLufs?: number; detail?: SoundDetail; voice?: VoiceMusic };
+const round = (n: number, d = 2) => Math.round(n * 10 ** d) / 10 ** d;
+
+// The whole measurement from decoded audio and the picture's frame differences. `detail` lists every event the counts were made from.
+export function soundReport(samples: ArrayLike<number>, rate: number, pictureDiffs: ArrayLike<number>, fps: number): SoundReport {
+  const seconds = samples.length / rate;
+  const hits = hitTimes(samples, rate), found = swells(samples, rate), changes = pictureChanges(pictureDiffs, fps), first = firstSoundSec(samples, rate);
+  return {
+    hitsPerSecond: seconds > 0 ? round(hits.length / seconds) : 0, swellsPerSecond: seconds > 0 ? round(found.length / seconds, 3) : 0,
+    pictureChanges: changes.length, changesWithHit: countWithHit(changes, hits), firstSoundSec: first,
+    detail: {
+      changes: changes.map((c) => { const m = nearestHit(c, hits); return { ...c, hit: m ? round(m.hit, 3) : null, distance: m ? round(m.distance, 3) : null, side: m?.side ?? null, matched: (m?.distance ?? Infinity) <= HIT_NEAR_SEC + 1e-9 }; }),
+      swells: found.map((w) => ({ start: round(w.start, 2), peak: round(w.peak, 2), length: round(w.length, 2) })),
+      hits: hits.map((h) => round(h, 3)),
+      firstSoundSec: first,
+    },
+  };
+}
+
+// The same report as lines of text, one per event, for `reelkit sound --detail`.
+export function detailLines(d: SoundDetail): string[] {
+  const t = (n: number) => `${n.toFixed(2)}s`;
+  const lines = ["Picture changes (the time and frame of the peak, how strong, and the nearest hit measured to the changing span):"];
+  for (const c of d.changes) {
+    const span = c.end > c.start ? ` (changing ${t(c.start)} to ${t(c.end)})` : "";
+    const hit = c.hit === null ? "no hit at all" : c.side === "inside" ? `hit at ${t(c.hit)}, inside the change` : `nearest hit at ${t(c.hit)}, ${t(c.distance!)} ${c.side} it`;
+    lines.push(`  ${t(c.time)}  frame ${c.frame}  strength ${c.strength}${span}: ${hit}${c.matched ? "" : "  <- no sound within 0.1s"}`);
+  }
+  if (!d.changes.length) lines.push("  none found");
+  lines.push("Swells (start, peak, length):");
+  for (const w of d.swells) lines.push(`  ${t(w.start)}  peak ${t(w.peak)}  length ${t(w.length)}`);
+  if (!d.swells.length) lines.push("  none found");
+  lines.push(`Hits: ${d.hits.length}${d.hits.length ? ` (${d.hits.slice(0, 40).map((h) => h.toFixed(2)).join(", ")}${d.hits.length > 40 ? ", ..." : ""})` : ""}`);
+  lines.push(`First sound: ${d.firstSoundSec === null ? "never" : t(d.firstSoundSec)}`);
+  return lines;
+}
+
+// Plain-word advice for a film with no voice, against the targets in reference/launch-film.md. It is a measurement and never a verdict.
+export function soundAdvice(r: SoundReport): string {
+  const hits = `${r.hitsPerSecond.toFixed(1)} hits a second`;
+  const every = r.swellsPerSecond > 0 ? 1 / r.swellsPerSecond : undefined;
+  const swell = every === undefined ? "no swell at all" : `a swell every ${every < 10 ? every.toFixed(1) : Math.round(every)} seconds`;
+  const swellFix = r.swellsPerSecond < 0.5 ? " (films like this have one every 1 to 2 seconds: add a whoosh to each move)" : r.swellsPerSecond > 1.3 ? " (films like this have one every 1 to 2 seconds: that is busy, so leave some moves silent)" : "";
+  const aim = Math.max(1, Math.ceil(r.pictureChanges * 0.6));
+  const changes = r.pictureChanges ? `${r.changesWithHit} of ${r.pictureChanges} picture changes have a sound within a tenth of a second (aim for ${aim} or more)` : "no clear picture change was found to compare with";
+  const start = r.firstSoundSec === null ? " The film is silent." : r.firstSoundSec > 0.1 ? ` The first sound is at ${r.firstSoundSec.toFixed(2)}s; the films started within 0.05s.` : "";
+  return `Sound: ${hits}; ${swell}${swellFix}; ${changes}.${start} This is a measurement of the file, not a judgement of how it sounds: listen to it too.`;
+}
+
+// ---- The voice against the music, for a narrated film ----------------------------------------------------------------------------------------
+// The mix is one channel, so the music cannot be measured alone. What can be measured is the mix while the voice speaks, the mix in the pauses
+// (where only the music and effects are heard), and the mix in the short pauses between words, where the music is still held down: that last level
+// is the estimate of "the music under the voice". The numbers say "estimated" for that reason.
+
+// A word's time in the film, in seconds. `sentenceEnd` is true for the last word of a sentence (it ends with . ? ! or ends its scene).
+export type SpokenWord = { start: number; end: number; sentenceEnd?: boolean };
+export type VoiceMusic = {
+  // The mix's level while the voice speaks, dBFS (RMS), and in pauses of at least 0.5 s where it does not.
+  speechDb: number;
+  pauseDb?: number;
+  // speechDb minus pauseDb: how far the voice stands above what is heard in a real pause.
+  voiceOverPauseDb?: number;
+  // The music's level under the voice, from the short pauses between words, and how far below the voice it is (estimated).
+  underVoiceDb?: number;
+  musicBelowVoiceDb?: number;
+  // How many times the level between two sentences rose more than 6 dB above the level under the voice, and how many such gaps were looked at.
+  pumps?: number;
+  pumpsPer30s?: number;
+  sentenceGaps?: number;
+  estimated: true;
+};
+
+export const PUMP_RISE_DB = 6;
+// The music under the voice should sit this far below it (dB): closer masks the voice, farther is not heard.
+export const MUSIC_BELOW_VOICE_DB: [number, number] = [10, 22];
+export const MAX_PUMPS_PER_30S = 2;
+const SPEECH_EDGE = 0.02, PAUSE_MIN = 0.5, PAUSE_EDGE = 0.1, SHORT_PAUSE_MIN = 0.12, SHORT_PAUSE_START = 0.05, SHORT_PAUSE_END = 0.03;
+const SENTENCE_GAP_MIN = 0.2, SENTENCE_GAP_START = 0.1, SENTENCE_GAP_END = 0.05, PUMP_WINDOW = 0.1, PUMP_STEP = 0.05;
+
+const toDb = (power: number) => (power > 1e-12 ? 10 * Math.log10(power) : -120);
+const r1 = (n: number) => Math.round(n * 10) / 10;
+
+// The measurement itself, from the decoded mix and the words' times. Returns undefined for a film with no words.
+export function voiceAgainstMusic(samples: ArrayLike<number>, rate: number, words: SpokenWord[]): VoiceMusic | undefined {
+  const ws = words.filter((w) => w.end > w.start).sort((a, b) => a.start - b.start);
+  if (!ws.length || samples.length < rate) return undefined;
+  const seconds = samples.length / rate;
+  // Prefix sums of the squares, so the power of any stretch is two lookups.
+  const acc = new Float64Array(samples.length + 1);
+  for (let i = 0; i < samples.length; i++) acc[i + 1] = acc[i]! + samples[i]! * samples[i]!;
+  const sumOf = (a: number, b: number): { sum: number; n: number } => {
+    const i = Math.max(0, Math.min(samples.length, Math.round(a * rate))), j = Math.max(0, Math.min(samples.length, Math.round(b * rate)));
+    return j > i ? { sum: acc[j]! - acc[i]!, n: j - i } : { sum: 0, n: 0 };
+  };
+  const powerOver = (spans: [number, number][]): number | undefined => {
+    let sum = 0, n = 0;
+    for (const [a, b] of spans) { const r = sumOf(a, b); sum += r.sum; n += r.n; }
+    return n > 0 ? sum / n : undefined;
+  };
+
+  const speech = powerOver(ws.map((w): [number, number] => [w.start + SPEECH_EDGE, w.end - SPEECH_EDGE]));
+  if (speech === undefined) return undefined;
+
+  // The gaps between consecutive words, with the start and the end of the film counted as gaps too (the last second is a fade-out, so it is left out).
+  type Gap = { from: number; to: number; after?: SpokenWord };
+  const gaps: Gap[] = [{ from: 0, to: ws[0]!.start }];
+  for (let i = 0; i + 1 < ws.length; i++) gaps.push({ from: ws[i]!.end, to: ws[i + 1]!.start, after: ws[i] });
+  gaps.push({ from: ws[ws.length - 1]!.end, to: Math.max(ws[ws.length - 1]!.end, seconds - 1) });
+
+  const pauses = gaps.filter((g) => g.to - g.from >= PAUSE_MIN).map((g): [number, number] => [g.from + PAUSE_EDGE, g.to - PAUSE_EDGE]).filter(([a, b]) => b - a >= 0.2);
+  const pause = powerOver(pauses);
+  // The music held down under the voice: the quiet moments between words (and, with tight gaps, between sentences), the voice's own tail trimmed off.
+  // Word times are rounded, so a short pause may still hold the end of a word: take the quietest quarter of its 50 ms blocks, which is the music (its median is what the gaps between sentences are compared with).
+  const blocks: number[] = [];
+  for (const g of gaps) {
+    if (!g.after || g.to - g.from < SHORT_PAUSE_MIN || g.to - g.from >= PAUSE_MIN) continue;
+    for (let t = g.from + SHORT_PAUSE_START; t + 0.05 <= g.to - SHORT_PAUSE_END + 1e-9; t += 0.05) { const r = sumOf(t, t + 0.05); if (r.n) blocks.push(r.sum / r.n); }
+  }
+  blocks.sort((a, b) => a - b);
+  const short = blocks.length ? blocks[Math.floor((blocks.length - 1) * 0.25)] : undefined;
+  // Between two sentences the music is compared with the typical level of those pauses.
+  const typical = blocks.length ? blocks[Math.floor((blocks.length - 1) * 0.5)] : undefined;
+
+  const out: VoiceMusic = { speechDb: r1(toDb(speech)), estimated: true };
+  if (pause !== undefined) { out.pauseDb = r1(toDb(pause)); out.voiceOverPauseDb = r1(toDb(speech) - toDb(pause)); }
+  if (short !== undefined) {
+    out.underVoiceDb = r1(toDb(short));
+    // The voice alone is the speech power less the music's: a level only a few dB above the music leaves little voice, so the floor is a tenth of it.
+    out.musicBelowVoiceDb = r1(toDb(Math.max(speech - short, speech * 0.1)) - toDb(short));
+    // Between two sentences: the loudest 0.1 s of the gap, apart from the voice's tail at its start and the next word's breath at its end.
+    let pumps = 0, looked = 0;
+    for (const g of gaps) {
+      if (!g.after?.sentenceEnd || g.to - g.from < SENTENCE_GAP_MIN) continue;
+      const a = g.from + SENTENCE_GAP_START, b = g.to - SENTENCE_GAP_END;
+      if (b - a < PUMP_WINDOW) continue;
+      looked++;
+      let loudest = -Infinity;
+      for (let t = a; t + PUMP_WINDOW <= b + 1e-9; t += PUMP_STEP) { const r = sumOf(t, t + PUMP_WINDOW); if (r.n) loudest = Math.max(loudest, toDb(r.sum / r.n)); }
+      if (loudest - toDb(typical ?? short) > PUMP_RISE_DB) pumps++;
+    }
+    out.pumps = pumps; out.sentenceGaps = looked; out.pumpsPer30s = r1((pumps * 30) / seconds);
+  }
+  return out;
+}
+
+// The words of a narrated film as times in the film, from its manifest: a word ends a sentence when it ends with . ? ! … or is a scene's last.
+export function spokenWords(manifest: { fps: number; scenes: { startFrame: number; words: { word: string; startSec: number; endSec: number }[] }[] }): SpokenWord[] {
+  return manifest.scenes.flatMap((s) => s.words.map((w, i) => ({ start: s.startFrame / manifest.fps + w.startSec, end: s.startFrame / manifest.fps + w.endSec, sentenceEnd: i === s.words.length - 1 || /[.!?…؟׃。！？]["'”’»)\]]*$/.test(w.word.trim()) })));
+}
+
+// Plain-word lines about the voice and the music, ending with advice when the music is too near the voice or too far from it, or pumps.
+export function voiceAdvice(v: VoiceMusic): string {
+  const parts: string[] = [];
+  if (v.voiceOverPauseDb !== undefined) parts.push(`the voice speaks ${v.voiceOverPauseDb.toFixed(1)} dB above the level of the pauses (${v.speechDb.toFixed(1)} against ${v.pauseDb!.toFixed(1)} dBFS)`);
+  else parts.push(`the voice speaks at ${v.speechDb.toFixed(1)} dBFS and there is no pause of 0.5 s to compare it with`);
+  if (v.musicBelowVoiceDb !== undefined) parts.push(`the music under the voice is about ${v.musicBelowVoiceDb.toFixed(0)} dB below it`);
+  if (v.pumps !== undefined) parts.push(`${v.pumps} pump${v.pumps === 1 ? "" : "s"} (${v.pumpsPer30s!.toFixed(1)} per 30 s) in ${v.sentenceGaps} gap${v.sentenceGaps === 1 ? "" : "s"} between sentences`);
+  const advice: string[] = [];
+  if (v.musicBelowVoiceDb !== undefined && v.musicBelowVoiceDb < MUSIC_BELOW_VOICE_DB[0]) advice.push(`The music is too close to the voice (under ${MUSIC_BELOW_VOICE_DB[0]} dB below it) and will compete with it: lower duckTo on <Music>.`);
+  if (v.musicBelowVoiceDb !== undefined && v.musicBelowVoiceDb > MUSIC_BELOW_VOICE_DB[1]) advice.push(`The music is hardly there under the voice (over ${MUSIC_BELOW_VOICE_DB[1]} dB below it): raise duckTo on <Music>.`);
+  if (v.pumpsPer30s !== undefined && v.pumpsPer30s > MAX_PUMPS_PER_30S) advice.push(`The music pumps: its level rises between sentences more than ${MAX_PUMPS_PER_30S} times in 30 s. Keep the gaps tight (plan gap), leave Music's defaults, and give no volume per scene.`);
+  return `Voice against music (estimated from the mix, which has the music and the voice in one signal): ${parts.join("; ")}. ${advice.length ? advice.join(" ") : "Both are inside the targets (the music 10 to 22 dB below the voice, at most 2 pumps in 30 s)."}`;
+}
+
+// Decodes the audio and the picture of a finished film and measures them. The loudness is passed in when mastering already measured it.
+export async function measureSound(path: string, loudness?: number, words?: SpokenWord[]): Promise<SoundReport> {
+  const audio = await tool("ffmpeg", ["-v", "error", "-i", path, "-vn", "-ac", "1", "-ar", String(AUDIO_RATE), "-f", "f32le", "-"]);
+  const samples = new Float32Array(audio.stdout.buffer.slice(audio.stdout.byteOffset, audio.stdout.byteOffset + Math.floor(audio.stdout.length / 4) * 4));
+  const info = await probeVideo(path, path);
+  const w = PICTURE_WIDTH, h = Math.max(2, Math.round((w * info.height) / info.width / 2) * 2);
+  const frames = await tool("ffmpeg", ["-v", "error", "-i", path, "-an", "-vf", `fps=${PICTURE_FPS},scale=${w}:${h}:flags=area,format=gray`, "-f", "rawvideo", "-pix_fmt", "gray", "-"]);
+  const diffs = meanAbsDiffs(new Uint8Array(frames.stdout.buffer, frames.stdout.byteOffset, frames.stdout.length), w * h);
+  const base = soundReport(samples, AUDIO_RATE, diffs, PICTURE_FPS);
+  const voice = words?.length ? voiceAgainstMusic(samples, AUDIO_RATE, words) : undefined;
+  const report: SoundReport = voice ? { ...base, voice } : base;
+  const lufs = loudness ?? (await loudnessLufs(path));
+  return lufs === undefined ? report : { ...report, loudnessLufs: lufs };
+}