@sudobility/music_codecs 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @sudobility/music_codecs — the score encoders and decoders.
+ *
+ * Every file format ScoreSmith reads or writes lives here: MIDI, MusicXML and
+ * the tracker modules. Each one turns bytes-shaped input into a `Score`, or a
+ * `Score` back out, and does nothing else — no store, no rendering, no audio,
+ * no platform.
+ *
+ * That is why it is its own package. `music_api` (backend) and `music_lib`
+ * (frontend) both need to read a MIDI file, and neither may depend on the
+ * other; before this package existed the server imported the frontend library
+ * to get at its importer, and separately hand-copied helpers to avoid doing
+ * so. Both sides now depend on this, and on `@sudobility/music_types` for the
+ * score model and the domain primitives these operate on.
+ *
+ * Raw byte work — parsing a MIDI file into tracks and notes, or XML into a
+ * DOM — belongs to `@sudobility/music_io`, which is injected: these modules
+ * take a `MidiCodec` or an `XmlParser` rather than importing one, so they stay
+ * free of anything platform-shaped.
+ */
+export * from './midi/analyze.js';
+export * from './midi/export.js';
+export * from './midi/grid-detection.js';
+export * from './midi/import.js';
+export * from './midi/import-options.js';
+export * from './midi/key-detection.js';
+export * from './midi/measures.js';
+export * from './musicxml/duration-map.js';
+export * from './musicxml/import.js';
+/**
+ * `safeFilename` is exported by both writers and they are not the same
+ * function — each sanitises for its own format's conventions. The MIDI one
+ * keeps the bare name it always had; the MusicXML one is named for its format
+ * rather than one of them silently shadowing the other.
+ */
+export { exportMusicXml, safeFilename as musicXmlSafeFilename, } from './musicxml/export.js';
+export * from './mod/export.js';
+export * from './mod/fill.js';
+export * from './mod/import.js';
+export * from './mod/limits.js';
+export * from './mod/timing.js';
+export * from './mod/types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC;;;;;GAKG;AACH,OAAO,EACL,cAAc,EACd,YAAY,IAAI,oBAAoB,GACrC,MAAM,sBAAsB,CAAC;AAG9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,46 @@
+/**
+ * @sudobility/music_codecs — the score encoders and decoders.
+ *
+ * Every file format ScoreSmith reads or writes lives here: MIDI, MusicXML and
+ * the tracker modules. Each one turns bytes-shaped input into a `Score`, or a
+ * `Score` back out, and does nothing else — no store, no rendering, no audio,
+ * no platform.
+ *
+ * That is why it is its own package. `music_api` (backend) and `music_lib`
+ * (frontend) both need to read a MIDI file, and neither may depend on the
+ * other; before this package existed the server imported the frontend library
+ * to get at its importer, and separately hand-copied helpers to avoid doing
+ * so. Both sides now depend on this, and on `@sudobility/music_types` for the
+ * score model and the domain primitives these operate on.
+ *
+ * Raw byte work — parsing a MIDI file into tracks and notes, or XML into a
+ * DOM — belongs to `@sudobility/music_io`, which is injected: these modules
+ * take a `MidiCodec` or an `XmlParser` rather than importing one, so they stay
+ * free of anything platform-shaped.
+ */
+// ---- MIDI -----------------------------------------------------------------
+export * from './midi/analyze.js';
+export * from './midi/export.js';
+export * from './midi/grid-detection.js';
+export * from './midi/import.js';
+export * from './midi/import-options.js';
+export * from './midi/key-detection.js';
+export * from './midi/measures.js';
+// ---- MusicXML -------------------------------------------------------------
+export * from './musicxml/duration-map.js';
+export * from './musicxml/import.js';
+/**
+ * `safeFilename` is exported by both writers and they are not the same
+ * function — each sanitises for its own format's conventions. The MIDI one
+ * keeps the bare name it always had; the MusicXML one is named for its format
+ * rather than one of them silently shadowing the other.
+ */
+export { exportMusicXml, safeFilename as musicXmlSafeFilename, } from './musicxml/export.js';
+// ---- Tracker modules (MOD, S3M, XM, IT, MPTM) -----------------------------
+export * from './mod/export.js';
+export * from './mod/fill.js';
+export * from './mod/import.js';
+export * from './mod/limits.js';
+export * from './mod/timing.js';
+export * from './mod/types.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,8EAA8E;AAC9E,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AAEnC,8EAA8E;AAC9E,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC;;;;;GAKG;AACH,OAAO,EACL,cAAc,EACd,YAAY,IAAI,oBAAoB,GACrC,MAAM,sBAAsB,CAAC;AAE9B,8EAA8E;AAC9E,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC"}

