@sudobility/music_types 0.13.26 → 0.13.27

package/dist/domain/editor/device-prefs.d.ts

@@ -0,0 +1,107 @@
+/**
+ * How this person likes to work, on this device: the vocabulary.
+ *
+ * The prefs themselves — validating a stored object, loading, saving, the
+ * store that holds them — are music_lib's. The closed lists and the shape are
+ * here because both apps draw a settings screen from them.
+ */
+import type { PitchDisplay } from "../score/display-score.js";
+import type { PickerOption } from "../notation/picker-options.js";
+/**
+ * The colour scheme a reader asked for.
+ *
+ * An array with the type read off it, not a bare union: a union has no runtime
+ * form, so the settings picker in each app would have to write the list out
+ * again — which is how one of them comes to offer a mode nothing applies.
+ * `system` means "follow the OS", and is the default because a device that has
+ * been told to go dark at sunset should take the app with it.
+ */
+export declare const THEME_MODES: readonly ["light", "dark", "system"];
+export type ThemeMode = (typeof THEME_MODES)[number];
+/** A scheme that can actually be drawn: never `system`. */
+export type ResolvedThemeMode = Exclude<ThemeMode, "system">;
+/**
+ * The word for each theme mode.
+ *
+ * The web's theme menu capitalised the mode's own name, so a Chinese reader
+ * chose between "Light", "Dark" and "System" in English; both apps then fixed
+ * that with the same three keys and each kept its own copy of the table. A
+ * `Record`, so a fourth mode fails to compile rather than printing a key.
+ *
+ * Here rather than beside the other picker tables in `picker-options.ts`, for
+ * the reason those live beside their own vocabularies: a list keyed by a closed
+ * vocabulary belongs next to the vocabulary. (`picker-options` is also
+ * evaluated before this module by the barrel, so a table there reading
+ * `THEME_MODES` would read it before it exists.)
+ */
+export declare const THEME_MODE_LABEL_KEY: Record<ThemeMode, string>;
+/** The three modes as a settings picker wants them: value plus its key. */
+export declare const THEME_MODE_OPTIONS: ReadonlyArray<PickerOption<ThemeMode>>;
+export declare const FONT_SIZES: readonly ["small", "medium", "large"];
+export type FontSize = (typeof FONT_SIZES)[number];
+/**
+ * The developer switches, shown while developer mode is on.
+ *
+ * Only one, and that is the point: this carried six overlay toggles from spec
+ * §33 as well (`showIds`, `showTicks`, `showMeasureBoundaries`,
+ * `showPlaybackScheduling`, `enableDiagnostics`, `enableValidationWarnings`),
+ * and no package in the family ever read one of them. Both apps drew a switch
+ * for each, so a developer could turn six settings on and watch nothing happen
+ * — which is worse than the absent feature, because it reads as a broken one.
+ * They are gone rather than left standing as a promise. A field added back here
+ * has to have a reader.
+ */
+export type DevSettings = {
+    /**
+     * Which generation backend new scores are asked from.
+     *
+     * A developer setting rather than a Generate-dialog control on purpose: the
+     * answer is the same for every generation until somebody is deliberately
+     * comparing two of them, and putting it in the ordinary flow would ask every
+     * user a question they have no basis to answer.
+     *
+     * Typed as a plain string rather than `GenerationVariant` so a value stored
+     * by a newer build cannot break an older one — the server resolves it through
+     * an allow-list and falls back to the default, so an unrecognised value is
+     * harmless at both ends.
+     */
+    generationVariant: string;
+};
+export type DevicePrefs = {
+    themeMode: ThemeMode;
+    developerMode: boolean;
+    pitchDisplay: PitchDisplay;
+    /** The piano keyboard panel. Expanded by default on both apps. */
+    keyboardCollapsed: boolean;
+    fontSize: FontSize;
+    /**
+     * The UI language as a BCP 47 tag, or `null` to follow the device.
+     *
+     * `null` rather than the device's language filled in, because "follow the
+     * device" has to survive the device changing language.
+     */
+    language: string | null;
+};
+/**
+ * The language to open in when nothing else has said.
+ *
+ * The reader's own choice first (the `language` pref, `null` for "follow the
+ * device", which is what the pref stores rather than a filled-in answer so a
+ * device that changes language is followed), then the device's own tags, then
+ * the first language the build ships — which is English in both apps, and is
+ * taken from the list rather than written in so a build that shipped another
+ * one first would not be told it was English.
+ *
+ * **Tags are matched by their language subtag.** A phone stores a BCP 47 tag
+ * and a browser reports `zh-CN`; neither `zh-Hans` nor `zh-CN` is a bundle
+ * either app has, and comparing whole tags is how the native app came to ignore
+ * its own reader's stored `zh-Hans` and open in English. A choice with no
+ * bundle is skipped rather than honoured, since honouring it renders every
+ * string as its raw key.
+ *
+ * `supported` stays each app's, because the two ship their strings differently
+ * — the web fetches a directory per language, the native app bundles a JSON —
+ * so which languages exist is a fact about the build. Only the rule is shared.
+ */
+export declare function preferredLanguage<T extends string>(chosen: string | null | undefined, deviceTags: readonly string[], supported: readonly [T, ...T[]]): T;
+//# sourceMappingURL=device-prefs.d.ts.map

