@sudobility/music_types 0.12.1 → 0.13.2

package/CLAUDE.md

@@ -39,6 +39,26 @@ Everything exports from a single sectioned `src/index.ts`:
 
 ## Gotchas
 
+- **The playhead is the one stateful service in this package, and that is a
+  deliberate precedent.** `MusicPosition` and its singleton live in
+  `src/position/`. Everything else here is model and primitives; the playhead
+  earns the exception because it has exactly one writer
+  (`@sudobility/music_player`) and readers in every other package — the caret,
+  the note highlighting, the piano keyboard — so any other home creates a
+  dependency edge that exists only to reach it. It still obeys the four rules:
+  works on both sides, no dependency, no hooks, no async.
+- **`base64.ts` is here because its two consumers ended up in different
+  packages.** `music_io`'s React Native file exporter encodes; `music_player`'s
+  sample-pack loader decodes. The module exists precisely so there is one
+  alphabet and one round-trip test rather than a copy each — splitting it would
+  break the property it was written to guarantee.
+- **The playback *plan* is here; the engine *contract* is not.** `PlaybackPlan`
+  composes `PerformanceTimeline`, which `performanceTimeline()` in
+  `domain/score/` produces, so the whole plan cluster is anchored here — moving
+  it would make this package import from `music_player`. `PlaybackEngine`,
+  `PlaybackObserver` and `AuditionVoice` did move, because that package is the
+  only thing that implements or calls them.
+
 - No domain logic here: tick math, factories, commands, validation logic all live in `@sudobility/music_lib`. This package must never depend on music_lib (music_api depends on this package and must not pull in UI/audio code).
 - `noteEventSchema`/`restEventSchema` are `.strict()` on purpose (a stray `pitch` key must not pass as a rest); other schemas strip unknown keys for forward compatibility.
 - Ticks are integers at 480 PPQ by convention; `startTick` is absolute.

package/dist/bytes/base64.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Base64, both directions.
+ *
+ * Here rather than in a platform package because its two consumers now live in
+ * different ones — `music_io`'s React Native file exporter encodes, and
+ * `music_player`'s sample-pack loader decodes — and this module exists
+ * precisely so there is one alphabet and one round-trip test rather than a
+ * copy each. Pure string and byte work: no dependency, no async, nothing
+ * platform-bound, so it sits inside this package's four rules.
+ *
+ * Written out rather than reached for because Hermes guarantees neither `btoa`
+ * nor Node's `Buffer`, and the two places that need it need opposite
+ * directions: `file/file.rn.ts` encodes bytes to hand `react-native-fs` a
+ * base64 string, and `playback/pack-library.ts` decodes the base64 mp3 data
+ * URIs inside a FluidR3 sample pack.
+ *
+ * One module rather than a copy each, so the alphabet is defined once and the
+ * pair can be round-tripped against each other — which is a stronger check than
+ * either direction gets alone, since a matching error in both would still
+ * survive testing them separately.
+ *
+ * **Both are hot enough to be worth the shape they are in.** A sample pack is
+ * ~2.7MB of base64 decoded on the way into playback, per instrument, and an
+ * audio export is tens of megabytes encoded on the way out — on a phone, with
+ * no JIT. The obvious implementations of each were measured at 77ms and 580ms
+ * for those sizes on a laptop; these are 9ms and 303ms.
+ */
+/** Bytes to base64, padded. */
+export declare function bytesToBase64(bytes: Uint8Array): string;
+/**
+ * Base64 to bytes. Anything outside the alphabet — padding, newlines a data URI
+ * may carry — is skipped rather than rejected.
+ *
+ * Skipped *inline* rather than stripped first: the obvious
+ * `replace(/[^A-Za-z0-9+/]/g, '')` copies the whole multi-megabyte string
+ * before any decoding starts, which on a sample pack costs as much as the
+ * decode itself.
+ */
+export declare function base64ToBytes(base64: string): ArrayBuffer;
+//# sourceMappingURL=base64.d.ts.map

package/dist/bytes/base64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.d.ts","sourceRoot":"","sources":["../../src/bytes/base64.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAyBH,+BAA+B;AAC/B,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAmBvD;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAoBzD"}

package/dist/bytes/base64.js

