@greenblacksky/honmoon 0.0.0-stage → 0.4.1

package/src/lib/music/voice.ts

@@ -0,0 +1,227 @@
+import { honmoon } from '../store/honmoon.svelte';
+import { pickOf } from '../util/random';
+
+/* ---------------- voice ----------------
+   A cold voice doing agility work is how people strain, so the stages run in
+   a fixed order and only the pattern and syllable inside each one are random. */
+export interface VoicePattern {
+  id: string;
+  n: string;
+  iv?: number[];
+  /** a siren: how far it slides, in semitones */
+  glide?: number;
+  beats: number;
+  staccato?: boolean;
+}
+export const VPATS: VoicePattern[] = [
+  { id: 'sus', n: 'Sustained', iv: [0], beats: 4 },
+  { id: 'p3', n: 'Three-note', iv: [0, 2, 4, 2, 0], beats: 1 },
+  { id: 'p5', n: 'Five-note scale', iv: [0, 2, 4, 5, 7, 5, 4, 2, 0], beats: 1 },
+  { id: 'tri', n: 'Triad', iv: [0, 4, 7, 4, 0], beats: 1 },
+  { id: 'arp', n: 'Arpeggio to the octave', iv: [0, 4, 7, 12, 7, 4, 0], beats: 1 },
+  { id: 'oct', n: 'Octave leap', iv: [0, 12, 0], beats: 2 },
+  {
+    id: 'p9',
+    n: 'Nine-note scale',
+    iv: [0, 2, 4, 5, 7, 9, 11, 12, 11, 9, 7, 5, 4, 2, 0],
+    beats: 0.5,
+  },
+  { id: 'stac', n: 'Staccato arpeggio', iv: [0, 4, 7, 12, 7, 4, 0], beats: 0.75, staccato: true },
+  { id: 'siren', n: 'Siren', glide: 13, beats: 6 },
+];
+export function vpat(id: string): VoicePattern {
+  return VPATS.find((pattern) => pattern.id === id) ?? VPATS[0];
+}
+
+/** A sound to make (`s`, e.g. "Lip trill") and a cue for how (`c`). */
+export interface VoiceSound {
+  s: string;
+  c: string;
+}
+export interface VoiceStage {
+  /** key, e.g. "sovt" */
+  k: string;
+  /** name */
+  n: string;
+  /** 1 when switched on by default */
+  on: 0 | 1;
+  /** a breathing stage: timed, with no notes to sing */
+  timed?: boolean;
+  /** the patterns this stage can use (ids from VPATS) */
+  pats?: string[];
+  /** what the stage is for */
+  d: string;
+  sounds: VoiceSound[];
+}
+export const VSTAGES: VoiceStage[] = [
+  {
+    k: 'breath',
+    n: 'Breath',
+    on: 1,
+    timed: true,
+    d: 'No pitch, just air. Sets the support everything else rests on.',
+    sounds: [
+      {
+        s: 'sss',
+        c: 'Hiss on a steady "sss" for the whole count. Even pressure, no fade at the end.',
+      },
+      {
+        s: '4 in, 8 out',
+        c: 'In through the nose for four, out on a thin "fff" for eight. Shoulders still.',
+      },
+      { s: 'shh', c: 'Short, firm "shh" pulses from the belly — four per breath.' },
+    ],
+  },
+  {
+    k: 'sovt',
+    n: 'Semi-occluded',
+    on: 1,
+    pats: ['sus', 'p3', 'p5', 'tri'],
+    d: 'A partly closed mouth balances the pressure across the folds. The safest thing you can do to a cold voice, and always first.',
+    sounds: [
+      {
+        s: 'Lip trill',
+        c: 'Brrr. If it stalls, rest two fingers on your cheeks to take the weight off.',
+      },
+      { s: 'Tongue trill', c: 'Rolled r. If you cannot roll one, use the lip trill instead.' },
+      {
+        s: 'Straw (oo)',
+        c: 'Sing "oo" through a narrow straw, or just purse your lips into a tiny circle.',
+      },
+      { s: 'vvv', c: 'A buzzy "v" — feel it in the lips and teeth.' },
+      { s: 'zzz', c: 'Voiced "z". Steady buzz, no wobble.' },
+      { s: 'Hum (mmm)', c: 'Lips together, teeth apart, jaw loose. Feel the buzz on the lips.' },
+      { s: 'ng', c: 'The back of "sing". Tongue up at the soft palate, sound in the nose.' },
+    ],
+  },
+  {
+    k: 'fry',
+    n: 'Fry and onset',
+    on: 1,
+    pats: ['sus', 'oct'],
+    d: 'Wakes the folds gently and teaches a clean start to a note, without pushing air.',
+    sounds: [
+      { s: 'Vocal fry', c: 'The lowest creaky rattle you can make. No pushing — almost no air.' },
+      {
+        s: 'Fry into "ah"',
+        c: 'Start in fry, then let it bloom into a tone on the note without a break.',
+      },
+      { s: 'uh-oh', c: 'A light glottal "uh-oh". Clean onset, no grab.' },
+    ],
+  },
+  {
+    k: 'glide',
+    n: 'Sirens and glides',
+    on: 1,
+    pats: ['siren'],
+    d: 'One smooth slide through your whole range. Finds the joins between registers and smooths them.',
+    sounds: [
+      {
+        s: 'ng siren',
+        c: 'Slide up and down on "ng" like a fire engine. Do not push through the bumps — go lighter.',
+      },
+      { s: 'Lip trill siren', c: 'Same slide, on a lip trill. Easiest way through the break.' },
+      { s: 'oo glide', c: 'Narrow "oo", slide slowly. Keep the volume even top to bottom.' },
+    ],
+  },
+  {
+    k: 'vowel',
+    n: 'Vowels',
+    on: 1,
+    pats: ['p5', 'tri', 'arp'],
+    d: 'The shapes you actually sing in. Keep the jaw still and let the tongue do the work.',
+    sounds: [
+      { s: 'ee', c: 'As in "see". Bright, forward, tongue high.' },
+      { s: 'eh', c: 'As in "bed". Jaw a touch lower than "ee".' },
+      { s: 'ah', c: 'As in "father". Open, but do not drop the jaw as far as it wants to go.' },
+      { s: 'oh', c: 'As in "go". Lips rounded, space inside.' },
+      { s: 'oo', c: 'As in "boot". Narrow lips, open throat.' },
+      { s: 'ee-eh-ah-oh-oo', c: 'One vowel per note, jaw as still as you can keep it.' },
+    ],
+  },
+  {
+    k: 'reson',
+    n: 'Resonance',
+    on: 1,
+    pats: ['p5', 'tri', 'p3'],
+    d: 'Moves the sound forward so it carries without extra effort.',
+    sounds: [
+      { s: 'nay', c: 'Deliberately bratty and nasal. It sounds awful alone and fixes placement.' },
+      { s: 'mum', c: 'Relaxed and round. Balances out the "nay".' },
+      { s: 'goo', c: 'Releases a tight tongue root.' },
+      { s: 'ng-ah', c: 'Start on "ng", open to "ah" keeping the same buzz.' },
+    ],
+  },
+  {
+    k: 'agility',
+    n: 'Agility',
+    on: 0,
+    pats: ['p9', 'stac', 'arp'],
+    d: 'Speed and flexibility. Last, never first — and drop the tempo before you drop the accuracy.',
+    sounds: [
+      { s: 'ah', c: 'Light and bouncy. Do not let it get heavy at the top.' },
+      {
+        s: 'hah-hah-hah',
+        c: 'A soft "h" on each note, powered from the belly rather than the throat.',
+      },
+      { s: 'ya', c: 'Quick and forward, tongue relaxed.' },
+    ],
+  },
+];
+export function vstage(key: string): VoiceStage {
+  return VSTAGES.find((stage) => stage.k === key) ?? (null as unknown as VoiceStage);
+}
+export function vstageOn(key: string): boolean {
+  return !(honmoon.settings.voff || []).includes(key);
+}
+/** Until a range has been measured: A2 to A4, a span most voices can manage
+    somewhere in it. */
+const DEFAULT_LOW = 45;
+const DEFAULT_HIGH = 69;
+/** The singer's comfortable range, or a default until it has been measured. */
+export function vRange(): { lo: number; hi: number; set: boolean } {
+  const low = honmoon.settings.vlo;
+  const high = honmoon.settings.vhi;
+  return {
+    lo: low ?? DEFAULT_LOW,
+    hi: high ?? DEFAULT_HIGH,
+    set: low != null && high != null,
+  };
+}
+
+/* ---------------- the warm-up routine ---------------- */
+export interface RoutineStep {
+  k: string;
+  sound: VoiceSound;
+  pat: VoicePattern | null;
+}
+/** Every stage that is switched on, in the fixed order, each with a sound and
+    a pattern drawn at random. */
+export function vBuildRoutine(): RoutineStep[] {
+  const out: RoutineStep[] = [];
+  for (const stage of VSTAGES) {
+    if (!vstageOn(stage.k)) {
+      continue;
+    }
+    const sound = pickOf(stage.sounds);
+    const pattern = stage.timed ? null : vpat(pickOf(stage.pats!));
+    out.push({ k: stage.k, sound, pat: pattern });
+  }
+  return out;
+}
+/** How far a pattern climbs above its starting note. */
+export function vSpan(pattern: VoicePattern | null): number {
+  if (!pattern) {
+    return 0;
+  }
+  if (pattern.glide) {
+    return pattern.glide;
+  }
+  return Math.max(...pattern.iv!);
+}
+/** Where the pattern can start without taking the top note outside the range. */
+export function vStartRange(pattern: VoicePattern | null): { lo: number; hi: number } {
+  const range = vRange();
+  const highestStart = range.hi - vSpan(pattern);
+  return { lo: range.lo, hi: Math.max(range.lo, highestStart) };
+}

