@onjmin/koe 1.0.5 → 1.0.7

package/dist/index.d.ts

@@ -1,16 +1,44 @@
 /**
  * UTAU `.frq` frequency-analysis files (FREQ0003). The same format OpenUtau
- * reads: an 8-byte header, hop size, then the average fundamental frequency of
- * the recording — exactly the reference pitch we need for correct resampling.
+ * reads: an 8-byte header, hop size, the average fundamental frequency of the
+ * whole recording, then a per-frame f0 / amplitude curve.
  *
  * Layout:
  *   char[8]  "FREQ0003"
- *   int32    hopSize
- *   float64  averageF0   ← the recorded pitch in Hz
+ *   int32    hopSize      ← in ORIGINAL WAV samples
+ *   float64  averageF0    ← whole-file average in Hz
  *   byte[16] (blank)
  *   int32    length
  *   { float64 f0, float64 amp } × length
  */
+interface FrqData {
+    /** Analysis hop in samples of the ORIGINAL wav (not the 48 kHz conversion) */
+    hopSize: number;
+    /** Whole-file average f0 in Hz, as stored in the header */
+    averageF0: number;
+    /** Per-frame f0 in Hz — 0 where the analyser found no clear pitch */
+    f0: Float64Array;
+    /** Per-frame amplitude, parallel to {@link f0} */
+    amp: Float64Array;
+}
+/** Parse a `.frq` file, including the per-frame curve. Null if not FREQ0003. */
+declare function parseFrq(buffer: ArrayBuffer): FrqData | null;
+/**
+ * Average f0 over the voiced frames covering a time span of the recording.
+ *
+ * The header's whole-file average includes leading silence and unvoiced
+ * consonants, so it can sit well away from the pitch actually sounding in the
+ * region a note is built from. Playback resamples the whole phoneme by one
+ * scalar ratio, so an inaccurate value both detunes the note and makes two
+ * crossfading notes drift apart in phase across the overlap — a 1% error at
+ * 233 Hz drifts ~25° over a 30 ms overlap and ~84° over 100 ms.
+ *
+ * @param startMs / endMs  span within the ORIGINAL recording, in milliseconds
+ * @param sourceRate       sample rate of the original WAV the frq describes
+ * @returns Hz, or 0 when the span holds no voiced frames
+ */
+declare function frqAverageF0InRange(frq: FrqData, startMs: number, endMs: number, sourceRate: number): number;
+/** Whole-file average f0 in Hz from a `.frq` file, or null. */
 declare function parseFrqAverageF0(buffer: ArrayBuffer): number | null;
 /** Map a WAV filename to its sibling frq filename: "あ.wav" → "あ_wav.frq". */
 declare function frqFileName(wavName: string): string;