package/dist/domain/editor/device-prefs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-prefs.d.ts","sourceRoot":"","sources":["../../../src/domain/editor/device-prefs.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAElE;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,sCAAuC,CAAC;AAEhE,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAErD,2DAA2D;AAC3D,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;AAE7D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAI1D,CAAC;AAEF,2EAA2E;AAC3E,eAAO,MAAM,kBAAkB,EAAE,aAAa,CAAC,YAAY,CAAC,SAAS,CAAC,CAIjE,CAAC;AAEN,eAAO,MAAM,UAAU,uCAAwC,CAAC;AAChE,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB;;;;;;;;;;;;OAYG;IACH,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,SAAS,EAAE,SAAS,CAAC;IACrB,aAAa,EAAE,OAAO,CAAC;IACvB,YAAY,EAAE,YAAY,CAAC;IAC3B,kEAAkE;IAClE,iBAAiB,EAAE,OAAO,CAAC;IAC3B,QAAQ,EAAE,QAAQ,CAAC;IACnB;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,EAChD,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,SAAS,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,GAC9B,CAAC,CAOH"}

package/dist/domain/editor/device-prefs.js

@@ -0,0 +1,66 @@
+/**
+ * The colour scheme a reader asked for.
+ *
+ * An array with the type read off it, not a bare union: a union has no runtime
+ * form, so the settings picker in each app would have to write the list out
+ * again — which is how one of them comes to offer a mode nothing applies.
+ * `system` means "follow the OS", and is the default because a device that has
+ * been told to go dark at sunset should take the app with it.
+ */
+export const THEME_MODES = ["light", "dark", "system"];
+/**
+ * The word for each theme mode.
+ *
+ * The web's theme menu capitalised the mode's own name, so a Chinese reader
+ * chose between "Light", "Dark" and "System" in English; both apps then fixed
+ * that with the same three keys and each kept its own copy of the table. A
+ * `Record`, so a fourth mode fails to compile rather than printing a key.
+ *
+ * Here rather than beside the other picker tables in `picker-options.ts`, for
+ * the reason those live beside their own vocabularies: a list keyed by a closed
+ * vocabulary belongs next to the vocabulary. (`picker-options` is also
+ * evaluated before this module by the barrel, so a table there reading
+ * `THEME_MODES` would read it before it exists.)
+ */
+export const THEME_MODE_LABEL_KEY = {
+    light: "settings.themeLight",
+    dark: "settings.themeDark",
+    system: "settings.themeSystem",
+};
+/** The three modes as a settings picker wants them: value plus its key. */
+export const THEME_MODE_OPTIONS = THEME_MODES.map((value) => ({
+    value,
+    labelKey: THEME_MODE_LABEL_KEY[value],
+}));
+export const FONT_SIZES = ["small", "medium", "large"];
+/**
+ * The language to open in when nothing else has said.
+ *
+ * The reader's own choice first (the `language` pref, `null` for "follow the
+ * device", which is what the pref stores rather than a filled-in answer so a
+ * device that changes language is followed), then the device's own tags, then
+ * the first language the build ships — which is English in both apps, and is
+ * taken from the list rather than written in so a build that shipped another
+ * one first would not be told it was English.
+ *
+ * **Tags are matched by their language subtag.** A phone stores a BCP 47 tag
+ * and a browser reports `zh-CN`; neither `zh-Hans` nor `zh-CN` is a bundle
+ * either app has, and comparing whole tags is how the native app came to ignore
+ * its own reader's stored `zh-Hans` and open in English. A choice with no
+ * bundle is skipped rather than honoured, since honouring it renders every
+ * string as its raw key.
+ *
+ * `supported` stays each app's, because the two ship their strings differently
+ * — the web fetches a directory per language, the native app bundles a JSON —
+ * so which languages exist is a fact about the build. Only the rule is shared.
+ */
+export function preferredLanguage(chosen, deviceTags, supported) {
+    for (const tag of [chosen, ...deviceTags]) {
+        const code = tag?.split("-")[0]?.toLowerCase() ?? "";
+        const match = supported.find((language) => language === code);
+        if (match)
+            return match;
+    }
+    return supported[0];
+}
+//# sourceMappingURL=device-prefs.js.map