@@ -0,0 +1,101 @@
+/**
+ * Base64, both directions.
+ *
+ * Here rather than in a platform package because its two consumers now live in
+ * different ones — `music_io`'s React Native file exporter encodes, and
+ * `music_player`'s sample-pack loader decodes — and this module exists
+ * precisely so there is one alphabet and one round-trip test rather than a
+ * copy each. Pure string and byte work: no dependency, no async, nothing
+ * platform-bound, so it sits inside this package's four rules.
+ *
+ * Written out rather than reached for because Hermes guarantees neither `btoa`
+ * nor Node's `Buffer`, and the two places that need it need opposite
+ * directions: `file/file.rn.ts` encodes bytes to hand `react-native-fs` a
+ * base64 string, and `playback/pack-library.ts` decodes the base64 mp3 data
+ * URIs inside a FluidR3 sample pack.
+ *
+ * One module rather than a copy each, so the alphabet is defined once and the
+ * pair can be round-tripped against each other — which is a stronger check than
+ * either direction gets alone, since a matching error in both would still
+ * survive testing them separately.
+ *
+ * **Both are hot enough to be worth the shape they are in.** A sample pack is
+ * ~2.7MB of base64 decoded on the way into playback, per instrument, and an
+ * audio export is tens of megabytes encoded on the way out — on a phone, with
+ * no JIT. The obvious implementations of each were measured at 77ms and 580ms
+ * for those sizes on a laptop; these are 9ms and 303ms.
+ */
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+/**
+ * Character code to sextet, -1 for anything else.
+ *
+ * A table rather than `ALPHABET.indexOf(char)`, which is a linear search over
+ * 64 characters *per character decoded* — 8.5x the total cost on a pack-sized
+ * input, and worse under an interpreter than under V8.
+ */
+const SEXTET = new Int8Array(256).fill(-1);
+for (let i = 0; i < ALPHABET.length; i += 1)
+    SEXTET[ALPHABET.charCodeAt(i)] = i;
+/**
+ * How much string to accumulate before pushing it into the chunk list.
+ *
+ * Growing one string four characters at a time asks the engine to keep
+ * re-materialising it; joining a list of moderate pieces is roughly twice as
+ * fast on an export-sized input. Large enough that the list stays short, small
+ * enough that no single piece is itself expensive to grow.
+ */
+const ENCODE_CHUNK_CHARS = 8192;
+/** Bytes to base64, padded. */
+export function bytesToBase64(bytes) {
+    const chunks = [];
+    let piece = '';
+    for (let i = 0; i < bytes.length; i += 3) {
+        const a = bytes[i];
+        const b = bytes[i + 1];
+        const c = bytes[i + 2];
+        piece +=
+            ALPHABET[a >> 2] +
+                ALPHABET[((a & 0x03) << 4) | ((b ?? 0) >> 4)] +
+                (b === undefined ? '=' : ALPHABET[((b & 0x0f) << 2) | ((c ?? 0) >> 6)]) +
+                (c === undefined ? '=' : ALPHABET[c & 0x3f]);
+        if (piece.length >= ENCODE_CHUNK_CHARS) {
+            chunks.push(piece);
+            piece = '';
+        }
+    }
+    if (piece)
+        chunks.push(piece);
+    return chunks.join('');
+}
+/**
+ * Base64 to bytes. Anything outside the alphabet — padding, newlines a data URI
+ * may carry — is skipped rather than rejected.
+ *
+ * Skipped *inline* rather than stripped first: the obvious
+ * `replace(/[^A-Za-z0-9+/]/g, '')` copies the whole multi-megabyte string
+ * before any decoding starts, which on a sample pack costs as much as the
+ * decode itself.
+ */
+export function base64ToBytes(base64) {
+    // An upper bound — exact when there is no padding or whitespace, over by at
+    // most a couple of bytes when there is. Trimmed at the end rather than
+    // counted in a first pass, which would be another walk over megabytes.
+    const out = new Uint8Array(((base64.length * 3) >> 2) + 3);
+    let outIndex = 0;
+    let accumulator = 0;
+    let bits = 0;
+    for (let i = 0; i < base64.length; i += 1) {
+        const sextet = SEXTET[base64.charCodeAt(i) & 0xff];
+        if (sextet < 0)
+            continue;
+        accumulator = (accumulator << 6) | sextet;
+        bits += 6;
+        if (bits >= 8) {
+            bits -= 8;
+            out[outIndex] = (accumulator >> bits) & 0xff;
+            outIndex += 1;
+        }
+    }
+    return out.buffer.slice(0, outIndex);
+}
+//# sourceMappingURL=base64.js.map

package/dist/bytes/base64.js.map

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

package/dist/bytes/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./base64.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/bytes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bytes/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/dist/bytes/index.js

@@ -0,0 +1,2 @@
+export * from "./base64.js";
+//# sourceMappingURL=index.js.map

package/dist/bytes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/bytes/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/dist/domain/commands/repair-commands.d.ts

@@ -0,0 +1,10 @@
+import type { ScoreCommand } from "./types.js";
+/**
+ * Repairs every validation issue that has an unambiguous fix.
+ *
+ * A no-op on a clean score: `repairScore` returns its input by reference, so
+ * the command produces an identical score and the caller can compare
+ * identities to decide whether anything happened.
+ */
+export declare function repairScoreCommand(label: string): ScoreCommand;
+//# sourceMappingURL=repair-commands.d.ts.map

