@sudobility/music_types 0.13.26 → 0.13.27

package/CLAUDE.md

@@ -5,7 +5,9 @@
 > explicitly asks in that turn**. Approval for an earlier change does not carry forward, and
 > finishing a task is not permission to commit it.
 
-TypeScript types and Zod schemas for the Moosiac music family (music_api, music_client, music_lib, music_app).
+The model of the Moosiac music family, and every name the family shares: the score types and their Zod schemas, the pure primitives both the frontend and the backend need (pitch and tick math, factories, commands, instrument knowledge, readout formatting, `outOfRangeNoteIds`), and **every shared type and closed vocabulary** — the codecs' option and result types, the platform contracts, the editor's vocabulary, the generation drafts, the export formats and the formats table. Consumed by music_api, music_codecs, music_player, music_drawing, music_editing, music_client, music_io, music_lib and both apps.
+
+**Two rules decide what lives here, and both are the user's.** *All type definitions and vocabulary constants live in music_types* — a shape or a closed list another package names is declared here once, never in the package that happens to use it first. *Pure helper functions used by both the frontend and the backend live in music_types* too. Either kind must still pass the four tests every module here passes: it works on both sides, adds no dependency (the runtime dependencies are `zod` and `immer`, and that is the whole list), contains no hook, and contains no async code. A type whose shape needs zustand, React, a class or a renderer stays with the package that has that dependency.
 
 ## Tech Stack
 
@@ -35,15 +37,42 @@ Everything exports from a single sectioned `src/index.ts`:
 8. Zod schemas for the project API
 9. Response envelope (`ApiResponse<T>`, `successResponse`, `errorResponse`, `API_ERROR_CODES`)
 
