@sudobility/music_codecs 0.1.1

package/dist/midi/measures.js

@@ -0,0 +1,141 @@
+/**
+ * Measure-timeline assembly for MIDI import (spec §15): turns a
+ * time-signature change list + a score end tick into consecutive `Measure`
+ * spans, and assembles a track's per-voice absolute-tick note events into
+ * `Measure[]` (splitting notes across measure boundaries with ties, filling
+ * silent gaps with rests). Kept independent of `@tonejs/midi` so it's usable
+ * (and unit-testable) purely in terms of the domain model.
+ */
+import { createId } from '@sudobility/music_types';
+import { splitNoteAcrossMeasures } from '@sudobility/music_types';
+import { measureDurationTicks } from '@sudobility/music_types';
+export const DEFAULT_TIME_SIGNATURE = {
+    numerator: 4,
+    denominator: 4,
+};
+/**
+ * Computes consecutive measure spans covering `[0, endTick)` from a set of
+ * time-signature changes (need not include a tick-0 entry — one is
+ * synthesized at `DEFAULT_TIME_SIGNATURE` if missing; need not be sorted).
+ * Always returns at least one span (a silent/empty file still gets a single
+ * default-meter measure, mirroring `createEmptyScore`'s "at least one
+ * measure" convention).
+ *
+ * A change tick that doesn't land exactly on a measure boundary of the
+ * preceding meter (uncommon, but not disallowed by the MIDI format) is
+ * absorbed into whichever measure is in progress when it's reached, rather
+ * than truncating a partial measure — a documented simplification, not a
+ * full mid-measure meter change.
+ */
+export function buildMeasureSpans(changes, ppq, endTick) {
+    const sorted = [...changes].sort((a, b) => a.tick - b.tick);
+    const withOrigin = sorted.length > 0 && sorted[0].tick === 0
+        ? sorted
+        : [{ tick: 0, timeSignature: DEFAULT_TIME_SIGNATURE }, ...sorted];
+    const spans = [];
+    let cursor = 0;
+    let index = 0;
+    for (let i = 0; i < withOrigin.length; i += 1) {
+        const timeSignature = withOrigin[i].timeSignature;
+        const measureTicks = measureDurationTicks(timeSignature, ppq);
+        if (measureTicks <= 0)
+            continue;
+        const isLastSegment = i === withOrigin.length - 1;
+        const segmentEnd = isLastSegment
+            ? Math.max(endTick, cursor + measureTicks)
+            : withOrigin[i + 1].tick;
+        while (cursor < segmentEnd) {
+            spans.push({
+                index,
+                startTick: cursor,
+                durationTicks: measureTicks,
+                timeSignature,
+            });
+            cursor += measureTicks;
+            index += 1;
+        }
+    }
+    if (spans.length === 0) {
+        const measureTicks = measureDurationTicks(DEFAULT_TIME_SIGNATURE, ppq);
+        spans.push({
+            index: 0,
+            startTick: 0,
+            durationTicks: measureTicks,
+            timeSignature: DEFAULT_TIME_SIGNATURE,
+        });
+    }
+    return spans;
+}
+/**
+ * Fills the gaps in one measure-voice's already-non-overlapping notes with
+ * fresh `RestEvent`s so the voice's events cover `[startTick, startTick +
+ * durationTicks)` exactly (spec §23's "voice content sums exactly to
+ * measure duration" invariant). Notes sharing an identical `startTick`
+ * (chords) are left as-is; `notes` need not be pre-sorted.
+ */
+function fillVoiceGaps(notes, startTick, durationTicks, trackId, voiceId) {
+    const sorted = [...notes].sort((a, b) => a.startTick - b.startTick);
+    const events = [];
+    const endTick = startTick + durationTicks;
+    let cursor = startTick;
+    for (const note of sorted) {
+        if (note.startTick > cursor) {
+            events.push({
+                id: createId(),
+                startTick: cursor,
+                durationTicks: note.startTick - cursor,
+                voiceId,
+                trackId,
+            });
+        }
+        events.push({ ...note, trackId, voiceId });
+        cursor = Math.max(cursor, note.startTick + note.durationTicks);
+    }
+    if (cursor < endTick) {
+        events.push({
+            id: createId(),
+            startTick: cursor,
+            durationTicks: endTick - cursor,
+            voiceId,
+            trackId,
+        });
+    }
+    return events;
+}
+/**
+ * Assembles one track's `Measure[]` from `voiceLanes` — each inner array a
+ * "notated voice" of mutually non-overlapping, absolute-tick `NoteEvent`s
+ * (as produced by `allocateVoices`) — over `spans`. A note spanning more
+ * than one span is split at every internal span boundary via
+ * `splitNoteAcrossMeasures` (producing a tied chain); each span's voice
+ * content is then gap-filled with rests. An empty `voiceLanes` (a track
+ * with no notes at all) still produces one fully-rested voice per measure,
+ * satisfying the "every measure has >=1 voice per track" invariant.
+ */
+export function assembleTrackMeasures(voiceLanes, spans, keySignature, trackId) {
+    const boundaries = spans.map(s => s.startTick);
+    const lanes = voiceLanes.length > 0 ? voiceLanes : [[]];
+    const splitLanes = lanes.map(lane => lane.flatMap(note => splitNoteAcrossMeasures(note, boundaries)));
+    return spans.map(span => {
+        const spanEnd = span.startTick + span.durationTicks;
+        const voices = splitLanes.map((lane, laneIndex) => {
+            const notesInSpan = lane.filter(n => n.startTick >= span.startTick && n.startTick < spanEnd);
+            const voiceId = createId();
+            return {
+                id: voiceId,
+                name: `Voice ${laneIndex + 1}`,
+                events: fillVoiceGaps(notesInSpan, span.startTick, span.durationTicks, trackId, voiceId),
+            };
+        });
+        return {
+            id: createId(),
+            index: span.index,
+            startTick: span.startTick,
+            durationTicks: span.durationTicks,
+            timeSignature: span.timeSignature,
+            keySignature,
+            voices,
+        };
+    });
+}
+//# sourceMappingURL=measures.js.map

