mevebu 1.10.0 → 2.0.0

package/mevebu/libs/js/icons.js

@@ -1,5 +1,5 @@
 // GENERATED FILE, DO NOT EDIT.
-// Source: lucide v1.57.0 (ISC), icons/174 names from scripts/vendor-icons.mjs
+// Source: lucide v1.57.0 (ISC), icons/175 names from scripts/vendor-icons.mjs
 // Regenerate with: npm run icons
 
 const D = {
@@ -45,6 +45,7 @@ const D = {
   "download": [ ["path", { d: "M12 15V3" }], ["path", { d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" }], ["path", { d: "m7 10 5 5 5-5" }] ],
   "upload": [ ["path", { d: "M12 3v12" }], ["path", { d: "m17 8-5-5-5 5" }], ["path", { d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" }] ],
   "delete": [ [ "path", { d: "M10 5a2 2 0 0 0-1.344.519l-6.328 5.74a1 1 0 0 0 0 1.481l6.328 5.741A2 2 0 0 0 10 19h10a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2z" } ], ["path", { d: "m12 9 6 6" }], ["path", { d: "m18 9-6 6" }] ],
+  "scissors": [ ["circle", { cx: "6", cy: "6", r: "3" }], ["path", { d: "M8.12 8.12 12 12" }], ["path", { d: "M20 4 8.12 15.88" }], ["circle", { cx: "6", cy: "18", r: "3" }], ["path", { d: "M14.8 14.8 20 20" }] ],
   "arrow-left-right": [ ["path", { d: "M8 3 4 7l4 4" }], ["path", { d: "M4 7h16" }], ["path", { d: "m16 21 4-4-4-4" }], ["path", { d: "M20 17H4" }] ],
   "trash": [ ["path", { d: "M10 11v6" }], ["path", { d: "M14 11v6" }], ["path", { d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6" }], ["path", { d: "M3 6h18" }], ["path", { d: "M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2" }] ],
   "plus": [ ["path", { d: "M5 12h14" }], ["path", { d: "M12 5v14" }] ],

package/mevebu/libs/js/pdf-engine.js

@@ -0,0 +1,67 @@
+// Loaders for the two vendored PDF libraries. Each one is fetched the first time
+// a tool needs it, so opening the index never downloads a PDF engine.
+const PDFJS_URL = new URL("./vendor/pdf.min.mjs", import.meta.url).href;
+const WORKER_URL = new URL("./vendor/pdf.worker.min.mjs", import.meta.url).href;
+const PDFLIB_URL = new URL("./vendor/pdf-lib.min.js", import.meta.url).href;
+
+let pdfjsPromise = null;
+let pdfLibPromise = null;
+
+/** pdf.js, configured to run its worker from this folder, never from a CDN. */
+export function loadPdfjs() {
+  if (!pdfjsPromise) {
+    pdfjsPromise = import(PDFJS_URL).then((module) => {
+      module.GlobalWorkerOptions.workerSrc = WORKER_URL;
+      return module;
+    });
+  }
+  return pdfjsPromise;
+}
+
+/** pdf-lib, which ships as a UMD bundle and lands on `globalThis.PDFLib`. */
+export function loadPdfLib() {
+  if (globalThis.PDFLib) return Promise.resolve(globalThis.PDFLib);
+  if (!pdfLibPromise) {
+    pdfLibPromise = new Promise((resolve, reject) => {
+      const script = document.createElement("script");
+      script.src = PDFLIB_URL;
+      script.onload = () =>
+        globalThis.PDFLib ? resolve(globalThis.PDFLib) : reject(new Error("The PDF writer did not start."));
+      script.onerror = () => reject(new Error("The PDF writer could not be loaded."));
+      document.head.append(script);
+    });
+  }
+  return pdfLibPromise;
+}
+
+export async function readPdfjs(file) {
+  const pdfjs = await loadPdfjs();
+  const bytes = new Uint8Array(await file.arrayBuffer());
+  return pdfjs.getDocument({ data: bytes, isEvalSupported: false }).promise;
+}
+
+export async function readPdfLib(file) {
+  const { PDFDocument } = await loadPdfLib();
+  return PDFDocument.load(await file.arrayBuffer(), { ignoreEncryption: false });
+}
+
+/** "1-3, 7, 10-" against a page count, returning zero based indexes. */
+export function parsePageRange(text, count) {
+  const clean = String(text || "").trim();
+  if (!clean) return Array.from({ length: count }, (_, i) => i);
+  const pages = new Set();
+  for (const part of clean.split(",")) {
+    const piece = part.trim();
+    if (!piece) continue;
+    const match = /^(\d+)?\s*(?:-\s*(\d+)?)?$/.exec(piece);
+    if (!match) throw new Error(`"${piece}" is not a page or a range.`);
+    const from = match[1] ? Number(match[1]) : 1;
+    const to = match[2] ? Number(match[2]) : match[1] ? from : count;
+    if (from < 1 || to < 1) throw new Error("Pages start at 1.");
+    if (from > count || to > count) throw new Error(`This file has ${count} page${count === 1 ? "" : "s"}.`);
+    if (from > to) throw new Error(`"${piece}" runs backwards.`);
+    for (let page = from; page <= to; page++) pages.add(page - 1);
+  }
+  if (!pages.size) throw new Error("That range selects no pages.");
+  return [...pages].sort((a, b) => a - b);
+}

package/mevebu/libs/js/registry.js

@@ -4,7 +4,7 @@
 // one object here plus one file in ./tools/.
 
 export const CATEGORIES = [
-  { id: "random", name: "Random", icon: "shuffle" },
+  { id: "data-gen", name: "Data Generator", icon: "database" },
   { id: "security", name: "Passwords and keys", icon: "shield-check" },
   { id: "developer", name: "Developer", icon: "terminal" },
   { id: "convert", name: "Convert", icon: "repeat" },
@@ -31,58 +31,94 @@ export const CATEGORIES = [
 // one-line intro plus a short list of steps. Keep steps concrete.
 export const TOOLS = [
   {
-    id: "spin-wheel",
-    category: "random",
-    name: "Spin the Wheel",
-    icon: "circle-dashed",
-    note: "Let the wheel pick from your options.",
-    about: "Type your options, press Spin, and the wheel chooses one.",
+    id: "team-generator",
+    category: "data-gen",
+    name: "Team Generator",
+    icon: "users-round",
+    note: "Split a list into balanced groups.",
+    about: "Two modes, exclusion pairs, and one lead per group.",
     tutorial: {
-      intro: "Add one option per line. The wheel picks one at random when you spin.",
+      intro: "Turn a list of names into balanced groups.",
       steps: [
-        "Type your options, one per line.",
-        "Press Spin. The wheel eases to a stop on one entry.",
-        "Each pick is added to the history strip below. Press Clear past picks to reset.",
+        "Paste the names, one per line.",
+        "Pick the number of groups or the size per group.",
+        "Add exclusion pairs and leads if you need them, then press Generate.",
       ],
     },
-    keywords: "random picker chooser decide raffle",
-    load: () => import("./tools/spin-wheel.js"),
+    keywords: "team generator group splitter random groups classroom workshop",
+    load: () => import("./tools/team-generator.js"),
   },
   {
-    id: "name-picker",
-    category: "random",
-    name: "Name Picker",
-    icon: "users",
-    note: "Draw one name or several from a list.",
-    about: "Paste a list, set how many you need, and draw.",
+    id: "roster-generator",
+    category: "data-gen",
+    name: "Roster Rotation",
+    icon: "calendar-check",
+    note: "Build a rotating duty roster.",
+    about: "Names take turns across dates, with pins and weekend skips.",
     tutorial: {
-      intro: "Paste a list of names and draw one or many at a time.",
+      intro: "Build a duty roster that rotates fairly.",
       steps: [
-        "Paste your list, one entry per line.",
-        "Set how many to draw. Toggle No repeats if you want unique picks.",
-        "The draw updates as you edit. Press Draw for a fresh result, then Copy.",
+        "Paste the names in the order they should take turns.",
+        "Set the date range, how many people per day, and whether to skip weekends.",
+        "Pin a date if someone must take it, then copy or download the roster.",
+      ],
+    },
+    keywords: "roster rotation duty schedule shift piket jadwal",
+    load: () => import("./tools/roster-generator.js"),
+  },
+  {
+    id: "sample-csv",
+    category: "data-gen",
+    name: "Sample CSV",
+    icon: "table",
+    note: "Generate a CSV with the columns you define.",
+    about: "Pick a type per column, a row count and a seed that reproduces the file.",
+    tutorial: {
+      intro: "Make a CSV that fits a shape you describe.",
+      steps: [
+        "Add a column and pick its type.",
+        "Set the row count and a seed. The same seed always makes the same file.",
+        "Press Download CSV, or copy from the preview.",
+      ],
+    },
+    keywords: "sample csv fake table fixture test data generator seed",
+    load: () => import("./tools/sample-csv.js"),
+  },
+  {
+    id: "sql-insert",
+    category: "data-gen",
+    name: "SQL Insert",
+    icon: "database",
+    note: "Turn a CSV into INSERT statements.",
+    about: "Postgres, MySQL and SQLite, with correct quoting and NULL handling.",
+    tutorial: {
+      intro: "Seed a database from a spreadsheet.",
+      steps: [
+        "Drop a CSV with a header row.",
+        "Set the table, the schema and the dialect.",
+        "Copy the SQL or download a .sql file.",
       ],
     },
-    keywords: "random draw winner lottery team",
-    load: () => import("./tools/name-picker.js"),
+    keywords: "sql insert generator csv to sql seed database postgres mysql sqlite",
+    load: () => import("./tools/sql-insert.js"),
   },
   {
-    id: "coin-flip",
-    category: "random",
-    name: "Coin Flip",
-    icon: "coins",
-    note: "Heads or tails, with a running count.",
-    about: "Flip as many times as you like. The tally keeps the score.",
+    id: "data-dictionary",
+    category: "data-gen",
+    name: "Data Dictionary",
+    icon: "table-2",
+    note: "Describe a CSV column by column.",
+    about: "Type, nulls, distinct values, range and a sample, as a table or Markdown.",
     tutorial: {
-      intro: "Flip a fair coin. The tally remembers your count across visits.",
+      intro: "Write the document a dataset needs.",
       steps: [
-        "Press Flip. The coin spins and lands on heads or tails.",
-        "The result lands in the field below the coin.",
-        "The tally updates and persists. Press Reset the count to clear it.",
+        "Drop a CSV.",
+        "Read the table: type, empty cells, distinct count, min, max, sample.",
+        "Copy the Markdown or download the CSV version.",
       ],
     },
-    keywords: "random toss decide heads tails",
-    load: () => import("./tools/coin-flip.js"),
+    keywords: "data dictionary csv schema profile columns nulls distinct metadata",
+    load: () => import("./tools/data-dictionary.js"),
   },
 
   {
@@ -395,6 +431,186 @@ export const TOOLS = [
     keywords: "favicon ico png apple touch icon android manifest icon generator",
     load: () => import("./tools/favicon-converter.js"),
   },
+  {
+    id: "image-to-pdf",
+    category: "convert",
+    name: "Image to PDF",
+    icon: "image-up",
+    note: "Turn images into one PDF.",
+    about: "Pick a page size, drag the images into order, and get one PDF.",
+    tutorial: {
+      intro: "Turn one image or a set into a single PDF.",
+      steps: [
+        "Drop the images and drag them into the order you want.",
+        "Pick A4 or Letter, a margin, and whether each image fits inside the page or fills it.",
+        "Press Build PDF. The file downloads from this tab.",
+      ],
+    },
+    keywords: "image to pdf jpg to pdf png to pdf photo to pdf combine images document",
+    load: () => import("./tools/image-to-pdf.js"),
+  },
+  {
+    id: "pdf-to-image",
+    category: "convert",
+    name: "PDF to Image",
+    icon: "file-text",
+    note: "Render every page as a PNG or JPEG.",
+    about: "Choose a page range and a scale, then take the pages as a ZIP of images.",
+    tutorial: {
+      intro: "Every page of a PDF as its own image.",
+      steps: [
+        "Drop a PDF. A preview of the first pages appears.",
+        "Set the range, the format, and the scale. 2x is a sharp screen size.",
+        "Press Download ZIP for one image per page.",
+      ],
+    },
+    keywords: "pdf to image pdf to png pdf to jpg render page screenshot",
+    load: () => import("./tools/pdf-to-image.js"),
+  },
+  {
+    id: "pdf-merge",
+    category: "convert",
+    name: "PDF Merge",
+    icon: "combine",
+    note: "Join several PDFs into one.",
+    about: "Files merge from top to bottom, and the pages stay as they were.",
+    tutorial: {
+      intro: "Combine PDFs without re-rendering them.",
+      steps: [
+        "Drop two or more PDFs.",
+        "Drag or use the arrows to set the order.",
+        "Press Merge PDFs. Text stays selectable because the pages are copied, not redrawn.",
+      ],
+    },
+    keywords: "merge pdf combine pdf join pdf append document",
+    load: () => import("./tools/pdf-merge.js"),
+  },
+  {
+    id: "pdf-split",
+    category: "convert",
+    name: "PDF Split",
+    icon: "scissors",
+    note: "Cut one PDF into parts.",
+    about: "Split by range, by a fixed page count, or one file per page.",
+    tutorial: {
+      intro: "Turn one PDF into several files.",
+      steps: [
+        "Drop a PDF.",
+        "Pick By range, Every N pages, or One per page.",
+        "Press Split and download for a ZIP of the parts.",
+      ],
+    },
+    keywords: "split pdf cut pdf separate pages extract range",
+    load: () => import("./tools/pdf-split.js"),
+  },
+  {
+    id: "pdf-to-text",
+    category: "convert",
+    name: "PDF to Text",
+    icon: "text-search",
+    note: "Copy the text out of a PDF.",
+    about: "Each page is labelled, so the order survives the copy.",
+    tutorial: {
+      intro: "Read the text layer of a PDF.",
+      steps: [
+        "Drop a PDF.",
+        "Set a page range, or leave it empty for every page.",
+        "Press Extract text, then copy it or download a .txt. A scan has no text layer, and the tool says so.",
+      ],
+    },
+    keywords: "pdf to text extract text copy pdf txt document",
+    load: () => import("./tools/pdf-to-text.js"),
+  },
+  {
+    id: "pdf-organizer",
+    category: "convert",
+    name: "PDF Page Organizer",
+    icon: "layout-grid",
+    note: "Reorder, rotate and delete pages.",
+    about: "Every page is a thumbnail. Drag it, turn it, or drop it.",
+    tutorial: {
+      intro: "Rearrange a PDF page by page.",
+      steps: [
+        "Drop a PDF and wait for the thumbnails.",
+        "Drag a page to move it, use the arrows, rotate it, or delete it.",
+        "Press Save PDF. Your original file is never touched.",
+      ],
+    },
+    keywords: "reorder pdf rotate pdf delete page organize pages arrange",
+    load: () => import("./tools/pdf-organizer.js"),
+  },
+  {
+    id: "text-to-pdf",
+    category: "convert",
+    name: "Text to PDF",
+    icon: "file-text",
+    note: "Turn plain text into a clean PDF.",
+    about: "Wrapped lines, real page breaks, selectable text.",
+    tutorial: {
+      intro: "Paste text and get a PDF.",
+      steps: [
+        "Paste the text and add an optional title.",
+        "Pick a page size, margin, font size and line height.",
+        "Press Build PDF. Long lines wrap and long text breaks onto new pages.",
+      ],
+    },
+    keywords: "text to pdf txt to pdf write document page break",
+    load: () => import("./tools/text-to-pdf.js"),
+  },
+  {
+    id: "svg-to-png",
+    category: "convert",
+    name: "SVG to PNG",
+    icon: "image-up",
+    note: "Render an SVG at any pixel size.",
+    about: "Drawn at the size you ask for, so the PNG stays sharp.",
+    tutorial: {
+      intro: "Turn a vector into a PNG.",
+      steps: [
+        "Drop an SVG.",
+        "Set the width and height, or pick a preset.",
+        "Choose a transparent or solid background, then download the PNG.",
+      ],
+    },
+    keywords: "svg to png vector rasterize icon export",
+    load: () => import("./tools/svg-to-png.js"),
+  },
+  {
+    id: "audio-converter",
+    category: "convert",
+    name: "Audio Converter",
+    icon: "activity",
+    note: "Convert audio to WAV.",
+    about: "Resample, trim and normalize, then write 16 bit PCM.",
+    tutorial: {
+      intro: "Decode an audio file and write a clean WAV.",
+      steps: [
+        "Drop an audio file the browser can decode.",
+        "Pick a sample rate and mono or stereo, then trim if you need to.",
+        "Press Convert to WAV.",
+      ],
+    },
+    keywords: "audio converter wav mp3 ogg flac resample normalize trim",
+    load: () => import("./tools/audio-converter.js"),
+  },
+  {
+    id: "video-converter",
+    category: "convert",
+    name: "Video Converter",
+    icon: "video",
+    note: "Convert a video to WebM.",
+    about: "Or pull the audio track out as Opus.",
+    tutorial: {
+      intro: "Record a video into WebM, or take its audio.",
+      steps: [
+        "Drop a video the browser can play.",
+        "Pick WebM video or audio only, a resolution and a bitrate.",
+        "Press Convert and leave the tab in front. Recording runs at real time.",
+      ],
+    },
+    keywords: "video converter webm mp4 opus audio track extract transcode",
+    load: () => import("./tools/video-converter.js"),
+  },
 
   {
     id: "lorem-ipsum",

package/mevebu/libs/js/tools/audio-converter.js

@@ -0,0 +1,228 @@
+// Audio to WAV. The file is decoded with the Web Audio API, optionally
+// resampled, normalized and trimmed, then written as 16 bit PCM by hand.
+import {
+  el, toast, download, bench, stack, panel, selectInput, numberInput, checkbox,
+  button, actions, toolcard, blank, notice,
+} from "../core.js";
+import { dropzone, baseName, formatBytes } from "../files.js";
+
+const RATES = [
+  { value: "22050", label: "22.05 kHz" },
+  { value: "44100", label: "44.1 kHz" },
+  { value: "48000", label: "48 kHz" },
+];
+
+function encodeWav(channels, sampleRate) {
+  const length = channels[0].length;
+  const count = channels.length;
+  const dataBytes = length * count * 2;
+  const buffer = new ArrayBuffer(44 + dataBytes);
+  const view = new DataView(buffer);
+  const bytes = new Uint8Array(buffer);
+  const ascii = (offset, text) => {
+    for (let i = 0; i < text.length; i++) bytes[offset + i] = text.charCodeAt(i);
+  };
+
+  ascii(0, "RIFF");
+  view.setUint32(4, 36 + dataBytes, true);
+  ascii(8, "WAVE");
+  ascii(12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, count, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, sampleRate * count * 2, true);
+  view.setUint16(32, count * 2, true);
+  view.setUint16(34, 16, true);
+  ascii(36, "data");
+  view.setUint32(40, dataBytes, true);
+
+  let at = 44;
+  for (let i = 0; i < length; i++) {
+    for (let channel = 0; channel < count; channel++) {
+      const sample = Math.max(-1, Math.min(1, channels[channel][i]));
+      view.setInt16(at, sample < 0 ? sample * 0x8000 : sample * 0x7fff, true);
+      at += 2;
+    }
+  }
+  return new Blob([buffer], { type: "audio/wav" });
+}
+
+export function mount(slot) {
+  let file = null;
+  let buffer = null;
+  let busy = false;
+  let token = 0;
+
+  const rate = selectInput(RATES, { value: "44100", "aria-label": "Sample rate" });
+  const channels = selectInput(
+    [
+      { value: "keep", label: "Keep" },
+      { value: "1", label: "Mono" },
+      { value: "2", label: "Stereo" },
+    ],
+    { value: "keep", "aria-label": "Channels" }
+  );
+  const start = numberInput({ min: "0", step: "0.1", value: "0", "aria-label": "Start seconds" });
+  const end = numberInput({ min: "0", step: "0.1", value: "0", "aria-label": "End seconds" });
+  const normalize = checkbox("Normalize volume", { checked: false });
+
+  const error = notice("warn");
+  const summary = el("p", { class: "text-sm text-ink-2" });
+  const wave = el("div", { class: "grid h-24 items-end gap-px rounded-r1 border border-orbit bg-deck-2 p-2 [grid-template-columns:repeat(96,minmax(0,1fr))]" });
+  const empty = blank("activity", "Open an audio file to convert it.");
+
+  const drop = dropzone({ label: "Drop audio here", accept: "audio/*", iconName: "activity" });
+  const clearButton = button("Clear", { icon: "trash", kind: "quiet" });
+  const convertButton = button("Convert to WAV", { icon: "download", kind: "fill" });
+
+  function reset() {
+    token++;
+    file = null;
+    buffer = null;
+    wave.replaceChildren();
+    wave.hidden = true;
+    summary.textContent = "";
+    error.write("");
+    empty.hidden = false;
+    convertButton.disabled = true;
+    clearButton.disabled = true;
+  }
+
+  function drawWave() {
+    const data = buffer.getChannelData(0);
+    const bars = 96;
+    const step = Math.max(1, Math.floor(data.length / bars));
+    wave.replaceChildren(
+      ...Array.from({ length: bars }, (_, index) => {
+        let peak = 0;
+        const from = index * step;
+        for (let i = from; i < Math.min(from + step, data.length); i += 16) {
+          const value = Math.abs(data[i]);
+          if (value > peak) peak = value;
+        }
+        return el("span", {
+          class: "block w-full rounded-[1px] bg-jade/70",
+          style: `height:${Math.max(2, Math.round(peak * 100))}%`,
+        });
+      })
+    );
+    wave.hidden = false;
+  }
+
+  async function open(files) {
+    const picked = Array.from(files).find((entry) => entry.type.startsWith("audio/") || /\.(wav|mp3|ogg|flac|m4a|aac|opus|webm)$/i.test(entry.name));
+    if (!picked) {
+      error.write("That file is not audio.");
+      return;
+    }
+    reset();
+    const current = ++token;
+    summary.textContent = "Decoding";
+    try {
+      const context = new AudioContext();
+      const decoded = await context.decodeAudioData(await picked.arrayBuffer());
+      await context.close();
+      if (current !== token) return;
+      file = picked;
+      buffer = decoded;
+      end.value = decoded.duration.toFixed(2);
+      summary.textContent = `${picked.name} · ${decoded.duration.toFixed(2)} s · ${decoded.sampleRate} Hz · ${decoded.numberOfChannels} ch · ${formatBytes(picked.size)}`;
+      empty.hidden = true;
+      convertButton.disabled = false;
+      clearButton.disabled = false;
+      error.write("");
+      drawWave();
+    } catch (caught) {
+      if (current !== token) return;
+      summary.textContent = "";
+      error.write(caught?.message || "This audio file could not be decoded.");
+    }
+  }
+
+  async function convert() {
+    if (!buffer || busy) return;
+    busy = true;
+    const current = ++token;
+    convertButton.disabled = true;
+    summary.textContent = "Rendering";
+    error.write("");
+    try {
+      const targetRate = Number(rate.value) || 44100;
+      const from = Math.max(0, Math.min(buffer.duration, Number(start.value) || 0));
+      const to = Math.max(from + 0.01, Math.min(buffer.duration, Number(end.value) || buffer.duration));
+      const seconds = to - from;
+      const targetChannels = channels.value === "keep" ? buffer.numberOfChannels : Number(channels.value);
+
+      const offline = new OfflineAudioContext(targetChannels, Math.ceil(seconds * targetRate), targetRate);
+      const source = offline.createBufferSource();
+      source.buffer = buffer;
+      source.connect(offline.destination);
+      source.start(0, from, seconds);
+      const rendered = await offline.startRendering();
+      if (current !== token) return;
+
+      const out = [];
+      for (let channel = 0; channel < targetChannels; channel++) {
+        const fromChannel = rendered.numberOfChannels === 1 ? 0 : Math.min(channel, rendered.numberOfChannels - 1);
+        out.push(rendered.getChannelData(fromChannel).slice());
+      }
+
+      if (normalize.input.checked) {
+        let peak = 0;
+        for (const channel of out) for (let i = 0; i < channel.length; i++) peak = Math.max(peak, Math.abs(channel[i]));
+        if (peak > 0) {
+          const gain = 0.98 / peak;
+          for (const channel of out) for (let i = 0; i < channel.length; i++) channel[i] *= gain;
+        }
+      }
+
+      const blob = encodeWav(out, targetRate);
+      download(`${baseName(file.name)}.wav`, blob);
+      summary.textContent = `${seconds.toFixed(2)} s · ${targetRate} Hz · ${targetChannels === 1 ? "mono" : "stereo"} · ${formatBytes(blob.size)}`;
+      toast("WAV ready");
+    } catch (caught) {
+      summary.textContent = "";
+      error.write(caught?.message || "Could not render this audio.");
+    } finally {
+      if (current === token) {
+        busy = false;
+        convertButton.disabled = false;
+      }
+    }
+  }
+
+  drop.onFiles(open);
+  convertButton.addEventListener("click", convert);
+  clearButton.addEventListener("click", reset);
+  reset();
+
+  const shell = toolcard({
+    body: bench(
+      stack(
+        drop,
+        panel("Sample rate", rate),
+        panel("Channels", channels),
+        el("div", { class: "grid grid-cols-2 gap-3" },
+          panel("Start (s)", start),
+          panel("End (s)", end)),
+        normalize,
+        error
+      ),
+      stack(summary, empty, wave,
+        el("p", { class: "m-0 text-2xs leading-[1.6] text-ink-3" },
+          "Output is uncompressed WAV, 16 bit PCM. A three minute stereo song at 44.1 kHz lands near 30 MB, which is normal for the format."))
+    ),
+    foot: actions(clearButton, convertButton),
+  });
+
+  slot.append(shell.node);
+
+  return {
+    unmount() {
+      token++;
+    },
+  };
+}
+
+export default { mount };