+Then the shared primitives under `src/domain/` (score, commands, instruments, notation, generation, …) and the shared vocabulary:
+
+- `src/formats/` — the codecs' option and result types and the audio-import extensions
+- `src/platform/` — the platform contracts (`ScoreFiles`, `PrefsStorage`/`DocumentFileStorage`, `XmlParser`, `FileExporter`, MIDI input, playback)
+- `src/domain/editor/` — the editor's vocabulary (edit modes, device prefs, toasts, `LAYOUT_MODES`/`LayoutMode`, `PAPER_OPTIONS`/`ORIENTATION_OPTIONS`, docs, inspector, toolbar and context-menu vocabularies, input shapes, copy contracts)
+- `src/domain/documents/` — `export-formats.ts` (`WRITABLE_EXPORT_FORMATS`), `formats.ts` (`IMPORT_FORMATS`/`EXPORT_FORMATS`), `templates.ts`, `document-state.ts`, `publish.ts`, and `project-file.ts` (`DOCUMENT_EXTENSION(S)`, `PROJECT_FILE_VERSION`, `ProjectFile`; the parser and serializer are music_codecs')
+- `src/domain/generation/request-drafts.ts` / `replace-drafts.ts` — the generation forms; `src/domain/score/transport-settings.ts` — `TransportSettings`/`PlayerFailure`
+
 `src/test-helpers.ts` is a test-only fixture helper (excluded from the published build); shared score factories live in this package under `domain/score/`.
 
 ## Gotchas
 
+- **Frontend vocabulary lives here too, as types and data only.** Both apps and every frontend library name the same closed lists and shapes, and music_lib re-exports this package *and* music_editing/music_codecs/music_drawing wholesale — so a shape declared in two of them is a TS2308 in music_lib and a "Cannot redefine property" crash in a CommonJS consumer. `domain/editor/` holds the editor's vocabulary (`EDIT_MODES`/`EDIT_MODE_OPTIONS`, `THEME_MODES`/`FONT_SIZES`/`DevicePrefs`/`DevSettings`, `Toast`/`ToastSink`, `LAYOUT_MODES`, `QUANTIZE_GRIDS`, the inspector, toolbar and context-menu vocabularies, `ClipboardData`, `ScoreCanvasHit` and the other input shapes, `EditingCopy`/`LibraryCopy`, the docs and shortcut shapes, the paper options, `AppErrorCode`); `domain/generation/request-drafts.ts` and `replace-drafts.ts` the generation forms (`NewProjectSubmission`, `LOCKABLE`, `ReplaceSubmission`); `domain/documents/` the export formats (`WRITABLE_EXPORT_FORMATS`) and the formats table (`formats.ts`, which came from music_editing), `TEMPLATE_IDS`, `DocumentOrigin`/`SaveState`, `PublishNames`, and the project file's name and version (`DOCUMENT_EXTENSION(S)`, `PROJECT_FILE_VERSION`); `domain/score/transport-settings.ts` `TransportSettings`/`PlayerFailure`; `formats/` the codecs' option and result types (`MidiImportOptions`, `MusicXmlWarnings`, `TrackerFitReport`) and the audio-import extensions; `platform/` the `ScoreFiles`, `PrefsStorage` and `DocumentFileStorage` contracts. The rules over them live with whatever owns the rule — `selectToolbarAvailability` in music_editing; `bindPlayer`, `planExport`, `decideClose`/`decideQuit`, `resolveThemeMode` and the docs content in music_lib; `litKeys` in music_drawing; the parsers and serializers in music_codecs. This package has no moved-names guard because it is where names move *to*; each package they left carries one (`__moved-to-types.test.ts` in music_codecs, music_client, music_io and music_lib, `__moved-out.test.ts` in music_drawing and music_editing).
+- **`outOfRangeNoteIds` is a pure question about the model**, so it lives in `domain/instruments/out-of-range.ts`, beside `trackRangeIsBinding` (`range-fit.ts`), rather than in music_drawing, which only colours the answer. It takes the **stored** score, never `displayScore`'s.
+- **A file named `document.ts` trips `platform-free.test.ts`**: the export path `./documents/document.js` reads as the `document.` global to its pattern. That is why it is `document-state.ts`.
+
+
 - **One row per General MIDI program, and every row says where its numbers came from** (`gm-catalogue.ts`). Range, polyphony and transposition used to be three tables of family defaults plus a handful of per-program overrides — which looked like deduplication and was not: 90 of the 128 programs inherited a compass nobody had chosen for them, and an inherited value was indistinguishable from a researched one. It hid a real bug (**Muted Trumpet** had no transposition entry, so a B-flat trumpet with a mute in the bell was treated as non-transposing and its part displayed a whole tone wrong), gave the **Clavinet** an 88-key piano compass where it has 60 keys F1-E6, and handed the flute's exact range to five instruments that share none of it. The repetition where eight guitars genuinely share a compass is the point: writing it eight times is a decision somebody made, where inheriting it eight times is a question nobody was asked. **`basis` is the field to read before trusting a number** — `measured` (checked against a source), `synthetic` (an electronic patch has no acoustic compass, so it gets the whole keyboard rather than an invented limit), `unpitched` (a sound effect), and `assumed` (**not verified**, carried over from the old default, left deliberately wide). No row is left `assumed`: the 31 that were have each been settled, most by looking the instrument up and ten by finding that the honest answer is `tunable` — a shamisen is tuned to the singer, a koto to the piece, an mbira to notes that are not on the tempered scale at all, and a pan flute or hammered dulcimer is built in many sizes; refusing a note against those would be refusing against the sampler rather than the instrument. Section patches (`String Ensemble`, `Brass Section`) take the **union of the instruments in them, computed rather than typed**, so a string section cannot end up narrower than the cello inside it. Where General MIDI names a family rather than an instrument the row covers the common members: "Recorder" is soprano and alto together, "Bagpipe" is the Highland chanter's nine notes and the uilleann's two octaves together — the Highland compass alone is fifteen semitones and rejected honest music. The split is now 75 measured, 30 synthetic, 13 unpitched, 10 tunable. `gmRangeIsBinding` answers `true` only for `measured`, and the generation inspector consults it before reporting an out-of-range note: refusing a note against a compass nobody checked rejects music that was fine, and since that finding drives a retry it would spend real money arguing about a limit we invented.
 
+- **`Track.midiProgram` means two different things, and
+  `domain/instruments/track-instrument.ts` is the only place that knows which.**
+  On a percussion-clef track (`isPercussionTrack`) it addresses a General MIDI
+  *drum kit* (`gm-kit.ts`); everywhere else it is an instrument (`gm.ts`). The two
+  never coincide — Brush is kit 40, and program 40 is Violin — so every
+  program-keyed table (`gm-range`, `gm-polyphony`, `gm-transposition`,
+  `gm-icon`) gives a confidently wrong answer for a drum track. Take a `Track`
+  and call `trackKeyboardRange`/`trackMaxPolyphony`/`trackWrittenTransposition`/
+  `trackInstrumentIcon`/`trackInstrumentLabel` instead; the program-keyed
+  functions stay exported for callers that genuinely hold only a program.
+  `scoreWithResolvedKits` (which music_editing's `setScore` runs inbound) snaps a
+  percussion track to a real kit and returns the **identical score** when there
+  is nothing to fix, which is what keeps opening a project from marking it dirty.
+
 - **A regeneration request says who is playing, and a kit gets told how a kit is written.** A `ScoreFragment` is measures and nothing else — no name, no clef, no program — so "Replace Track" used to hand the model anonymous bars and let it infer the instrument from the notes in front of it. On a drum track there is nothing to infer from: the pitches are drum numbers, not notes. Measured on a real Power Kit regeneration, the result was the kick on every eighth of all 118 bars at a constant velocity 100, the snare on all four beats instead of the backbeat, and five of the 47 drums used — a metronome, not a groove. `RegenerateRegionRequest.tracks` now carries a `GenerateScoreRequestTrack` per fragment track, built by `describeTrackForGeneration` in music_types so whole-score generation and regeneration describe a track the *same* way; the range and polyphony come from `trackKeyboardRange`/`trackMaxPolyphony`, which answer about the **kit** on a percussion track rather than about whatever melodic program shares its number. The roster is matched to the fragment **by position**, so `buildRegeneratePrompt` emits it only when the lengths agree — a roster of a different length is not partial information but wrong information, naming the kit as the cello. And `percussionRules()` — previously generate-only, and previously just the GM map — now travels on both paths and states the two Expression rules that **invert** for percussion: an accent is the rule rather than the exception (velocity variation between accented and ghost notes *is* the groove), and a kit does play continuously even though each individual drum still rests. The map alone is not enough, which is the thing that had to be measured to be believed.
 
-- **One fact, one declaration — and `src/__single-source.test.ts` enforces it.** A constant restated in a second package agrees with the first right up until one of them is edited, and nothing fails when they part: the build is clean, the types match, and the only symptom is a wrong sound or a picker quietly missing an entry. Measured across the family, 23 UPPER_CASE constants were declared in more than one repo — `CC_VOLUME` three times, `DYNAMICS` four, `C_MAJOR` five, and `DEFAULT_TIME_SIGNATURE` in four places under two names. The guard reads the list of names **from music_types at runtime** rather than restating it, because a check against duplication that duplicates what it checks would drift like everything else; its `ALLOWED` list is empty on purpose, so an exemption is a decision somebody writes down. Two shapes matter beyond the constants themselves. **A closed vocabulary is declared as an array and the type read off it** (`export const DYNAMICS = [...] as const; export type Dynamic = (typeof DYNAMICS)[number];`) — a TypeScript union has no runtime form, so anything that must *validate* a value has to write the list out again, which is exactly how music_api's decoder came to check generated music against its own private copy. **A label or option list keyed by the vocabulary is a `Record<T, ...>`, never a parallel array** — a record fails to compile when a member is added, an array silently goes on offering the old set; that is why the inspector's picker lists are `ACCIDENTAL_OPTIONS`/`ARTICULATION_OPTIONS` built from the vocabulary rather than `ACCIDENTALS`/`ARTICULATIONS` retyped. Test fixtures follow the same rule: the score fixtures live once, in `@sudobility/music_types/test`, and a package that needs a rendering fixture of its own re-exports them and adds to them.
+- **One fact, one declaration — and each consuming package's `src/__single-source.test.ts` enforces it** (here, `domain/vocabulary-source.test.ts` pins the array-then-type shape). A constant restated in a second package agrees with the first right up until one of them is edited, and nothing fails when they part: the build is clean, the types match, and the only symptom is a wrong sound or a picker quietly missing an entry. Measured across the family, 23 UPPER_CASE constants were declared in more than one repo — `CC_VOLUME` three times, `DYNAMICS` four, `C_MAJOR` five, and `DEFAULT_TIME_SIGNATURE` in four places under two names. The guard reads the list of names **from music_types at runtime** rather than restating it, because a check against duplication that duplicates what it checks would drift like everything else; its `ALLOWED` list is empty on purpose, so an exemption is a decision somebody writes down. Two shapes matter beyond the constants themselves. **A closed vocabulary is declared as an array and the type read off it** (`export const DYNAMICS = [...] as const; export type Dynamic = (typeof DYNAMICS)[number];`) — a TypeScript union has no runtime form, so anything that must *validate* a value has to write the list out again, which is exactly how music_api's decoder came to check generated music against its own private copy. **A label or option list keyed by the vocabulary is a `Record<T, ...>`, never a parallel array** — a record fails to compile when a member is added, an array silently goes on offering the old set; that is why the inspector's picker lists are `ACCIDENTAL_OPTIONS`/`ARTICULATION_OPTIONS` built from the vocabulary rather than `ACCIDENTALS`/`ARTICULATIONS` retyped. Test fixtures follow the same rule: the score fixtures live once, in `@sudobility/music_types/test`, and a package that needs a rendering fixture of its own re-exports them and adds to them.
 
 - **The playhead is the one stateful service in this package, and that is a
   deliberate precedent.** `MusicPosition` and its singleton live in
@@ -67,7 +96,8 @@ Everything exports from a single sectioned `src/index.ts`:
 
 - Pure shared domain logic belongs here when both frontend and backend need it:
   tick math, factories, commands, validation, instrument knowledge, generation
-  presets and prompt-facing shared data. This package must never depend on
+  presets and prompt-facing shared data — and every type and vocabulary
+  constant, whoever uses it (see the two rules at the top). This package must never depend on
   `music_lib`, and `music_api` must never pull in frontend UI/audio code just
   to reach a shared rule.
 - `noteEventSchema`/`restEventSchema` are `.strict()` on purpose (a stray `pitch` key must not pass as a rest); other schemas strip unknown keys for forward compatibility.

package/dist/domain/documents/document-state.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A document, as vocabulary: where its bytes live and whether they are
+ * written. The per-document store and the saver are music_lib's.
+ */
+/** Where a document's bytes live, and therefore what saving it means. */
+export type DocumentOrigin = {
+    kind: "unsaved";
+} | {
+    kind: "file";
+    uri: string;
+} | {
+    kind: "project";
+    projectId: string;
+};
+/** Whether the document on screen is the one written. */
+export type SaveState = "saved" | "saving" | "unsaved";
+//# sourceMappingURL=document-state.d.ts.map

package/dist/domain/documents/document-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-state.d.ts","sourceRoot":"","sources":["../../../src/domain/documents/document-state.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,yEAAyE;AACzE,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC7B;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3C,yDAAyD;AACzD,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC"}

package/dist/domain/documents/document-state.js

@@ -0,0 +1,6 @@
+/**
+ * A document, as vocabulary: where its bytes live and whether they are
+ * written. The per-document store and the saver are music_lib's.
+ */
+export {};
+//# sourceMappingURL=document-state.js.map

package/dist/domain/documents/document-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-state.js","sourceRoot":"","sources":["../../../src/domain/documents/document-state.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/domain/documents/export-formats.d.ts

@@ -0,0 +1,74 @@
+/**
+ * What an export can write, as vocabulary: the formats, their extensions and
+ * labels, and the shape of a plan to write one.
+ *
+ * Both apps offer the same menu of formats, and the docs table of export
+ * formats (`EXPORT_FORMATS`, beside this) is derived from the same list, so the
+ * menu and the documentation cannot come to disagree. Deciding a plan
+ * (`planExport`) is music_lib's; naming the file, rendering audio and the write
+ * itself belong to the packages that own each.
+ */
+import type { Score } from "../../model/score.js";
+/**
+ * How a format reaches disk.
+ *
+ * `notation` is a single codec call; `tracker` has a fit report to show first;
+ * `audio` has to be rendered by a synth before it is encoded; `project` writes
+ * the document itself.
+ */
+export type ExportRoute = "notation" | "tracker" | "audio" | "project";
+export declare const WRITABLE_EXPORT_FORMATS: readonly [{
+    readonly id: "midi";
+    readonly extension: "mid";
+    readonly route: "notation";
+    readonly labelKey: "editor.midi";
+    readonly noteKey: "docs.formats.out.midi";
+}, {
+    readonly id: "musicxml";
+    readonly extension: "musicxml";
+    readonly route: "notation";
+    readonly labelKey: "editor.musicXml";
+    readonly noteKey: "docs.formats.out.musicxml";
+}, {
+    readonly id: "xm";
+    readonly extension: "xm";
+    readonly route: "tracker";
+    readonly labelKey: "editor.xmModule";
+    readonly noteKey: "docs.formats.out.tracker";
+}, {
+    readonly id: "wav";
+    readonly extension: "wav";
+    readonly route: "audio";
+    readonly labelKey: "editor.audioWav";
+    readonly noteKey: "docs.formats.out.wav";
+}, {
+    readonly id: "mp3";
+    readonly extension: "mp3";
+    readonly route: "audio";
+    readonly labelKey: "editor.audioMp3";
+    readonly noteKey: "docs.formats.out.mp3";
+}, {
+    readonly id: "project";
+    readonly extension: "moo";
+    readonly route: "project";
+    readonly labelKey: "editor.projectJson";
+    readonly noteKey: "docs.formats.out.project";
+}];
+export type WritableExportFormat = (typeof WRITABLE_EXPORT_FORMATS)[number];
+export type ExportFormatId = WritableExportFormat["id"];
+/** Which tracks an export covers; see `exportScopeNeedsPrompt` for when to ask. */
+export type ExportScope = "all" | "visible";
+export type ExportPlan = {
+    format: ExportFormatId;
+    extension: string;
+    route: ExportRoute;
+    /** The score to write — already narrowed to the scope. */
+    target: Score;
+    /**
+     * What the file is named after: the score's own title, not a project or
+     * document name. Hand it to `exportFilename`, which keeps it and replaces
+     * only the characters a filesystem refuses.
+     */
+    title: string;
+};
+//# sourceMappingURL=export-formats.d.ts.map

package/dist/domain/documents/export-formats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-formats.d.ts","sourceRoot":"","sources":["../../../src/domain/documents/export-formats.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAGlD;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;AAEvE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwDlC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;AAC5E,MAAM,MAAM,cAAc,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC;AAExD,mFAAmF;AACnF,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,SAAS,CAAC;AAE5C,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE,cAAc,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,WAAW,CAAC;IACnB,0DAA0D;IAC1D,MAAM,EAAE,KAAK,CAAC;IACd;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;CACf,CAAC"}

package/dist/domain/documents/export-formats.js

@@ -0,0 +1,53 @@
+import { DOCUMENT_EXTENSION } from "./project-file.js";
+export const WRITABLE_EXPORT_FORMATS = [
+    {
+        id: "midi",
+        extension: "mid",
+        route: "notation",
+        labelKey: "editor.midi",
+        noteKey: "docs.formats.out.midi",
+    },
+    {
+        id: "musicxml",
+        extension: "musicxml",
+        route: "notation",
+        labelKey: "editor.musicXml",
+        noteKey: "docs.formats.out.musicxml",
+    },
+    {
+        id: "xm",
+        extension: "xm",
+        route: "tracker",
+        labelKey: "editor.xmModule",
+        noteKey: "docs.formats.out.tracker",
+    },
+    {
+        id: "wav",
+        extension: "wav",
+        route: "audio",
+        labelKey: "editor.audioWav",
+        noteKey: "docs.formats.out.wav",
+    },
+    {
+        id: "mp3",
+        extension: "mp3",
+        route: "audio",
+        labelKey: "editor.audioMp3",
+        noteKey: "docs.formats.out.mp3",
+    },
+    {
+        id: "project",
+        /*
+          The document's own extension. This said `json` — the web's old export —
+          long after both apps had moved to `.moo`, so each overrode the plan by
+          hand and the docs table went on calling a project file JSON. The file is
+          still JSON inside; the name is what the platform uses to hand it back to
+          this app.
+        */
+        extension: DOCUMENT_EXTENSION,
+        route: "project",
+        labelKey: "editor.projectJson",
+        noteKey: "docs.formats.out.project",
+    },
+];
+//# sourceMappingURL=export-formats.js.map

package/dist/domain/documents/export-formats.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-formats.js","sourceRoot":"","sources":["../../../src/domain/documents/export-formats.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAWvD,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC;QACE,EAAE,EAAE,MAAM;QACV,SAAS,EAAE,KAAK;QAChB,KAAK,EAAE,UAAU;QACjB,QAAQ,EAAE,aAAa;QACvB,OAAO,EAAE,uBAAuB;KACjC;IACD;QACE,EAAE,EAAE,UAAU;QACd,SAAS,EAAE,UAAU;QACrB,KAAK,EAAE,UAAU;QACjB,QAAQ,EAAE,iBAAiB;QAC3B,OAAO,EAAE,2BAA2B;KACrC;IACD;QACE,EAAE,EAAE,IAAI;QACR,SAAS,EAAE,IAAI;QACf,KAAK,EAAE,SAAS;QAChB,QAAQ,EAAE,iBAAiB;QAC3B,OAAO,EAAE,0BAA0B;KACpC;IACD;QACE,EAAE,EAAE,KAAK;QACT,SAAS,EAAE,KAAK;QAChB,KAAK,EAAE,OAAO;QACd,QAAQ,EAAE,iBAAiB;QAC3B,OAAO,EAAE,sBAAsB;KAChC;IACD;QACE,EAAE,EAAE,KAAK;QACT,SAAS,EAAE,KAAK;QAChB,KAAK,EAAE,OAAO;QACd,QAAQ,EAAE,iBAAiB;QAC3B,OAAO,EAAE,sBAAsB;KAChC;IACD;QACE,EAAE,EAAE,SAAS;QACb;;;;;;UAME;QACF,SAAS,EAAE,kBAAkB;QAC7B,KAAK,EAAE,SAAS;QAChB,QAAQ,EAAE,oBAAoB;QAC9B,OAAO,EAAE,0BAA0B;KACpC;CAOD,CAAC"}

package/dist/domain/documents/formats.d.ts

@@ -0,0 +1,17 @@
+export type FormatEntry = {
+    id: string;
+    /** Extensions as a reader would write them. */
+    extensions: string;
+    /** i18n key describing what survives the trip. */
+    noteKey: string;
+};
+export declare const IMPORT_FORMATS: readonly FormatEntry[];
+/**
+ * What the docs export table lists: every format the export menu writes, then
+ * printing, which produces a document rather than a file.
+ *
+ * Derived from `WRITABLE_EXPORT_FORMATS` rather than written out beside it: the
+ * table was its own list, and a list about the menu is a copy of the menu.
+ */
+export declare const EXPORT_FORMATS: readonly FormatEntry[];
+//# sourceMappingURL=formats.d.ts.map

package/dist/domain/documents/formats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formats.d.ts","sourceRoot":"","sources":["../../../src/domain/documents/formats.ts"],"names":[],"mappings":"AAiBA,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAC;IACnB,kDAAkD;IAClD,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,SAAS,WAAW,EA4BhD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,EAAE,SAAS,WAAW,EAOhD,CAAC"}

package/dist/domain/documents/formats.js

@@ -0,0 +1,61 @@
+/**
+ * Every file format the app reads and writes, declared once.
+ *
+ * The documentation, and anything else that has to list them, reads this —
+ * rather than a paragraph of prose naming formats, which is a copy of the list
+ * that stops being true the first time a format is added.
+ *
+ * **Here because both apps document these formats**, and what this product
+ * can open is a fact about the product, not about a web page. A table of
+ * vocabulary rather than logic, so it sits with the rest of the vocabulary.
+ *
+ * Every description is an i18n key, so the prose lives in each host's locale
+ * files and no library holds strings in any language.
+ */
+import { DOCUMENT_EXTENSIONS } from "./project-file.js";
+import { WRITABLE_EXPORT_FORMATS } from "./export-formats.js";
+export const IMPORT_FORMATS = [
+    { id: "midi", extensions: ".mid, .midi", noteKey: "docs.formats.in.midi" },
+    {
+        id: "musicxml",
+        extensions: ".musicxml, .xml",
+        noteKey: "docs.formats.in.musicxml",
+    },
+    {
+        id: "tracker",
+        extensions: ".mod, .dsm, .s3m, .xm, .it, .mptm",
+        noteKey: "docs.formats.in.tracker",
+    },
+    {
+        id: "audio",
+        extensions: ".wav, .mp3, .mpa",
+        noteKey: "docs.formats.in.audio",
+    },
+    /*
+      Every extension a project file opens under — the `.moo` both apps write,
+      the `.moosiac` documents were saved as before it was shortened, and the
+      web's old `.json` export — read from the list the codec decides by, so the
+      table cannot list fewer than the importer accepts.
+    */
+    {
+        id: "project",
+        extensions: DOCUMENT_EXTENSIONS.map((ext) => `.${ext}`).join(", "),
+        noteKey: "docs.formats.in.project",
+    },
+];
+/**
+ * What the docs export table lists: every format the export menu writes, then
+ * printing, which produces a document rather than a file.
+ *
+ * Derived from `WRITABLE_EXPORT_FORMATS` rather than written out beside it: the
+ * table was its own list, and a list about the menu is a copy of the menu.
+ */
+export const EXPORT_FORMATS = [
+    ...WRITABLE_EXPORT_FORMATS.map((format) => ({
+        id: format.id,
+        extensions: `.${format.extension}`,
+        noteKey: format.noteKey,
+    })),
+    { id: "print", extensions: "—", noteKey: "docs.formats.out.print" },
+];
+//# sourceMappingURL=formats.js.map

package/dist/domain/documents/formats.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formats.js","sourceRoot":"","sources":["../../../src/domain/documents/formats.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAU9D,MAAM,CAAC,MAAM,cAAc,GAA2B;IACpD,EAAE,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,aAAa,EAAE,OAAO,EAAE,sBAAsB,EAAE;IAC1E;QACE,EAAE,EAAE,UAAU;QACd,UAAU,EAAE,iBAAiB;QAC7B,OAAO,EAAE,0BAA0B;KACpC;IACD;QACE,EAAE,EAAE,SAAS;QACb,UAAU,EAAE,mCAAmC;QAC/C,OAAO,EAAE,yBAAyB;KACnC;IACD;QACE,EAAE,EAAE,OAAO;QACX,UAAU,EAAE,kBAAkB;QAC9B,OAAO,EAAE,uBAAuB;KACjC;IACD;;;;;MAKE;IACF;QACE,EAAE,EAAE,SAAS;QACb,UAAU,EAAE,mBAAmB,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;QAClE,OAAO,EAAE,yBAAyB;KACnC;CACF,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,cAAc,GAA2B;IACpD,GAAG,uBAAuB,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;QAC1C,EAAE,EAAE,MAAM,CAAC,EAAE;QACb,UAAU,EAAE,IAAI,MAAM,CAAC,SAAS,EAAE;QAClC,OAAO,EAAE,MAAM,CAAC,OAAO;KACxB,CAAC,CAAC;IACH,EAAE,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,OAAO,EAAE,wBAAwB,EAAE;CACpE,CAAC"}

package/dist/domain/documents/project-file.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The project file, as vocabulary: what it is called, which version this build
+ * writes, and its shape.
+ *
+ * Declared here rather than beside the parser in music_codecs, because these
+ * are facts other packages read without needing to parse anything. The export
+ * formats and the docs formats table beside this module name the file, the apps
+ * pick files by extension, and a package that only wants the word `moo` must
+ * not have to depend on a codec to get it — music_editing briefly did, while it
+ * held the export menu and the formats table, which is how a package for
+ * editing came to import the file-format layer. The serializer and
+ * the parser stay in music_codecs; the words and the types they read and write
+ * are the model's.
+ */
+import type { Score } from "../../index.js";
+/** The format version this build writes and the newest it reads. */
+export declare const PROJECT_FILE_VERSION = 1;
+/** What the apps write. */
+export declare const DOCUMENT_EXTENSION = "moo";
+/**
+ * What the apps open: their own extension, the longer one documents were
+ * saved under before it was shortened, and the web's `.json` project export.
+ */
+export declare const DOCUMENT_EXTENSIONS: readonly ["moo", "moosiac", "json"];
+/** A project file as it is written: the score, plus its title. */
+export type ProjectFile = {
+    version: number;
+    title: string;
+    score: Score;
+};
+/** Why a project file could not be read, for an app to word. */
+export type ProjectFileErrorReason = "invalidJson" | "notAProject" | "newerVersion" | "invalidScore";
+//# sourceMappingURL=project-file.d.ts.map

package/dist/domain/documents/project-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-file.d.ts","sourceRoot":"","sources":["../../../src/domain/documents/project-file.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C,oEAAoE;AACpE,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC,2BAA2B;AAC3B,eAAO,MAAM,kBAAkB,QAAQ,CAAC;AAExC;;;GAGG;AACH,eAAO,MAAM,mBAAmB,qCAItB,CAAC;AAEX,kEAAkE;AAClE,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEF,gEAAgE;AAChE,MAAM,MAAM,sBAAsB,GAC9B,aAAa,GACb,aAAa,GACb,cAAc,GACd,cAAc,CAAC"}

package/dist/domain/documents/project-file.js

@@ -0,0 +1,14 @@
+/** The format version this build writes and the newest it reads. */
+export const PROJECT_FILE_VERSION = 1;
+/** What the apps write. */
+export const DOCUMENT_EXTENSION = "moo";
+/**
+ * What the apps open: their own extension, the longer one documents were
+ * saved under before it was shortened, and the web's `.json` project export.
+ */
+export const DOCUMENT_EXTENSIONS = [
+    DOCUMENT_EXTENSION,
+    "moosiac",
+    "json",
+];
+//# sourceMappingURL=project-file.js.map

package/dist/domain/documents/project-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-file.js","sourceRoot":"","sources":["../../../src/domain/documents/project-file.ts"],"names":[],"mappings":"AAgBA,oEAAoE;AACpE,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC;AAEtC,2BAA2B;AAC3B,MAAM,CAAC,MAAM,kBAAkB,GAAG,KAAK,CAAC;AAExC;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,kBAAkB;IAClB,SAAS;IACT,MAAM;CACE,CAAC"}

package/dist/domain/documents/publish.d.ts

@@ -0,0 +1,6 @@
+/** The two names a published snapshot carries: who published it, and what it is called in public. */
+export type PublishNames = {
+    publisherName: string;
+    publicName: string;
+};
+//# sourceMappingURL=publish.d.ts.map

package/dist/domain/documents/publish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish.d.ts","sourceRoot":"","sources":["../../../src/domain/documents/publish.ts"],"names":[],"mappings":"AAAA,qGAAqG;AACrG,MAAM,MAAM,YAAY,GAAG;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/dist/domain/documents/publish.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=publish.js.map

package/dist/domain/documents/publish.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish.js","sourceRoot":"","sources":["../../../src/domain/documents/publish.ts"],"names":[],"mappings":""}

package/dist/domain/documents/templates.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Which starter scores exist, as vocabulary.
+ *
+ * The templates themselves — the instruments, clefs and bar counts each builds
+ * — are music_lib's. The ids are here because a host keys its copy off them.
+ */
+/** Every template music_lib can build. Stable — it is persisted in nothing, but hosts key their copy off it. */
+export declare const TEMPLATE_IDS: readonly ["lead-sheet", "piano-grand-staff", "string-quartet", "jazz-combo", "rock-band", "satb-choir", "drum-kit", "waltz", "jig", "gentle-piano-melody", "pop-arrangement", "orchestral-passage"];
+export type TemplateId = (typeof TEMPLATE_IDS)[number];
+/**
+ * The name and description shown for each template, supplied by the host.
+ *
+ * music_lib's templates own the *music* — which instruments, clefs, keys and
+ * bar counts a starter score has — and nothing else. The words describing them
+ * are the host's, because only the host knows what language it is speaking.
+ */
+export type TemplateCopy = Record<TemplateId, {
+    name: string;
+    description: string;
+}>;
+//# sourceMappingURL=templates.d.ts.map

package/dist/domain/documents/templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../../src/domain/documents/templates.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,gHAAgH;AAChH,eAAO,MAAM,YAAY,qMAaf,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvD;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAC/B,UAAU,EACV;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CACtC,CAAC"}

package/dist/domain/documents/templates.js

@@ -0,0 +1,22 @@
+/**
+ * Which starter scores exist, as vocabulary.
+ *
+ * The templates themselves — the instruments, clefs and bar counts each builds
+ * — are music_lib's. The ids are here because a host keys its copy off them.
+ */
+/** Every template music_lib can build. Stable — it is persisted in nothing, but hosts key their copy off it. */
+export const TEMPLATE_IDS = [
+    "lead-sheet",
+    "piano-grand-staff",
+    "string-quartet",
+    "jazz-combo",
+    "rock-band",
+    "satb-choir",
+    "drum-kit",
+    "waltz",
+    "jig",
+    "gentle-piano-melody",
+    "pop-arrangement",
+    "orchestral-passage",
+];
+//# sourceMappingURL=templates.js.map

package/dist/domain/documents/templates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.js","sourceRoot":"","sources":["../../../src/domain/documents/templates.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,gHAAgH;AAChH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,YAAY;IACZ,mBAAmB;IACnB,gBAAgB;IAChB,YAAY;IACZ,WAAW;IACX,YAAY;IACZ,UAAU;IACV,OAAO;IACP,KAAK;IACL,qBAAqB;IACrB,iBAAiB;IACjB,oBAAoB;CACZ,CAAC"}

package/dist/domain/editor/app-errors.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The frontend's failure taxonomy (spec §28), as vocabulary.
+ *
+ * The `AppError` class and `reportError`, which turns any thrown value into a
+ * toast, are music_lib's.
+ */
+/** Stable, machine-readable failure categories (spec §28's list). */
+export type AppErrorCode = "midi-import" | "midi-export" | "musicxml-import" | "musicxml-export" | "project-load" | "project-save" | "project-data" | "audio-init" | "generation" | "storage-quota" | "rendering" | "unsupported-feature" | "unknown";
+export type AppErrorOptions = {
+    code: AppErrorCode;
+    /** Shown to the user, verbatim, in a toast — never a raw stack trace or exception class name. */
+    userMessage: string;
+    /** Technical detail (the original error, Zod issues, ...), logged via `console.debug` only in development. */
+    detail?: unknown;
+};
+//# sourceMappingURL=app-errors.d.ts.map

package/dist/domain/editor/app-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-errors.d.ts","sourceRoot":"","sources":["../../../src/domain/editor/app-errors.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,qEAAqE;AACrE,MAAM,MAAM,YAAY,GACpB,aAAa,GACb,aAAa,GACb,iBAAiB,GACjB,iBAAiB,GACjB,cAAc,GACd,cAAc,GACd,cAAc,GACd,YAAY,GACZ,YAAY,GACZ,eAAe,GACf,WAAW,GACX,qBAAqB,GACrB,SAAS,CAAC;AAEd,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,YAAY,CAAC;IACnB,iGAAiG;IACjG,WAAW,EAAE,MAAM,CAAC;IACpB,8GAA8G;IAC9G,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC"}

package/dist/domain/editor/app-errors.js

@@ -0,0 +1,8 @@
+/**
+ * The frontend's failure taxonomy (spec §28), as vocabulary.
+ *
+ * The `AppError` class and `reportError`, which turns any thrown value into a
+ * toast, are music_lib's.
+ */
+export {};
+//# sourceMappingURL=app-errors.js.map

package/dist/domain/editor/app-errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-errors.js","sourceRoot":"","sources":["../../../src/domain/editor/app-errors.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/domain/editor/context-menu.d.ts

@@ -0,0 +1,74 @@
+/**
+ * The score's context menu, and the two things it acts between: what the
+ * selection is *of*, and what the clipboard holds.
+ *
+ * The model and the rules (`scoreContextMenuModel`, `selectionKind`,
+ * `canPasteInto`) are music_editing's. Keys, never words.
+ */
+import type { NoteEvent, Track } from "../../model/score.js";
+import type { MeasureSlice } from "../commands/clipboard-commands.js";
+/**
+ * What a selection is *of*. **Notes win, then measures, then tracks** — see
+ * `selectionKind` in music_editing.
+ */
+export type SelectionKind = "notes" | "measures" | "track";
+/**
+ * What was copied, tagged with what kind of thing it is.
+ *
+ * A union rather than three fields, because the clipboard holds exactly one
+ * thing and Paste is only offered when its kind matches the selection's — see
+ * `canPasteInto`. It was a bare `{events, anchorTick}` while notes were the only
+ * thing that could be copied at all.
+ *
+ * A **measures** entry is a vertical slice: the bars at those indices across
+ * every track, not one part's. That is what the score model already means by a
+ * bar — `deleteMeasureCommand` removes one from every track — and it is what
+ * lets insert and replace put a slice back without leaving the parts
+ * disagreeing about where bar 40 is.
+ */
+export type ClipboardData = ({
+    kind: "notes";
+    events: NoteEvent[];
+    anchorTick: number;
+} | {
+    kind: "measures";
+    slice: MeasureSlice;
+    count: number;
+} | {
+    kind: "track";
+    track: Track;
+}) & {
+    /**
+     * Whether the clipboard was filled by a cut rather than a copy.
+     *
+     * It matters only when a paste is refused: after a copy the music is still
+     * where it was, but after a cut it exists nowhere except the clipboard and
+     * the undo history, so the refusal offers Undo. Absent reads as a copy, so a
+     * clipboard built by hand elsewhere needs no change.
+     */
+    fromCut?: boolean;
+};
+/** Every entry, in the order the menu shows them. */
+export declare const SCORE_CONTEXT_ACTIONS: readonly ["copy", "cut", "clear", "delete", "paste", "selectAll"];
+export type ScoreContextAction = (typeof SCORE_CONTEXT_ACTIONS)[number];
+/** The label each entry is read as. A record, so a new action fails to compile here. */
+export declare const SCORE_CONTEXT_ACTION_LABEL_KEY: Record<ScoreContextAction, string>;
+export type ScoreContextMenuEntry = {
+    action: ScoreContextAction;
+    labelKey: string;
+    enabled: boolean;
+};
+export type ScoreContextMenuModel = {
+    /** The menu's accessible name / sheet title. */
+    titleKey: string;
+    /**
+     * What every entry acts on — "Track", "Bars", "Notes" — or null with nothing
+     * selected. `count` is for the plural; translate with `{ count }`.
+     */
+    subject: {
+        key: string;
+        count: number;
+    } | null;
+    entries: readonly ScoreContextMenuEntry[];
+};
+//# sourceMappingURL=context-menu.d.ts.map

package/dist/domain/editor/context-menu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-menu.d.ts","sourceRoot":"","sources":["../../../src/domain/editor/context-menu.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAEtE;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,UAAU,GAAG,OAAO,CAAC;AAE3D;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,aAAa,GAAG,CACxB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,SAAS,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAC1D;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACxD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAClC,GAAG;IACF;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,qDAAqD;AACrD,eAAO,MAAM,qBAAqB,mEAOxB,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC;AAExE,wFAAwF;AACxF,eAAO,MAAM,8BAA8B,EAAE,MAAM,CACjD,kBAAkB,EAClB,MAAM,CAQP,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,kBAAkB,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,gDAAgD;IAChD,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC/C,OAAO,EAAE,SAAS,qBAAqB,EAAE,CAAC;CAC3C,CAAC"}

package/dist/domain/editor/context-menu.js

@@ -0,0 +1,19 @@
+/** Every entry, in the order the menu shows them. */
+export const SCORE_CONTEXT_ACTIONS = [
+    "copy",
+    "cut",
+    "clear",
+    "delete",
+    "paste",
+    "selectAll",
+];
+/** The label each entry is read as. A record, so a new action fails to compile here. */
+export const SCORE_CONTEXT_ACTION_LABEL_KEY = {
+    copy: "editor.copy",
+    cut: "editor.cut",
+    clear: "editor.clear",
+    delete: "editor.deleteSelection",
+    paste: "editor.paste",
+    selectAll: "editor.selectAllNotes",
+};
+//# sourceMappingURL=context-menu.js.map

package/dist/domain/editor/context-menu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-menu.js","sourceRoot":"","sources":["../../../src/domain/editor/context-menu.ts"],"names":[],"mappings":"AA8CA,qDAAqD;AACrD,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,MAAM;IACN,KAAK;IACL,OAAO;IACP,QAAQ;IACR,OAAO;IACP,WAAW;CACH,CAAC;AAIX,wFAAwF;AACxF,MAAM,CAAC,MAAM,8BAA8B,GAGvC;IACF,IAAI,EAAE,aAAa;IACnB,GAAG,EAAE,YAAY;IACjB,KAAK,EAAE,cAAc;IACrB,MAAM,EAAE,wBAAwB;IAChC,KAAK,EAAE,cAAc;IACrB,SAAS,EAAE,uBAAuB;CACnC,CAAC"}