package/dist/domain/commands/repair-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repair-commands.d.ts","sourceRoot":"","sources":["../../../src/domain/commands/repair-commands.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAE9D"}

package/dist/domain/commands/repair-commands.js

@@ -0,0 +1,25 @@
+/**
+ * The "fix every issue you can" edit, as one undoable command.
+ *
+ * One command rather than one per rule, because that is what the reader asked
+ * for: the issue list is a single list and clearing it is a single decision.
+ * Splitting it would also make undo wrong — stepping back through twelve
+ * separate repairs to get the score you had before pressing one button.
+ *
+ * `kind` is left at the default `content`, so this is refused while the
+ * transport is playing like every other edit. Rewriting notes out from under
+ * a running engine is exactly what that lock exists to prevent.
+ */
+import { transformCommand } from "./snapshot.js";
+import { repairScore } from "../validation/repair.js";
+/**
+ * Repairs every validation issue that has an unambiguous fix.
+ *
+ * A no-op on a clean score: `repairScore` returns its input by reference, so
+ * the command produces an identical score and the caller can compare
+ * identities to decide whether anything happened.
+ */
+export function repairScoreCommand(label) {
+    return transformCommand(label, (score) => repairScore(score).score);
+}
+//# sourceMappingURL=repair-commands.js.map

package/dist/domain/commands/repair-commands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repair-commands.js","sourceRoot":"","sources":["../../../src/domain/commands/repair-commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtD;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAa;IAC9C,OAAO,gBAAgB,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC;AACtE,CAAC"}

package/dist/domain/validation/limits.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The numeric bounds every validation rule is written against.
+ *
+ * Extracted so `validator.ts` and `repair.ts` cannot drift: a repair that
+ * clamped to its own idea of "valid" would hand back a score the validator
+ * still rejects, and the Fix button would appear to do nothing. One
+ * definition means a clamp to these bounds provably clears the rule that
+ * cited them.
+ */
+export declare const MIN_MIDI = 0;
+export declare const MAX_MIDI = 127;
+export declare const MIN_VELOCITY = 0;
+export declare const MAX_VELOCITY = 127;
+export declare const MIN_MIDI_PROGRAM = 0;
+export declare const MAX_MIDI_PROGRAM = 127;
+export declare const MIN_MIDI_CHANNEL = 0;
+export declare const MAX_MIDI_CHANNEL = 15;
+export declare const VALID_TIME_SIG_DENOMINATORS: Set<number>;
+export declare const MIN_FIFTHS = -7;
+export declare const MAX_FIFTHS = 7;
+export declare const MIN_BPM = 20;
+export declare const MAX_BPM = 400;
+/**
+ * Maximum number of notes sounding at once (within a single track) before a
+ * "too many simultaneous notes" readability warning fires. Spec §23 names
+ * this rule but doesn't give a number; 10 is a deliberate implementer
+ * default (roughly as many notes as a two-hand piano voicing on one staff
+ * can render legibly), documented here so a later task can make it
+ * configurable if that turns out to be too strict/loose in practice.
+ */
+export declare const MAX_SIMULTANEOUS_NOTES = 10;
+//# sourceMappingURL=limits.d.ts.map

package/dist/domain/validation/limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limits.d.ts","sourceRoot":"","sources":["../../../src/domain/validation/limits.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,IAAI,CAAC;AAC1B,eAAO,MAAM,QAAQ,MAAM,CAAC;AAC5B,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,eAAO,MAAM,YAAY,MAAM,CAAC;AAChC,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAClC,eAAO,MAAM,gBAAgB,MAAM,CAAC;AACpC,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAClC,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,eAAO,MAAM,2BAA2B,aAAgC,CAAC;AACzE,eAAO,MAAM,UAAU,KAAK,CAAC;AAC7B,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,eAAO,MAAM,OAAO,KAAK,CAAC;AAC1B,eAAO,MAAM,OAAO,MAAM,CAAC;AAE3B;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,KAAK,CAAC"}

package/dist/domain/validation/limits.js

