@miadi/ava8-measure 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Miadi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,174 @@
+# `@miadi/ava8-measure`
+
+**Read a rendered artefact and hold it to a claim.**
+
+Every other package in the ava8 family writes. `@miadi/ava8-core` writes MIDI;
+`@miadi/movement-conductor` records and summarises a take; `@miadi/capture` stores one.
+Nothing read a rendered artefact back and asked whether it is what it said it was.
+
+That is this package.
+
+ESM only. Zero runtime dependencies beyond `@miadi/ava8-atelier`. No DOM, no filesystem —
+bytes in, numbers out — so it runs in a browser, in a test, and on a capture device.
+
+```bash
+npm install @miadi/ava8-measure
+```
+
+## The rule that defines it
+
+**Read the rendered artefact, never the source.** A generator's header states an intention.
+Three tools sit between that intention and the file, and each has silently changed something
+at least once: an accidental contaminated its bar and moved a note a semitone; a bare `Q:`
+line was ignored so a tempo change existed only in a comment; a container refused a codec and
+wrote zero bytes while reporting success.
+
+**A count that comes out right is not proof.** The right number of drum hits can land off the
+beat. Read placement, not totals.
+
+## Three surfaces
+
+| subpath | reads | answers |
+|---|---|---|
+| `./midi` | Standard MIDI bytes | registers per track and their overlap, band occupancy, duration-weighted pitch classes, mode purity, drum position within the bar, note-for-note and multiset identity between two files |
+| `./audio` | PCM WAV bytes | spectral share in a named band, stridence, f0 by autocorrelation with octave folding, held notes, motif versus drone, recurring interval cells, crossfade seams |
+| `./movement` | OSC capture text | held-value ratio and the real new-value rate, per-second magnitudes, onsets, unwrapped heading, compass sextants, stillness spans |
+
+## The first act on a movement capture is always dedupe
+
+A capture requested at 100 Hz delivered 1627 packets in 16.6 s — 98 Hz of packets, of which
+**1232 were repeats of their predecessor**. 395 new values: 23.8 Hz, median gap 41 ms.
+
+Onsets computed on the raw stream returned 28 attacks spaced 120–133 ms: regular, credible,
+and entirely false. That was the staircase of the held values, not a body. On the deduped
+stream: 15 attacks, spaced 153 to 1481 ms.
+
+So `dedupe` is not an option and it is not a filter you may skip. `onsets` deduplicates by
+default and reports whether it did.
+
+## What the numbers mean, and what they do not
+
+`stridence` is **comparable to itself**. It does not reproduce two figures published by the
+session that invented the method — it reads 15–25 % low against them — because the spectral
+code was never committed and the candidate renders are gone. Re-measure every candidate
+rather than quoting a figure from that day. The doc comment says so at the call site, where
+it is harder to ignore.
+
+`onsets` reproduces the count and the shape of a published list; 11 of 15 timestamps land
+within 30 ms and four do not, because that session's peak-picking was never written down.
+
+Movement captures carry **no declared units**. The capture's own field ledger says the
+channel semantic map is absent. Numbers are reported without units, and the music is built
+from ratios, so nothing is lost — but a unit invented here would be a claim nobody can
+support.
+
+## The conformance harness
+
+This package is a port of three Python programs (`atelier_midi.py`, `atelier_audio.py`,
+`atelier_movement.py`). The port was checked against them — and the checking happened in a
+scratch directory that is gone, leaving a paragraph in a commit message. **A claim nobody can
+re-run is a claim, not a proof**, which is the exact failure this package exists to name, so
+the check now lives in the repository:
+
+| | |
+|---|---|
+| `test/fixtures/` | 19 committed fixtures, 195 KB — 8 MIDI, 6 WAV, 5 OSC captures |
+| `test/fixtures/expected-*.json` | 356 measurements (276 structural, 80 numeric), all written by the Python |
+| `test/conformance.test.mjs` | mirrors every one of them in TypeScript and compares |
+| `scripts/regenerate-fixtures.mjs` | rebuilds the corpus **and** the expected values, end to end |
+
+Those 356 measurements expand to 1741 structural values and 454 numeric ones, because a
+measurement is often a list: every note of a rendered file as a six-tuple, every voiced frame
+of an f0 track, every sextant of a walked circle.
+
+**Synthetic fixtures only.** Every byte of the corpus comes out of a counter or a table in
+`regenerate-fixtures.mjs`. No recording, no movement capture, and nothing out of a composition
+folder is committed, read, or compared against here — consent forbids a person's voice or
+recordings leaving the device they were made on, and "just to compare" is not an exception.
+The harness prints `synthetic fixtures only` on every run.
+
+`node --test test/conformance.test.mjs` needs **no Python and no numpy**. It reads the
+committed JSON. Only regeneration needs the oracle, which is what makes the suite runnable on
+a host where numpy cannot be imported at all.
+
+### Two tiers, and they are not the same claim
+
+**Structural results are compared for exact equality**: note counts, per-track registers and
+their overlaps, band occupancy, drum slots and their bar numbers, dedupe counts, onset counts
+and their rounded times, sextant sequences, heading wraps, stillness spans, held-note
+boundaries, and the formatted verdict strings. Both programs reach these by integer arithmetic
+or by a single division of two counts, so a difference is a defect and never a rounding.
+
+**Spectral and other accumulated results are compared within a published tolerance** — a mean
+power spectrum, an autocorrelation, a compensated mean, anything summed over many
+floating-point operations, where the two languages accumulate in a different order:
+
+| | |
+|---|---|
+| relative tolerance | **1e-9** |
+| absolute floor, for values near zero where a ratio says nothing | **1e-12** |
+
+Both numbers live in `test/fixtures/tolerances.json` and the suite asserts that this table
+still states them, so the two cannot drift apart.
+
+**How they were chosen.** The worst relative divergence this corpus actually produces is
+1.6e-12 (a spectrum bin), and the worst absolute divergence is 1.4e-14 (an f0 frame in MIDI
+floats). 1e-9 leaves roughly three orders of magnitude of headroom over that, which absorbs a
+different libm on a different host without absorbing anything that could change a musical
+verdict: the stridence thresholds are 0.03 apart, seven orders of magnitude coarser. The run
+prints the worst divergence it observed, so the headroom is visible rather than asserted.
+
+### What the harness deliberately does not encode
+
+The two figures named above under *What the numbers mean* are **absent from the corpus on
+purpose**, and `test/conformance.test.mjs` records them under `NOT_REPRODUCED` with the reason
+rather than leaving a silent hole that would read as coverage:
+
+- **stridence** against the session's published 7.60 % and 11.30 % — the spectral code that
+  produced them was never committed and the renders are gone, so a fixture asserting 7.60 %
+  would assert a number no program on this machine can produce. The corpus pins stridence
+  against the Python oracle only: that proves the port agrees with `atelier_audio.py`, and
+  proves nothing about that day's figures.
+- **onsets** against the session's fifteen timestamps — its peak-picking was never written
+  down, and the take is a person's movement capture, which may not leave the device it was
+  made on. The corpus pins `onsets` on a synthetic staircase instead, where the raw stream's
+  three ghost attacks and the deduped stream's three real ones are both committed.
+
+### Regenerating
+
+```bash
+ATELIER_SCRIPTS=/path/to/atelier-jerry/scripts node scripts/regenerate-fixtures.mjs
+node --test test/conformance.test.mjs
+```
+
+The first command writes the corpus, then hands it to `scripts/oracle.py`, which imports the
+three Python modules and writes the expected values. The TypeScript is never consulted during
+regeneration — a harness that generated its own expectations would be comparing the port
+against itself and would prove nothing.
+
+## The FFT is hand-written on purpose
+
+About 120 lines of iterative radix-2 Cooley–Tukey over `Float64Array`. Every call site uses a
+power-of-two length, so radix-2 covers all of it.
+
+The house builds with `tsc` and no bundler. A hand-written transform is smaller than the
+argument about which npm FFT package to trust, and it can be audited in one sitting.
+
+Two details that would silently change every number if they were wrong, and are asserted in
+the tests: the Hann window is the **symmetric** one (`n-1` in the denominator, as numpy
+writes it, not the periodic form every tutorial gives), and a band share sums **magnitude**,
+not power — power puts every piece under one percent and makes a 13.12 % threshold
+unreachable by any sound.
+
+## What it does not own
+
+| | |
+|---|---|
+| the thresholds, the register plan, provenance, consent | `@miadi/ava8-atelier` |
+| writing ABC or MIDI | `@miadi/ava8-core` |
+| rendering or playing a score | `@miadi/ava8-abcjs`, `@miadi/ava8-react` |
+| recording a take, conducting movement into frames | `@miadi/capture`, `@miadi/movement-conductor` |
+| turning a MIDI into audio | `@miadi/jeremyai` |
+
+This package measures. It does not decide what the measurement means — that judgement lives
+in `@miadi/ava8-atelier`, and the decision itself belongs to a person.