package/dist/midi/measures.js.map

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

package/dist/mod/export.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Turning a score into a neutral tracker module.
+ *
+ * The exact inverse of `trackerToScore`, and it shares that file's grid:
+ * `rowsPerBeat` 4 means a row is a sixteenth, so a 4/4 bar is 16 rows and a
+ * 64-row pattern is four bars. Writing on the grid the importer reads is what
+ * makes a round trip comparable rather than approximate.
+ *
+ * **Everything lossy is counted, never hidden.** A tracker row grid, a channel
+ * count and a three-octave range are all narrower than a score, so an export
+ * can lose material — and a file that quietly is not the music is the failure
+ * mode this codebase designs against. The counts go in `TrackerFitReport` and
+ * the app shows them before writing.
+ *
+ * Pure: no bytes, no platform, no store. `TrackerCodec.encode` turns the result
+ * into a file.
+ */
+import type { Score, TrackerModule } from '@sudobility/music_types';
+import { type WritableTrackerFormat } from './limits.js';
+export type TrackerExportOptions = {
+    format: WritableTrackerFormat;
+    /** Rows per quarter note. 4 gives sixteenths and cannot express triplets. */
+    rowsPerBeat?: number;
+};
+export type TrackerFitReport = {
+    /** Notes moved into range. */
+    clampedNotes: number;
+    /** Voices that did not fit the format's channel count. */
+    droppedVoices: number;
+    /** Notes shorter than one row, lost to the grid. */
+    droppedShortNotes: number;
+    /** Notes whose start moved to land on a row. */
+    quantisedNotes: number;
+};
+export type TrackerExportResult = {
+    module: TrackerModule;
+    report: TrackerFitReport;
+};
+/** True when nothing was lost — the case that must not cost the user a click. */
+export declare function isCleanFit(report: TrackerFitReport): boolean;
+/**
+ * Speed and tempo for a musical BPM.
+ *
+ * `effectiveBpm(speed, tempo) = 6 * tempo / speed`, so at speed 6 the tempo
+ * field *is* the BPM. That only works while the result fits a byte, and a score
+ * may hold 20-400 BPM, so a slow score raises the speed and a fast one lowers
+ * it. Every score-legal BPM lands in 32-255 under one of the three.
+ */
+export declare function speedAndTempoFor(bpm: number): {
+    speed: number;
+    tempo: number;
+};
+export declare function scoreToTracker(score: Score, options: TrackerExportOptions): TrackerExportResult;
+//# sourceMappingURL=export.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../src/mod/export.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EACV,KAAK,EAEL,aAAa,EACd,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAkB,KAAK,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAYzE,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,qBAAqB,CAAC;IAC9B,6EAA6E;IAC7E,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,8BAA8B;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,0DAA0D;IAC1D,aAAa,EAAE,MAAM,CAAC;IACtB,oDAAoD;IACpD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gDAAgD;IAChD,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,aAAa,CAAC;IACtB,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AAEF,iFAAiF;AACjF,wBAAgB,UAAU,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAO5D;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAUA;AAmBD,wBAAgB,cAAc,CAC5B,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,oBAAoB,GAC5B,mBAAmB,CAsIrB"}

package/dist/mod/export.js