package/dist/domain/editor/device-prefs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-prefs.js","sourceRoot":"","sources":["../../../src/domain/editor/device-prefs.ts"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAU,CAAC;AAOhE;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAA8B;IAC7D,KAAK,EAAE,qBAAqB;IAC5B,IAAI,EAAE,oBAAoB;IAC1B,MAAM,EAAE,sBAAsB;CAC/B,CAAC;AAEF,2EAA2E;AAC3E,MAAM,CAAC,MAAM,kBAAkB,GAC7B,WAAW,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAC1B,KAAK;IACL,QAAQ,EAAE,oBAAoB,CAAC,KAAK,CAAC;CACtC,CAAC,CAAC,CAAC;AAEN,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAU,CAAC;AAgDhE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,iBAAiB,CAC/B,MAAiC,EACjC,UAA6B,EAC7B,SAA+B;IAE/B,KAAK,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,UAAU,CAAC,EAAE,CAAC;QAC1C,MAAM,IAAI,GAAG,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC;QACrD,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC;QAC9D,IAAI,KAAK;YAAE,OAAO,KAAK,CAAC;IAC1B,CAAC;IACD,OAAO,SAAS,CAAC,CAAC,CAAC,CAAC;AACtB,CAAC"}

package/dist/domain/editor/docs.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The documentation's vocabulary: which topics exist, how they group, and the
+ * shapes of a topic, a resource link and a shortcut row.
+ *
+ * The content tables built from these — `DOCS_TOPICS`, `RESOURCE_GROUPS` —
+ * are music_lib's, and `SHORTCUTS` is music_editing's, beside the bindings it
+ * is checked against. Every description is an i18n key: the prose lives in
+ * each host's locale files.
+ */
+/** Every documentation topic, in the order the list shows them. */
+export declare const DOCS_TOPIC_IDS: readonly ["getting-started", "navigation", "editor", "notation", "structure", "tracks", "playback", "midi-input", "inspector", "generation", "sharing", "settings", "shortcuts", "instruments", "formats", "limits"];
+export type DocsTopicId = (typeof DOCS_TOPIC_IDS)[number];
+/** Extra content a topic renders beneath its prose, built from live data. */
+export type DocsWidget = "shortcuts" | "instruments" | "formats";
+export type DocsSubsection = {
+    /** i18n key for the subsection heading. */
+    heading: string;
+    /** i18n keys, one per paragraph. */
+    body: readonly string[];
+};
+export type DocsTopic = {
+    id: DocsTopicId;
+    /** i18n key for the title shown in the list and at the head of the page. */
+    title: string;
+    /** i18n key for the one-line summary under the title in the list. */
+    summary: string;
+    sections: readonly DocsSubsection[];
+    widget?: DocsWidget;
+};
+/** The group a topic sits under in the navigation list. */
+export declare const DOCS_GROUPS: readonly ["start", "using", "reference"];
+export type DocsGroup = (typeof DOCS_GROUPS)[number];
+/** One place to find music to open. */
+export type Resource = {
+    /** i18n key suffix under `resources.link`, and the React key. */
+    key: string;
+    name: string;
+    url: string;
+};
+/** Resources grouped by which importer the files feed. */
+export type ResourceGroup = {
+    /** i18n key suffix under `resources.group`, for the title and route line. */
+    key: string;
+    links: readonly Resource[];
+};
+export type ShortcutRow = {
+    /** The keys, written out. Mutually exclusive with `keysKey`. */
+    keys?: string;
+    /** A translated description of the gesture, where it is not a key chord. */
+    keysKey?: string;
+    actionKey: string;
+};
+/** Which part of the editor a shortcut belongs to — the docs group by these. */
+export declare const SHORTCUT_GROUPS: readonly ["transport", "editing", "selection", "noteEntry", "marks", "caret", "pointer"];
+export type ShortcutGroup = (typeof SHORTCUT_GROUPS)[number];
+//# sourceMappingURL=docs.d.ts.map