package/src/lib/music/warmups.ts

@@ -0,0 +1,318 @@
+import { honmoon } from '../store/honmoon.svelte';
+import { STRINGS } from './bass';
+import { pickOf, rnd } from '../util/random';
+import type { TabStep } from '../notation/tab';
+
+/* ---------------- bass warm-ups ----------------
+   The pattern is random, the family is not. Novelty keeps a warm-up from
+   getting stale; the tempo log hangs off the family, so the number that
+   measures you still means something six weeks from now. */
+export interface WarmFamily {
+  k: string;
+  n: string;
+  d: string;
+  bpm: number;
+}
+export const FAMS: WarmFamily[] = [
+  {
+    k: 'perm',
+    n: 'Permutations',
+    d: 'One finger per fret, four notes reordered. The spider, in all 24 of its orders.',
+    bpm: 60,
+  },
+  {
+    k: 'cross',
+    n: 'String crossing',
+    d: 'A small shape bounced between two strings, adjacent or skipping. Where the right hand falls apart.',
+    bpm: 60,
+  },
+  {
+    k: 'shift',
+    n: 'Position shifts',
+    d: 'One shape relocated up and down the neck. Builds confidence away from the nut.',
+    bpm: 52,
+  },
+  {
+    k: 'chrom',
+    n: 'Chromatic runs',
+    d: 'Every fret in order, along one string or across the neck at one position.',
+    bpm: 64,
+  },
+  {
+    k: 'right',
+    n: 'Right hand',
+    d: 'Strict alternation and rakes, one note per string. The half nobody practises.',
+    bpm: 70,
+  },
+  {
+    k: 'sub',
+    n: 'Subdivisions',
+    d: 'One dull pattern as quarters, eighths, triplets, sixteenths. The least fun, the most useful.',
+    bpm: 60,
+  },
+];
+export function famDef(key: string): WarmFamily {
+  return FAMS.find((family) => family.k === key) ?? (null as unknown as WarmFamily);
+}
+export function famOff(key: string): boolean {
+  return (honmoon.settings.woff || []).includes(key);
+}
+const FALLBACK_BPM = 60;
+/** The tempo this family is on now: where you left it, or its starting tempo. */
+export function famBpm(key: string): number {
+  const record = honmoon.tempo[key];
+  return (record && record.bpm) || (famDef(key) || { bpm: FALLBACK_BPM }).bpm || FALLBACK_BPM;
+}
+
+export interface Exercise {
+  fam: string;
+  title: string;
+  steps: TabStep[];
+  note: string;
+  sub?: number[];
+}
+
+/** String indices, top row first: 0 = G … 3 = E. */
+const LOWEST_STRING = 3;
+const FINGERS = 4;
+/** The right-hand fingers, index and middle. */
+const RH = ['i', 'm'];
+
+/** All 24 orders of the four fingers (0 = index … 3 = little). */
+const PERMS: number[][] = (() => {
+  const out: number[][] = [];
+  (function permute(chosen: number[], remaining: number[]) {
+    if (!remaining.length) {
+      out.push(chosen.slice());
+      return;
+    }
+    for (let i = 0; i < remaining.length; i++) {
+      const rest = remaining.slice();
+      const next = rest.splice(i, 1)[0];
+      permute(chosen.concat(next), rest);
+    }
+  })([], [0, 1, 2, 3]);
+  return out;
+})();
+
+/** One finger per fret from `startFret`, the four fingers in `fingerOrder`,
+    up through the strings from the lowest and back down. */
+function acrossAndBack(startFret: number, fingerOrder: number[]): TabStep[] {
+  const steps: TabStep[] = [];
+  const play = (string: number, finger: number) =>
+    steps.push({ s: string, f: startFret + finger, fin: finger + 1 });
+  for (let string = LOWEST_STRING; string >= 0; string--) {
+    for (let i = 0; i < FINGERS; i++) {
+      play(string, fingerOrder[i]);
+    }
+  }
+  for (let string = 1; string <= LOWEST_STRING; string++) {
+    for (let i = FINGERS - 1; i >= 0; i--) {
+      play(string, fingerOrder[i]);
+    }
+  }
+  return steps;
+}
+
+function genPerm(): Exercise {
+  const fingerOrder = pickOf(PERMS);
+  const startFret = 3 + rnd(6);
+  return {
+    fam: 'perm',
+    title: 'Permutation ' + fingerOrder.map((finger) => finger + 1).join('-'),
+    steps: acrossAndBack(startFret, fingerOrder),
+    note:
+      'One finger per fret starting at fret ' +
+      startFret +
+      '. Up through the strings and back down. When it is clean, move the whole thing up a fret and go again.',
+  };
+}
+function genCross(): Exercise {
+  const [first, second] = pickOf([
+    [3, 2],
+    [2, 1],
+    [1, 0],
+    [3, 1],
+    [2, 0],
+    [3, 0],
+  ]);
+  const fret = 3 + rnd(6);
+  const span = pickOf([2, 3]);
+  const steps: TabStep[] = [];
+  const reps = pickOf([2, 3]);
+  const low = (string: number) => ({ s: string, f: fret, fin: 1 });
+  const high = (string: number) => ({ s: string, f: fret + span, fin: span + 1 });
+  for (let rep = 0; rep < reps; rep++) {
+    steps.push(low(first), low(second), high(first), high(second));
+  }
+  for (let rep = 0; rep < reps; rep++) {
+    steps.push(high(second), high(first), low(second), low(first));
+  }
+  steps.forEach((step, i) => {
+    step.rh = RH[i % 2];
+  });
+  const skipsAString = Math.abs(first - second) > 1;
+  return {
+    fam: 'cross',
+    title: STRINGS[first].n + ' ↔ ' + STRINGS[second].n + (skipsAString ? ' (skipping)' : ''),
+    steps,
+    note:
+      'Alternate i and m strictly. ' +
+      (skipsAString
+        ? 'The skipped string in the middle must stay silent — mute it with the plucking finger as you pass.'
+        : 'Keep the two notes even in volume; the crossing is where the tone usually dips.'),
+  };
+}
+function genShift(): Exercise {
+  const string = rnd(4);
+  const route = pickOf([
+    [1, 3, 5, 7],
+    [5, 7, 9, 7],
+    [3, 5, 7, 5, 3],
+    [1, 4, 7, 4],
+    [7, 5, 3, 5, 7],
+  ]);
+  const steps: TabStep[] = [];
+  for (const position of route) {
+    for (let finger = 0; finger < FINGERS; finger++) {
+      steps.push({
+        s: string,
+        f: position + finger,
+        fin: finger + 1,
+        bar: finger === 0 ? 'fret ' + position : null,
+      });
+    }
+  }
+  return {
+    fam: 'shift',
+    title: 'Shifts on the ' + STRINGS[string].n + ' string',
+    steps,
+    note: 'Move the whole hand, do not stretch. Look at the fret you are going to before you leave the one you are on.',
+  };
+}
+function genChrom(): Exercise {
+  const across = Math.random() < 0.5;
+  if (across) {
+    const position = 1 + rnd(7);
+    return {
+      fam: 'chrom',
+      title: 'Chromatic across, position ' + position,
+      steps: acrossAndBack(position, [0, 1, 2, 3]),
+      note: 'The hand never moves. Every finger stays over its own fret for the whole exercise.',
+    };
+  }
+  const string = rnd(4);
+  const from = 1 + rnd(3);
+  /** eight frets: four, a shift, four more — and back */
+  const length = 2 * FINGERS;
+  const steps: TabStep[] = [];
+  for (let i = 0; i < length; i++) {
+    steps.push({
+      s: string,
+      f: from + i,
+      fin: (i % FINGERS) + 1,
+      bar: i % FINGERS === 0 ? 'shift ' + (i / FINGERS + 1) : null,
+    });
+  }
+  for (let i = length - 1; i >= 0; i--) {
+    steps.push({ s: string, f: from + i, fin: (i % FINGERS) + 1 });
+  }
+  return {
+    fam: 'chrom',
+    title: 'Chromatic along the ' + STRINGS[string].n + ' string, from fret ' + from,
+    steps,
+    note: 'Four frets, shift, four more, and back. The shift should not be audible — no gap, no scoop.',
+  };
+}
+/** The left-hand finger for a fret held all exercise: none when open, the
+    index at fret 5, the middle at fret 7 (so the hand sits in position). */
+function holdingFinger(fret: number): number {
+  if (!fret) {
+    return 0;
+  }
+  return fret === 5 ? 1 : 2;
+}
+function genRight(): Exercise {
+  const fret = pickOf([0, 0, 5, 7]);
+  const stringOrder = pickOf([
+    [3, 2, 1, 0, 0, 1, 2, 3],
+    [3, 1, 2, 0, 3, 1, 2, 0],
+    [0, 1, 2, 3, 3, 2, 1, 0],
+    [3, 2, 3, 1, 3, 0, 3, 1],
+    [0, 2, 1, 3, 0, 2, 1, 3],
+  ]);
+  const startFinger = rnd(2);
+  const steps: TabStep[] = stringOrder.map((string, i) => ({
+    s: string,
+    f: fret,
+    fin: holdingFinger(fret),
+    rh: RH[(i + startFinger) % 2],
+  }));
+  /* a line that only ever moves towards thicker strings can be raked */
+  const onlyDescends = stringOrder.every((string, i) => i === 0 || string >= stringOrder[i - 1]);
+  return {
+    fam: 'right',
+    title: 'Alternation, starting with ' + RH[startFinger],
+    steps,
+    note:
+      (fret ? 'All at fret ' + fret + '. ' : 'All open strings. ') +
+      'Strict alternation — no repeated finger, even across a string change.' +
+      (onlyDescends
+        ? ' Where the line moves to a thicker string, let one finger rake through instead.'
+        : ''),
+  };
+}
+const BEATS_PER_BAR = 4;
+/** Notes per beat → what they are called. */
+const SUBDIVISION_NAMES: Record<number, string> = {
+  1: 'quarters',
+  2: 'eighths',
+  3: 'triplets',
+  4: 'sixteenths',
+};
+function genSub(): Exercise {
+  const stringOrder = pickOf([
+    [3, 2, 1, 0],
+    [3, 1, 2, 0],
+    [0, 1, 2, 3],
+    [3, 2, 3, 1],
+  ]);
+  const fret = pickOf([0, 5, 7]);
+  /** the two subdivisions, as notes per beat: one bar of each */
+  const subdivisions = pickOf([
+    [1, 2],
+    [2, 3],
+    [2, 4],
+    [1, 3],
+  ]);
+  const steps: TabStep[] = [];
+  for (const perBeat of subdivisions) {
+    const notesInBar = BEATS_PER_BAR * perBeat;
+    for (let i = 0; i < notesInBar; i++) {
+      steps.push({
+        s: stringOrder[i % stringOrder.length],
+        f: fret,
+        fin: fret ? 1 : 0,
+        bar: i === 0 ? SUBDIVISION_NAMES[perBeat] : null,
+      });
+    }
+  }
+  return {
+    fam: 'sub',
+    title: SUBDIVISION_NAMES[subdivisions[0]] + ' into ' + SUBDIVISION_NAMES[subdivisions[1]],
+    steps,
+    sub: subdivisions,
+    note: 'Leave the metronome on quarter notes and fit the subdivision between the clicks yourself. One bar of each, no pause at the change — that join is the whole exercise.',
+  };
+}
+const GENS: Record<string, () => Exercise> = {
+  perm: genPerm,
+  cross: genCross,
+  shift: genShift,
+  chrom: genChrom,
+  right: genRight,
+  sub: genSub,
+};
+export function genExercise(key: string): Exercise {
+  return (GENS[key] || genPerm)();
+}

