@hraness/dawg 0.6.1 → 0.8.0

package/core/diff.ts

@@ -10,10 +10,6 @@
  * canonical order, so insertion order never matters).
  */
 
-import {
-  NOTE_EXPRESSION_FIELDS,
-  TRACK_PERFORMANCE_FIELDS,
-} from "./expression.ts";
 import {
   applyScoreOperation,
   TrackScore,
@@ -31,34 +27,109 @@ export class DiffError extends Error {
   }
 }
 
-const EFFECTS = [
-  "filter",
-  "delay",
-  "reverb",
-  "sampler",
-  "fx",
-  "fxAutomation",
-  "synth",
-  "wavetable",
-  "string",
-  "granular",
-  "keys",
-  "modal",
-  "softPedal",
-  "sostenuto",
-  // f061-guitar: fretting setup.
-  "guitar",
-  "wind",
-] as const;
-const LANES = [
-  "volumeAutomation",
-  "panAutomation",
-  "filterAutomation",
-  "resonanceAutomation",
-  "delayFeedbackAutomation",
-  "delayMixAutomation",
-  "wtAutomation",
-] as const;
+/**
+ * How each field diffs: `same` is identity (never patched), `set` patches
+ * the new value, `clear` patches the new value or null, `zero` treats
+ * absent as 0, `flag` treats absent as false and `lane` treats absent as
+ * []. The records are keyed by every field of `Note` and `Track`, so a new
+ * field fails typechecking until it is classified here.
+ */
+type FieldRule = "same" | "set" | "clear" | "zero" | "flag" | "lane";
+
+const NOTE_FIELDS: { readonly [K in keyof Note]-?: FieldRule } = {
+  id: "same",
+  trackId: "same",
+  startTick: "set",
+  durationTicks: "set",
+  pitch: "set",
+  velocity: "set",
+  cents: "zero",
+  lyric: "clear",
+  vowel: "clear",
+  articulation: "clear",
+  glide: "clear",
+  bend: "clear",
+  vibrato: "clear",
+  humanize: "clear",
+  drift: "clear",
+};
+
+const TRACK_FIELDS: { readonly [K in keyof Track]-?: FieldRule } = {
+  id: "same",
+  name: "set",
+  instrument: "set",
+  muted: "set",
+  volume: "set",
+  pan: "set",
+  solo: "flag",
+  volumeAutomation: "lane",
+  panAutomation: "lane",
+  filterAutomation: "lane",
+  resonanceAutomation: "lane",
+  delayFeedbackAutomation: "lane",
+  delayMixAutomation: "lane",
+  wtAutomation: "lane",
+  filter: "clear",
+  delay: "clear",
+  reverb: "clear",
+  fx: "clear",
+  fxAutomation: "clear",
+  synth: "clear",
+  wavetable: "clear",
+  sampler: "clear",
+  rhythm: "clear",
+  kit: "clear",
+  time: "clear",
+  tuning: "clear",
+  string: "clear",
+  granular: "clear",
+  keys: "clear",
+  modal: "clear",
+  softPedal: "clear",
+  sostenuto: "clear",
+  guitar: "clear",
+  wind: "clear",
+  sing: "clear",
+  vocoder: "clear",
+  clips: "clear",
+  takes: "clear",
+  autotune: "clear",
+  glide: "clear",
+  pedal: "clear",
+  velocityCurve: "clear",
+  humanize: "clear",
+};
+
+/** Field names of `Note` and `Track`, for tests that check completeness. */
+export const NOTE_FIELD_NAMES = Object.freeze(
+  Object.keys(NOTE_FIELDS),
+) as readonly (keyof Note)[];
+export const TRACK_FIELD_NAMES = Object.freeze(
+  Object.keys(TRACK_FIELDS),
+) as readonly (keyof Track)[];
+
+function fieldPatch(
+  rules: Readonly<Record<string, FieldRule>>,
+  a: Readonly<Record<string, unknown>>,
+  b: Readonly<Record<string, unknown>>,
+): Record<string, unknown> | undefined {
+  const patch: Record<string, unknown> = {};
+  for (const [key, rule] of Object.entries(rules)) {
+    const before = a[key];
+    const after = b[key];
+    if (rule === "same") continue;
+    if (rule === "set") {
+      if (!deepEqual(before, after)) patch[key] = after;
+    } else if (rule === "zero") {
+      if (!deepEqual(before ?? 0, after ?? 0)) patch[key] = after ?? 0;
+    } else if (rule === "flag") {
+      if ((before ?? false) !== (after ?? false)) patch[key] = after ?? false;
+    } else if (rule === "lane") {
+      if (!deepEqual(before ?? [], after ?? [])) patch[key] = after ?? [];
+    } else if (!deepEqual(before, after)) patch[key] = after ?? null;
+  }
+  return Object.keys(patch).length > 0 ? patch : undefined;
+}
 
 /** Operations turning `a` into `b`; empty when they are equal. */
 export function diffScores(
@@ -69,31 +140,7 @@ export function diffScores(
     throw new DiffError(
       `ticksPerBeat differs (${a.ticksPerBeat} → ${b.ticksPerBeat}); the session resolution is fixed`,
     );
-  const ops: ScoreOperation[] = [];
-  if (a.beatsPerBar !== b.beatsPerBar)
-    ops.push({ type: "setMeter", beatsPerBar: b.beatsPerBar });
-  if (a.bars !== b.bars) ops.push({ type: "setBars", bars: b.bars });
-  if (a.tempoBpm !== b.tempoBpm)
-    ops.push({ type: "setTempo", tempoBpm: b.tempoBpm });
-  if (a.key !== b.key) ops.push({ type: "setKey", key: b.key });
-  if (!deepEqual(a.time, b.time))
-    ops.push({ type: "setTime", time: b.time ?? null });
-  if (!deepEqual(a.tuning, b.tuning))
-    ops.push({ type: "setTuning", tuning: b.tuning ?? null });
-  if (!deepEqual(a.master, b.master))
-    ops.push({ type: "setMaster", master: b.master ?? null });
-  if (
-    !deepEqual(a.sections, b.sections) ||
-    !deepEqual(a.form, b.form) ||
-    a.loopSection !== b.loopSection
-  )
-    ops.push({
-      type: "setSections",
-      sections: b.sections,
-      form: b.form,
-      ...(b.loopSection === undefined ? {} : { loopSection: b.loopSection }),
-    });
-
+  const ops: ScoreOperation[] = [...songOperations(a, b)];
   const aTracks = new Map(a.tracks.map((track) => [track.id, track]));
   const bTracks = new Map(b.tracks.map((track) => [track.id, track]));
   const aNotes = new Map(a.notes.map((note) => [note.id, note]));
@@ -101,32 +148,26 @@ export function diffScores(
 
   const updates: ScoreOperation[] = [];
   const additions: ScoreOperation[] = [];
+  // Notes that leave `a`: dropped with their track, or removed one by one
+  // (a note may name a track the score lacks, so check `a` too).
+  const gone = new Set<string>();
   for (const note of a.notes) {
-    if (!bTracks.has(note.trackId)) continue; // removed with its track
+    if (aTracks.has(note.trackId) && !bTracks.has(note.trackId)) {
+      gone.add(note.id); // removed with its track
+      continue;
+    }
     const next = bNotes.get(note.id);
     if (!next || next.trackId !== note.trackId) {
       ops.push({ type: "removeNote", noteId: note.id });
+      gone.add(note.id);
       continue;
     }
     const patch = notePatch(note, next);
     if (patch) updates.push({ type: "updateNote", noteId: note.id, patch });
   }
-  for (const note of b.notes) {
-    const previous = aNotes.get(note.id);
-    if (
-      previous &&
-      previous.trackId === note.trackId &&
-      bTracks.has(note.trackId)
-    )
-      continue;
-    if (
-      previous &&
-      previous.trackId === note.trackId &&
-      !aTracks.has(note.trackId)
-    )
-      continue;
-    additions.push({ type: "addNote", note });
-  }
+  for (const note of b.notes)
+    if (!aNotes.has(note.id) || gone.has(note.id))
+      additions.push({ type: "addNote", note });
 
   for (const track of a.tracks)
     if (!bTracks.has(track.id))
@@ -156,6 +197,71 @@ export function diffScores(
   return Object.freeze(ops);
 }
 
+/**
+ * Song settings, ordered so every step is valid on its own: constraints
+ * that go away are dropped first (sections before meter changes, fermatas
+ * before the tempo or meter that time them) and constraints that arrive
+ * are added last. Steps are checked on a copy without tracks or notes,
+ * because song settings never depend on them.
+ */
+function songOperations(a: TrackScore, b: TrackScore): ScoreOperation[] {
+  const ops: ScoreOperation[] = [];
+  let song = new TrackScore({ ...a.toJSON(), tracks: [], notes: [] });
+  const emit = (operation: ScoreOperation): void => {
+    song = applyScoreOperation(song, operation);
+    ops.push(operation);
+  };
+  const sectionsDiffer = (): boolean =>
+    !deepEqual(song.sections, b.sections) ||
+    !deepEqual(song.form, b.form) ||
+    song.loopSection !== b.loopSection;
+  const setSections = (): void =>
+    emit({
+      type: "setSections",
+      sections: b.sections,
+      form: b.form,
+      ...(b.loopSection === undefined ? {} : { loopSection: b.loopSection }),
+    });
+  if (b.sections.length === 0 && sectionsDiffer()) setSections();
+  const retimed =
+    song.beatsPerBar !== b.beatsPerBar ||
+    song.bars !== b.bars ||
+    song.tempoBpm !== b.tempoBpm;
+  if (retimed && song.time?.fermatas && !deepEqual(song.time, b.time)) {
+    const { fermatas: _fermatas, ...rest } = b.time ?? {};
+    const interim = Object.keys(rest).length > 0 ? rest : null;
+    if (!deepEqual(song.time, interim ?? undefined))
+      emit({ type: "setTime", time: interim });
+  } else if (retimed && song.time?.fermatas) {
+    // Same fermatas before and after, but timed by a new tempo or meter.
+    const { fermatas: _fermatas, ...rest } = song.time;
+    emit({
+      type: "setTime",
+      time: Object.keys(rest).length > 0 ? rest : null,
+    });
+  }
+  if (song.beatsPerBar !== b.beatsPerBar)
+    emit({ type: "setMeter", beatsPerBar: b.beatsPerBar });
+  if (song.bars !== b.bars) emit({ type: "setBars", bars: b.bars });
+  if (song.tempoBpm !== b.tempoBpm)
+    emit({ type: "setTempo", tempoBpm: b.tempoBpm });
+  if (song.key !== b.key) emit({ type: "setKey", key: b.key });
+  if (!deepEqual(song.time, b.time))
+    emit({ type: "setTime", time: b.time ?? null });
+  if (!deepEqual(song.tuning, b.tuning))
+    emit({ type: "setTuning", tuning: b.tuning ?? null });
+  if (!deepEqual(song.master, b.master))
+    emit({ type: "setMaster", master: b.master ?? null });
+  if ((song.calibration ?? 0) !== (b.calibration ?? 0))
+    emit({ type: "setCalibration", calibration: b.calibration ?? null });
+  if (!deepEqual(song.style, b.style))
+    emit({ type: "setStyle", style: b.style ?? null });
+  if (sectionsDiffer()) setSections();
+  if (!deepEqual(song.loop, b.loop))
+    emit({ type: "setLoop", loop: b.loop ?? null });
+  return ops;
+}
+
 /** Applies operations in order; the inverse of `diffScores`. */
 export function applyScoreOperations(
   score: TrackScore,
@@ -165,43 +271,17 @@ export function applyScoreOperations(
 }
 
 function notePatch(a: Note, b: Note): NotePatch | undefined {
-  const patch: Record<string, unknown> = {};
-  for (const key of [
-    "startTick",
-    "durationTicks",
-    "pitch",
-    "velocity",
-  ] as const)
-    if (a[key] !== b[key]) patch[key] = b[key];
-  for (const key of NOTE_EXPRESSION_FIELDS)
-    if (!deepEqual(a[key], b[key])) patch[key] = b[key] ?? null;
-  if ((a.cents ?? 0) !== (b.cents ?? 0)) patch.cents = b.cents ?? 0;
-  return Object.keys(patch).length > 0 ? (patch as NotePatch) : undefined;
+  return fieldPatch(NOTE_FIELDS, a, b) as NotePatch | undefined;
 }
 
 function trackPatch(a: Track, b: Track): TrackPatch | undefined {
-  const patch: Record<string, unknown> = {};
-  for (const key of ["name", "instrument", "muted", "volume", "pan"] as const)
-    if (a[key] !== b[key]) patch[key] = b[key];
-  if ((a.solo ?? false) !== (b.solo ?? false)) patch.solo = b.solo ?? false;
-  for (const key of EFFECTS)
-    if (!deepEqual(a[key], b[key])) patch[key] = b[key] ?? null;
-  for (const key of [
-    "rhythm",
-    "kit",
-    "time",
-    "tuning",
-    ...TRACK_PERFORMANCE_FIELDS,
-  ] as const)
-    if (!deepEqual(a[key], b[key])) patch[key] = b[key] ?? null;
-  for (const key of LANES)
-    if (!deepEqual(a[key] ?? [], b[key] ?? [])) patch[key] = b[key] ?? [];
-  return Object.keys(patch).length > 0 ? (patch as TrackPatch) : undefined;
+  return fieldPatch(TRACK_FIELDS, a, b) as TrackPatch | undefined;
 }
 
 /** Structural equality for plain JSON-like data. */
 export function deepEqual(a: unknown, b: unknown): boolean {
-  if (Object.is(a, b)) return true;
+  // === so -0 equals 0: a printed song.ts reads -0 back as 0.
+  if (a === b) return true;
   if (
     typeof a !== "object" ||
     typeof b !== "object" ||

package/core/expression.ts

@@ -125,6 +125,11 @@ export type NoteExpression = Readonly<{
    * track's humanize seed, 1 when it has none). `{}` keeps the note exact.
    */
   humanize?: NoteHumanize;
+  /**
+   * Optional (0.7): on an autotune guide note, the share of slow pitch drift
+   * removed (0..1), overriding the track's `autotune.drift` for this note.
+   */
+  drift?: number;
 }>;
 
 /** Per-note humanize: amounts as in `Humanize`, absent ones 0. */
@@ -141,6 +146,7 @@ export type NoteExpressionPatch = Readonly<{
   bend?: readonly BendPoint[] | null;
   vibrato?: NoteVibrato | null;
   humanize?: NoteHumanize | null;
+  drift?: number | null;
 }>;
 
 export const NOTE_EXPRESSION_FIELDS = [
@@ -149,6 +155,7 @@ export const NOTE_EXPRESSION_FIELDS = [
   "bend",
   "vibrato",
   "humanize",
+  "drift",
 ] as const;
 
 export const GLIDE_MODES = ["legato", "mono", "poly"] as const;
@@ -325,6 +332,12 @@ export function normalizeVibrato(value: unknown): NoteVibrato | undefined {
   return Object.freeze({ rate, depth, ...(delay > 0 ? { delay } : {}) });
 }
 
+/** A guide note's autotune drift share (0.7), 0..1. */
+export function normalizeNoteDrift(value: unknown): number | undefined {
+  if (value === undefined || value === null) return undefined;
+  return finite(value, "note drift", 0, 1);
+}
+
 /** Validates a note's expression fields; only the set ones are returned. */
 export function normalizeNoteExpression(
   input: Readonly<Record<string, unknown>>,
@@ -334,12 +347,14 @@ export function normalizeNoteExpression(
   const bend = normalizeBend(input.bend);
   const vibrato = normalizeVibrato(input.vibrato);
   const humanize = normalizeNoteHumanize(input.humanize);
+  const drift = normalizeNoteDrift(input.drift);
   return {
     ...(articulation ? { articulation } : {}),
     ...(glide !== undefined ? { glide } : {}),
     ...(bend ? { bend } : {}),
     ...(vibrato ? { vibrato } : {}),
     ...(humanize ? { humanize } : {}),
+    ...(drift !== undefined ? { drift } : {}),
   };
 }
 

package/core/fx.ts

@@ -13,10 +13,12 @@
  */
 
 import { MODAL_LANE_PARAMS, WIND_LANE_PARAMS } from "./resonators.ts";
+import { VOCODER_LANE_PARAMS } from "./vocoder.ts";
 import { SYNTH_LANE_PARAMS } from "./synth.ts";
 import { STRING_LANE_PARAMS } from "./strings.ts";
 import { KEYS_LANE_PARAMS } from "./keys.ts";
 import { GRANULAR_LANE_PARAMS } from "./granular.ts";
+import { SING_LANE_PARAMS } from "./sing.ts";
 import {
   FxValidationError,
   normalizeParam,
@@ -49,6 +51,8 @@ export const FX_CHAIN = Object.freeze([
   "filter",
   "djf",
   "autofilter",
+  // 0.7 formant shift at constant pitch (src/audio/effects/formant.ts).
+  "formant",
   "vowel",
   "crush",
   "distort",
@@ -110,7 +114,7 @@ const sync = (fallback: number, strudel?: readonly string[]): NumberParam => ({
   default: fallback,
   step: 0.25,
   unit: "beats",
-  doc: "LFO cycle length in beats (tempo-synced); 0 uses rate in Hz",
+  doc: "LFO period in beats (tempo-synced); 0 uses rate in Hz",
   ...(strudel ? { strudel } : {}),
 });
 const mix = (fallback: number, strudel?: readonly string[]): NumberParam => ({
@@ -124,6 +128,25 @@ const mix = (fallback: number, strudel?: readonly string[]): NumberParam => ({
   ...(strudel ? { strudel } : {}),
 });
 
+/** Vowels of the `vowel` effect (src/audio/dsp/formant.ts tables). */
+export const VOWEL_VALUES = Object.freeze([
+  "a",
+  "e",
+  "i",
+  "o",
+  "u",
+  "ae",
+  "aa",
+  "oe",
+  "ue",
+  "y",
+  "uh",
+  "un",
+  "en",
+  "an",
+  "on",
+] as const);
+
 /**
  * Effects stored under `track.fx`. Every number is bounded; enabling an
  * effect stores all of its parameters so a document says exactly what plays.
@@ -131,7 +154,7 @@ const mix = (fallback: number, strudel?: readonly string[]): NumberParam => ({
 export const FX_SPECS = Object.freeze({
   autofilter: {
     label: "auto filter",
-    doc: "filter whose cutoff an LFO sweeps around a centre, optionally opened by the input level",
+    doc: "filter whose cutoff an LFO sweeps around a center, optionally opened by the input level",
     simple: ["type", "cutoff", "depth", "sync", "shape"],
     strudel:
       "none built in (Strudel fakes it with lpf(sine.range(..)).seg(n)); names follow lpf/lpq",
@@ -151,7 +174,7 @@ export const FX_SPECS = Object.freeze({
         step: "log",
         unit: "Hz",
         automate: true,
-        doc: "centre cutoff",
+        doc: "center cutoff",
         strudel: ["lpf", "cutoff"],
       },
       resonance: {
@@ -172,7 +195,7 @@ export const FX_SPECS = Object.freeze({
         step: 0.25,
         unit: "oct",
         automate: true,
-        doc: "sweep width in octaves around the centre",
+        doc: "sweep width in octaves around the center",
       },
       sync: sync(4),
       rate: rate(0.5),
@@ -216,11 +239,30 @@ export const FX_SPECS = Object.freeze({
         default: 0.5,
         step: 0.02,
         automate: true,
-        doc: "0 dark … 0.5 open … 1 thin",
+        doc: "0 dark (20 Hz low-pass) … 0.5 open … 1 thin (10 kHz high-pass)",
         strudel: ["djf"],
       },
     },
   },
+  formant: {
+    label: "formant",
+    doc: "formant shift at constant pitch: moves the spectral envelope (throat or gender knob), any source",
+    simple: ["shift", "mix"],
+    strudel: "none (not a Strudel concept)",
+    params: {
+      shift: {
+        kind: "number",
+        min: -12,
+        max: 12,
+        default: 0,
+        step: 0.5,
+        unit: "st",
+        automate: true,
+        doc: "semitones the formants move (negative deeper, positive smaller); pitch stays",
+      },
+      mix: mix(1),
+    },
+  },
   vowel: {
     label: "vowel",
     doc: "formant filter bank: five band-passes per vowel",
@@ -229,28 +271,30 @@ export const FX_SPECS = Object.freeze({
     params: {
       vowel: {
         kind: "enum",
-        values: [
-          "a",
-          "e",
-          "i",
-          "o",
-          "u",
-          "ae",
-          "aa",
-          "oe",
-          "ue",
-          "y",
-          "uh",
-          "un",
-          "en",
-          "an",
-          "on",
-        ],
+        values: VOWEL_VALUES,
         default: "a",
         doc: "vowel formants (a e i o u plus the extended set)",
         strudel: ["vowel"],
       },
       mix: mix(1),
+      // 0.7: optional morph target; absent keeps the static bank exactly.
+      to: {
+        kind: "enum",
+        values: VOWEL_VALUES,
+        default: "a",
+        optional: true,
+        doc: "vowel to morph toward (absent: no morph)",
+      },
+      morph: {
+        kind: "number",
+        min: 0,
+        max: 1,
+        default: 0,
+        step: 0.05,
+        optional: true,
+        automate: true,
+        doc: "position between vowel (0) and to (1), log-frequency formant morph",
+      },
     },
   },
   crush: {
@@ -467,7 +511,7 @@ export const FX_SPECS = Object.freeze({
         step: 1,
         unit: "dB",
         optional: true,
-        doc: "noise gate threshold before the amp (absent: no gate)",
+        doc: "noise gate threshold before the amp (absent: no gate; 0 dB gates all)",
       },
       level: {
         kind: "number",
@@ -498,7 +542,7 @@ export const FX_SPECS = Object.freeze({
         max: 1,
         default: 0.3,
         step: 0.05,
-        doc: "microphone position: 0 centre (bright) .. 1 edge (dark)",
+        doc: "microphone position: 0 center (bright) .. 1 edge (dark)",
       },
       mix: mix(1),
     },
@@ -628,7 +672,7 @@ export const FX_SPECS = Object.freeze({
         max: 1,
         default: 0.6,
         step: 0.05,
-        doc: "0 centred .. 1 the two takes hard left and right",
+        doc: "0 centered .. 1 the two takes hard left and right",
       },
     },
   },
@@ -771,7 +815,7 @@ export const FX_SPECS = Object.freeze({
         default: 1000,
         step: "log",
         unit: "Hz",
-        doc: "sweep centre",
+        doc: "sweep center",
         strudel: ["phasercenter", "phc"],
       },
       sweep: {
@@ -955,7 +999,7 @@ export const TRACK_EFFECT_SPECS = Object.freeze({
         step: "log",
         unit: "Hz",
         automate: true,
-        doc: "cutoff (lpf/hpf) or centre (bpf) frequency",
+        doc: "cutoff (lpf/hpf) or center (bpf) frequency",
         strudel: [
           "lpf",
           "cutoff",
@@ -1221,7 +1265,7 @@ export function normalizeFx(input: unknown): TrackFx | undefined {
 
 /** Automation lane name of an `fx` parameter, e.g. `distort-drive`. */
 export type FxLane =
-  `${FxName | "reverb" | "synth" | "string" | "keys" | "modal" | "grain" | "wind"}-${string}`;
+  `${FxName | "reverb" | "synth" | "string" | "keys" | "modal" | "grain" | "wind" | "sing" | "vocoder"}-${string}`;
 
 /** Every automatable `fx` parameter as `{ lane, effect, param, spec }`. */
 export const FX_LANES: readonly Readonly<{
@@ -1234,7 +1278,9 @@ export const FX_LANES: readonly Readonly<{
     | "keys"
     | "modal"
     | "grain"
-    | "wind";
+    | "wind"
+    | "sing"
+    | "vocoder";
   param: string;
   spec: NumberParam;
 }>[] = Object.freeze([
@@ -1309,6 +1355,24 @@ export const FX_LANES: readonly Readonly<{
       spec,
     }),
   ),
+  // Sing parameters (core/sing.ts, 0.7), read every 32-sample control tick.
+  ...SING_LANE_PARAMS.map(({ param, spec }) =>
+    Object.freeze({
+      lane: `sing-${param}` as FxLane,
+      effect: "sing" as const,
+      param,
+      spec,
+    }),
+  ),
+  // Vocoder (core/vocoder.ts, 0.7), read per 32-sample block on the song grid.
+  ...VOCODER_LANE_PARAMS.map(({ param, spec }) =>
+    Object.freeze({
+      lane: `vocoder-${param}` as FxLane,
+      effect: "vocoder" as const,
+      param,
+      spec,
+    }),
+  ),
 ]);
 
 /**
@@ -1355,6 +1419,12 @@ export const FX_PRESETS: Readonly<
       resonance: 0.6,
     },
   },
+  formant: {
+    deep: { shift: -4 },
+    giant: { shift: -8 },
+    bright: { shift: 3 },
+    tiny: { shift: 7 },
+  },
   vowel: { a: { vowel: "a" }, o: { vowel: "o" }, ee: { vowel: "i" } },
   crush: {
     "8-bit": { bits: 8, coarse: 1 },