package/dist/domain/editor/docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"docs.d.ts","sourceRoot":"","sources":["../../../src/domain/editor/docs.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,mEAAmE;AACnE,eAAO,MAAM,cAAc,sNAiBjB,CAAC;AACX,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1D,6EAA6E;AAC7E,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,aAAa,GAAG,SAAS,CAAC;AAEjE,MAAM,MAAM,cAAc,GAAG;IAC3B,2CAA2C;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,oCAAoC;IACpC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,WAAW,CAAC;IAChB,4EAA4E;IAC5E,KAAK,EAAE,MAAM,CAAC;IACd,qEAAqE;IACrE,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,SAAS,cAAc,EAAE,CAAC;IACpC,MAAM,CAAC,EAAE,UAAU,CAAC;CACrB,CAAC;AAEF,2DAA2D;AAC3D,eAAO,MAAM,WAAW,0CAA2C,CAAC;AACpE,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAErD,uCAAuC;AACvC,MAAM,MAAM,QAAQ,GAAG;IACrB,iEAAiE;IACjE,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,0DAA0D;AAC1D,MAAM,MAAM,aAAa,GAAG;IAC1B,6EAA6E;IAC7E,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,gEAAgE;IAChE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,eAAe,0FAQlB,CAAC;AACX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/domain/editor/docs.js

@@ -0,0 +1,41 @@
+/**
+ * The documentation's vocabulary: which topics exist, how they group, and the
+ * shapes of a topic, a resource link and a shortcut row.
+ *
+ * The content tables built from these — `DOCS_TOPICS`, `RESOURCE_GROUPS` —
+ * are music_lib's, and `SHORTCUTS` is music_editing's, beside the bindings it
+ * is checked against. Every description is an i18n key: the prose lives in
+ * each host's locale files.
+ */
+/** Every documentation topic, in the order the list shows them. */
+export const DOCS_TOPIC_IDS = [
+    "getting-started",
+    "navigation",
+    "editor",
+    "notation",
+    "structure",
+    "tracks",
+    "playback",
+    "midi-input",
+    "inspector",
+    "generation",
+    "sharing",
+    "settings",
+    "shortcuts",
+    "instruments",
+    "formats",
+    "limits",
+];
+/** The group a topic sits under in the navigation list. */
+export const DOCS_GROUPS = ["start", "using", "reference"];
+/** Which part of the editor a shortcut belongs to — the docs group by these. */
+export const SHORTCUT_GROUPS = [
+    "transport",
+    "editing",
+    "selection",
+    "noteEntry",
+    "marks",
+    "caret",
+    "pointer",
+];
+//# sourceMappingURL=docs.js.map

package/dist/domain/editor/docs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"docs.js","sourceRoot":"","sources":["../../../src/domain/editor/docs.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,mEAAmE;AACnE,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,iBAAiB;IACjB,YAAY;IACZ,QAAQ;IACR,UAAU;IACV,WAAW;IACX,QAAQ;IACR,UAAU;IACV,YAAY;IACZ,WAAW;IACX,YAAY;IACZ,SAAS;IACT,UAAU;IACV,WAAW;IACX,aAAa;IACb,SAAS;IACT,QAAQ;CACA,CAAC;AAuBX,2DAA2D;AAC3D,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,CAAU,CAAC;AA0BpE,gFAAgF;AAChF,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,WAAW;IACX,SAAS;IACT,WAAW;IACX,WAAW;IACX,OAAO;IACP,OAAO;IACP,SAAS;CACD,CAAC"}

package/dist/domain/editor/edit-mode.d.ts

@@ -0,0 +1,31 @@
+/**
+ * What happens to music already at the caret when a new note is written.
+ */
+import type { NotationIconName } from "../notation/notation-icon-art.js";
+/**
+ * `insert` shifts the active track's later notes out of the way, `replace`
+ * overwrites them, `stack` joins them as a chord. Deliberately NOT about
+ * whether one gesture makes a chord — keys held together are one chord in
+ * every mode, because that is what playing them means.
+ */
+export declare const EDIT_MODES: readonly ["insert", "replace", "stack"];
+export type EditMode = (typeof EDIT_MODES)[number];
+/**
+ * The edit modes as a toolbar offers them: in order, each with its glyph and
+ * its label and hint keys.
+ *
+ * Beside `EditMode` because that is what it lists — one declaration of the
+ * vocabulary and one of its options, in the package every app and library
+ * reads vocabulary from.
+ *
+ * Stack's hint has a second form, `editor.stackModeUnavailable`, for a track
+ * whose instrument cannot play a chord — that depends on the track, so the
+ * caller picks it (`editModeHintKey` in music_editing).
+ */
+export declare const EDIT_MODE_OPTIONS: ReadonlyArray<{
+    value: EditMode;
+    icon: NotationIconName;
+    labelKey: string;
+    hintKey: string;
+}>;
+//# sourceMappingURL=edit-mode.d.ts.map

package/dist/domain/editor/edit-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-mode.d.ts","sourceRoot":"","sources":["../../../src/domain/editor/edit-mode.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAEzE;;;;;GAKG;AACH,eAAO,MAAM,UAAU,yCAA0C,CAAC;AAElE,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC;IAC5C,KAAK,EAAE,QAAQ,CAAC;IAChB,IAAI,EAAE,gBAAgB,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAmBA,CAAC"}

package/dist/domain/editor/edit-mode.js

@@ -0,0 +1,40 @@
+/**
+ * `insert` shifts the active track's later notes out of the way, `replace`
+ * overwrites them, `stack` joins them as a chord. Deliberately NOT about
+ * whether one gesture makes a chord — keys held together are one chord in
+ * every mode, because that is what playing them means.
+ */
+export const EDIT_MODES = ["insert", "replace", "stack"];
+/**
+ * The edit modes as a toolbar offers them: in order, each with its glyph and
+ * its label and hint keys.
+ *
+ * Beside `EditMode` because that is what it lists — one declaration of the
+ * vocabulary and one of its options, in the package every app and library
+ * reads vocabulary from.
+ *
+ * Stack's hint has a second form, `editor.stackModeUnavailable`, for a track
+ * whose instrument cannot play a chord — that depends on the track, so the
+ * caller picks it (`editModeHintKey` in music_editing).
+ */
+export const EDIT_MODE_OPTIONS = [
+    {
+        value: "insert",
+        icon: "InsertModeIcon",
+        labelKey: "editor.insertMode",
+        hintKey: "editor.insertModeHint",
+    },
+    {
+        value: "replace",
+        icon: "ReplaceModeIcon",
+        labelKey: "editor.replaceMode",
+        hintKey: "editor.replaceModeHint",
+    },
+    {
+        value: "stack",
+        icon: "ChordIcon",
+        labelKey: "editor.stackMode",
+        hintKey: "editor.stackModeHint",
+    },
+];
+//# sourceMappingURL=edit-mode.js.map

package/dist/domain/editor/edit-mode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-mode.js","sourceRoot":"","sources":["../../../src/domain/editor/edit-mode.ts"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,CAAU,CAAC;AAIlE;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAKzB;IACH;QACE,KAAK,EAAE,QAAQ;QACf,IAAI,EAAE,gBAAgB;QACtB,QAAQ,EAAE,mBAAmB;QAC7B,OAAO,EAAE,uBAAuB;KACjC;IACD;QACE,KAAK,EAAE,SAAS;QAChB,IAAI,EAAE,iBAAiB;QACvB,QAAQ,EAAE,oBAAoB;QAC9B,OAAO,EAAE,wBAAwB;KAClC;IACD;QACE,KAAK,EAAE,OAAO;QACd,IAAI,EAAE,WAAW;QACjB,QAAQ,EAAE,kBAAkB;QAC5B,OAAO,EAAE,sBAAsB;KAChC;CACF,CAAC"}