@@ -0,0 +1,172 @@
+import { isNoteEvent } from '@sudobility/music_types';
+import { pitchToMidi } from '@sudobility/music_types';
+import { TRACKER_LIMITS } from './limits.js';
+const DEFAULT_ROWS_PER_BEAT = 4;
+const ROWS_PER_PATTERN = 64;
+const DEFAULT_BPM = 125;
+/** What a tracker's one-byte tempo field will accept. */
+const MIN_TEMPO = 32;
+const MAX_TEMPO = 255;
+/** Tried in order; the first that puts tempo in range wins. */
+const SPEED_CHOICES = [6, 12, 3];
+/** True when nothing was lost — the case that must not cost the user a click. */
+export function isCleanFit(report) {
+    return (report.clampedNotes === 0 &&
+        report.droppedVoices === 0 &&
+        report.droppedShortNotes === 0 &&
+        report.quantisedNotes === 0);
+}
+/**
+ * Speed and tempo for a musical BPM.
+ *
+ * `effectiveBpm(speed, tempo) = 6 * tempo / speed`, so at speed 6 the tempo
+ * field *is* the BPM. That only works while the result fits a byte, and a score
+ * may hold 20-400 BPM, so a slow score raises the speed and a fast one lowers
+ * it. Every score-legal BPM lands in 32-255 under one of the three.
+ */
+export function speedAndTempoFor(bpm) {
+    for (const speed of SPEED_CHOICES) {
+        const tempo = Math.round((bpm * speed) / 6);
+        if (tempo >= MIN_TEMPO && tempo <= MAX_TEMPO)
+            return { speed, tempo };
+    }
+    // Unreachable for a valid score; clamp rather than emit an illegal byte.
+    return {
+        speed: 6,
+        tempo: Math.min(MAX_TEMPO, Math.max(MIN_TEMPO, Math.round(bpm))),
+    };
+}
+const emptyCell = () => ({ instrument: 0, note: null });
+/**
+ * Move a note into range by whole octaves.
+ *
+ * Octaves rather than a hard clamp to the boundary: an octave displacement is
+ * still the same pitch class, so a bassline pushed up an octave still reads as
+ * that bassline where a note pinned to the lowest available semitone does not.
+ */
+function clampToRange(midi, lowest, highest) {
+    let value = midi;
+    while (value < lowest)
+        value += 12;
+    while (value > highest)
+        value -= 12;
+    // A range narrower than an octave cannot satisfy both; prefer in-bounds.
+    return Math.min(highest, Math.max(lowest, value));
+}
+export function scoreToTracker(score, options) {
+    const limits = TRACKER_LIMITS[options.format];
+    const rowsPerBeat = options.rowsPerBeat ?? DEFAULT_ROWS_PER_BEAT;
+    const ticksPerRow = score.ppq / rowsPerBeat;
+    const report = {
+        clampedNotes: 0,
+        droppedVoices: 0,
+        droppedShortNotes: 0,
+        quantisedNotes: 0,
+    };
+    // Channel allocation: each track gets as many channels as its widest measure
+    // has voices, and they are laid out consecutively so a track's voices stay
+    // together. The total is capped by the format, and the overflow is counted.
+    let nextChannel = 0;
+    const channelOfVoice = [];
+    for (const track of score.tracks) {
+        const widest = track.measures.reduce((n, m) => Math.max(n, m.voices.length), 0);
+        const map = new Map();
+        for (let v = 0; v < widest; v += 1) {
+            if (nextChannel < limits.channels) {
+                map.set(v, nextChannel);
+                nextChannel += 1;
+            }
+            else {
+                report.droppedVoices += 1;
+            }
+        }
+        channelOfVoice.push(map);
+    }
+    const channels = Math.max(1, Math.min(limits.channels, nextChannel));
+    // How long the score runs, in rows.
+    let lastTick = 0;
+    for (const track of score.tracks) {
+        for (const measure of track.measures) {
+            lastTick = Math.max(lastTick, measure.startTick + measure.durationTicks);
+        }
+    }
+    const totalRows = Math.max(ROWS_PER_PATTERN, Math.ceil(lastTick / ticksPerRow));
+    const patternCount = Math.ceil(totalRows / ROWS_PER_PATTERN);
+    const patterns = Array.from({ length: patternCount }, () => Array.from({ length: ROWS_PER_PATTERN }, () => Array.from({ length: channels }, emptyCell)));
+    const cellAt = (row, channel) => {
+        const p = Math.floor(row / ROWS_PER_PATTERN);
+        if (p >= patterns.length)
+            return null;
+        return patterns[p][row % ROWS_PER_PATTERN][channel];
+    };
+    score.tracks.forEach((track, trackIndex) => {
+        const instrument = trackIndex + 1;
+        if (instrument > limits.instruments)
+            return;
+        const voiceChannels = channelOfVoice[trackIndex];
+        for (const measure of track.measures) {
+            measure.voices.forEach((voice, voiceIndex) => {
+                const channel = voiceChannels.get(voiceIndex);
+                if (channel === undefined)
+                    return; // counted as a dropped voice already
+                for (const event of voice.events) {
+                    if (!isNoteEvent(event))
+                        continue;
+                    const startRow = Math.round(event.startTick / ticksPerRow);
+                    const endRow = Math.round((event.startTick + event.durationTicks) / ticksPerRow);
+                    if (endRow <= startRow) {
+                        report.droppedShortNotes += 1;
+                        continue;
+                    }
+                    if (event.startTick % ticksPerRow !== 0)
+                        report.quantisedNotes += 1;
+                    const sounding = pitchToMidi(event.pitch);
+                    const midi = clampToRange(sounding, limits.lowestMidi, limits.highestMidi);
+                    if (midi !== sounding)
+                        report.clampedNotes += 1;
+                    const start = cellAt(startRow, channel);
+                    if (start) {
+                        start.note = midi;
+                        start.instrument = instrument;
+                    }
+                    // A release, unless something else already claims that row on this
+                    // channel — a new note supersedes the release anyway.
+                    const end = cellAt(endRow, channel);
+                    if (end && end.note === null)
+                        end.note = 'off';
+                }
+            });
+        }
+    });
+    // Tempo. The first entry sets both knobs in row 0; later ones move whichever
+    // the BPM needs, which `tempoChanges` on the import side reads back.
+    const tempoMap = score.tempoMap.length > 0
+        ? score.tempoMap
+        : [{ tick: 0, bpm: DEFAULT_BPM }];
+    for (const entry of tempoMap) {
+        const row = Math.round(entry.tick / ticksPerRow);
+        const cell = cellAt(row, 0);
+        if (!cell)
+            continue;
+        const { speed, tempo } = speedAndTempoFor(entry.bpm);
+        cell.speed = speed;
+        cell.bpm = tempo;
+    }
+    return {
+        module: {
+            format: options.format,
+            title: score.metadata.title,
+            channels,
+            instruments: score.tracks
+                .slice(0, limits.instruments)
+                .map((track, i) => ({
+                index: i + 1,
+                name: track.instrumentName || track.name,
+            })),
+            order: Array.from({ length: patternCount }, (_, i) => i),
+            patterns,
+        },
+        report,
+    };
+}
+//# sourceMappingURL=export.js.map