package/dist/audio.d.ts

@@ -0,0 +1,343 @@
+/**
+ * Spectral share and pitch, read back off a rendered artefact.
+ *
+ * A port of the atelier's `atelier_audio.py` (numpy + the standard library
+ * `wave` module) onto typed arrays, so the same measurement can run where
+ * numpy cannot. The numbers are the point: this file agrees with that program
+ * on synthetic signals to better than 1e-6 relative, and four details are the
+ * reason it does. Each one silently changes every number if it is written the
+ * way a DSP tutorial writes it.
+ *
+ *  1. `hann(n)` is `np.hanning(n)` — the SYMMETRIC window, denominator `n - 1`,
+ *     not the periodic `n`. The difference is a fraction of a percent of a band
+ *     share, measured against a reject line that sits at 13.12 %.
+ *  2. `bandShare` sums MAGNITUDE by default, not power. Summing |X|² instead
+ *     puts every real piece under 1 % and makes the reject line unreachable by
+ *     any sound, which cannot be what the threshold was calibrated against.
+ *  3. A median over an even-length window is the mean of the two middle values,
+ *     and `medianSmooth` drops NaNs BEFORE taking the median.
+ *  4. The band mask is half-open — `freqs >= lo && freqs < hi`. The `<` decides
+ *     a whole bin at a band edge. (`octaveErrorCheck` uses a CLOSED interval
+ *     around each partial; that difference is in the original and is kept.)
+ *
+ * ## NaN is load-bearing
+ *
+ * `f0Track` returns a `Float64Array` carrying `NaN` for every unvoiced frame,
+ * and `isNaN` guards nearly every loop downstream. Silence with a pitch
+ * attached is an invention, and an unvoiced frame that reads as a number is
+ * how one gets invented. Do not reach for `number | null` here.
+ *
+ * ## Bytes in, never a path
+ *
+ * `decodeWav` takes a `Uint8Array`. This module opens no file, imports no
+ * `node:fs`, and touches no `Buffer` — a measurement library that reads the
+ * disk decides where a recording lives, and that decision belongs to whoever
+ * consented to the recording.
+ */
+import { STRIDENCE, stridenceVerdict } from "@miadi/ava8-atelier";
+import type { StridenceVerdict } from "@miadi/ava8-atelier";
+export { STRIDENCE, stridenceVerdict };
+export type { StridenceVerdict };
+/** Mono float samples in [-1, 1], and the sample rate that produced them. */
+export interface Audio {
+    readonly samples: Float64Array;
+    readonly rate: number;
+    /** Channel count of the source, before the mixdown. */
+    readonly channels: number;
+}
+/** Thrown for a WAV this module will not guess at. */
+export declare class UnsupportedWav extends Error {
+    constructor(message: string);
+}
+/**
+ * Decode a PCM WAV from bytes and mix it down to mono.
+ *
+ * Mono on purpose: every measure here is about spectral content and pitch, and
+ * a stereo pair measured separately would answer twice without deciding
+ * anything. Refuses a compressed or float WAV rather than guessing — a silent
+ * wrong answer is worse than a stop, and it is the same refusal the numpy
+ * original inherits from Python's `wave` module.
+ *
+ * 8-bit is unsigned, 16/24/32-bit are signed little-endian, matching the
+ * original byte for byte — including its `float32` intermediate, which is why
+ * a 32-bit source rounds identically here and there.
+ */
+export declare function decodeWav(bytes: Uint8Array): Audio;
+/** Default analysis frame, so the same file measured on two hosts agrees. */
+export declare const N_FFT = 2048;
+/** Default hop: 50 % overlap. */
+export declare const HOP = 1024;
+/**
+ * `np.hanning(n)` — the SYMMETRIC Hann window, denominator `n - 1`.
+ *
+ * Not the periodic window (`denominator n`) that most DSP writing means by
+ * "Hann". The two differ by about 1e-1 at the shoulders of a short window and
+ * shift a band share by a fraction of a percent, which is the whole margin
+ * between one verdict and another.
+ *
+ * Written as numpy writes it — `0.5 + 0.5·cos(π·n/(M-1))` over
+ * `n = 1-M, 3-M, … M-1` — rather than the algebraically equal
+ * `0.5 - 0.5·cos(2πi/(M-1))`, because the two forms differ in the last bit and
+ * only this one reproduces `np.hanning` exactly.
+ */
+export declare function hann(n: number): Float64Array;
+export interface SpectrumOptions {
+    /** Analysis frame length; must be a power of two. */
+    nFft?: number;
+    /** Frame advance in samples. */
+    hop?: number;
+}
+export interface MeanSpectrum {
+    /** Bin centre frequencies in Hz. */
+    freqs: Float64Array;
+    /** Mean |X|² per bin over every whole frame. */
+    power: Float64Array;
+}
+/**
+ * Mean power spectrum over the whole file, Hann-windowed.
+ *
+ * Fixed 2048-point frames with 50 % overlap, so the same file measured twice
+ * returns the same number. A band edge is given in Hz, never in bins.
+ */
+export declare function spectrum(audio: Audio, opts?: SpectrumOptions): MeanSpectrum;
+export interface BandShareOptions extends SpectrumOptions {
+    /**
+     * `"magnitude"` sums |X| and is the default. `"power"` sums |X|² and is a
+     * DIFFERENT number — never compare one against the other.
+     */
+    weight?: "magnitude" | "power";
+}
+/**
+ * Share of total spectral weight inside an arbitrary Hz band, whole file.
+ *
+ * Decides which instrument a piece gets, and whether an arrangement will mask
+ * a singer. Two bands are read for every candidate timbre: 2-5 kHz (does it
+ * scratch) and the singer's own band in Hz (does it sit on top of them). The
+ * winner is the best of the two numbers, not the prettiest sound.
+ *
+ * `weight: "magnitude"` sums |X| — the default, and the only scale on which
+ * the thresholds in `@miadi/ava8-atelier` mean anything. Summing |X|² instead
+ * puts every real piece under 1 % and makes a 13.12 % reject line unreachable
+ * by any sound, which cannot be what those thresholds were calibrated against.
+ *
+ * The mask is half-open: `freqs >= lo && freqs < hi`.
+ */
+export declare function bandShare(audio: Audio, loHz: number, hiHz: number, opts?: BandShareOptions): number;
+/**
+ * Share of spectral magnitude in 2000-5000 Hz over the whole file.
+ *
+ * THE timbre decision. See `STRIDENCE` and `stridenceVerdict` in
+ * `@miadi/ava8-atelier` for the thresholds; they belong to a musician and are
+ * not redefined here. Whole file on purpose: a bright section measured alone
+ * answers a different question than "does the piece scratch".
+ *
+ * UNVERIFIED against the session's own figures. The atelier's stridence code
+ * was never written down in a generator, and the candidate renders it read
+ * are gone, so this implementation could not be checked number for number.
+ * Measured here on the surviving renders of 2026-08-16: op019 2.09 %,
+ * op018 4.42 %, ava2v2 6.50 %, op023 8.44 % — the same ordering and the same
+ * 4-8 % range the session reported for that day, running 15-25 % low against
+ * the two figures it named (ava2v2 7.60 %, op023 11.30 %). Treat a number
+ * from this function as comparable to another number from this function, and
+ * re-measure every candidate rather than quoting a figure from the day.
+ */
+export declare function stridence(audio: Audio, opts?: BandShareOptions): number;
+export interface F0Track {
+    /** Frame centres, seconds. */
+    times: Float64Array;
+    /** MIDI floats, NaN where unvoiced. */
+    midi: Float64Array;
+    /** Hz, NaN where unvoiced. Recomputed from `midi` after smoothing. */
+    hz: Float64Array;
+    /** Per-frame RMS. */
+    rms: Float64Array;
+    /** Normalised autocorrelation peak, 0-1. */
+    confidence: Float64Array;
+    rate: number;
+    windowS: number;
+    hopS: number;
+}
+export interface F0Options {
+    windowS?: number;
+    hopS?: number;
+    fmin?: number;
+    fmax?: number;
+    confFloor?: number;
+    rmsFloor?: number;
+    /** Frames in the median smoother; 0 or 1 disables it. */
+    smooth?: number;
+}
+/**
+ * Autocorrelation f0 per 40 ms window, 5-frame median smoothing.
+ *
+ * Decides what is actually sung, as opposed to what a listener reports. Two
+ * guards, both earned:
+ *   · frames below `confFloor` or `rmsFloor` are UNVOICED (NaN), not forced to
+ *     a pitch — silence with a pitch attached is an invention;
+ *   · the median smoother removes single-frame octave flips, which are the
+ *     cheap half of the octave problem. The expensive half needs
+ *     `octaveErrorCheck`, and skipping it once invented a note nobody sang.
+ */
+export declare function f0Track(audio: Audio, opts?: F0Options): F0Track;
+/**
+ * Median over `k` frames, NaN-aware. A single wild frame must not become a note.
+ *
+ * NaNs are dropped BEFORE the median, not treated as values and not
+ * propagated: a window that is half unvoiced still has a real median, and a
+ * window that is entirely unvoiced stays NaN.
+ */
+export declare function medianSmooth(series: ArrayLike<number>, k: number): Float64Array;
+/**
+ * Fold every MIDI value down by octaves until it sits at or under `ceiling`.
+ *
+ * Decides where a voice really is. A tracker that reports B4 for a man droning
+ * B2 is reporting its own error, and folding is the first half of the fix —
+ * the second half is `octaveErrorCheck`, which says whether the fold was
+ * warranted or whether the note up there was genuinely sung.
+ */
+export declare function foldOctaves(midiSeries: ArrayLike<number>, ceiling: number, floor?: number): Float64Array;
+export interface OctaveCheckOptions {
+    /** Which sub-partial to test against; 4 asks about f/4. */
+    ratioHz?: number;
+    /** Half-width of the measurement band, as a fraction of the centre. */
+    bandFrac?: number;
+    /** Below this, f/ratio is too low to measure and the frame is skipped. */
+    minHz?: number;
+    /** The analysis window is this many times the tracker's. */
+    longWindowFactor?: number;
+}
+export interface OctaveCheck {
+    frames: number;
+    medianRatio: number | null;
+    meanRatio: number | null;
+    shareBelow: number | null;
+    verdict: string;
+}
+/**
+ * Energy at f/4 against energy at f, frame by frame. This caught an invented note.
+ *
+ * Decides whether a reported high pitch is real. When `shareBelow` is high and
+ * `medianRatio` > 1, the tracker is octave-doubling and the series must be
+ * folded before a note is claimed.
+ *
+ * The analysis window here is longer than the tracker's (4× by default): f/4
+ * of 494 Hz is 123 Hz, which a 40 ms window cannot resolve. Measuring the
+ * correction at the resolution that produced the error would reproduce it.
+ *
+ * The ratio is a POWER ratio, so a component at four times the amplitude reads
+ * 16 and not 4. Verified against a synthesised case: f/4 built at 5× amplitude
+ * reads 24.82. Say which ratio you mean when you quote it.
+ *
+ * Note the band here is CLOSED — `>= lo && <= hi` — unlike the half-open mask
+ * in `bandShare`. That asymmetry is in the original and is preserved.
+ */
+export declare function octaveErrorCheck(audio: Audio, f0: F0Track, opts?: OctaveCheckOptions): OctaveCheck;
+export interface HeldNote {
+    start: number;
+    end: number;
+    midi: number;
+    rms: number;
+    duration: number;
+}
+export interface HeldNoteOptions {
+    minMs?: number;
+    tolSemitones?: number;
+}
+/** What `heldNotes` needs of a track, so a folded MIDI series can be swapped in. */
+export interface F0Like {
+    times: ArrayLike<number>;
+    midi: ArrayLike<number>;
+    rms: ArrayLike<number>;
+    hopS: number;
+}
+/**
+ * Frames that stay within ±1 semitone for at least 200 ms become one note.
+ *
+ * Decides what is singing and what is speech. Speech never holds a pitch for
+ * 200 ms; a drone holds it for seconds. Everything downstream — the
+ * pitch-class profile, the motif database, the interval cells — is built on
+ * these notes and not on frames, because a frame count is a property of the
+ * tracker's hop and a held note is a property of the singer.
+ */
+export declare function heldNotes(f0: F0Like, opts?: HeldNoteOptions): HeldNote[];
+export declare const MOTIF_MIN_NOTES = 3;
+export declare const MOTIF_MIN_DISTINCT = 3;
+export declare const MOTIF_MIN_SPAN = 3;
+export interface Gesture {
+    kind: "motif" | "drone";
+    start: number;
+    end: number;
+    duration: number;
+    nNotes: number;
+    distinct: number;
+    span: number;
+    pitches: number[];
+    intervals: number[];
+    notes: HeldNote[];
+}
+/**
+ * Split held notes into gestures at every silence, then classify each one.
+ *
+ * The rule, and it is a rule and not an impression: a gesture is a MOTIF when
+ * it has ≥3 notes, ≥3 distinct pitches and a span of ≥3 semitones. Anything
+ * else is a DRONE. Without it, someone who drones reads as a melodist — which
+ * is exactly the mistake that would have had them handed a tune to sing
+ * instead of a world to stand inside.
+ */
+export declare function motifs(notes: readonly HeldNote[], opts?: {
+    gapS?: number;
+}): Gesture[];
+export interface IntervalCell {
+    cell: number[];
+    length: number;
+    count: number;
+    times: number[];
+    gestures: number[];
+}
+/**
+ * Recurring interval sequences across gestures, with the time of every hit.
+ *
+ * Intervals and not pitches on purpose: a cell sung twice at different heights
+ * is the same cell, and counting pitches would miss it.
+ *
+ * Returns cells sorted by count then length, each with its timestamps. A cell
+ * that appears once is still returned; the timestamps are what let a human
+ * listen and disagree.
+ */
+export declare function intervalCells(gestures: readonly Gesture[], opts?: {
+    lengths?: readonly number[];
+    motifsOnly?: boolean;
+}): IntervalCell[];
+export interface Seam {
+    at: number;
+    windowS: number;
+    rmsBefore: number;
+    rmsDuring: number;
+    rmsAfter: number;
+    dbBefore: number;
+    dbDuring: number;
+    dbAfter: number;
+    /** `null` when either side is silence — a ratio would excuse the hole. */
+    jumpDb: number | null;
+    silent: boolean;
+    dip: boolean;
+}
+/**
+ * RMS before, during and after every crossfade point.
+ *
+ * Decides whether an assembled piece is listenable. A seam that dips to
+ * silence is a hole; a seam that jumps is a click. Both are audible and both
+ * are invisible in the source score, because the score does not know the
+ * pieces were glued. Reported as levels and as a difference: dB differences
+ * are what an ear notices, and `jumpDb` is the number to argue about.
+ */
+export declare function seams(audio: Audio, times: readonly number[], opts?: {
+    windowS?: number;
+}): Seam[];
+/**
+ * Python's `round(x, d)` — half to EVEN, where JavaScript rounds half away
+ * from zero. `round(2.5)` is 2 in Python and 3 in JavaScript, and the pitches
+ * a motif is classified on are rounded MIDI floats.
+ */
+export declare function pyRound(x: number, digits: number): number;
+//# sourceMappingURL=audio.d.ts.map

package/dist/audio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio.d.ts","sourceRoot":"","sources":["../src/audio.ts"],"names":[],"mappings":"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"}