package/dist/domain/editor/editing-copy.d.ts

@@ -0,0 +1,91 @@
+/**
+ * The words an edit is described in, as a contract the host fills in.
+ *
+ * An edit has to be *named* — in the undo history and in the occasional toast
+ * — and no library in this family holds user-facing strings in any language.
+ * So music_editing declares what it needs to say as keys and facts, and each
+ * app supplies the sentences (`setEditingCopy`, built by music_lib's
+ * `createLibraryCopy`). The contract is declared here so the library that
+ * reads it and the one that builds it name one shape.
+ */
+/**
+ * One key per command, named for the command rather than its wording.
+ *
+ * An array with the type read off it, not a bare union: a host has to prove
+ * every one of these has a translation, and a union has no runtime form to
+ * walk. Both apps' undo histories printed raw keys for labels nobody had
+ * written — the web for eleven commands, the native app for all but four —
+ * because nothing could enumerate what was needed.
+ */
+export declare const COMMAND_LABEL_KEYS: readonly ["addNote", "addMeasure", "addTrack", "changeAccidental", "changeArticulation", "changeDuration", "changeDynamic", "changePitch", "changeClef", "changeKeySignature", "changeRepeats", "changeMetadata", "changeTempo", "changeTimeSignature", "changeTrackProps", "changeVelocity", "deleteEvents", "changeVoice", "clearBars", "clearTrack", "deleteMeasure", "deleteTrack", "importScore", "insertWithRipple", "moveNotes", "pasteEvents", "pasteBars", "pasteTrack", "quantize", "relocateNotes", "resizeNotes", "setChordSymbol", "setFingering", "setPickup", "setLyric", "toGraceNote", "changeBeam", "changeBarline", "changeMeasureClef", "changeNavigation", "changeOrnament", "toggleArpeggiate", "toggleGlissando", "toggleOttava", "toggleFermata", "toggleHairpin", "toggleSlur", "toggleTie", "transpose"];
+export type CommandLabelKey = (typeof COMMAND_LABEL_KEYS)[number];
+/**
+ * What an edit that was refused had been about to do.
+ *
+ * The tail of the sentence — "so it was not added", "so nothing was pasted" —
+ * and a closed list so a host's copy table fails to compile when a new route
+ * starts refusing, rather than printing a key.
+ */
+export declare const REFUSED_EDITS: readonly ["addNote", "addChord", "changeNote", "changeAccidental", "moveNote", "moveNotes", "transpose", "paste"];
+export type RefusedEdit = (typeof REFUSED_EDITS)[number];
+/** Which side of an instrument's compass a refused pitch fell. */
+export type RangeDirection = "above" | "below";
+export type OutOfRangeCopy = {
+    /** The refused sounding pitch, written as `pitchToString` writes it: `C#2`. */
+    pitch: string;
+    /** The track's instrument name, as the catalogue spells it. */
+    instrument: string;
+    /** The compass's lowest and highest sounding pitches, written the same way. */
+    low: string;
+    high: string;
+    direction: RangeDirection;
+    refused: RefusedEdit;
+};
+export type PolyphonyCopy = {
+    /** `null` when the target track could not be resolved. */
+    instrument: string | null;
+    /** How many notes the instrument plays at once; 1 is a monophonic part. */
+    limit: number;
+    refused: RefusedEdit;
+};
+export type EditingCopy = {
+    /**
+     * What each command is called in the undo history.
+     *
+     * A resolver rather than a snapshot: labels are read at dispatch time, so the
+     * label stored in history is the one the edit was actually made under — which
+     * is what you want when reading back what you did, and what a table captured
+     * at bootstrap would get wrong the moment somebody switches language.
+     */
+    commandLabel: (key: CommandLabelKey) => string;
+    /**
+     * An edit introduced a validation error that was not there before.
+     *
+     * A function rather than a string because it has to carry the validator's own
+     * account of what went wrong, and where that detail sits in the sentence is a
+     * question about the language, not about the edit.
+     */
+    validationProblem: (detail: string) => string;
+    /** Refusing to delete a track's only measure. */
+    lastMeasureKept: string;
+    /**
+     * A note the instrument cannot play was refused.
+     *
+     * Facts rather than a sentence: the pitch, the instrument, its compass, which
+     * side of it the note fell and what was being attempted. Every one of those
+     * used to be spliced into an English string, so a Chinese reader was told in
+     * English why the note they played did not appear — and the order of the
+     * parts ("C2 is below Violin's range") is itself a fact about English.
+     */
+    outOfRange: (detail: OutOfRangeCopy) => string;
+    /** A chord was refused because the instrument plays fewer notes at once. */
+    tooManyNotes: (detail: PolyphonyCopy) => string;
+    /**
+     * The label on a toast's Undo button.
+     *
+     * Offered where a refusal leaves somebody's music only in the undo history —
+     * a paste refused after a cut, whose notes are no longer anywhere else.
+     */
+    undoAction: () => string;
+};
+//# sourceMappingURL=editing-copy.d.ts.map