@@ -0,0 +1,32 @@
+/**
+ * The numeric bounds every validation rule is written against.
+ *
+ * Extracted so `validator.ts` and `repair.ts` cannot drift: a repair that
+ * clamped to its own idea of "valid" would hand back a score the validator
+ * still rejects, and the Fix button would appear to do nothing. One
+ * definition means a clamp to these bounds provably clears the rule that
+ * cited them.
+ */
+export const MIN_MIDI = 0;
+export const MAX_MIDI = 127;
+export const MIN_VELOCITY = 0;
+export const MAX_VELOCITY = 127;
+export const MIN_MIDI_PROGRAM = 0;
+export const MAX_MIDI_PROGRAM = 127;
+export const MIN_MIDI_CHANNEL = 0;
+export const MAX_MIDI_CHANNEL = 15;
+export const VALID_TIME_SIG_DENOMINATORS = new Set([1, 2, 4, 8, 16, 32]);
+export const MIN_FIFTHS = -7;
+export const MAX_FIFTHS = 7;
+export const MIN_BPM = 20;
+export const MAX_BPM = 400;
+/**
+ * Maximum number of notes sounding at once (within a single track) before a
+ * "too many simultaneous notes" readability warning fires. Spec §23 names
+ * this rule but doesn't give a number; 10 is a deliberate implementer
+ * default (roughly as many notes as a two-hand piano voicing on one staff
+ * can render legibly), documented here so a later task can make it
+ * configurable if that turns out to be too strict/loose in practice.
+ */
+export const MAX_SIMULTANEOUS_NOTES = 10;
+//# sourceMappingURL=limits.js.map

package/dist/domain/validation/limits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"limits.js","sourceRoot":"","sources":["../../../src/domain/validation/limits.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAC;AAC1B,MAAM,CAAC,MAAM,QAAQ,GAAG,GAAG,CAAC;AAC5B,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC;AAC9B,MAAM,CAAC,MAAM,YAAY,GAAG,GAAG,CAAC;AAChC,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC;AAClC,MAAM,CAAC,MAAM,gBAAgB,GAAG,GAAG,CAAC;AACpC,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC;AAClC,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,CAAC;AACnC,MAAM,CAAC,MAAM,2BAA2B,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;AACzE,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC,CAAC;AAC7B,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC;AAC5B,MAAM,CAAC,MAAM,OAAO,GAAG,EAAE,CAAC;AAC1B,MAAM,CAAC,MAAM,OAAO,GAAG,GAAG,CAAC;AAE3B;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,CAAC"}

package/dist/domain/validation/repair.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Automatic repair for the rules `validateScore` checks (`./validator.ts`).
+ *
+ * The validator's inverse, and deliberately its neighbour: a repair that
+ * clamped to its own idea of "valid" would hand back a score the validator
+ * still rejects, so both read their bounds from `./limits.ts` and this module
+ * *measures* its own result rather than asserting it — `repairScore`
+ * re-validates at the end and reports the before/after counts per code. That
+ * is what makes "Fix" honest about the issues it could not resolve instead of
+ * quietly claiming all of them.
+ *
+ * Pure: never mutates its input, and returns a fresh `Score`.
+ *
+ * Each pass repairs toward what the notation *means*, not toward whatever
+ * silences the rule fastest:
+ *
+ * - Two same-pitch notes that overlap are one note struck twice, so the
+ *   earlier one is truncated to end where the later begins. An exact
+ *   duplicate — same tick, same length, same spelling — cannot be played
+ *   twice at once and is simply dropped.
+ * - A pitch out of MIDI range moves by whole **octaves**, keeping its pitch
+ *   class, for the reason the tracker exporter does it: a bassline pushed to
+ *   the boundary stops being that bassline.
+ * - A misordered measure is moved by shifting its events with it, because an
+ *   event's `startTick` is absolute; rewriting the measure's own start alone
+ *   would strand every note it contains outside it.
+ * - The count of notes sounding at once is left alone. There is no
+ *   non-arbitrary choice of which note to delete, and it is a readability
+ *   warning rather than a broken score.
+ */
+import type { Score } from "../../index.js";
+export type ScoreRepair = {
+    /** The repaired score. Identical by reference to the input when nothing needed fixing. */
+    score: Score;
+    /** How many issues of each code the repair actually cleared, measured by re-validating. */
+    fixed: Record<string, number>;
+    /** What the repaired score still reports, by code — the rules this cannot resolve. */
+    remaining: Record<string, number>;
+};
+/**
+ * Repairs every rule this can, and reports what it actually achieved.
+ *
+ * Returns the input score by reference when it was already clean, so a caller
+ * dispatching this as a command can tell "nothing to do" from "something
+ * changed" without diffing.
+ */
+export declare function repairScore(score: Score): ScoreRepair;
+//# sourceMappingURL=repair.d.ts.map

package/dist/domain/validation/repair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repair.d.ts","sourceRoot":"","sources":["../../../src/domain/validation/repair.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,KAAK,EAIV,KAAK,EAIN,MAAM,gBAAgB,CAAC;AAsBxB,MAAM,MAAM,WAAW,GAAG;IACxB,0FAA0F;IAC1F,KAAK,EAAE,KAAK,CAAC;IACb,2FAA2F;IAC3F,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,sFAAsF;IACtF,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC,CAAC;AAuWF;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,WAAW,CA2DrD"}