package/dist/midi/analyze.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Read-only summary of a raw MIDI file, for the import wizard (spec §15):
+ * per-track name/channel/program/note-count/duration, tempo events, and
+ * time signatures, without importing anything into the score model yet.
+ */
+import type { MidiCodec, MidiFile } from '@sudobility/music_types';
+import { type DetectedGrid } from './grid-detection.js';
+export type MidiTrackSummary = {
+    index: number;
+    name: string;
+    channel: number;
+    program: number;
+    instrumentName: string;
+    noteCount: number;
+    durationSeconds: number;
+    /** True when the track's channel is 9 (GM channel 10), the standard percussion channel. */
+    isPercussion: boolean;
+    /** Mean MIDI note number of the track's notes, or `null` if it has none — used to default a target clef. */
+    averageMidi: number | null;
+};
+export type MidiTempoEventSummary = {
+    tick: number;
+    bpm: number;
+};
+export type MidiTimeSignatureSummary = {
+    tick: number;
+    numerator: number;
+    denominator: number;
+};
+export type MidiSummary = {
+    ppq: number;
+    durationSeconds: number;
+    tracks: MidiTrackSummary[];
+    tempoEvents: MidiTempoEventSummary[];
+    timeSignatures: MidiTimeSignatureSummary[];
+    /**
+     * The grid the file's onsets already sit on, which the wizard opens
+     * pre-filled with. Detected rather than assumed so that importing a file
+     * written in triplets or swing does not snap it onto a straight grid — see
+     * `grid-detection.ts`.
+     */
+    detectedGrid: DetectedGrid;
+};
+/**
+ * Parses `data` as a Standard MIDI File and summarizes it for the import
+ * wizard's track list/preview. Throws if `data` isn't valid MIDI (parsing
+ * errors are a caller concern — the file picker/wizard is expected to
+ * surface them, per spec §28).
+ */
+export declare function analyzeMidiFile(midi: MidiFile): MidiSummary;
+/** Decodes `data` and summarizes it. The codec is the only platform-bound part. */
+export declare function analyzeMidi(data: ArrayBuffer, codec: MidiCodec): MidiSummary;
+//# sourceMappingURL=analyze.d.ts.map

package/dist/midi/analyze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../src/midi/analyze.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EACV,SAAS,EACT,QAAQ,EAET,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAc,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEpE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,2FAA2F;IAC3F,YAAY,EAAE,OAAO,CAAC;IACtB,4GAA4G;IAC5G,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAElE,MAAM,MAAM,wBAAwB,GAAG;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,WAAW,EAAE,qBAAqB,EAAE,CAAC;IACrC,cAAc,EAAE,wBAAwB,EAAE,CAAC;IAC3C;;;;;OAKG;IACH,YAAY,EAAE,YAAY,CAAC;CAC5B,CAAC;AAsBF;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,WAAW,CAiC3D;AAED,mFAAmF;AACnF,wBAAgB,WAAW,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,GAAG,WAAW,CAE5E"}

package/dist/midi/analyze.js

@@ -0,0 +1,58 @@
+import { detectGrid } from './grid-detection.js';
+function summarizeTrack(track, index) {
+    const noteCount = track.notes.length;
+    const averageMidi = noteCount > 0
+        ? track.notes.reduce((sum, note) => sum + note.midi, 0) / noteCount
+        : null;
+    return {
+        index,
+        name: track.name.length > 0 ? track.name : `Track ${index + 1}`,
+        channel: track.channel,
+        program: track.instrument.number,
+        instrumentName: track.instrument.name ?? 'Instrument',
+        noteCount,
+        durationSeconds: track.durationSeconds,
+        isPercussion: track.channel === 9,
+        averageMidi,
+    };
+}
+/**
+ * Parses `data` as a Standard MIDI File and summarizes it for the import
+ * wizard's track list/preview. Throws if `data` isn't valid MIDI (parsing
+ * errors are a caller concern — the file picker/wizard is expected to
+ * surface them, per spec §28).
+ */
+export function analyzeMidiFile(midi) {
+    // Every track counts, percussion included. Excluding the drums was a
+    // mistake: the grid chosen here is applied to *all* of them, so leaving a
+    // hi-hat laid on thirty-seconds out of the decision let the melody pick a
+    // quarter-note grid and then collapsed the whole kit onto the beat. Erring
+    // toward a finer grid costs only some tidiness in the notation; erring
+    // toward a coarser one destroys the groove.
+    //
+    // Note ends go in alongside onsets because the chosen grid quantizes
+    // durations too — see `detectGrid`. Percussion contributes onsets only: a
+    // drum hit's length is an artefact of how it was recorded, not something
+    // anyone plays or reads, and those arbitrary note-offs fit no grid at all,
+    // so counting them would send every file with drums to the fallback.
+    const positions = midi.tracks.flatMap(track => track.notes.flatMap(note => track.channel === 9
+        ? [note.ticks]
+        : [note.ticks, note.ticks + note.durationTicks]));
+    return {
+        ppq: midi.header.ppq,
+        detectedGrid: detectGrid(positions, midi.header.ppq),
+        durationSeconds: midi.duration,
+        tracks: midi.tracks.map(summarizeTrack),
+        tempoEvents: midi.header.tempos.map(t => ({ tick: t.ticks, bpm: t.bpm })),
+        timeSignatures: midi.header.timeSignatures.map(t => ({
+            tick: t.ticks,
+            numerator: t.timeSignature[0],
+            denominator: t.timeSignature[1],
+        })),
+    };
+}
+/** Decodes `data` and summarizes it. The codec is the only platform-bound part. */
+export function analyzeMidi(data, codec) {
+    return analyzeMidiFile(codec.decode(data));
+}
+//# sourceMappingURL=analyze.js.map