package/dist/domain/editor/editing-copy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editing-copy.d.ts","sourceRoot":"","sources":["../../../src/domain/editor/editing-copy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,oyBAkDrB,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC;AAElE;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,mHAShB,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzD,kEAAkE;AAClE,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,OAAO,CAAC;AAE/C,MAAM,MAAM,cAAc,GAAG;IAC3B,+EAA+E;IAC/E,KAAK,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,UAAU,EAAE,MAAM,CAAC;IACnB,+EAA+E;IAC/E,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,cAAc,CAAC;IAC1B,OAAO,EAAE,WAAW,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,0DAA0D;IAC1D,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,2EAA2E;IAC3E,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,WAAW,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB;;;;;;;OAOG;IACH,YAAY,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,MAAM,CAAC;IAC/C;;;;;;OAMG;IACH,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;IAC9C,iDAAiD;IACjD,eAAe,EAAE,MAAM,CAAC;IACxB;;;;;;;;OAQG;IACH,UAAU,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,MAAM,CAAC;IAC/C,4EAA4E;IAC5E,YAAY,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,MAAM,CAAC;IAChD;;;;;OAKG;IACH,UAAU,EAAE,MAAM,MAAM,CAAC;CAC1B,CAAC"}

package/dist/domain/editor/editing-copy.js