@@ -77,7 +105,7 @@ declare function parseOto(content: string): OtoEntry[];
 
 interface PackInput {
     oto: OtoEntry;
-    /** Full normalized PCM of the source WAV (48kHz / 16bit / mono) */
+    /** Full PCM of the source WAV (48kHz / 16bit / mono) */
     pcm: Int16Array;
     /** Known recorded pitch in Hz (e.g. from the .frq file). 0/undefined → auto-detect. */
     recordedPitch?: number;
@@ -93,6 +121,16 @@ interface TrimmedPhoneme {
     /** Manifest params relative to the trimmed start (sample 0 = oto offset) */
     entry: Omit<PhonemeEntry, "offset">;
 }
+/**
+ * Resolve an oto entry's usable region within the full 48 kHz PCM.
+ *
+ * Shared with the converter CLI, which needs the same bounds to look up the
+ * region's local f0 in a `.frq` curve.
+ */
+declare function otoRegion(pcmLength: number, oto: OtoEntry): {
+    start: number;
+    end: number;
+};
 /**
  * Cut the full WAV PCM down to its usable oto region and recompute parameters
  * relative to the trimmed start.
@@ -107,8 +145,8 @@ interface TrimmedPhoneme {
  */
 declare function trimToOto(pcm: Int16Array, oto: OtoEntry, recordedPitch?: number): TrimmedPhoneme;
 /**
- * Pack normalized PCM phonemes into voice.bin + manifest.json.
- * Each phoneme is trimmed to its oto region first.
+ * Pack phonemes into voice.bin + manifest.json.
+ * Each phoneme is trimmed to its oto region and DC-centred first.
  * Duplicate aliases are silently overwritten by the later entry.
  */
 declare function pack(inputs: PackInput[], referencePitch?: number): PackOutput;
@@ -142,7 +180,27 @@ declare function toMono(wav: WavData): WavData;
 declare function resample(wav: WavData, targetRate: number): WavData;
 /** Convert Float32 [-1,1] samples to Int16 PCM. */
 declare function toInt16(samples: Float32Array): Int16Array;
-/** Normalize then convert a WAV to 48kHz/16bit/mono Int16 PCM. */
+/**
+ * Decode a WAV to 48kHz/16bit/mono Int16 PCM, reporting the source sample rate.
+ *
+ * The rate is needed to index a sibling `.frq` file, whose analysis hop is
+ * counted in ORIGINAL samples — see {@link frqAverageF0InRange}.
+ *
+ * Note this does not touch amplitude: peak levels are carried through
+ * unchanged, so a bank's own relative loudness between phonemes is preserved
+ * (UTAU's engine instead normalises each region to −6 dBFS, which is why its
+ * イ/エ段 and 語尾 samples come out louder than recorded).
+ */
+declare function readWavPcm48k(buf: ArrayBuffer): {
+    pcm: Int16Array;
+    sourceRate: number;
+};
+/**
+ * Convert a WAV to 48kHz/16bit/mono Int16 PCM.
+ *
+ * @deprecated Misnomer — this never normalised amplitude. Use
+ * {@link readWavPcm48k}, which also reports the source sample rate.
+ */
 declare function normalizePcm(buf: ArrayBuffer): Int16Array;
 
 /** Minimal file-like handle so zip entries can stand in for `File` objects. */
@@ -159,6 +217,14 @@ interface ZipFile {
  * original bytes and re-decode with the right encoding per entry.
  */
 declare function unzipToFileMap(data: ArrayBuffer): Promise<Record<string, ZipFile>>;
+/**
+ * Pack a path → bytes map into a zip Blob.
+ *
+ * Entry names are written as UTF-8 with the language flag set, which is what
+ * every current unzip tool reads — including Windows Explorer, so a bank whose
+ * folders are named in Japanese comes back out intact.
+ */
+declare function zipFiles(files: Record<string, Uint8Array>): Blob;
 
 /**
  * Read-only access to a .koe voice bank: its manifest plus per-phoneme PCM,
@@ -203,6 +269,21 @@ interface KoeEngineOptions {
     /** URL to koe-worklet.js. Defaults to './koe-worklet.js'. */
     workletUrl?: string;
 }
+interface PlayOptions {
+    /**
+     * Play the first note's lead-in (its consonant / preutterance region) instead
+     * of skipping straight to the vowel.
+     *
+     * Every note but the first gets its lead-in from the crossfade with the note
+     * before it. The first note has no predecessor, so the lead-in has to come
+     * from somewhere: with `leadIn` the phrase starts one preutterance EARLIER
+     * relative to its beats, and {@link KoeEngine.play} returns that offset in
+     * samples so a sequencer can schedule around it. Left off (the default), the
+     * first note keeps its beat exactly but opens on its vowel, dropping the
+     * consonant.
+     */
+    leadIn?: boolean;
+}
 /**
  * Main-thread API for the koe concatenative synthesis engine.
  *
@@ -237,8 +318,18 @@ declare class KoeEngine {
     load(koe: Blob | string): Promise<void>;
     /** Fetch one phoneme's PCM and deliver it to the worklet (deduped, cached). */
     private ensurePhoneme;
-    /** Stop current playback, preload the phonemes for `notes`, then queue them. */
-    play(notes: NoteEvent[]): Promise<void>;
+    /**
+     * Stop current playback, preload the phonemes for `notes`, then queue them.
+     *
+     * @returns the lead-in offset in samples — how far the first note's audio
+     *          starts ahead of its beat. 0 unless {@link PlayOptions.leadIn}.
+     */
+    play(notes: NoteEvent[], options?: PlayOptions): Promise<number>;
+    /**
+     * Output samples the first note's lead-in occupies ahead of its beat —
+     * mirrors what the worklet does with `leadIn`, so callers can compensate.
+     */
+    private leadInSamples;
     /** Stop playback and clear the queue. */
     stop(): void;
     /** Resume the AudioContext if suspended (e.g. after autoplay block). */
@@ -310,6 +401,25 @@ interface WorldlineLoadOptions {
  * function you give it once per frame.
  */
 type CurveInput = number | ((tMs: number, totalMs: number) => number);
+interface PhraseUnit {
+    pcm: Float64Array;
+    posMs: number;
+    skipMs: number;
+    lengthMs: number;
+    fadeInMs: number;
+    fadeOutMs: number;
+    consonantMs: number;
+    cutMs?: number;
+}
+interface RenderPhraseParams {
+    units: PhraseUnit[];
+    pitch: CurveInput;
+    gender?: CurveInput;
+    tension?: CurveInput;
+    breathiness?: CurveInput;
+    voicing?: CurveInput;
+    tempo?: number;
+}
 interface RenderNoteParams {
     /**
      * Source phoneme PCM normalised to [-1, 1] (e.g. from
@@ -402,6 +512,7 @@ declare class Worldline {
      * @returns Float32 PCM, or null when `pcm` is shorter than
      *          {@link MIN_WORLDLINE_SAMPLES} (too short for stable F0 analysis).
      */
+    renderPhrase(params: RenderPhraseParams): Float32Array | null;
     renderNote(params: RenderNoteParams): Float32Array | null;
 }
 
@@ -420,4 +531,303 @@ declare function parseKoeHeader(headerBytes: ArrayBuffer): {
 /** Byte offset where PCM data begins, given the JSON length. */
 declare const pcmBase: (jsonLength: number) => number;
 
-export { KoeEngine, type KoeEngineOptions, MIN_WORLDLINE_SAMPLES, type Manifest, type NoteEvent, type OtoEntry, type PackInput, type PackOutput, type PhonemeEntry, type RenderNoteParams, type TrimmedPhoneme, VoiceBank, WORLDLINE_SAMPLE_RATE, type WavData, Worldline, type WorldlineLoadOptions, type ZipFile, detectF0, frqFileName, leadInFromEntry, normalizePcm, noteNameToHz, pack, packKoe, parseFrqAverageF0, parseKoeHeader, parseOto, parseWav, pcmBase, pitchFromAliasSuffix, resample, samplesToMs, toInt16, toMono, trimToOto, unzipToFileMap };
+/**
+ * Frame-level acoustic features used to locate mora boundaries.
+ *
+ * Everything downstream reasons in *frames* at a fixed 2 ms hop, so a frame
+ * index doubles as a millisecond timestamp once multiplied by {@link HOP_MS}.
+ * The analysis runs at 16 kHz regardless of the source rate: that is well past
+ * the 4–8 kHz band where fricative noise lives, and keeps a 512-point FFT to
+ * 32 ms — short enough to see a plosive burst, long enough to resolve F1.
+ */
+
+interface Frames {
+    /** Number of frames. */
+    n: number;
+    /** Source duration in milliseconds. */
+    durationMs: number;
+    /** Short-time level in dBFS, −120 for digital silence. */
+    rmsDb: Float32Array;
+    /** {@link rmsDb} smoothed over ~30 ms, for threshold crossings. */
+    smoothDb: Float32Array;
+    /** Normalised autocorrelation peak, 0–1. Above ~0.5 reads as voiced. */
+    voiced: Float32Array;
+    /** Share of spectral energy above 4 kHz — high for /s/, /sh/, /ch/. */
+    highRatio: Float32Array;
+    /** Level of the >4 kHz band alone, in dB. Frication shows here first. */
+    highDb: Float32Array;
+    /** Noise floor of {@link highDb}, in dB. */
+    highFloorDb: number;
+    /** Positive spectral flux, normalised so its own median is 1. */
+    flux: Float32Array;
+    /** Median f0 of the voiced portion, in Hz (0 when nothing is voiced). */
+    f0: number;
+    /** Noise floor in dBFS, estimated from the quietest tenth of the file. */
+    floorDb: number;
+    /**
+     * Level of the quietest 50 ms in the file — a true noise floor, unlike
+     * {@link floorDb}, which a short recording's own voice can drag upwards.
+     * Used to trace an attack back past the point where it is merely audible.
+     */
+    quietDb: number;
+    /** Loudest smoothed frame, in dBFS. */
+    peakDb: number;
+}
+/** Extract every feature the mora estimator needs from one mono signal. */
+declare function analyze(wav: WavData): Frames;
+/** Convenience wrapper: decode a WAV buffer and analyse it. */
+declare function analyzeWav(buf: ArrayBuffer): Frames;
+
+/**
+ * Kana → phoneme tables for oto.ini generation.
+ *
+ * A UTAU recording's filename *is* its phonetic transcript: `か.wav` holds one
+ * mora, `_ああいあうえあ.wav` holds seven. Everything the estimator does — where
+ * to look for the vowel, how wide to make the crossfade, whether the overlap
+ * goes negative — follows from which consonant a mora starts with, so the kana
+ * has to be resolved into (consonant, vowel) before any audio is touched.
+ */
+/**
+ * Articulation class of a mora's initial consonant. The estimator branches on
+ * this to pick where the preutterance lands and what overlap the mora gets;
+ * see `ARTICULATION` in `estimate.ts`.
+ */
+type ConsonantClass = 
+/** あ/い/う/え/お — no consonant at all. */
+"vowel"
+/** ん — a syllabic nasal that is its own nucleus. */
+ | "nasalN"
+/** な/ま行 — voiced throughout, vowel starts at the nasal release. */
+ | "nasal"
+/** ら行 — a flap: brief closure, then the vowel. */
+ | "liquid"
+/** や/わ行 and vowel glides (いぇ, うぉ) — barely a consonant at all. */
+ | "semivowel"
+/** さ/は行 — voiceless noise, so voicing onset *is* the vowel onset. */
+ | "fricativeVoiceless"
+/** ざ行, ヴ — voiced noise. */
+ | "fricativeVoiced"
+/** つ/ち — a stop released into friction; behaves like a plosive. */
+ | "affricate"
+/** か/た/ぱ行 — a silent closure precedes the burst. */
+ | "plosiveVoiceless"
+/** が/だ/ば行 — may prevoice through the closure. */
+ | "plosiveVoiced";
+interface Syllable {
+    /** The kana as written, e.g. "きゃ". Used verbatim in the alias. */
+    kana: string;
+    /** Romanised onset, e.g. "ky". Empty for bare vowels and ん. */
+    consonant: string;
+    /** Romanised nucleus: a/i/u/e/o, or "n" for ん. */
+    vowel: string;
+    cls: ConsonantClass;
+}
+/**
+ * Katakana → hiragana, so ヴァ and ゔぁ resolve identically. Only the kana
+ * block is folded; ー and everything else is left alone for the caller to
+ * reject.
+ */
+declare function toHiragana(s: string): string;
+/**
+ * Split a kana string into moras.
+ *
+ * Returns null if any character is not kana we can resolve — that is the
+ * signal to skip the file entirely, which is what keeps a bank's karaoke
+ * tracks and readme audio out of the generated oto.ini.
+ */
+declare function splitKana(text: string): Syllable[] | null;
+
+/**
+ * Parameter estimation for oto.ini entries.
+ *
+ * The rules encoded here follow the UTAU音源制作wiki's 原音設定 articles
+ * (https://w.atwiki.jp/vbmaker/pages/17.html and its 単独音 / 連続音 sequels):
+ *
+ * - オフセット sits just before the consonant, keeping a little room so the
+ *   attack is never clipped.
+ * - 先行発声 marks where the *vowel* begins — the voicing onset for a voiceless
+ *   consonant, the release for a nasal or a flap, the midpoint of the glide for
+ *   や/わ行.
+ * - 子音部 runs from the offset through the vowel's onset until the spectrum
+ *   settles, so a long note stretches only steady-state vowel.
+ * - オーバーラップ is ~20 ms for さ/な/ま/ら行, ~30 ms for や/わ行, and goes
+ *   *negative* for 破裂音 to reproduce the silent closure of か/た/ぱ行.
+ * - 右ブランク lands just before the note starts to decay.
+ */
+
+/** Frame positions the oto parameters are built from. */
+interface MoraPosition {
+    /** Frame where the consonant (or vowel, if there is none) begins. */
+    consStart: number;
+    /** Frame where the vowel begins — the 先行発声 anchor. */
+    vowelOnset: number;
+    /** Frame past which the vowel is steady. */
+    stable: number;
+    /** True when a voiced stop prevoiced into its burst. */
+    prevoiced: boolean;
+}
+/**
+ * Locate one mora inside `[from, to)`, given what consonant it starts with.
+ */
+declare function locateMora(f: Frames, cls: ConsonantClass, from: number, to: number): MoraPosition;
+/**
+ * 単独音: one mora per file, one entry per alias.
+ *
+ * `aliases` lets a caller emit the usual family for a file — the bare kana plus
+ * a `- か` head variant — all sharing the same measurements.
+ */
+declare function estimateSolo(wav: string, f: Frames, syl: Syllable, aliases: string[]): OtoEntry[];
+/**
+ * A 母音結合 entry (`* あ`): a mid-phrase vowel taken from the steady part of
+ * the note, with the long symmetric crossfade those aliases are used with.
+ */
+declare function estimateVowelJoin(wav: string, f: Frames, syl: Syllable, alias: string): OtoEntry | null;
+/** A 連続音 recording's rhythmic grid. */
+interface Grid {
+    /** Frame of the first mora's onset. */
+    start: number;
+    /** Frames between successive moras. */
+    interval: number;
+    /** Per-mora onset frames, snapped to the strongest nearby transition. */
+    onsets: number[];
+}
+/**
+ * Fit `count` evenly spaced moras to the recording.
+ *
+ * 連続音 lists are sung to a guide BGM, so the moras land on a metronomic grid —
+ * which is exactly why the wiki treats 連続音 oto as something you *generate*
+ * and then touch up. Fitting a global tempo first, and only then snapping each
+ * mora to the nearest real transition, keeps one mis-detected onset from
+ * dragging the rest of the file out of alignment.
+ */
+declare function detectGrid(f: Frames, count: number): Grid | null;
+/**
+ * 連続音: every mora in the file gets an entry, aliased against the vowel it
+ * follows (`a か`), with the first written as a phrase head (`- あ`).
+ *
+ * The template — 先行発声 at half the mora interval, オーバーラップ at a third of
+ * that, 固定範囲 half again as long, 右ブランク two thirds of an interval past the
+ * note — is the one the established 連続音 banks ship, and it survives a mora
+ * whose consonant is longer than average because half an interval is far more
+ * room than any Japanese onset needs.
+ */
+declare function estimateSequence(wav: string, f: Frames, syllables: Syllable[], opts?: {
+    suffix?: string;
+    prefix?: string;
+    trailingRest?: boolean;
+}): OtoEntry[];
+
+/**
+ * Folder → oto.ini, with no manual step in between.
+ *
+ * The filename carries the transcript, so the recording style falls out of it:
+ * one mora per file is 単独音, several is 連続音. Everything else — which
+ * aliases to emit, where the phrase head goes, whether a trailing R belongs on
+ * the end — follows from the same parse.
+ */
+
+interface GenerateOptions {
+    /**
+     * Appended to every alias — the usual home for a multi-pitch or expression
+     * marker (`_G4`, `強`). Defaults to the folder's own note name when it has
+     * one; pass `""` to suppress that.
+     */
+    suffix?: string;
+    /** Emit `- か` phrase-head aliases alongside the bare kana. Default true. */
+    headAliases?: boolean;
+    /** Emit `* あ` 母音結合 aliases for vowel-only files. Default true. */
+    vowelJoinAliases?: boolean;
+}
+/** One file that could not be transcribed, and why. */
+interface SkippedFile {
+    wav: string;
+    reason: string;
+}
+interface GenerateResult {
+    entries: OtoEntry[];
+    skipped: SkippedFile[];
+    /** Recording style inferred from the filenames. */
+    style: "solo" | "sequence" | "mixed" | "empty";
+}
+/** What one recording produced. */
+interface FileResult {
+    entries: OtoEntry[];
+    /** Set instead of entries when the file could not be set up. */
+    skipped: SkippedFile | null;
+    /** Style this one file was read as, or null if it was skipped. */
+    style: "solo" | "sequence" | null;
+}
+interface WavInput {
+    /** Filename as it appears in oto.ini, e.g. `_ああいあう.wav`. */
+    name: string;
+    data: ArrayBuffer;
+}
+interface Transcript {
+    syllables: Syllable[];
+    trailingRest: boolean;
+    /** Non-kana marker before the kana, e.g. the `x` of `_xか.wav`. */
+    prefix: string;
+    /** Non-kana marker after the kana, e.g. the `b` of `_あb.wav`. */
+    mark: string;
+}
+/**
+ * Read the transcript out of a filename.
+ *
+ * The leading `_` that marks a recording-list file, an extension, and a
+ * trailing pitch tag are all noise; what is left has to be kana end to end, or
+ * the file is not a voice sample we can set up (a karaoke track, a sample song,
+ * a readme recording).
+ */
+declare function transcribe(filename: string): Transcript | null;
+/**
+ * Alias suffix implied by a folder's name.
+ *
+ * A multi-pitch bank keeps one folder per pitch and merges every oto.ini into
+ * one alias namespace, so without the pitch tag each folder's `- あ` would
+ * overwrite the last. The tag is taken either from a folder named for nothing
+ * but the pitch (`G4`) or from an explicit `_G4` token inside a longer name
+ * (`多音階03：_G4（連続音）`). A bare `G4` buried in a name is left alone — in
+ * `表情音01：強（G4歌連続音）` it describes the take, and the suffix the bank
+ * actually uses there is `強`, which no filename carries.
+ */
+declare function suffixFromFolderName(folder: string): string;
+/**
+ * Estimate oto.ini entries for every WAV in one folder.
+ *
+ * Decoding and analysis are per-file and independent, so a bad WAV is reported
+ * and skipped rather than failing the folder.
+ */
+declare function generateOtoForFile(file: WavInput, options?: GenerateOptions): FileResult;
+/**
+ * Estimate oto.ini entries for every WAV in one folder.
+ *
+ * Decoding and analysis are per-file and independent, so a bad WAV is reported
+ * and skipped rather than failing the folder. A caller that needs to stay
+ * responsive — a browser UI, say — should drive {@link generateOtoForFile}
+ * itself and yield between files.
+ */
+declare function generateOto(files: readonly WavInput[], options?: GenerateOptions): GenerateResult;
+/** Fold per-file styles into the one label that describes the folder. */
+declare function summarise(solo: number, sequence: number): GenerateResult["style"];
+
+/**
+ * oto.ini serialisation.
+ *
+ * UTAU reads oto.ini as Shift-JIS, and OpenUtau follows a bank's declared
+ * encoding, so writing UTF-8 would leave every kana alias mojibake in the
+ * original editor. There is no Shift-JIS *encoder* in the platform — only a
+ * decoder — so the table is built by decoding every legal byte pair once and
+ * inverting the result.
+ */
+
+/**
+ * Encode text as Shift-JIS. Characters with no Shift-JIS form become `?`,
+ * matching what UTAU's own tools do rather than corrupting the line.
+ */
+declare function encodeShiftJis(text: string): Uint8Array;
+/** Render entries as oto.ini text (CRLF, as UTAU writes it). */
+declare function formatOto(entries: readonly OtoEntry[]): string;
+/** Render entries as Shift-JIS oto.ini bytes, ready to write to disk. */
+declare function encodeOto(entries: readonly OtoEntry[]): Uint8Array;
+
+export { type ConsonantClass, type FileResult, type Frames, type FrqData, type GenerateOptions, type GenerateResult, type Grid, KoeEngine, type KoeEngineOptions, MIN_WORLDLINE_SAMPLES, type Manifest, type MoraPosition, type NoteEvent, type OtoEntry, type PackInput, type PackOutput, type PhonemeEntry, type PlayOptions, type RenderNoteParams, type SkippedFile, type Syllable, type TrimmedPhoneme, VoiceBank, WORLDLINE_SAMPLE_RATE, type WavData, type WavInput, Worldline, type WorldlineLoadOptions, type ZipFile, analyze, analyzeWav, detectF0, detectGrid, encodeOto, encodeShiftJis, estimateSequence, estimateSolo, estimateVowelJoin, formatOto, frqAverageF0InRange, frqFileName, generateOto, generateOtoForFile, leadInFromEntry, locateMora, normalizePcm, noteNameToHz, otoRegion, pack, packKoe, parseFrq, parseFrqAverageF0, parseKoeHeader, parseOto, parseWav, pcmBase, pitchFromAliasSuffix, readWavPcm48k, resample, samplesToMs, splitKana, suffixFromFolderName, summarise, toHiragana, toInt16, toMono, transcribe, trimToOto, unzipToFileMap, zipFiles };