package/dist/mod/export.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.js","sourceRoot":"","sources":["../../src/mod/export.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,cAAc,EAA8B,MAAM,aAAa,CAAC;AAEzE,MAAM,qBAAqB,GAAG,CAAC,CAAC;AAChC,MAAM,gBAAgB,GAAG,EAAE,CAAC;AAC5B,MAAM,WAAW,GAAG,GAAG,CAAC;AAExB,yDAAyD;AACzD,MAAM,SAAS,GAAG,EAAE,CAAC;AACrB,MAAM,SAAS,GAAG,GAAG,CAAC;AACtB,+DAA+D;AAC/D,MAAM,aAAa,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAU,CAAC;AAwB1C,iFAAiF;AACjF,MAAM,UAAU,UAAU,CAAC,MAAwB;IACjD,OAAO,CACL,MAAM,CAAC,YAAY,KAAK,CAAC;QACzB,MAAM,CAAC,aAAa,KAAK,CAAC;QAC1B,MAAM,CAAC,iBAAiB,KAAK,CAAC;QAC9B,MAAM,CAAC,cAAc,KAAK,CAAC,CAC5B,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,GAAW;IAI1C,KAAK,MAAM,KAAK,IAAI,aAAa,EAAE,CAAC;QAClC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;QAC5C,IAAI,KAAK,IAAI,SAAS,IAAI,KAAK,IAAI,SAAS;YAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;IACxE,CAAC;IACD,yEAAyE;IACzE,OAAO;QACL,KAAK,EAAE,CAAC;QACR,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;KACjE,CAAC;AACJ,CAAC;AAED,MAAM,SAAS,GAAG,GAAgB,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;AAErE;;;;;;GAMG;AACH,SAAS,YAAY,CAAC,IAAY,EAAE,MAAc,EAAE,OAAe;IACjE,IAAI,KAAK,GAAG,IAAI,CAAC;IACjB,OAAO,KAAK,GAAG,MAAM;QAAE,KAAK,IAAI,EAAE,CAAC;IACnC,OAAO,KAAK,GAAG,OAAO;QAAE,KAAK,IAAI,EAAE,CAAC;IACpC,yEAAyE;IACzE,OAAO,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;AACpD,CAAC;AAED,MAAM,UAAU,cAAc,CAC5B,KAAY,EACZ,OAA6B;IAE7B,MAAM,MAAM,GAAG,cAAc,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9C,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,IAAI,qBAAqB,CAAC;IACjE,MAAM,WAAW,GAAG,KAAK,CAAC,GAAG,GAAG,WAAW,CAAC;IAE5C,MAAM,MAAM,GAAqB;QAC/B,YAAY,EAAE,CAAC;QACf,aAAa,EAAE,CAAC;QAChB,iBAAiB,EAAE,CAAC;QACpB,cAAc,EAAE,CAAC;KAClB,CAAC;IAEF,6EAA6E;IAC7E,2EAA2E;IAC3E,4EAA4E;IAC5E,IAAI,WAAW,GAAG,CAAC,CAAC;IACpB,MAAM,cAAc,GAA+B,EAAE,CAAC;IACtD,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;QACjC,MAAM,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAC,MAAM,CAClC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,EACtC,CAAC,CACF,CAAC;QACF,MAAM,GAAG,GAAG,IAAI,GAAG,EAAkB,CAAC;QACtC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;YACnC,IAAI,WAAW,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;gBAClC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;gBACxB,WAAW,IAAI,CAAC,CAAC;YACnB,CAAC;iBAAM,CAAC;gBACN,MAAM,CAAC,aAAa,IAAI,CAAC,CAAC;YAC5B,CAAC;QACH,CAAC;QACD,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC3B,CAAC;IACD,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC;IAErE,oCAAoC;IACpC,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;QACjC,KAAK,MAAM,OAAO,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;YACrC,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,SAAS,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;QAC3E,CAAC;IACH,CAAC;IACD,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CACxB,gBAAgB,EAChB,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,WAAW,CAAC,CAClC,CAAC;IACF,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,gBAAgB,CAAC,CAAC;IAE7D,MAAM,QAAQ,GAAsB,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,GAAG,EAAE,CAC5E,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAE,EAAE,GAAG,EAAE,CAC5C,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC,CAC5C,CACF,CAAC;IACF,MAAM,MAAM,GAAG,CAAC,GAAW,EAAE,OAAe,EAAsB,EAAE;QAClE,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,gBAAgB,CAAC,CAAC;QAC7C,IAAI,CAAC,IAAI,QAAQ,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC;QACtC,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,gBAAgB,CAAC,CAAC,OAAO,CAAC,CAAC;IACtD,CAAC,CAAC;IAEF,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE;QACzC,MAAM,UAAU,GAAG,UAAU,GAAG,CAAC,CAAC;QAClC,IAAI,UAAU,GAAG,MAAM,CAAC,WAAW;YAAE,OAAO;QAC5C,MAAM,aAAa,GAAG,cAAc,CAAC,UAAU,CAAC,CAAC;QAEjD,KAAK,MAAM,OAAO,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;YACrC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE;gBAC3C,MAAM,OAAO,GAAG,aAAa,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;gBAC9C,IAAI,OAAO,KAAK,SAAS;oBAAE,OAAO,CAAC,qCAAqC;gBACxE,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;oBACjC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC;wBAAE,SAAS;oBAElC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,GAAG,WAAW,CAAC,CAAC;oBAC3D,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CACvB,CAAC,KAAK,CAAC,SAAS,GAAG,KAAK,CAAC,aAAa,CAAC,GAAG,WAAW,CACtD,CAAC;oBACF,IAAI,MAAM,IAAI,QAAQ,EAAE,CAAC;wBACvB,MAAM,CAAC,iBAAiB,IAAI,CAAC,CAAC;wBAC9B,SAAS;oBACX,CAAC;oBACD,IAAI,KAAK,CAAC,SAAS,GAAG,WAAW,KAAK,CAAC;wBAAE,MAAM,CAAC,cAAc,IAAI,CAAC,CAAC;oBAEpE,MAAM,QAAQ,GAAG,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;oBAC1C,MAAM,IAAI,GAAG,YAAY,CACvB,QAAQ,EACR,MAAM,CAAC,UAAU,EACjB,MAAM,CAAC,WAAW,CACnB,CAAC;oBACF,IAAI,IAAI,KAAK,QAAQ;wBAAE,MAAM,CAAC,YAAY,IAAI,CAAC,CAAC;oBAEhD,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;oBACxC,IAAI,KAAK,EAAE,CAAC;wBACV,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC;wBAClB,KAAK,CAAC,UAAU,GAAG,UAAU,CAAC;oBAChC,CAAC;oBACD,mEAAmE;oBACnE,sDAAsD;oBACtD,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;oBACpC,IAAI,GAAG,IAAI,GAAG,CAAC,IAAI,KAAK,IAAI;wBAAE,GAAG,CAAC,IAAI,GAAG,KAAK,CAAC;gBACjD,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,6EAA6E;IAC7E,qEAAqE;IACrE,MAAM,QAAQ,GACZ,KAAK,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC;QACvB,CAAC,CAAC,KAAK,CAAC,QAAQ;QAChB,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,WAAW,EAAE,CAAC,CAAC;IACtC,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;QAC7B,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,GAAG,WAAW,CAAC,CAAC;QACjD,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;QAC5B,IAAI,CAAC,IAAI;YAAE,SAAS;QACpB,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,gBAAgB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACrD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,GAAG,GAAG,KAAK,CAAC;IACnB,CAAC;IAED,OAAO;QACL,MAAM,EAAE;YACN,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK;YAC3B,QAAQ;YACR,WAAW,EAAE,KAAK,CAAC,MAAM;iBACtB,KAAK,CAAC,CAAC,EAAE,MAAM,CAAC,WAAW,CAAC;iBAC5B,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;gBAClB,KAAK,EAAE,CAAC,GAAG,CAAC;gBACZ,IAAI,EAAE,KAAK,CAAC,cAAc,IAAI,KAAK,CAAC,IAAI;aACzC,CAAC,CAAC;YACL,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;YACxD,QAAQ;SACT;QACD,MAAM;KACP,CAAC;AACJ,CAAC"}