package/dist/midi/analyze.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.js","sourceRoot":"","sources":["../../src/midi/analyze.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,UAAU,EAAqB,MAAM,qBAAqB,CAAC;AAuCpE,SAAS,cAAc,CAAC,KAAoB,EAAE,KAAa;IACzD,MAAM,SAAS,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC;IACrC,MAAM,WAAW,GACf,SAAS,GAAG,CAAC;QACX,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,SAAS;QACnE,CAAC,CAAC,IAAI,CAAC;IAEX,OAAO;QACL,KAAK;QACL,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,KAAK,GAAG,CAAC,EAAE;QAC/D,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,OAAO,EAAE,KAAK,CAAC,UAAU,CAAC,MAAM;QAChC,cAAc,EAAE,KAAK,CAAC,UAAU,CAAC,IAAI,IAAI,YAAY;QACrD,SAAS;QACT,eAAe,EAAE,KAAK,CAAC,eAAe;QACtC,YAAY,EAAE,KAAK,CAAC,OAAO,KAAK,CAAC;QACjC,WAAW;KACZ,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAC,IAAc;IAC5C,qEAAqE;IACrE,0EAA0E;IAC1E,0EAA0E;IAC1E,2EAA2E;IAC3E,uEAAuE;IACvE,4CAA4C;IAC5C,EAAE;IACF,qEAAqE;IACrE,0EAA0E;IAC1E,yEAAyE;IACzE,2EAA2E;IAC3E,qEAAqE;IACrE,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAC5C,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CACzB,KAAK,CAAC,OAAO,KAAK,CAAC;QACjB,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC;QACd,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,CAClD,CACF,CAAC;IAEF,OAAO;QACL,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG;QACpB,YAAY,EAAE,UAAU,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC;QACpD,eAAe,EAAE,IAAI,CAAC,QAAQ;QAC9B,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,cAAc,CAAC;QACvC,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;QACzE,cAAc,EAAE,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACnD,IAAI,EAAE,CAAC,CAAC,KAAK;YACb,SAAS,EAAE,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC;YAC7B,WAAW,EAAE,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC;SAChC,CAAC,CAAC;KACJ,CAAC;AACJ,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,WAAW,CAAC,IAAiB,EAAE,KAAgB;IAC7D,OAAO,eAAe,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AAC7C,CAAC"}

package/dist/midi/export.d.ts

@@ -0,0 +1,20 @@
+import type { MidiCodec, Score } from '@sudobility/music_types';
+/**
+ * Exports `score` as a Standard MIDI File byte array: PPQ, tempo map, time
+ * signatures, per-track name/program/channel (percussion-clef tracks use
+ * channel 9/GM channel 10), notes (with velocity), and volume (CC7) / pan
+ * (CC10) set at each track's start. Tied notes are rejoined into single MIDI
+ * notes before export (MIDI has no tie concept). Sustain pedal data isn't
+ * part of the internal `Score` model, so none is emitted (spec §16's
+ * "sustain where represented" — nothing is represented here yet).
+ */
+export declare function exportMidi(score: Score, codec: MidiCodec): Uint8Array;
+/**
+ * Slugifies `title` into a filesystem/URL-safe download filename (no
+ * extension): lowercase, `[a-z0-9]` runs joined by single hyphens, leading/
+ * trailing hyphens trimmed. Falls back to `"untitled"` for a title with no
+ * alphanumeric characters at all (empty, whitespace-only, or
+ * punctuation-only).
+ */
+export declare function safeFilename(title: string): string;
+//# sourceMappingURL=export.d.ts.map