@@ -0,0 +1,88 @@
+/**
+ * The words an edit is described in, as a contract the host fills in.
+ *
+ * An edit has to be *named* — in the undo history and in the occasional toast
+ * — and no library in this family holds user-facing strings in any language.
+ * So music_editing declares what it needs to say as keys and facts, and each
+ * app supplies the sentences (`setEditingCopy`, built by music_lib's
+ * `createLibraryCopy`). The contract is declared here so the library that
+ * reads it and the one that builds it name one shape.
+ */
+/**
+ * One key per command, named for the command rather than its wording.
+ *
+ * An array with the type read off it, not a bare union: a host has to prove
+ * every one of these has a translation, and a union has no runtime form to
+ * walk. Both apps' undo histories printed raw keys for labels nobody had
+ * written — the web for eleven commands, the native app for all but four —
+ * because nothing could enumerate what was needed.
+ */
+export const COMMAND_LABEL_KEYS = [
+    "addNote",
+    "addMeasure",
+    "addTrack",
+    "changeAccidental",
+    "changeArticulation",
+    "changeDuration",
+    "changeDynamic",
+    "changePitch",
+    "changeClef",
+    "changeKeySignature",
+    "changeRepeats",
+    "changeMetadata",
+    "changeTempo",
+    "changeTimeSignature",
+    "changeTrackProps",
+    "changeVelocity",
+    "deleteEvents",
+    "changeVoice",
+    "clearBars",
+    "clearTrack",
+    "deleteMeasure",
+    "deleteTrack",
+    "importScore",
+    "insertWithRipple",
+    "moveNotes",
+    "pasteEvents",
+    "pasteBars",
+    "pasteTrack",
+    "quantize",
+    "relocateNotes",
+    "resizeNotes",
+    "setChordSymbol",
+    "setFingering",
+    "setPickup",
+    "setLyric",
+    "toGraceNote",
+    "changeBeam",
+    "changeBarline",
+    "changeMeasureClef",
+    "changeNavigation",
+    "changeOrnament",
+    "toggleArpeggiate",
+    "toggleGlissando",
+    "toggleOttava",
+    "toggleFermata",
+    "toggleHairpin",
+    "toggleSlur",
+    "toggleTie",
+    "transpose",
+];
+/**
+ * What an edit that was refused had been about to do.
+ *
+ * The tail of the sentence — "so it was not added", "so nothing was pasted" —
+ * and a closed list so a host's copy table fails to compile when a new route
+ * starts refusing, rather than printing a key.
+ */
+export const REFUSED_EDITS = [
+    "addNote",
+    "addChord",
+    "changeNote",
+    "changeAccidental",
+    "moveNote",
+    "moveNotes",
+    "transpose",
+    "paste",
+];
+//# sourceMappingURL=editing-copy.js.map

package/dist/domain/editor/editing-copy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"editing-copy.js","sourceRoot":"","sources":["../../../src/domain/editor/editing-copy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,SAAS;IACT,YAAY;IACZ,UAAU;IACV,kBAAkB;IAClB,oBAAoB;IACpB,gBAAgB;IAChB,eAAe;IACf,aAAa;IACb,YAAY;IACZ,oBAAoB;IACpB,eAAe;IACf,gBAAgB;IAChB,aAAa;IACb,qBAAqB;IACrB,kBAAkB;IAClB,gBAAgB;IAChB,cAAc;IACd,aAAa;IACb,WAAW;IACX,YAAY;IACZ,eAAe;IACf,aAAa;IACb,aAAa;IACb,kBAAkB;IAClB,WAAW;IACX,aAAa;IACb,WAAW;IACX,YAAY;IACZ,UAAU;IACV,eAAe;IACf,aAAa;IACb,gBAAgB;IAChB,cAAc;IACd,WAAW;IACX,UAAU;IACV,aAAa;IACb,YAAY;IACZ,eAAe;IACf,mBAAmB;IACnB,kBAAkB;IAClB,gBAAgB;IAChB,kBAAkB;IAClB,iBAAiB;IACjB,cAAc;IACd,eAAe;IACf,eAAe;IACf,YAAY;IACZ,WAAW;IACX,WAAW;CACH,CAAC;AAIX;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,SAAS;IACT,UAAU;IACV,YAAY;IACZ,kBAAkB;IAClB,UAAU;IACV,WAAW;IACX,WAAW;IACX,OAAO;CACC,CAAC"}