package/dist/mod/fill.d.ts

@@ -0,0 +1,11 @@
+import type { MusicalEvent, NoteEvent, UUID } from '@sudobility/music_types';
+/**
+ * `events` with rests inserted before, between and after them, so the result
+ * tiles `[measureStartTick, measureStartTick + measureDurationTicks)` exactly.
+ *
+ * `events` must be sorted by `startTick` and must not overlap — which is what
+ * the caller's voice allocation already guarantees, since a note that overlaps
+ * one already placed goes to the next voice.
+ */
+export declare function fillVoiceWithRests(events: NoteEvent[], measureStartTick: number, measureDurationTicks: number, ppq: number, trackId: UUID, voiceId: UUID): MusicalEvent[];
+//# sourceMappingURL=fill.d.ts.map

package/dist/mod/fill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fill.d.ts","sourceRoot":"","sources":["../../src/mod/fill.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAE7E;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,SAAS,EAAE,EACnB,gBAAgB,EAAE,MAAM,EACxB,oBAAoB,EAAE,MAAM,EAC5B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,IAAI,EACb,OAAO,EAAE,IAAI,GACZ,YAAY,EAAE,CA6BhB"}

package/dist/mod/fill.js

@@ -0,0 +1,50 @@
+/**
+ * Filling a voice's gaps with rests.
+ *
+ * A voice must cover its measure exactly or the notation is wrong — a bar
+ * carrying 1200 ticks of a 1920-tick measure renders short. The module importer
+ * did not do this, which produced 554 `measure-underfull` warnings on a real
+ * module and bars that visibly did not add up.
+ *
+ * Pure arithmetic over an event list: no score model, no bytes, and every
+ * tracker format's importer gets it for free.
+ */
+import { decomposeDuration } from '@sudobility/music_types';
+import { createId } from '@sudobility/music_types';
+/**
+ * `events` with rests inserted before, between and after them, so the result
+ * tiles `[measureStartTick, measureStartTick + measureDurationTicks)` exactly.
+ *
+ * `events` must be sorted by `startTick` and must not overlap — which is what
+ * the caller's voice allocation already guarantees, since a note that overlaps
+ * one already placed goes to the next voice.
+ */
+export function fillVoiceWithRests(events, measureStartTick, measureDurationTicks, ppq, trackId, voiceId) {
+    const measureEnd = measureStartTick + measureDurationTicks;
+    const out = [];
+    let at = measureStartTick;
+    /** A gap may be longer than any single drawable value, so it can become several rests. */
+    const addRests = (from, to) => {
+        let cursor = from;
+        for (const ticks of decomposeDuration(to - from, ppq)) {
+            out.push({
+                id: createId(),
+                startTick: cursor,
+                durationTicks: ticks,
+                voiceId,
+                trackId,
+            });
+            cursor += ticks;
+        }
+    };
+    for (const event of events) {
+        if (event.startTick > at)
+            addRests(at, event.startTick);
+        out.push({ ...event, voiceId, trackId });
+        at = event.startTick + event.durationTicks;
+    }
+    if (at < measureEnd)
+        addRests(at, measureEnd);
+    return out;
+}
+//# sourceMappingURL=fill.js.map