package/dist/midi/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../src/midi/export.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,SAAS,EAMT,KAAK,EAGN,MAAM,yBAAyB,CAAC;AAmFjC;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,GAAG,UAAU,CAoCrE;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMlD"}

package/dist/midi/export.js

@@ -0,0 +1,135 @@
+/**
+ * Score -> Standard MIDI File export (spec §16). Pure and read-only: never
+ * mutates `score`. `@tonejs/midi` is the designated MIDI library (spec §15)
+ * and its use here is an explicitly sanctioned exception to the
+ * adapters/services "no non-domain library" purity rule.
+ */
+import { pitchToMidi } from '@sudobility/music_types';
+import { joinTiedNotes } from '@sudobility/music_types';
+import { isNoteEvent } from '@sudobility/music_types';
+/** General MIDI channel 10 (0-indexed 9), the standard percussion channel. */
+const PERCUSSION_CHANNEL = 9;
+const CC_VOLUME = 7;
+const CC_PAN = 10;
+const MIDI_VELOCITY_MAX = 127;
+function clamp01(v) {
+    return Math.max(0, Math.min(1, v));
+}
+/** Maps a track's `pan` ([-1, 1], 0 = center) to MIDI CC10's normalized [0, 1] range (0.5 = center). */
+function panToNormalized(pan) {
+    return clamp01((pan + 1) / 2);
+}
+/** The most voices any single measure of `track` has (so every "voice channel" ordinal position is covered). */
+function maxVoiceCount(track) {
+    return track.measures.reduce((max, measure) => Math.max(max, measure.voices.length), 0);
+}
+/**
+ * All of `track`'s note events, ordinal-voice ties rejoined across measure
+ * boundaries. Notes are gathered per "voice channel" — the same ordinal
+ * voice-index-across-measures approximation `domain/score/ties.ts` uses
+ * internally (see its `voiceChannel` doc comment) — since a measure's voice
+ * ids aren't stable across a barline, so a chain can only be tracked by
+ * position. Order across channels/within is by `startTick`.
+ */
+function collectTrackNotes(track) {
+    const voiceCount = maxVoiceCount(track);
+    const notes = [];
+    for (let voiceIndex = 0; voiceIndex < voiceCount; voiceIndex += 1) {
+        const channelEvents = [];
+        for (const measure of track.measures) {
+            const voice = measure.voices[voiceIndex];
+            if (voice)
+                channelEvents.push(...voice.events);
+        }
+        channelEvents.sort((a, b) => a.startTick - b.startTick);
+        notes.push(...joinTiedNotes(channelEvents).filter(isNoteEvent));
+    }
+    return notes;
+}
+/**
+ * Distinct `(tick, [numerator, denominator])` time-signature changes,
+ * derived from the first track's measures (spec §16 approximation: MIDI
+ * has one shared meter timeline, while this app's `Score` technically
+ * stores a `timeSignature` per measure per track — in practice every track
+ * shares the same meter sequence, so the first track's is authoritative).
+ * Falls back to a single 4/4-at-0 entry for a score with no tracks/measures.
+ */
+function collectTimeSignatureChanges(score) {
+    const track = score.tracks[0];
+    if (!track || track.measures.length === 0)
+        return [{ ticks: 0, timeSignature: [4, 4] }];
+    const changes = [];
+    let last = null;
+    for (const measure of track.measures) {
+        const ts = measure.timeSignature;
+        if (!last ||
+            last.numerator !== ts.numerator ||
+            last.denominator !== ts.denominator) {
+            changes.push({
+                ticks: measure.startTick,
+                timeSignature: [ts.numerator, ts.denominator],
+            });
+            last = ts;
+        }
+    }
+    return changes;
+}
+/**
+ * Exports `score` as a Standard MIDI File byte array: PPQ, tempo map, time
+ * signatures, per-track name/program/channel (percussion-clef tracks use
+ * channel 9/GM channel 10), notes (with velocity), and volume (CC7) / pan
+ * (CC10) set at each track's start. Tied notes are rejoined into single MIDI
+ * notes before export (MIDI has no tie concept). Sustain pedal data isn't
+ * part of the internal `Score` model, so none is emitted (spec §16's
+ * "sustain where represented" — nothing is represented here yet).
+ */
+export function exportMidi(score, codec) {
+    const file = {
+        header: {
+            name: score.metadata.title,
+            ppq: score.ppq,
+            tempos: score.tempoMap.map(t => ({ ticks: t.tick, bpm: t.bpm })),
+            timeSignatures: collectTimeSignatureChanges(score),
+        },
+        tracks: score.tracks.map((track) => ({
+            name: track.name,
+            channel: track.clef === 'percussion' ? PERCUSSION_CHANNEL : track.midiChannel,
+            instrument: { number: track.midiProgram },
+            notes: collectTrackNotes(track).map(note => ({
+                midi: pitchToMidi(note.pitch),
+                ticks: note.startTick,
+                durationTicks: Math.max(1, note.durationTicks),
+                velocity: clamp01(note.velocity / MIDI_VELOCITY_MAX),
+            })),
+            controlChanges: {
+                [CC_VOLUME]: [
+                    { number: CC_VOLUME, ticks: 0, value: clamp01(track.volume) },
+                ],
+                [CC_PAN]: [
+                    { number: CC_PAN, ticks: 0, value: panToNormalized(track.pan) },
+                ],
+            },
+            // Durations are outputs of decoding, not inputs to encoding; the codec
+            // ignores them here.
+            durationTicks: 0,
+            durationSeconds: 0,
+        })),
+        duration: 0,
+    };
+    return codec.encode(file);
+}
+/**
+ * Slugifies `title` into a filesystem/URL-safe download filename (no
+ * extension): lowercase, `[a-z0-9]` runs joined by single hyphens, leading/
+ * trailing hyphens trimmed. Falls back to `"untitled"` for a title with no
+ * alphanumeric characters at all (empty, whitespace-only, or
+ * punctuation-only).
+ */
+export function safeFilename(title) {
+    const slug = title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return slug.length > 0 ? slug : 'untitled';
+}
+//# sourceMappingURL=export.js.map