package/src/lib/nav.svelte.ts

@@ -0,0 +1,53 @@
+import { holdStop } from './audio/synth';
+
+/* ---------------- navigation ----------------
+   One current screen, by name. Each app decides which names it has and which
+   component draws each one; the engine only ever asks to go somewhere by name,
+   and checks hasRoute() before offering a link to a screen an app may not
+   include (the Staff map lives in Zoey, for instance). */
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type ViewOpt = Record<string, any>;
+export interface View {
+  name: string;
+  opt: ViewOpt;
+}
+export const nav: { view: View } = $state({ view: { name: 'home', opt: {} } });
+
+// Set once at start-up by the app and never watched: a plain Set on purpose.
+let routes: ReadonlySet<string> = new Set();
+export function configureRoutes(names: string[]): void {
+  // eslint-disable-next-line svelte/prefer-svelte-reactivity
+  routes = new Set(names);
+}
+export function hasRoute(name: string): boolean {
+  return routes.has(name);
+}
+
+type Hook = (from: string, to: string, opt: ViewOpt) => void;
+const hooks: Hook[] = [];
+/** Run something whenever the screen changes — stopping a timer, releasing the
+    microphone, dropping a finished session. */
+export function onNavigate(hook: Hook): void {
+  hooks.push(hook);
+}
+
+let scroller: HTMLElement | null = null;
+export function setScroller(element: HTMLElement | null): void {
+  scroller = element;
+}
+export function scrollToTop(): void {
+  if (scroller && scroller.scrollTo) {
+    scroller.scrollTo(0, 0);
+  }
+}
+
+export function go(name: string, opt: ViewOpt = {}): void {
+  holdStop();
+  const from = nav.view.name;
+  for (const hook of hooks) {
+    hook(from, name, opt);
+  }
+  nav.view = { name, opt };
+  scrollToTop();
+}