package/dist/mod/fill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fill.js","sourceRoot":"","sources":["../../src/mod/fill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGnD;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAAmB,EACnB,gBAAwB,EACxB,oBAA4B,EAC5B,GAAW,EACX,OAAa,EACb,OAAa;IAEb,MAAM,UAAU,GAAG,gBAAgB,GAAG,oBAAoB,CAAC;IAC3D,MAAM,GAAG,GAAmB,EAAE,CAAC;IAC/B,IAAI,EAAE,GAAG,gBAAgB,CAAC;IAE1B,0FAA0F;IAC1F,MAAM,QAAQ,GAAG,CAAC,IAAY,EAAE,EAAU,EAAQ,EAAE;QAClD,IAAI,MAAM,GAAG,IAAI,CAAC;QAClB,KAAK,MAAM,KAAK,IAAI,iBAAiB,CAAC,EAAE,GAAG,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC;YACtD,GAAG,CAAC,IAAI,CAAC;gBACP,EAAE,EAAE,QAAQ,EAAE;gBACd,SAAS,EAAE,MAAM;gBACjB,aAAa,EAAE,KAAK;gBACpB,OAAO;gBACP,OAAO;aACR,CAAC,CAAC;YACH,MAAM,IAAI,KAAK,CAAC;QAClB,CAAC;IACH,CAAC,CAAC;IAEF,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,KAAK,CAAC,SAAS,GAAG,EAAE;YAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;QACxD,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;QACzC,EAAE,GAAG,KAAK,CAAC,SAAS,GAAG,KAAK,CAAC,aAAa,CAAC;IAC7C,CAAC;IAED,IAAI,EAAE,GAAG,UAAU;QAAE,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC,CAAC;IAE9C,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/mod/import.d.ts