package/dist/midi/export.js.map

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

package/dist/midi/grid-detection.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Choosing the quantization grid a MIDI file actually needs.
+ *
+ * Import used to snap every file to a fixed sixteenth grid. That is
+ * destructive for files that were already sequenced on another grid: an
+ * eighth-note triplet sits at 1/3 of a beat, the nearest sixteenth is 1/4 or
+ * 1/2, and the even triplet comes out as a limping dotted-sixteenth figure.
+ * Measured on a 120bpm triplet line, every second and third note of each group
+ * moved by 42ms. Swung eighths break the same way.
+ * The notes are all still there, which is why this reads as "the timing is
+ * wrong" rather than as anything missing.
+ *
+ * So: find the coarsest grid the file's own onsets already sit on, and use
+ * that — quantizing to a grid the music is on cannot move anything. If nothing
+ * fits, keep quantization off by default. A performance MIDI is already the
+ * timing the listener expects, and snapping it is an editing choice, not a
+ * safe default.
+ */
+import type { DurationName } from '@sudobility/music_types';
+export type DetectedGrid = {
+    grid: DurationName | null;
+    /** Triplet subdivision of `grid` — 2/3 of it, matching `quantize`'s `tripletGrid`. */
+    triplet: boolean;
+};
+/** No grid is assumed when the onsets fit nothing; preserve performance timing. */
+export declare const FALLBACK_GRID: DetectedGrid;
+/**
+ * The coarsest grid `positions` already sit on, or no grid when none does.
+ * `ppq` is the file's own resolution — positions are compared in beats, so a
+ * 960-ppq file and a 480-ppq one holding the same music detect alike.
+ *
+ * Callers pass note *ends* as well as onsets. The chosen grid quantizes
+ * durations too, so a grid picked from onsets alone can still be too coarse to
+ * express the file: a piece played in staccato quarters has quarter-note
+ * onsets but eighth-note ends, and snapping those ends up to the quarter grid
+ * would smear every note into the next and make the whole thing sound
+ * sluggish. Feeding ends in makes the detector reject a grid that cannot hold
+ * them.
+ */
+export declare function detectGrid(positions: number[], ppq: number): DetectedGrid;
+//# sourceMappingURL=grid-detection.d.ts.map

package/dist/midi/grid-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid-detection.d.ts","sourceRoot":"","sources":["../../src/midi/grid-detection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAE5D,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;IAC1B,sFAAsF;IACtF,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAwBF,mFAAmF;AACnF,eAAO,MAAM,aAAa,EAAE,YAA6C,CAAC;AA0B1E;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,YAAY,CAKzE"}

package/dist/midi/grid-detection.js