package/dist/domain/editor/inspector.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The property sheet's vocabulary: its tabs, the controls that stay live while
+ * the transport plays, and the patches its fields write.
+ *
+ * The rules over these — which tab a selection opens, what a typed tempo
+ * commits — are music_editing's. Keys, never words.
+ */
+import type { Clef, Track } from "../../model/score.js";
+import type { INHERIT_CLEF } from "../notation/picker-options.js";
+/**
+ * The inspector's tabs, in the web order.
+ *
+ * Score first, then Track — the only tab that always has something to show,
+ * since there is always an active track — then Note and Bar. The native panel
+ * listed Track, Note, Measure, Score; one order means a reader moving between
+ * the apps finds the same tab in the same place.
+ *
+ * `measure` is the id and the model's word; the label is "Bar" (see the app's
+ * copy), because the reader is shown a bar and the code keeps `Measure`.
+ */
+export declare const INSPECTOR_TABS: readonly ["score", "track", "note", "measure"];
+export type InspectorTab = (typeof INSPECTOR_TABS)[number];
+/** The copy key naming each tab. */
+export declare const INSPECTOR_TAB_LABEL_KEY: Record<InspectorTab, string>;
+/**
+ * The controls that stay live while the transport plays.
+ *
+ * Mixing, not editing: these are `kind: 'mix'` commands and reach the engine
+ * live, because muting a part while listening is how an arrangement gets
+ * listened to. Everything else in the inspector locks. A list rather than a
+ * flag per control so the exemption is one decision, written down.
+ */
+export declare const MIX_ONLY_CONTROLS: readonly ["trackVolume", "trackPan", "trackMute", "trackSolo"];
+export type MixOnlyControl = (typeof MIX_ONLY_CONTROLS)[number];
+/** A picker value for a bar's clef: a clef, or inherit-what-is-in-force. */
+export type MeasureClefValue = Clef | typeof INHERIT_CLEF;
+/** The mixing properties, which stay editable while the transport plays. */
+export type TrackMixPatch = Partial<Pick<Track, "volume" | "pan" | "muted" | "solo">>;
+/** The metadata fields a user can edit. `createdAt` is the score's, not theirs. */
+export type ScoreMetadataPatch = {
+    title?: string;
+    composer?: string;
+    description?: string;
+};
+//# sourceMappingURL=inspector.d.ts.map

package/dist/domain/editor/inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspector.d.ts","sourceRoot":"","sources":["../../../src/domain/editor/inspector.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAElE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,gDAAiD,CAAC;AAE7E,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAE3D,oCAAoC;AACpC,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,YAAY,EAAE,MAAM,CAKhE,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,gEAKpB,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhE,4EAA4E;AAC5E,MAAM,MAAM,gBAAgB,GAAG,IAAI,GAAG,OAAO,YAAY,CAAC;AAE1D,4EAA4E;AAC5E,MAAM,MAAM,aAAa,GAAG,OAAO,CACjC,IAAI,CAAC,KAAK,EAAE,QAAQ,GAAG,KAAK,GAAG,OAAO,GAAG,MAAM,CAAC,CACjD,CAAC;AAEF,mFAAmF;AACnF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC"}

package/dist/domain/editor/inspector.js

@@ -0,0 +1,34 @@
+/**
+ * The inspector's tabs, in the web order.
+ *
+ * Score first, then Track — the only tab that always has something to show,
+ * since there is always an active track — then Note and Bar. The native panel
+ * listed Track, Note, Measure, Score; one order means a reader moving between
+ * the apps finds the same tab in the same place.
+ *
+ * `measure` is the id and the model's word; the label is "Bar" (see the app's
+ * copy), because the reader is shown a bar and the code keeps `Measure`.
+ */
+export const INSPECTOR_TABS = ["score", "track", "note", "measure"];
+/** The copy key naming each tab. */
+export const INSPECTOR_TAB_LABEL_KEY = {
+    score: "inspector.score",
+    track: "inspector.track",
+    note: "inspector.note",
+    measure: "inspector.measure",
+};
+/**
+ * The controls that stay live while the transport plays.
+ *
+ * Mixing, not editing: these are `kind: 'mix'` commands and reach the engine
+ * live, because muting a part while listening is how an arrangement gets
+ * listened to. Everything else in the inspector locks. A list rather than a
+ * flag per control so the exemption is one decision, written down.
+ */
+export const MIX_ONLY_CONTROLS = [
+    "trackVolume",
+    "trackPan",
+    "trackMute",
+    "trackSolo",
+];
+//# sourceMappingURL=inspector.js.map

package/dist/domain/editor/inspector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspector.js","sourceRoot":"","sources":["../../../src/domain/editor/inspector.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,CAAU,CAAC;AAI7E,oCAAoC;AACpC,MAAM,CAAC,MAAM,uBAAuB,GAAiC;IACnE,KAAK,EAAE,iBAAiB;IACxB,KAAK,EAAE,iBAAiB;IACxB,IAAI,EAAE,gBAAgB;IACtB,OAAO,EAAE,mBAAmB;CAC7B,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,aAAa;IACb,UAAU;IACV,WAAW;IACX,WAAW;CACH,CAAC"}