@@ -0,0 +1,14 @@
+import { effectiveBpm, tempoChanges } from './timing.js';
+import type { TrackerCell, TrackerModule } from './types.js';
+import type { Score } from '@sudobility/music_types';
+/**
+ * Rows in playback order, honouring `patternBreak`.
+ *
+ * `Dxx` ends a pattern where it appears rather than at row 64. Ignoring it —
+ * which this did — imports a module that uses breaks with too many bars, and
+ * silently.
+ */
+export declare function flattenRows(module: TrackerModule): TrackerCell[][];
+export declare function trackerToScore(module: TrackerModule): Score;
+export { effectiveBpm, tempoChanges };
+//# sourceMappingURL=import.d.ts.map

package/dist/mod/import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../src/mod/import.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEzD,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC7D,OAAO,KAAK,EAEV,KAAK,EAGN,MAAM,yBAAyB,CAAC;AAajC;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,WAAW,EAAE,EAAE,CAWlE;AAkDD,wBAAgB,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,KAAK,CAgH3D;AAED,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,CAAC"}

package/dist/mod/import.js

@@ -0,0 +1,182 @@
+/**
+ * Turning a parsed module into a score.
+ *
+ * Sits beside the MIDI importer, and for the same reason: the codec hands over
+ * raw data, and the mapping to the score model happens here where it is
+ * testable without the platform layer.
+ *
+ * Two decisions shape everything below:
+ *
+ * - **Notes group by sample, not by channel**, so all the bass lands on one
+ *   track wherever it was played from. The consequence is that a track is not
+ *   always a single line — two channels on one sample at the same row produce
+ *   simultaneous notes, which go into separate **voices**.
+ * - **The order list is flattened.** A pattern played three times becomes
+ *   three sets of measures; a score has no "repeat this pattern", and
+ *   inventing one would trade an editable score for a faithful one.
+ */
+import { createEmptyScore } from '@sudobility/music_types';
+import { createId } from '@sudobility/music_types';
+import { midiToPitch } from '@sudobility/music_types';
+import { effectiveBpm, tempoChanges } from './timing.js';
+import { fillVoiceWithRests } from './fill.js';
+/** A tracker row is a sixteenth: four to the beat. */
+const ROWS_PER_BEAT = 4;
+const BEATS_PER_MEASURE = 4;
+/**
+ * Rows in playback order, honouring `patternBreak`.
+ *
+ * `Dxx` ends a pattern where it appears rather than at row 64. Ignoring it —
+ * which this did — imports a module that uses breaks with too many bars, and
+ * silently.
+ */
+export function flattenRows(module) {
+    const flat = [];
+    for (const patternIndex of module.order) {
+        const pattern = module.patterns[patternIndex];
+        if (!pattern)
+            continue;
+        for (const row of pattern) {
+            flat.push(row);
+            if (row.some(cell => cell.patternBreak))
+                break;
+        }
+    }
+    return flat;
+}
+/**
+ * Every note in playback order, with the row each ends on.
+ *
+ * A channel holds one note at a time. It ends when that channel plays another
+ * note, or on an explicit note-off — which MOD never sends, so there the first
+ * rule is the only one, exactly as it always was.
+ */
+function placeNotes(module) {
+    const flat = flattenRows(module);
+    const placed = [];
+    const open = new Map();
+    flat.forEach((cells, row) => {
+        cells.forEach((cell, channel) => {
+            if (cell.note === null)
+                return;
+            const previous = open.get(channel);
+            if (previous)
+                previous.endRow = row;
+            open.delete(channel);
+            // A release ends whatever was sounding and starts nothing.
+            if (cell.note === 'off')
+                return;
+            const note = {
+                instrument: cell.instrument,
+                startRow: row,
+                endRow: row + 1,
+                midi: cell.note,
+            };
+            open.set(channel, note);
+            placed.push(note);
+        });
+    });
+    return placed;
+}
+/** Tempo events at ticks, from the flattened row sequence. */
+function tempoMapOf(module, ticksPerRow) {
+    // Given the *flattened* sequence, not one pattern: a change in a later
+    // pattern would otherwise be invisible.
+    return tempoChanges(flattenRows(module)).map(change => ({
+        id: createId(),
+        tick: change.row * ticksPerRow,
+        bpm: change.bpm,
+    }));
+}
+export function trackerToScore(module) {
+    const placed = placeNotes(module);
+    // One track per instrument actually used, in first-heard order so the result
+    // is stable rather than dependent on the instrument bank's layout.
+    const usedInstruments = [];
+    for (const note of placed) {
+        if (!usedInstruments.includes(note.instrument))
+            usedInstruments.push(note.instrument);
+    }
+    const nameOf = (instrument) => {
+        const found = module.instruments.find(s => s.index === instrument);
+        return found && found.name.length > 0
+            ? found.name
+            : `Instrument ${instrument}`;
+    };
+    // Counted from the flattened rows, so a pattern break shortens the score
+    // rather than leaving empty bars at the end.
+    const totalRows = Math.max(1, flattenRows(module).length);
+    const measures = Math.max(1, Math.ceil(totalRows / (ROWS_PER_BEAT * BEATS_PER_MEASURE)));
+    const base = createEmptyScore({
+        title: module.title.length > 0 ? module.title : 'Module',
+        measures,
+        tracks: usedInstruments.length > 0
+            ? usedInstruments.map(s => ({
+                name: nameOf(s),
+                instrumentName: nameOf(s),
+                clef: 'treble',
+            }))
+            : [
+                {
+                    name: 'Module',
+                    instrumentName: 'Module',
+                    clef: 'treble',
+                },
+            ],
+    });
+    const ticksPerRow = base.ppq / ROWS_PER_BEAT;
+    const tracks = base.tracks.map((track, trackIndex) => {
+        const instrument = usedInstruments[trackIndex];
+        const mine = placed.filter(n => n.instrument === instrument);
+        const withNotes = track.measures.map(measure => {
+            const measureEnd = measure.startTick + measure.durationTicks;
+            const here = mine.filter(n => {
+                const tick = n.startRow * ticksPerRow;
+                return tick >= measure.startTick && tick < measureEnd;
+            });
+            // An untouched measure already carries a full-measure rest from
+            // `createEmptyScore`, so it is already complete.
+            if (here.length === 0)
+                return measure;
+            // Voice allocation: a note overlapping one already placed in a voice
+            // goes to the next. This is what lets a sample-grouped track hold two
+            // channels sounding at once.
+            const voiceEnds = [];
+            const voiceEvents = [];
+            for (const note of here) {
+                const startTick = note.startRow * ticksPerRow;
+                const endTick = Math.min(note.endRow * ticksPerRow, measureEnd);
+                let voice = voiceEnds.findIndex(end => end <= startTick);
+                if (voice === -1) {
+                    voice = voiceEnds.length;
+                    voiceEnds.push(0);
+                    voiceEvents.push([]);
+                }
+                voiceEnds[voice] = endTick;
+                voiceEvents[voice].push({
+                    id: createId(),
+                    pitch: midiToPitch(note.midi, measure.keySignature),
+                    startTick,
+                    durationTicks: Math.max(1, endTick - startTick),
+                    velocity: 80,
+                    voiceId: '',
+                    trackId: track.id,
+                });
+            }
+            const voices = voiceEvents.map((events, i) => {
+                const id = measure.voices[i]?.id ?? createId();
+                return {
+                    id,
+                    name: `Voice ${i + 1}`,
+                    // Rests around the notes, or the bar does not add up — see `fill.ts`.
+                    events: fillVoiceWithRests(events, measure.startTick, measure.durationTicks, base.ppq, track.id, id),
+                };
+            });
+            return { ...measure, voices };
+        });
+        return { ...track, measures: withNotes };
+    });
+    return { ...base, tracks, tempoMap: tempoMapOf(module, ticksPerRow) };
+}
+export { effectiveBpm, tempoChanges };
+//# sourceMappingURL=import.js.map