@@ -0,0 +1,61 @@
+/**
+ * Candidates coarsest first, so the first fit wins: a file of straight eighths
+ * should be described as eighths, not as the thirtysecond grid that also
+ * happens to contain them. Both straight and triplet subdivisions are offered
+ * at each level; the finest entry (1/12 beat) is the grid that contains both
+ * sixteenths and eighth triplets, for files that use the two together.
+ */
+const CANDIDATES = [
+    { grid: 'quarter', triplet: false, beats: 1 },
+    { grid: 'quarter', triplet: true, beats: 2 / 3 },
+    { grid: 'eighth', triplet: false, beats: 1 / 2 },
+    { grid: 'eighth', triplet: true, beats: 1 / 3 },
+    { grid: 'sixteenth', triplet: false, beats: 1 / 4 },
+    { grid: 'sixteenth', triplet: true, beats: 1 / 6 },
+    { grid: 'thirtysecond', triplet: false, beats: 1 / 8 },
+    { grid: 'thirtysecond', triplet: true, beats: 1 / 12 },
+];
+/** No grid is assumed when the onsets fit nothing; preserve performance timing. */
+export const FALLBACK_GRID = { grid: null, triplet: false };
+/**
+ * How far off a grid line an onset may sit and still count as on it, in beats.
+ * ~10ms at 120bpm: wide enough for the tick-level rounding a sequencer leaves
+ * behind, far too narrow to swallow played-by-hand timing.
+ */
+const TOLERANCE_BEATS = 0.02;
+/**
+ * The share of onsets that must fit. Not 100%: real files carry a few grace
+ * notes, flams and hand-nudged accents, and one of those should not force the
+ * whole file onto a finer grid than it is written on.
+ */
+const REQUIRED_FIT = 0.98;
+function fits(onsetBeats, gridBeats) {
+    let on = 0;
+    for (const beat of onsetBeats) {
+        const offset = Math.abs(beat / gridBeats - Math.round(beat / gridBeats)) * gridBeats;
+        if (offset <= TOLERANCE_BEATS)
+            on += 1;
+    }
+    return on / onsetBeats.length >= REQUIRED_FIT;
+}
+/**
+ * The coarsest grid `positions` already sit on, or no grid when none does.
+ * `ppq` is the file's own resolution — positions are compared in beats, so a
+ * 960-ppq file and a 480-ppq one holding the same music detect alike.
+ *
+ * Callers pass note *ends* as well as onsets. The chosen grid quantizes
+ * durations too, so a grid picked from onsets alone can still be too coarse to
+ * express the file: a piece played in staccato quarters has quarter-note
+ * onsets but eighth-note ends, and snapping those ends up to the quarter grid
+ * would smear every note into the next and make the whole thing sound
+ * sluggish. Feeding ends in makes the detector reject a grid that cannot hold
+ * them.
+ */
+export function detectGrid(positions, ppq) {
+    if (positions.length === 0 || ppq <= 0)
+        return FALLBACK_GRID;
+    const onsetBeats = positions.map(tick => tick / ppq);
+    const match = CANDIDATES.find(candidate => fits(onsetBeats, candidate.beats));
+    return match ? { grid: match.grid, triplet: match.triplet } : FALLBACK_GRID;
+}
+//# sourceMappingURL=grid-detection.js.map

package/dist/midi/grid-detection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid-detection.js","sourceRoot":"","sources":["../../src/midi/grid-detection.ts"],"names":[],"mappings":"AA0BA;;;;;;GAMG;AACH,MAAM,UAAU,GAIX;IACH,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE;IAC7C,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE;IAChD,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE;IAChD,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE;IAC/C,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE;IACnD,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE;IAClD,EAAE,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE;IACtD,EAAE,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,GAAG,EAAE,EAAE;CACvD,CAAC;AAEF,mFAAmF;AACnF,MAAM,CAAC,MAAM,aAAa,GAAiB,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;AAE1E;;;;GAIG;AACH,MAAM,eAAe,GAAG,IAAI,CAAC;AAE7B;;;;GAIG;AACH,MAAM,YAAY,GAAG,IAAI,CAAC;AAE1B,SAAS,IAAI,CAAC,UAAoB,EAAE,SAAiB;IACnD,IAAI,EAAE,GAAG,CAAC,CAAC;IACX,KAAK,MAAM,IAAI,IAAI,UAAU,EAAE,CAAC;QAC9B,MAAM,MAAM,GACV,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC;QACxE,IAAI,MAAM,IAAI,eAAe;YAAE,EAAE,IAAI,CAAC,CAAC;IACzC,CAAC;IACD,OAAO,EAAE,GAAG,UAAU,CAAC,MAAM,IAAI,YAAY,CAAC;AAChD,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,UAAU,CAAC,SAAmB,EAAE,GAAW;IACzD,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC;QAAE,OAAO,aAAa,CAAC;IAC7D,MAAM,UAAU,GAAG,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC;IACrD,MAAM,KAAK,GAAG,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;IAC9E,OAAO,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC;AAC9E,CAAC"}

package/dist/midi/import-options.d.ts

@@ -0,0 +1,45 @@
+/**
+ * MIDI import wizard options (spec §15): what to include, how to clean up
+ * performance timing, and how to lay tracks out on staves. `MidiImportOptions`
+ * is the exact shape the Task 7 brief specifies; `defaultMidiImportOptions`
+ * derives sensible starting values from an `analyzeMidi` summary so the
+ * wizard can open pre-filled.
+ */
+import type { MidiSummary } from './analyze.js';
+import type { Clef, DurationName } from '@sudobility/music_types';
+export type MidiTrackSelection = {
+    sourceIndex: number;
+    include: boolean;
+    clef: Clef;
+    name: string;
+};
+export type MidiImportOptions = {
+    trackSelections: MidiTrackSelection[];
+    /** Quantization grid value (spec §15's "whole" .. "sixteenth triplet" list); `null` skips start/duration quantization entirely. */
+    quantizeGrid: DurationName | null;
+    /** Use a triplet subdivision of `quantizeGrid` when quantizing. */
+    tripletDetection: boolean;
+    /** Notes shorter than this (at 480 ppq) are dropped as accidental/ornamental noise; `1` preserves every representable note. */
+    minDurationTicks: number;
+    /** Cluster near-simultaneous onsets within a small tolerance onto a shared start tick. */
+    mergeNearDuplicates: boolean;
+    /** `"extend"` lengthens notes to the sustain-pedal release point; `"ignore"` uses raw note-off timing. */
+    sustainPedal: 'extend' | 'ignore';
+    /** Split a single MIDI track into two linked grand-staff tracks ("Piano RH"/"Piano LH") instead of one track on `defaultClefFor`'s guessed clef. */
+    pianoStaffSplit: boolean;
+    /** MIDI note number at/above which a note is placed on the upper (RH/treble) staff when `pianoStaffSplit` is set. */
+    splitPointMidi: number;
+    /** Estimate a key signature from the included tracks' notes (Krumhansl-style) instead of defaulting to C major. */
+    detectKey: boolean;
+};
+/**
+ * `MidiImportOptions` with defaults pre-filled from `summary`: every
+ * non-empty track included, clef guessed per `defaultClefFor`, quantized to
+ * the grid the file itself is written on (`summary.detectedGrid`), or no
+ * quantization when no grid was confidently detected. Notes are preserved by
+ * default (`minDurationTicks: 1`); users can opt into cleanup from the wizard.
+ * Sustain pedal extension is honored, with no near-duplicate merging or piano
+ * staff split, and key detection on.
+ */
+export declare function defaultMidiImportOptions(summary: MidiSummary): MidiImportOptions;
+//# sourceMappingURL=import-options.d.ts.map

package/dist/midi/import-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-options.d.ts","sourceRoot":"","sources":["../../src/midi/import-options.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,WAAW,EAAoB,MAAM,cAAc,CAAC;AAClE,OAAO,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAElE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,IAAI,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,eAAe,EAAE,kBAAkB,EAAE,CAAC;IACtC,mIAAmI;IACnI,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC;IAClC,mEAAmE;IACnE,gBAAgB,EAAE,OAAO,CAAC;IAC1B,+HAA+H;IAC/H,gBAAgB,EAAE,MAAM,CAAC;IACzB,0FAA0F;IAC1F,mBAAmB,EAAE,OAAO,CAAC;IAC7B,0GAA0G;IAC1G,YAAY,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAClC,oJAAoJ;IACpJ,eAAe,EAAE,OAAO,CAAC;IACzB,qHAAqH;IACrH,cAAc,EAAE,MAAM,CAAC;IACvB,mHAAmH;IACnH,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAYF;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,WAAW,GACnB,iBAAiB,CAiBnB"}

package/dist/midi/import-options.js

@@ -0,0 +1,38 @@
+/** Middle C — the conventional grand-staff RH/LH split point. */
+const DEFAULT_SPLIT_POINT_MIDI = 60;
+/** Percussion tracks default to the percussion clef; otherwise treble/bass by note centroid (>= middle C -> treble), defaulting to treble for a note-free track. */
+function defaultClefFor(track) {
+    if (track.isPercussion)
+        return 'percussion';
+    if (track.averageMidi === null)
+        return 'treble';
+    return track.averageMidi >= DEFAULT_SPLIT_POINT_MIDI ? 'treble' : 'bass';
+}
+/**
+ * `MidiImportOptions` with defaults pre-filled from `summary`: every
+ * non-empty track included, clef guessed per `defaultClefFor`, quantized to
+ * the grid the file itself is written on (`summary.detectedGrid`), or no
+ * quantization when no grid was confidently detected. Notes are preserved by
+ * default (`minDurationTicks: 1`); users can opt into cleanup from the wizard.
+ * Sustain pedal extension is honored, with no near-duplicate merging or piano
+ * staff split, and key detection on.
+ */
+export function defaultMidiImportOptions(summary) {
+    return {
+        trackSelections: summary.tracks.map(track => ({
+            sourceIndex: track.index,
+            include: track.noteCount > 0,
+            clef: defaultClefFor(track),
+            name: track.name,
+        })),
+        quantizeGrid: summary.detectedGrid.grid,
+        tripletDetection: summary.detectedGrid.triplet,
+        minDurationTicks: 1,
+        mergeNearDuplicates: false,
+        sustainPedal: 'extend',
+        pianoStaffSplit: false,
+        splitPointMidi: DEFAULT_SPLIT_POINT_MIDI,
+        detectKey: true,
+    };
+}
+//# sourceMappingURL=import-options.js.map

package/dist/midi/import-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-options.js","sourceRoot":"","sources":["../../src/midi/import-options.ts"],"names":[],"mappings":"AAqCA,iEAAiE;AACjE,MAAM,wBAAwB,GAAG,EAAE,CAAC;AAEpC,oKAAoK;AACpK,SAAS,cAAc,CAAC,KAAuB;IAC7C,IAAI,KAAK,CAAC,YAAY;QAAE,OAAO,YAAY,CAAC;IAC5C,IAAI,KAAK,CAAC,WAAW,KAAK,IAAI;QAAE,OAAO,QAAQ,CAAC;IAChD,OAAO,KAAK,CAAC,WAAW,IAAI,wBAAwB,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC;AAC3E,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,wBAAwB,CACtC,OAAoB;IAEpB,OAAO;QACL,eAAe,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YAC5C,WAAW,EAAE,KAAK,CAAC,KAAK;YACxB,OAAO,EAAE,KAAK,CAAC,SAAS,GAAG,CAAC;YAC5B,IAAI,EAAE,cAAc,CAAC,KAAK,CAAC;YAC3B,IAAI,EAAE,KAAK,CAAC,IAAI;SACjB,CAAC,CAAC;QACH,YAAY,EAAE,OAAO,CAAC,YAAY,CAAC,IAAI;QACvC,gBAAgB,EAAE,OAAO,CAAC,YAAY,CAAC,OAAO;QAC9C,gBAAgB,EAAE,CAAC;QACnB,mBAAmB,EAAE,KAAK;QAC1B,YAAY,EAAE,QAAQ;QACtB,eAAe,EAAE,KAAK;QACtB,cAAc,EAAE,wBAAwB;QACxC,SAAS,EAAE,IAAI;KAChB,CAAC;AACJ,CAAC"}

package/dist/midi/import.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Standard MIDI File -> `Score` import (spec §15). `@tonejs/midi` is the
+ * designated MIDI library (spec §15) and its use here is a sanctioned
+ * exception to the adapters/services "no non-domain library" purity rule.
+ *
+ * MIDI stores performance timing, not notation semantics — this import is
+ * necessarily an approximation (quantization, voice allocation, clef/staff
+ * assignment, and key estimation are all best-effort heuristics), which is
+ * why every result carries a `warnings` array the caller/wizard is expected
+ * to surface (spec §15: "Do not claim MIDI import perfectly reconstructs
+ * notation").
+ */
+import type { MidiCodec, MidiFile } from '@sudobility/music_types';
+import type { MidiImportOptions } from './import-options.js';
+import type { Score } from '@sudobility/music_types';
+export type MidiImportResult = {
+    score: Score;
+    warnings: string[];
+};
+/**
+ * Imports a Standard MIDI File as a `Score` (spec §15): converts note times
+ * to 480-ppq score ticks, imports the tempo map and time signatures,
+ * applies sustain-pedal extension, Task 4 quantization (grid/triplet/
+ * minimum-duration/near-duplicate merging), key estimation and enharmonic
+ * respelling, Task 4 voice allocation, optional piano grand-staff split,
+ * and measure generation (notes split across measure boundaries with
+ * ties) — per track selected in `options.trackSelections`. Always returns a
+ * `warnings` array (never throws for merely-imperfect input); the caller is
+ * expected to surface it before the import is committed (spec §15: MIDI
+ * import must be reviewable, and one undoable operation once committed).
+ */
+/**
+ * Converts an already-decoded MIDI file into a `Score`.
+ *
+ * Split out from `importMidi` so the heavy work — quantization and voice
+ * allocation — can be handed to a worker without the worker needing a codec.
+ * `MidiFile` is plain data and therefore structured-cloneable; a `MidiCodec` is
+ * not, and giving the worker one would make music_lib depend on music_io.
+ */
+export declare function importMidiFile(midi: MidiFile, options: MidiImportOptions): MidiImportResult;
+/** Decodes `data` and imports it. The codec is the only platform-bound part. */
+export declare function importMidi(data: ArrayBuffer, options: MidiImportOptions, codec: MidiCodec): MidiImportResult;
+//# sourceMappingURL=import.d.ts.map