@hidechae/eztab-mcp 0.1.2 → 0.3.0

package/dist/server.js

@@ -4,16 +4,17 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { WebSocket, WebSocketServer } from "ws";
 
 // ../src/types/tab.ts
 var TAB_FILE_VERSION = 1;
+var SUPPORTED_FORMAT_REVISION = 2;
+var MULTI_TRACK_FORMAT_REVISION = 2;
+var MAX_TRACKS = 4;
+var DEFAULT_MAIN_TRACK_NAME = "Guitar";
 var DEFAULT_TEMPO = 120;
 var DEFAULT_MIX = { melody: 1, backing: 0.4 };
 function shiftSectionsForInsert(sections, index) {
-  return sections.map(
-    (s) => s.measure >= index ? { ...s, measure: s.measure + 1 } : s
-  );
+  return sections.map((s) => s.measure >= index ? { ...s, measure: s.measure + 1 } : s);
 }
 function shiftSectionsForDelete(sections, index) {
   return sections.filter((s) => s.measure !== index).map((s) => s.measure > index ? { ...s, measure: s.measure - 1 } : s);
@@ -27,9 +28,7 @@ function activeKeyAt(keys, measure) {
   return result;
 }
 function shiftKeysForInsert(keys, index) {
-  const shifted = keys.map(
-    (k) => k.measure >= index ? { ...k, measure: k.measure + 1 } : k
-  );
+  const shifted = keys.map((k) => k.measure >= index ? { ...k, measure: k.measure + 1 } : k);
   if (!shifted.some((k) => k.measure === 0)) {
     shifted.unshift({ measure: 0, tonic: keys[0].tonic, mode: keys[0].mode });
   }
@@ -42,40 +41,196 @@ function shiftKeysForDelete(keys, index) {
   }
   return next;
 }
+function cellPalmMute(c) {
+  return typeof c === "object" && c !== null && !!c.pm;
+}
+var CHORD_REST = "rest";
+var CHORD_REST_LABEL = "N.C.";
+function chordDisplay(label) {
+  if (!label) return "";
+  return label === CHORD_REST ? CHORD_REST_LABEL : label;
+}
+function parseChordInput(raw) {
+  if (raw === "") return "";
+  if (/^(r|n\.?c?\.?)$/i.test(raw)) return CHORD_REST;
+  const v = raw.charAt(0).toUpperCase() + raw.slice(1);
+  return /^[A-G]/.test(v) ? v : null;
+}
 function setMeasureTimeSignature(measure, beats, beatUnit) {
-  const cols = beats * measure.subdivisions;
-  const cells = measure.cells.map(
-    (row) => Array.from({ length: cols }, (_, c) => row[c] ?? null)
-  );
-  const chords = Array.from(
+  const subdivisions = Array.from(
     { length: beats },
-    (_, b) => measure.chords?.[b] ?? null
+    (_, b) => measure.subdivisions[Math.min(b, measure.subdivisions.length - 1)] ?? DEFAULT_SUBDIVISIONS
   );
-  return { ...measure, beats, beatUnit, cells, chords };
+  const cols = subdivisions.reduce((a, b) => a + b, 0);
+  const cells = measure.cells.map((row) => Array.from({ length: cols }, (_, c) => row[c] ?? null));
+  const chords = Array.from({ length: cols }, (_, c) => measure.chords?.[c] ?? null);
+  return { ...measure, beats, beatUnit, subdivisions, cells, chords };
 }
 function columnCount(measure) {
-  return measure.beats * measure.subdivisions;
+  let sum = 0;
+  for (const s of measure.subdivisions) sum += s;
+  return sum;
 }
-var PRESET_TUNINGS = {
-  "Guitar (6)": ["E4", "B3", "G3", "D3", "A2", "E2"],
-  "Bass (4)": ["G2", "D2", "A1", "E1"],
-  "Bass (5)": ["G2", "D2", "A1", "E1", "B0"],
-  "Ukulele (4)": ["A4", "E4", "C4", "G4"]
-};
+function uniformSubdivision(measure) {
+  const first = measure.subdivisions[0];
+  return measure.subdivisions.every((s) => s === first) ? first : null;
+}
+function normalizeChords(raw, subdivisions) {
+  const beats = subdivisions.length;
+  const cols = subdivisions.reduce((a, b) => a + b, 0);
+  const src = Array.isArray(raw) ? raw : [];
+  const out = Array.from({ length: cols }, () => null);
+  if (src.length > beats) {
+    for (let c = 0; c < Math.min(cols, src.length); c++) {
+      out[c] = src[c] || null;
+    }
+  } else {
+    let col = 0;
+    for (let b = 0; b < beats; b++) {
+      if (b < src.length) out[col] = src[b] || null;
+      col += subdivisions[b];
+    }
+  }
+  return out;
+}
+function normalizeDocument(data) {
+  if (!data || !Array.isArray(data.tuning) || !Array.isArray(data.measures)) {
+    throw new Error("Not a valid EZTab document");
+  }
+  data.measures = data.measures.map((m) => {
+    let beats = m.beats;
+    let rawSubs = m.subdivisions;
+    const subsValid = typeof rawSubs === "number" || Array.isArray(rawSubs) && rawSubs.length > 0;
+    if (!Number.isInteger(beats) || beats < 1 || beats > MAX_BEATS || !subsValid) {
+      const cols2 = m.cells?.[0]?.length ?? m.columns ?? 8;
+      const sub = cols2 % 4 === 0 ? cols2 / 4 : 2;
+      beats = cols2 % 4 === 0 ? 4 : Math.max(1, Math.round(cols2 / sub));
+      rawSubs = sub;
+    }
+    const rawUnit = m.beatUnit;
+    const beatUnit = BEAT_UNITS.includes(rawUnit) ? rawUnit : DEFAULT_BEAT_UNIT;
+    const subdivisions = Array.from({ length: beats }, (_, b) => {
+      const v = Array.isArray(rawSubs) ? rawSubs[Math.min(b, rawSubs.length - 1)] : rawSubs;
+      return typeof v === "number" && Number.isInteger(v) && v >= 1 && v <= MAX_SUBDIVISION ? v : DEFAULT_SUBDIVISIONS;
+    });
+    const cols = subdivisions.reduce((a, b) => a + b, 0);
+    const cells = (m.cells ?? []).map(
+      (row) => Array.from({ length: cols }, (_, c) => row?.[c] ?? null)
+    );
+    const rawChords = Array.isArray(m.chords) ? m.chords : typeof m.chord === "string" && m.chord ? [m.chord] : [];
+    const chords = normalizeChords(rawChords, subdivisions);
+    return { beats, beatUnit, subdivisions, cells, chords };
+  });
+  if (!Array.isArray(data.keys) || data.keys.length === 0) {
+    data.keys = [{ measure: 0, tonic: "C", mode: "major" }];
+  }
+  if (typeof data.artist !== "string") data.artist = "";
+  if (!Array.isArray(data.sections)) data.sections = [];
+  if (typeof data.tempo !== "number") data.tempo = DEFAULT_TEMPO;
+  if (!data.mix || typeof data.mix.melody !== "number") {
+    data.mix = { ...DEFAULT_MIX };
+  }
+  normalizeTracks(data);
+  data.version = TAB_FILE_VERSION;
+  return data;
+}
+function normalizeTrackMeta(raw, fallbackName) {
+  const volume = Number(raw?.volume);
+  return {
+    id: typeof raw?.id === "string" && raw.id ? raw.id : newTabId(),
+    name: typeof raw?.name === "string" && raw.name.trim() ? raw.name : fallbackName,
+    volume: Number.isFinite(volume) ? Math.max(0, Math.min(1, volume)) : 1,
+    muted: raw?.muted === true
+  };
+}
+function defaultMainTrack() {
+  return { id: newTabId(), name: DEFAULT_MAIN_TRACK_NAME, volume: 1, muted: false };
+}
+function normalizeTracks(data) {
+  if (data.trackMismatch !== true) delete data.trackMismatch;
+  delete data.workspace;
+  const rawTracks = Array.isArray(data.tracks) ? data.tracks : [];
+  if (data.mainTrack != null || rawTracks.length > 0) {
+    data.mainTrack = normalizeTrackMeta(data.mainTrack, DEFAULT_MAIN_TRACK_NAME);
+  }
+  if (rawTracks.length === 0) {
+    delete data.tracks;
+    return;
+  }
+  const measures = data.measures;
+  data.tracks = rawTracks.slice(0, MAX_TRACKS - 1).map((t, i) => {
+    const tuning = Array.isArray(t?.tuning) && t.tuning.length > 0 && t.tuning.every((n) => typeof n === "string") ? [...t.tuning] : [...PRESET_TUNINGS["Guitar (6)"]];
+    const rawMeasures = Array.isArray(t?.measures) ? t.measures : [];
+    if (rawMeasures.length !== measures.length) data.trackMismatch = true;
+    return {
+      ...normalizeTrackMeta(t, `Track ${i + 2}`),
+      tuning,
+      measures: measures.map((m, mi) => fitTrackMeasure(rawMeasures[mi], m, tuning.length))
+    };
+  });
+}
+function fitTrackMeasure(raw, main, stringCount) {
+  const rawSubs = Array.isArray(raw?.subdivisions) ? raw.subdivisions : [];
+  const subdivisions = Array.from({ length: main.beats }, (_, b) => {
+    const v = rawSubs[Math.min(b, rawSubs.length - 1)];
+    return typeof v === "number" && Number.isInteger(v) && v >= 1 && v <= MAX_SUBDIVISION ? v : DEFAULT_SUBDIVISIONS;
+  });
+  const cols = subdivisions.reduce((a, b) => a + b, 0);
+  const rows = Array.isArray(raw?.cells) ? raw.cells : [];
+  const cells = Array.from(
+    { length: stringCount },
+    (_, s) => Array.from({ length: cols }, (_2, c) => rows[s]?.[c] ?? null)
+  );
+  return { subdivisions, cells };
+}
+var MAX_SUBDIVISION = 12;
+var PRESET_TUNING_GROUPS = [
+  {
+    group: "Standard",
+    items: [
+      { name: "Guitar (6)", tuning: ["E4", "B3", "G3", "D3", "A2", "E2"] },
+      { name: "Guitar (7)", tuning: ["E4", "B3", "G3", "D3", "A2", "E2", "B1"] },
+      { name: "Bass (4)", tuning: ["G2", "D2", "A1", "E1"] },
+      { name: "Bass (5)", tuning: ["G2", "D2", "A1", "E1", "B0"] },
+      { name: "Bass (6)", tuning: ["C3", "G2", "D2", "A1", "E1", "B0"] },
+      { name: "Ukulele (4)", tuning: ["A4", "E4", "C4", "G4"] }
+    ]
+  },
+  {
+    group: "Drop",
+    items: [{ name: "Drop D", tuning: ["E4", "B3", "G3", "D3", "A2", "D2"] }]
+  },
+  {
+    group: "Open / Modal",
+    items: [
+      { name: "DADGAD", tuning: ["D4", "A3", "G3", "D3", "A2", "D2"] },
+      { name: "Open G", tuning: ["D4", "B3", "G3", "D3", "G2", "D2"] },
+      { name: "Open D", tuning: ["D4", "A3", "F#3", "D3", "A2", "D2"] },
+      { name: "Open E", tuning: ["E4", "B3", "G#3", "E3", "B2", "E2"] }
+    ]
+  }
+];
+var PRESET_TUNINGS = Object.fromEntries(
+  PRESET_TUNING_GROUPS.flatMap((g) => g.items.map((i) => [i.name, i.tuning]))
+);
 var DEFAULT_BEATS = 4;
 var DEFAULT_BEAT_UNIT = 4;
 var DEFAULT_SUBDIVISIONS = 2;
+var MAX_FRET = 24;
+var MAX_BEATS = 32;
+var BEAT_UNITS = [1, 2, 4, 8, 16, 32];
 function createMeasure(stringCount, beats = DEFAULT_BEATS, subdivisions = DEFAULT_SUBDIVISIONS, beatUnit = DEFAULT_BEAT_UNIT) {
-  const columns = beats * subdivisions;
+  const subs = Array.from(
+    { length: beats },
+    (_, b) => typeof subdivisions === "number" ? subdivisions : subdivisions[Math.min(b, subdivisions.length - 1)] ?? DEFAULT_SUBDIVISIONS
+  );
+  const columns = subs.reduce((a, b) => a + b, 0);
   return {
     beats,
     beatUnit,
-    subdivisions,
-    cells: Array.from(
-      { length: stringCount },
-      () => Array.from({ length: columns }, () => null)
-    ),
-    chords: Array.from({ length: beats }, () => null)
+    subdivisions: subs,
+    cells: Array.from({ length: stringCount }, () => Array.from({ length: columns }, () => null)),
+    chords: Array.from({ length: columns }, () => null)
   };
 }
 function newTabId() {
@@ -91,10 +246,7 @@ function createDocument(tuning = PRESET_TUNINGS["Guitar (6)"], measureCount = 4)
     title: "Untitled",
     artist: "",
     tuning: [...tuning],
-    measures: Array.from(
-      { length: measureCount },
-      () => createMeasure(tuning.length)
-    ),
+    measures: Array.from({ length: measureCount }, () => createMeasure(tuning.length)),
     keys: [{ measure: 0, tonic: "C", mode: "major" }],
     sections: [],
     tempo: DEFAULT_TEMPO,
@@ -109,54 +261,302 @@ function resizeMeasureStrings(measure, stringCount) {
   );
   return { ...measure, cells };
 }
-function setMeasureSubdivisions(measure, subdivisions) {
-  const oldCols = columnCount(measure);
-  const newCols = measure.beats * subdivisions;
+function remapToSubdivisions(measure, subs) {
+  const newCols = subs.reduce((a, b) => a + b, 0);
+  const map = [];
+  let newStart = 0;
+  for (let b = 0; b < measure.subdivisions.length; b++) {
+    const os = measure.subdivisions[b];
+    const ns = subs[b];
+    for (let s = 0; s < os; s++) {
+      map.push(newStart + Math.min(ns - 1, Math.round(s * ns / os)));
+    }
+    newStart += ns;
+  }
   const cells = measure.cells.map((row) => {
     const next = Array.from({ length: newCols }, () => null);
-    for (let c = 0; c < oldCols; c++) {
-      if (row[c] == null) continue;
-      const ni = Math.round(c * subdivisions / measure.subdivisions);
-      if (ni >= 0 && ni < newCols) next[ni] = row[c];
-    }
+    row.forEach((cell, c) => {
+      if (cell != null && map[c] != null) next[map[c]] = cell;
+    });
     return next;
   });
-  return { ...measure, subdivisions, cells };
+  let chords = measure.chords;
+  if (chords) {
+    const next = Array.from({ length: newCols }, () => null);
+    chords.forEach((label, c) => {
+      if (label && map[c] != null) next[map[c]] = label;
+    });
+    chords = next;
+  }
+  return { ...measure, subdivisions: subs, cells, chords };
+}
+function setMeasureSubdivisions(measure, subdivisions) {
+  return remapToSubdivisions(
+    measure,
+    Array.from({ length: measure.beats }, () => subdivisions)
+  );
+}
+function setBeatSubdivision(measure, beat, subdivision) {
+  const subs = [...measure.subdivisions];
+  subs[beat] = subdivision;
+  return remapToSubdivisions(measure, subs);
 }
 
-// eztab.ts
-function normalize(data) {
-  if (!data || !Array.isArray(data.tuning) || !Array.isArray(data.measures)) {
-    throw new Error("Not a valid EZTab document");
+// ../src/lib/tracks.ts
+function newUid() {
+  return newTabId();
+}
+function storedMeasure(m) {
+  const { uid: _uid, ...rest } = m;
+  return rest;
+}
+function openWorkspace(doc) {
+  if (doc.workspace) return doc;
+  const measures = doc.measures.map((m) => ({ ...m, uid: m.uid ?? newUid() }));
+  const extras = doc.tracks ?? [];
+  const metas = [
+    doc.mainTrack ?? defaultMainTrack(),
+    ...extras.map(({ tuning: _t, measures: _m, ...meta }) => meta)
+  ];
+  const parked = [
+    null,
+    ...extras.map(
+      (t) => ({
+        tuning: [...t.tuning],
+        measures: measures.map(
+          (main, i) => trackMeasureToMeasure(
+            main,
+            t.measures[i]?.subdivisions,
+            t.measures[i]?.cells,
+            t.tuning.length
+          )
+        )
+      })
+    )
+  ];
+  const { mainTrack: _mt, tracks: _tr, ...rest } = doc;
+  return { ...rest, measures, workspace: { active: 0, metas, parked } };
+}
+function trackMeasureToMeasure(main, subdivisions, cells, stringCount) {
+  const base = createMeasure(
+    stringCount,
+    main.beats,
+    subdivisions ?? main.subdivisions,
+    main.beatUnit
+  );
+  return {
+    ...base,
+    cells: base.cells.map((row, s) => row.map((_, c) => cells?.[s]?.[c] ?? null)),
+    uid: main.uid
+  };
+}
+function trackBodies(doc) {
+  const ws = doc.workspace;
+  if (!ws) return [{ tuning: doc.tuning, measures: doc.measures }];
+  return ws.parked.map(
+    (b, i) => i === ws.active ? { tuning: doc.tuning, measures: doc.measures } : b
+  );
+}
+function trackMetas(doc) {
+  return doc.workspace?.metas ?? [doc.mainTrack ?? defaultMainTrack()];
+}
+function mainMeasures(doc) {
+  return trackBodies(doc)[0].measures;
+}
+function closeWorkspace(doc) {
+  const ws = doc.workspace;
+  if (!ws) return doc;
+  const bodies = trackBodies(doc);
+  const main = bodies[0];
+  const {
+    workspace: _ws,
+    trackMismatch: _tm,
+    mainTrack: _mt,
+    tracks: _tr,
+    formatRevision,
+    ...rest
+  } = doc;
+  const out = {
+    ...rest,
+    tuning: [...main.tuning],
+    measures: main.measures.map(storedMeasure)
+  };
+  const extras = bodies.slice(1).map(
+    (b, i) => ({
+      ...ws.metas[i + 1],
+      tuning: [...b.tuning],
+      measures: b.measures.map((m) => ({ subdivisions: m.subdivisions, cells: m.cells }))
+    })
+  );
+  const mainMeta = ws.metas[0];
+  const mainIsDefault = mainMeta.name === DEFAULT_MAIN_TRACK_NAME && mainMeta.volume === 1 && !mainMeta.muted;
+  if (extras.length > 0 || !mainIsDefault) out.mainTrack = mainMeta;
+  if (extras.length > 0) {
+    out.tracks = extras;
+    out.formatRevision = Math.max(formatRevision ?? 1, MULTI_TRACK_FORMAT_REVISION);
+  } else if (formatRevision != null && formatRevision > MULTI_TRACK_FORMAT_REVISION) {
+    out.formatRevision = formatRevision;
   }
-  data.measures = data.measures.map((m) => {
-    let beats = m.beats;
-    let subdivisions = m.subdivisions;
-    if (typeof beats !== "number" || typeof subdivisions !== "number") {
-      const cols2 = m.cells?.[0]?.length ?? m.columns ?? 8;
-      subdivisions = cols2 % 4 === 0 ? cols2 / 4 : 2;
-      beats = cols2 % 4 === 0 ? 4 : Math.max(1, Math.round(cols2 / subdivisions));
+  return out;
+}
+function reconcileTracks(prev, next) {
+  let doc = next.workspace ? next : openWorkspace(next);
+  const ws = doc.workspace;
+  const measures = assignUids(prev, doc.measures);
+  if (measures !== doc.measures) doc = { ...doc, measures };
+  let changed = false;
+  const parked = ws.parked.map((body) => {
+    if (!body) return body;
+    const fitted = fitBody(body, measures);
+    if (fitted !== body) changed = true;
+    return fitted;
+  });
+  if (changed) doc = { ...doc, workspace: { ...ws, parked } };
+  return doc;
+}
+function assignUids(prev, measures) {
+  const seen = /* @__PURE__ */ new Set();
+  let out = null;
+  const present = new Set(measures.map((m) => m.uid).filter(Boolean));
+  measures.forEach((m, i) => {
+    let uid = m.uid;
+    if (uid && seen.has(uid)) uid = void 0;
+    if (!uid) {
+      const old = prev?.measures[i]?.uid;
+      uid = old && !present.has(old) && !seen.has(old) ? old : newUid();
+      out ??= [...measures];
+      out[i] = { ...m, uid };
     }
-    const beatUnit = typeof m.beatUnit === "number" ? m.beatUnit : 4;
-    const cols = beats * subdivisions;
-    const cells = (m.cells ?? []).map(
-      (row) => Array.from({ length: cols }, (_, c) => row?.[c] ?? null)
+    seen.add(uid);
+  });
+  return out ?? measures;
+}
+function fitBody(body, measures) {
+  const same = body.measures.length === measures.length && body.measures.every(
+    (m, i) => m.uid === measures[i].uid && m.beats === measures[i].beats && m.beatUnit === measures[i].beatUnit
+  );
+  if (same) return body;
+  const byUid = new Map(body.measures.map((m) => [m.uid, m]));
+  const stringCount = body.tuning.length;
+  const out = [];
+  measures.forEach((m) => {
+    let pm = byUid.get(m.uid);
+    if (!pm) {
+      const before = out[out.length - 1];
+      const subs = before && before.beats === m.beats ? before.subdivisions : void 0;
+      pm = createMeasure(stringCount, m.beats, subs, m.beatUnit);
+    } else if (pm.beats !== m.beats || pm.beatUnit !== m.beatUnit) {
+      pm = setMeasureTimeSignature(pm, m.beats, m.beatUnit);
+    }
+    out.push({ ...pm, uid: m.uid });
+  });
+  return { ...body, measures: out };
+}
+function switchTrack(doc, index) {
+  const ws = doc.workspace;
+  if (!ws || index === ws.active || index < 0 || index >= ws.metas.length) return doc;
+  const parked = [...ws.parked];
+  parked[ws.active] = { tuning: doc.tuning, measures: doc.measures };
+  const body = parked[index];
+  parked[index] = null;
+  return {
+    ...doc,
+    tuning: body.tuning,
+    measures: body.measures,
+    workspace: { ...ws, active: index, parked }
+  };
+}
+function addTrack(doc, name, tuning) {
+  const ws = doc.workspace;
+  if (!ws || ws.metas.length >= MAX_TRACKS) return doc;
+  const main = mainMeasures(doc);
+  const body = {
+    tuning: [...tuning],
+    measures: main.map((m) => ({
+      ...createMeasure(tuning.length, m.beats, m.subdivisions, m.beatUnit),
+      uid: m.uid
+    }))
+  };
+  const meta = { id: newTabId(), name, volume: 1, muted: false };
+  const added = {
+    ...doc,
+    workspace: { ...ws, metas: [...ws.metas, meta], parked: [...ws.parked, body] }
+  };
+  return switchTrack(added, ws.metas.length);
+}
+function removeTrack(doc, index) {
+  const ws = doc.workspace;
+  if (!ws || index <= 0 || index >= ws.metas.length) return doc;
+  const shown = ws.active === index ? switchTrack(doc, 0) : doc;
+  const w = shown.workspace;
+  const metas = w.metas.filter((_, i) => i !== index);
+  const parked = w.parked.filter((_, i) => i !== index);
+  const active = w.active > index ? w.active - 1 : w.active;
+  return { ...shown, workspace: { active, metas, parked } };
+}
+function storedSize(doc) {
+  return new TextEncoder().encode(JSON.stringify(closeWorkspace(doc))).length;
+}
+
+// ../src/lib/config.ts
+var CLOUD_BASE_URL = "https://eztab-sync-736328841982.asia-northeast1.run.app";
+
+// cloud.ts
+var CloudError = class extends Error {
+};
+var BASE_URL = process.env.EZTAB_API_URL ?? CLOUD_BASE_URL;
+function token() {
+  const t = process.env.EZTAB_TOKEN?.trim();
+  if (!t) {
+    throw new CloudError(
+      `EZTAB_TOKEN is not set. Issue an MCP link token in the EZTab app (Settings \u2192 MCP \u9023\u643A), then add it to this MCP server's config: "env": { "EZTAB_TOKEN": "eztab_\u2026" }.`
     );
-    let chords = Array.isArray(m.chords) ? m.chords.slice(0, beats) : [];
-    while (chords.length < beats) chords.push(null);
-    return { beats, beatUnit, subdivisions, cells, chords };
+  }
+  return t;
+}
+async function req(path, init = {}) {
+  const res = await fetch(`${BASE_URL}${path}`, {
+    ...init,
+    headers: { ...init.headers ?? {}, authorization: `Bearer ${token()}` }
   });
-  if (!Array.isArray(data.keys) || data.keys.length === 0) {
-    data.keys = [{ measure: 0, tonic: "C", mode: "major" }];
+  if (res.status === 401) {
+    throw new CloudError(
+      "EZTab rejected the MCP link token (revoked or mistyped). Issue a new one in the app's settings."
+    );
   }
-  if (typeof data.artist !== "string") data.artist = "";
-  if (!Array.isArray(data.sections)) data.sections = [];
-  if (typeof data.tempo !== "number") data.tempo = 120;
-  if (!data.mix || typeof data.mix.melody !== "number") {
-    data.mix = { melody: 1, backing: 0.4 };
+  if (!res.ok) {
+    const body = await res.json().catch(() => null);
+    throw new CloudError(
+      `EZTab request ${path} failed (${res.status})${body?.error ? `: ${body.error}` : ""}`
+    );
   }
-  data.version = 1;
-  return data;
+  return res;
+}
+var cloud = {
+  async list() {
+    const { tabs } = await (await req("/tabs")).json();
+    return tabs;
+  },
+  async get(id) {
+    return (await req(`/tabs/${encodeURIComponent(id)}`)).json();
+  },
+  async sendToInbox(payload) {
+    await req("/inbox", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        // The newest tab format this build edits safely; the server refuses
+        // newer tabs from older builds (docs/design/0001-multiple-tracks.md).
+        "x-eztab-format-revision": String(SUPPORTED_FORMAT_REVISION)
+      },
+      body: JSON.stringify(payload)
+    });
+  }
+};
+
+// eztab.ts
+function normalize(data) {
+  return normalizeDocument(data);
 }
 function cellText(cell) {
   if (cell === null) return "--";
@@ -170,233 +570,208 @@ function cellText(cell) {
   }
   return String(cell).padStart(2, "-");
 }
-function render(doc) {
+function render(doc, from = 0, to = doc.measures.length - 1, track) {
+  const bodies = trackBodies(doc);
+  const metas = trackMetas(doc);
+  const multi = bodies.length > 1;
+  const main = bodies[0];
+  const shown = bodies.map((_, i) => i).filter((i) => track == null || i === track);
   const lines = [];
-  lines.push(
-    `Title: ${doc.title}${doc.artist ? ` \u2014 ${doc.artist}` : ""}   tempo=${doc.tempo}`
-  );
-  lines.push(
-    `Tuning (top\u2192bottom): ${doc.tuning.join(" ")}   measures=${doc.measures.length}`
-  );
+  lines.push(`Title: ${doc.title}${doc.artist ? ` \u2014 ${doc.artist}` : ""}   tempo=${doc.tempo}`);
+  if (multi) {
+    lines.push(`Tracks (track index: name, tuning top\u2192bottom)   measures=${main.measures.length}`);
+    metas.forEach((t, i) => {
+      lines.push(
+        `  ${i}: ${t.name}  ${bodies[i].tuning.join(" ")}${i === 0 ? "  (main: carries the chords)" : ""}`
+      );
+    });
+  } else {
+    lines.push(`Tuning (top\u2192bottom): ${main.tuning.join(" ")}   measures=${main.measures.length}`);
+  }
   const ann = [];
-  doc.measures.forEach((_, m) => {
+  main.measures.forEach((_, m) => {
     const k = doc.keys.find((x) => x.measure === m);
     const s = doc.sections.find((x) => x.measure === m);
-    if (k) ann.push(`m${m + 1}:key=${k.tonic} ${k.mode}`);
-    if (s && s.label) ann.push(`m${m + 1}:section="${s.label}"`);
+    if (k) ann.push(`m${m}:key=${k.tonic} ${k.mode}`);
+    if (s && s.label) ann.push(`m${m}:section="${s.label}"`);
   });
   if (ann.length) lines.push(`Markers: ${ann.join(", ")}`);
-  doc.measures.forEach((m, mi) => {
+  main.measures.forEach((m, mi) => {
+    if (mi < from || mi > to) return;
     const key = activeKeyAt(doc.keys, mi);
     lines.push("");
+    if (!multi) {
+      lines.push(
+        `--- measure ${mi} (bar ${mi + 1})  (${m.beats}/${m.beatUnit}, ${subText(m)}, ${columnCount(m)} cols, key ${key.tonic} ${key.mode}) ---`
+      );
+      lines.push(chordLine(m));
+      measureRows(lines, m, main.tuning);
+      return;
+    }
     lines.push(
-      `--- Measure ${mi + 1}  (${m.beats}/${m.beatUnit}, ${m.subdivisions}/beat, ${columnCount(m)} cols, key ${key.tonic} ${key.mode}) ---`
+      `--- measure ${mi} (bar ${mi + 1})  (${m.beats}/${m.beatUnit}, key ${key.tonic} ${key.mode}) ---`
     );
-    const chordRow = (m.chords ?? []).map((c, b) => `b${b + 1}:${c ?? "-"}`).join("  ");
-    lines.push(`chords: ${chordRow}`);
-    const ruler = Array.from(
-      { length: columnCount(m) },
-      (_, c) => String(c).padStart(2, " ")
-    ).join(" ");
-    lines.push(`col:   ${ruler}`);
-    m.cells.forEach((row, s) => {
-      const label = (doc.tuning[s] ?? "?").padEnd(3, " ");
-      const cells = row.map(cellText).join(" ");
-      lines.push(`${label}| ${cells}`);
-    });
+    lines.push(`${chordLine(m)}   (columns of track 0)`);
+    for (const t of shown) {
+      const tm = bodies[t].measures[mi];
+      lines.push(`[track ${t}: ${metas[t].name}]  ${subText(tm)}, ${columnCount(tm)} cols`);
+      measureRows(lines, tm, bodies[t].tuning);
+    }
   });
   return lines.join("\n");
 }
-
-// server.ts
-var PORT = Number(process.env.EZTAB_LIVE_PORT ?? 47823);
-var state = {
-  doc: null,
-  version: 0
-};
-var mode = "host";
-var clients = /* @__PURE__ */ new Set();
-var upstream = null;
-var appView = null;
-var appEditable = null;
-var pending = /* @__PURE__ */ new Map();
-var reqSeq = 0;
-var reqTag = Math.random().toString(36).slice(2, 8);
-function findAppClient() {
-  for (const c of clients) {
-    if (c._isApp && c.readyState === WebSocket.OPEN) return c;
-  }
-  return void 0;
-}
-function requestFromApp(action, params = {}, timeoutMs = 6e3) {
-  const reqId = `${reqTag}-${++reqSeq}`;
-  return new Promise((resolve, reject) => {
-    const out = JSON.stringify({ type: "request", reqId, action, params });
-    if (mode === "host") {
-      const app = findAppClient();
-      if (!app) {
-        reject(
-          new Error(
-            "No EZTab app is connected. Ask the user to open the app and enable Live (toolbar)."
-          )
-        );
-        return;
-      }
-      const timer = setTimeout(() => {
-        pending.delete(reqId);
-        reject(new Error("The EZTab app didn't respond in time."));
-      }, timeoutMs);
-      pending.set(reqId, { resolve, reject, timer });
-      app.send(out);
-    } else if (upstream && upstream.readyState === WebSocket.OPEN) {
-      const timer = setTimeout(() => {
-        pending.delete(reqId);
-        reject(new Error("The EZTab app didn't respond in time."));
-      }, timeoutMs);
-      pending.set(reqId, { resolve, reject, timer });
-      upstream.send(out);
-    } else {
-      reject(new Error("Not connected to the hub."));
-    }
+function subText(m) {
+  const sub = uniformSubdivision(m);
+  return sub != null ? `${sub}/beat` : `[${m.subdivisions.join(",")}]/beat`;
+}
+function chordLine(m) {
+  const row = (m.chords ?? []).map((label, c) => label ? `c${c}:${chordDisplay(label)}` : null).filter(Boolean).join("  ");
+  return `chords: ${row || "(none)"}`;
+}
+function measureRows(lines, m, tuning) {
+  const ruler = Array.from({ length: columnCount(m) }, (_, c) => String(c).padStart(2, " ")).join(
+    " "
+  );
+  lines.push(`col:    ${ruler}`);
+  m.cells.forEach((row, s) => {
+    const label = `${s + 1} ${tuning[s] ?? "?"}`.padEnd(6, " ");
+    lines.push(`${label}| ${row.map(cellText).join(" ")}`);
   });
+  const pm = Array.from(
+    { length: columnCount(m) },
+    (_, c) => m.cells.some((row) => cellPalmMute(row[c] ?? null)) ? "PM" : "  "
+  );
+  if (pm.some((x) => x !== "  ")) lines.push(`pm:     ${pm.join(" ")}`);
 }
-function settleResponse(reqId, data) {
-  const p = pending.get(reqId);
-  if (p) {
-    clearTimeout(p.timer);
-    pending.delete(reqId);
-    p.resolve(data);
+
+// notation.ts
+var BEAT_UNITS2 = [2, 4, 8, 16];
+var BENDS = { b: 0.5, B: 1, "^": 1.5 };
+function parseTime(text2) {
+  const m = /^\s*(\d+)\s*\/\s*(\d+)\s*$/.exec(text2);
+  const beats = m ? Number(m[1]) : NaN;
+  const beatUnit = m ? Number(m[2]) : NaN;
+  if (!(beats >= 1 && beats <= 32) || !BEAT_UNITS2.includes(beatUnit)) {
+    throw new Error(`bad time signature "${text2}" (e.g. "4/4", "6/8")`);
   }
+  return { beats, beatUnit };
 }
-function pushState() {
-  if (mode === "host") {
-    const msg = JSON.stringify({
-      type: "state",
-      doc: state.doc,
-      version: state.version
-    });
-    for (const c of clients) {
-      if (c.readyState === WebSocket.OPEN) c.send(msg);
-    }
-  } else if (upstream && upstream.readyState === WebSocket.OPEN) {
-    upstream.send(JSON.stringify({ type: "set", doc: state.doc }));
-  }
+function parseValue(raw, where) {
+  if (raw === "x") return "mute";
+  if (raw === "r") return "rest";
+  const m = /^(~?)(\d+)([bB^p]*)$/.exec(raw);
+  if (!m) throw new Error(`${where}: bad value "${raw}"`);
+  const fret = Number(m[2]);
+  if (fret > MAX_FRET) throw new Error(`${where}: fret ${fret} is above ${MAX_FRET}`);
+  const mods = m[3];
+  const bendMarks = [...mods].filter((c) => c in BENDS);
+  if (bendMarks.length > 1) throw new Error(`${where}: more than one choke mark in "${raw}"`);
+  const note = { fret };
+  if (bendMarks.length) note.bend = BENDS[bendMarks[0]];
+  if (m[1]) note.tie = true;
+  if (mods.includes("p")) note.pm = true;
+  return Object.keys(note).length === 1 ? fret : note;
 }
-function broadcastExcept(except) {
-  const msg = JSON.stringify({
-    type: "state",
-    doc: state.doc,
-    version: state.version
-  });
-  for (const c of clients) {
-    if (c !== except && c.readyState === WebSocket.OPEN) c.send(msg);
+function parseBeat(text2, stringCount, where) {
+  const slots = text2.trim().split(/\s+/);
+  if (slots.length === 1 && slots[0] === "") {
+    throw new Error(`${where}: empty beat (write "-" for a beat with nothing on it)`);
   }
-}
-var wss = new WebSocketServer({ port: PORT });
-wss.on("connection", (ws) => {
-  clients.add(ws);
-  ws.send(
-    JSON.stringify({ type: "state", doc: state.doc, version: state.version })
-  );
-  ws.on("message", (data) => {
-    let msg;
-    try {
-      msg = JSON.parse(data.toString());
-    } catch {
-      return;
-    }
-    if (msg.type === "set" && msg.doc) {
-      state.doc = normalize(msg.doc);
-      state.version += 1;
-      broadcastExcept(ws);
-    } else if (msg.type === "seed" && msg.doc) {
-      if (!state.doc) {
-        state.doc = normalize(msg.doc);
-        state.version += 1;
-        broadcastExcept(ws);
-      }
-    } else if (msg.type === "get") {
-      ws.send(
-        JSON.stringify({
-          type: "state",
-          doc: state.doc,
-          version: state.version
-        })
-      );
-    } else if (msg.type === "appstate") {
-      appView = msg.view === "editor" || msg.view === "library" ? msg.view : null;
-      appEditable = typeof msg.editable === "boolean" ? msg.editable : null;
-      ws._isApp = true;
-      const out = JSON.stringify({ type: "appstate", view: appView, editable: appEditable });
-      for (const c of clients) {
-        if (c !== ws && c.readyState === WebSocket.OPEN) c.send(out);
+  if (slots.length > MAX_SUBDIVISION) {
+    throw new Error(`${where}: ${slots.length} slots exceeds the max of ${MAX_SUBDIVISION}`);
+  }
+  return slots.map((slot, i) => {
+    const at = `${where} slot ${i + 1}`;
+    const cells = /* @__PURE__ */ new Map();
+    let chord = null;
+    if (slot === "-") return { cells, chord };
+    for (const item of slot.split("+")) {
+      if (item.startsWith("@")) {
+        const parsed = parseChordInput(item.slice(1));
+        if (!parsed) throw new Error(`${at}: bad chord "${item}"`);
+        chord = parsed;
+        continue;
       }
-    } else if (msg.type === "request" && msg.reqId) {
-      const app = findAppClient();
-      if (app) app.send(JSON.stringify(msg));
-    } else if (msg.type === "response" && msg.reqId) {
-      settleResponse(msg.reqId, msg.data);
-      const out = JSON.stringify(msg);
-      for (const c of clients) {
-        if (c !== ws && c.readyState === WebSocket.OPEN) c.send(out);
+      const m = /^(\d+):(.+)$/.exec(item);
+      if (!m) throw new Error(`${at}: bad item "${item}" (expected string:value or @Chord)`);
+      const string = Number(m[1]);
+      if (string < 1 || string > stringCount) {
+        throw new Error(`${at}: string ${string} out of range (1..${stringCount})`);
       }
+      if (cells.has(string - 1)) throw new Error(`${at}: string ${string} written twice`);
+      cells.set(string - 1, parseValue(m[2], at));
     }
+    return { cells, chord };
   });
-  const onGone = () => {
-    clients.delete(ws);
-    if (ws._isApp) {
-      appView = null;
-      appEditable = null;
-      const out = JSON.stringify({ type: "appstate", view: null, editable: null });
-      for (const c of clients) {
-        if (c.readyState === WebSocket.OPEN) c.send(out);
-      }
+}
+function buildMeasure(spec, stringCount, fallback, where = "measure") {
+  const time = spec.time ? parseTime(spec.time) : fallback;
+  if (spec.beats.length !== time.beats) {
+    throw new Error(
+      `${where}: ${spec.beats.length} beats given but the time signature ${time.beats}/${time.beatUnit} has ${time.beats}`
+    );
+  }
+  const beats = spec.beats.map((b, i) => parseBeat(b, stringCount, `${where} beat ${i + 1}`));
+  const measure = createMeasure(
+    stringCount,
+    time.beats,
+    beats.map((slots) => slots.length),
+    time.beatUnit
+  );
+  const chords = measure.chords;
+  let col = 0;
+  for (const slots of beats) {
+    for (const slot of slots) {
+      for (const [s, cell] of slot.cells) measure.cells[s][col] = cell;
+      if (slot.chord) chords[col] = slot.chord;
+      col++;
     }
-  };
-  ws.on("close", onGone);
-  ws.on("error", onGone);
-});
-wss.on("error", (e) => {
-  if (e.code === "EADDRINUSE") {
-    enterClientMode();
-  } else {
-    console.error("hub error:", e);
-  }
-});
-function enterClientMode() {
-  mode = "client";
-  console.error(`port ${PORT} in use; proxying to existing hub as a client`);
-  const connect = () => {
-    const ws = new WebSocket(`ws://127.0.0.1:${PORT}`);
-    upstream = ws;
-    ws.on("open", () => ws.send(JSON.stringify({ type: "get" })));
-    ws.on("message", (data) => {
-      try {
-        const msg = JSON.parse(data.toString());
-        if (msg.type === "state" && msg.doc) {
-          state.doc = normalize(msg.doc);
-          state.version = msg.version;
-        } else if (msg.type === "appstate") {
-          appView = msg.view === "editor" || msg.view === "library" ? msg.view : null;
-          appEditable = typeof msg.editable === "boolean" ? msg.editable : null;
-        } else if (msg.type === "response" && msg.reqId) {
-          settleResponse(msg.reqId, msg.data);
-        }
-      } catch {
-      }
-    });
-    ws.on("close", () => {
-      upstream = null;
-      setTimeout(connect, 2e3);
-    });
-    ws.on("error", () => ws.close());
-  };
-  connect();
+  }
+  return measure;
 }
+
+// prompts.ts
+var IMPORT_TAB_FROM_IMAGE = `Transcribe the TAB in the attached image(s) into an EZTab document with the eztab tools.
+
+## 1. Survey before writing
+- Identify which staff to take. A band score has several parts (Vocal, Guitar I/II, Keyboard, Bass, Drums). If a part was not named and more than one has TAB, list the parts you see and ask which one \u2014 do not guess.
+- From the image work out: instrument and string count (6 lines = guitar, 4 = bass), tuning if printed (assume standard otherwise), time signature, key signature, tempo mark, and how many bars you will transcribe. Printed bar numbers (e.g. 35, 36 \u2026) are just labels \u2014 the document starts at measure 0.
+- Start with new_tab (preset "Guitar (6)" / "Bass (4)" / \u2026, measures: 1, title if known). If the user is adding to a document already open in this session, append to it instead.
+- To transcribe several parts into one tab (e.g. guitar + bass), write the first part on track 0, then add_track for each further part and pass its \`track\` index to write_measures. Measures and time signatures are shared by all tracks; chords (@Name) go on track 0 only.
+- Set the key with set_key when there is a key signature (1 flat \u2192 F major, or D minor if the harmony says so), and the tempo with set_tempo when one is printed.
+
+## 2. Write bar by bar with write_measures
+Read each bar's rhythm first (beams, flags, dots, tuplet brackets, rests), then the fret numbers, then write it. Send a few bars per call, in order. In a fresh document the first bar goes to measure 0 (replacing the empty measure new_tab made); after that append at the current measure count.
+- Subdivision per beat = the fewest slots that put every onset of the beat on a slot: quarter \u2192 1, eighths \u2192 2, 16ths or dotted-8th + 16th \u2192 4, triplet \u2192 3. Only onsets are stored; a held note is just empty slots ("-") after it.
+- Use the TAB numbers for frets, and the staff notation (when present) to settle rhythm and ambiguous digits. String 1 is the TOP line of the TAB.
+- Chord names printed above the staff go on the chord row with @Name at the slot where the chord changes (usually beat 1).
+- Rests: write S:r on the string that was ringing only when the line clearly stops (a rest symbol); otherwise leave "-".
+
+## 3. Map notation EZTab cannot store exactly
+- Hammer-on (H), pull-off (P), slide into a note (S, gliss line from a fretted note): mark the destination note tied, S:~F.
+- A tie arc to the same fret, or a parenthesised fret "(6)" that continues a note: S:~F with the same fret.
+- Choke / bend (C, Cho., "full", "1/2", up arrow): S:FB for full, S:Fb for \xBD, S:F^ for 1\xBD. A release / down choke: write the returning note tied.
+- Bridge mute (M, P.M. bracket in Japanese band scores = \u30DF\u30E5\u30FC\u30C8): add p to every note under the bracket.
+- Dead notes / brushing (x): S:x.
+- Natural/artificial harmonics (o, Harm., <7>): plain fret. Vibrato, slide-in from nowhere (/6), slide-out, arpeggio wavy line, grace notes: write the main note only.
+- Chord diagrams / chord-form boxes drawn inside the TAB staff (no fret numbers): write the chord name on the chord row. Write the voicing as notes only if the user asks or the diagram is unambiguous.
+- Repeats, D.S., Coda, 1st/2nd endings: transcribe the bars as printed and tell the user; do not expand them unless asked.
+
+## 4. Check, then report
+- After writing, call get_tab with from/to for the bars you wrote and compare them bar by bar against the image: beat count, slot positions, string lines and fret numbers. Fix anything off with write_measures (rewrite the bar).
+- Then call send_to_eztab with a label naming the part and bars (e.g. "Guitar II, bars 35\u201343"); the user applies it in the app. If it fails because no token is configured, tell the user how to set it up (the error says how) \u2014 the document stays in this session.
+- Finish with a short report: what was transcribed (part, bars), the notation you had to simplify (from section 3), and any digits or rhythms you were unsure of, by measure index.`;
+
+// server.ts
+var state = {
+  doc: null,
+  version: 0,
+  source: null
+};
 var server = new McpServer(
-  { name: "eztab", version: "0.2.0" },
+  { name: "eztab", version: "0.3.0" },
   {
-    instructions: "All indices are 0-based: measure 0 is the first measure, beat 0 is the first beat of a measure, string 0 is the top (highest) string, and column 0 is the first column. add_measures `at` is a 0-based insert position too. No need to ask the user about indexing."
+    instructions: "All indices are 0-based: measure 0 is the first measure, string 0 is the top (highest) string, and column 0 is the first column. Notes and chords share the same column grid. Subdivisions are per beat and can differ within a measure (e.g. [2,2,3,2] mixes a triplet beat into straight eighths), so columns per measure = the sum of its per-beat subdivisions; get_tab's ruler shows the column indices. add_measures `at` is a 0-based insert position too. No need to ask the user about indexing. Exception: write_measures uses guitar string numbers (1 = top line), matching the labels get_tab prints. To write whole measures (e.g. transcribing a score or an image), prefer write_measures over set_cells \u2014 it takes one string per beat and does the column arithmetic for you. For transcribing from an image, follow the import_tab_from_image prompt. To deliver a result to the EZTab app, call send_to_eztab; to fix an existing tab, list_tabs \u2192 open_tab \u2192 edit \u2192 send_to_eztab. A tab can hold up to 4 tracks (parts, e.g. guitar + bass); track 0 is the main track. Tools that edit notes take an optional 0-based `track` (default 0). Measures and time signatures are shared by all tracks (adding/removing a measure affects every track); subdivisions are per track; chords belong to track 0 and use its columns."
   }
 );
 function text(s) {
@@ -404,44 +779,48 @@ function text(s) {
 }
 function requireDoc() {
   if (!state.doc) {
-    throw new Error(
-      "No document is open. Open the EZTab app (it will connect and share its tab), or call new_tab first."
-    );
+    throw new Error("No document is open. Call new_tab first.");
   }
   return state.doc;
 }
-function assertEditable() {
-  if (appView === "library") {
-    throw new Error(
-      "The EZTab app is on the library screen \u2014 no tab is open to edit. Ask the user to open a tab in the app and switch it to Edit mode, then retry."
-    );
+function onTrack(doc, track = 0) {
+  const n = trackMetas(doc).length;
+  if (!Number.isInteger(track) || track < 0 || track >= n) {
+    throw new Error(`track ${track} out of range (0..${n - 1}); get_tab lists the tracks`);
   }
-  if (appEditable === false) {
+  return switchTrack(doc, track);
+}
+function edit(track, mutate) {
+  const current = requireDoc();
+  if ((current.formatRevision ?? 1) > SUPPORTED_FORMAT_REVISION) {
     throw new Error(
-      "The open tab is in View mode, so it can't be changed. Ask the user to switch the tab to Edit mode in the app, then retry. (Reading is always allowed.)"
+      "This tab was saved by a newer EZTab and can only be read here. Update the EZTab MCP server (npx -y @hidechae/eztab-mcp@latest)."
     );
   }
-}
-function applyEdit(mutate) {
-  assertEditable();
-  const doc = requireDoc();
+  const before = onTrack(current, track);
+  const doc = structuredClone(before);
   mutate(doc);
+  state.doc = reconcileTracks(before, doc);
   state.version += 1;
-  pushState();
-  const connected = mode === "host" ? clients.size > 0 : upstream != null;
-  return text(
-    `${connected ? "Pushed to app. " : "No app connected (will sync when it opens). "}
-
-${render(doc)}`
-  );
+  return state.doc;
+}
+function applyEdit(mutate, track) {
+  return text(render(edit(track, mutate)));
+}
+function applyEditRange(mutate, track) {
+  let range = [0, 0];
+  const doc = edit(track, (d) => {
+    range = mutate(d);
+  });
+  return text(render(doc, range[0], range[1], track));
 }
 function setDoc(doc) {
-  assertEditable();
-  state.doc = doc;
+  state.doc = openWorkspace(doc);
   state.version += 1;
-  pushState();
-  return text(render(doc));
+  return text(render(state.doc));
 }
+var MISMATCH_NOTE = "Warning: this tab's extra tracks may be shifted against the main track \u2014 an older EZTab app added or removed measures without them. Check that the tracks line up (get_tab) and ask the user before sending it back.";
+var trackParam = z.number().int().min(0).optional().describe("0-based track (part) index from get_tab; default 0, the main track.");
 function assertMeasure(doc, m) {
   if (!Number.isInteger(m) || m < 0 || m >= doc.measures.length) {
     throw new Error(`measure ${m} out of range (0..${doc.measures.length - 1})`);
@@ -449,67 +828,23 @@ function assertMeasure(doc, m) {
 }
 server.tool(
   "get_tab",
-  "Return a readable rendering of the tab the EZTab app currently has open. If the app isn't connected, or is on the library screen (no tab open), this says so instead \u2014 relay that to the user (ask them to open the app / open a tab) rather than guessing.",
-  {},
-  async () => {
-    if (appView === "library") {
-      return text(
-        "The EZTab app is open on the library screen \u2014 no tab is selected, so there's nothing to show. Ask the user to open a tab in the app."
-      );
-    }
-    if (appView === "editor" && state.doc) {
-      return text(render(state.doc));
-    }
-    if (state.doc) {
-      return text(render(state.doc));
-    }
-    return text(
-      "No tab is open. Ask the user to open the EZTab app and open a tab (it will be shared here automatically), or call new_tab to start a fresh one."
-    );
-  }
-);
-server.tool(
-  "list_tabs",
-  "List the tabs in the user's EZTab library (id, title, artist, measures, tempo). Read-only. Requires the app to be open with Live enabled.",
-  {},
-  async () => {
-    try {
-      const tabs = await requestFromApp("list_tabs");
-      return text(JSON.stringify(tabs, null, 2));
-    } catch (e) {
-      return text(String(e?.message ?? e));
-    }
-  }
-);
-server.tool(
-  "list_playlists",
-  "List the user's playlists (id, name, song count). Read-only. Requires the app to be open with Live enabled.",
-  {},
-  async () => {
-    try {
-      const pls = await requestFromApp("list_playlists");
-      return text(JSON.stringify(pls, null, 2));
-    } catch (e) {
-      return text(String(e?.message ?? e));
-    }
-  }
-);
-server.tool(
-  "get_playlist",
-  "Show a playlist's songs in order (resolved to titles). Provide its `id` or `name` (use list_playlists first). Read-only. Requires the app open with Live enabled.",
-  { id: z.string().optional(), name: z.string().optional() },
+  "Return a readable rendering of the document currently under edit in this session. `from`/`to` (0-based, inclusive) limit it to a range of measures. If nothing has been created yet, say so and offer new_tab.",
+  {
+    from: z.number().int().min(0).optional(),
+    to: z.number().int().min(0).optional(),
+    track: trackParam.describe("Show only this track (default: all tracks).")
+  },
   async (a) => {
-    try {
-      const pl = await requestFromApp("get_playlist", { id: a.id, name: a.name });
-      return text(JSON.stringify(pl, null, 2));
-    } catch (e) {
-      return text(String(e?.message ?? e));
+    if (state.doc) {
+      if (a.track != null) onTrack(state.doc, a.track);
+      return text(render(state.doc, a.from, a.to, a.track));
     }
+    return text("No document is open in this session. Call new_tab to start one.");
   }
 );
 server.tool(
   "new_tab",
-  "Replace the live document with a fresh one and push it to the app. Tuning is top (highest) to bottom (lowest).",
+  "Start a fresh document, replacing any current one. Tuning is top (highest) to bottom (lowest).",
   {
     title: z.string().optional(),
     artist: z.string().optional(),
@@ -524,9 +859,98 @@ server.tool(
     if (a.title) doc.title = a.title;
     if (a.artist) doc.artist = a.artist;
     if (a.tempo) doc.tempo = a.tempo;
+    state.source = null;
     return setDoc(doc);
   }
 );
+function formatTime(ms) {
+  return ms ? new Date(ms).toLocaleString("ja-JP", { timeZone: "Asia/Tokyo" }) : "?";
+}
+async function withCloud(fn) {
+  try {
+    return await fn();
+  } catch (e) {
+    if (e instanceof CloudError) throw new Error(e.message);
+    throw e;
+  }
+}
+server.tool(
+  "list_tabs",
+  "List the tabs in the user's EZTab library (id, title, artist, measures, last update). Tabs open for editing in the app are marked with the device. Use the id with open_tab.",
+  { query: z.string().optional().describe("Filter by title/artist (case-insensitive).") },
+  async (a) => withCloud(async () => {
+    const q = a.query?.toLowerCase() ?? "";
+    const tabs = (await cloud.list()).filter((t) => !q || `${t.title} ${t.artist}`.toLowerCase().includes(q)).sort((x, y) => y.updatedAt - x.updatedAt);
+    if (!tabs.length) return text(q ? `No tabs match "${a.query}".` : "The library is empty.");
+    return text(
+      tabs.map(
+        (t) => `${t.id}  ${t.title || "(untitled)"}${t.artist ? ` \u2014 ${t.artist}` : ""}  [${t.measures} measures, updated ${formatTime(t.updatedAt)}]` + (t.lock ? `  \u2190 editing on ${t.lock.deviceName || "another device"}` : "")
+      ).join("\n")
+    );
+  })
+);
+server.tool(
+  "open_tab",
+  "Load a tab from the user's EZTab library into this session (replacing the current document) so it can be read and edited with the other tools. send_to_eztab then delivers it back to the app as a revision of that tab.",
+  { id: z.string().describe("Tab id from list_tabs.") },
+  async (a) => withCloud(async () => {
+    const meta = (await cloud.list()).find((t) => t.id === a.id);
+    if (!meta) throw new Error(`No tab with id ${a.id}. Use list_tabs to find it.`);
+    const doc = normalize(await cloud.get(a.id));
+    state.source = { tabId: a.id, title: meta.title, baseUpdatedAt: meta.updatedAt };
+    const shown = setDoc(doc);
+    if (doc.trackMismatch) {
+      shown.content.unshift({ type: "text", text: MISMATCH_NOTE });
+    }
+    if ((doc.formatRevision ?? 1) > SUPPORTED_FORMAT_REVISION) {
+      shown.content.unshift({
+        type: "text",
+        text: "Note: this tab was saved by a newer EZTab; it can be read but not edited here. Update the EZTab MCP server to edit it."
+      });
+    }
+    return shown;
+  })
+);
+server.tool(
+  "send_to_eztab",
+  "Send the current document to the EZTab app's inbox. The user then chooses in the app what to do with it \u2014 insert its measures at the cursor, create a new tab, or (for a document opened with open_tab) replace that tab \u2014 and it stays unsaved until they press Save. Call this once the document has been checked with get_tab.",
+  {
+    label: z.string().optional().describe("Short description shown in the app, e.g. 'Guitar II, bars 1\u20138'."),
+    tracks_checked: z.boolean().optional().describe(
+      "Set to true after checking with the user that the extra tracks line up, when open_tab warned that they may be shifted."
+    ),
+    as_new: z.boolean().optional().describe(
+      "For a document opened with open_tab: send it as new material instead of a revision of that tab."
+    )
+  },
+  async (a) => withCloud(async () => {
+    if (requireDoc().trackMismatch && !a.tracks_checked) {
+      throw new Error(
+        `${MISMATCH_NOTE} Not sent: confirm the alignment, then call send_to_eztab again with tracks_checked: true.`
+      );
+    }
+    const doc = closeWorkspace(requireDoc());
+    if ((doc.formatRevision ?? 1) > SUPPORTED_FORMAT_REVISION) {
+      throw new Error(
+        "This tab was saved by a newer EZTab; update the EZTab MCP server before sending it."
+      );
+    }
+    if (storedSize(doc) > 4.5 * 1024 * 1024) {
+      throw new Error(
+        "The tab is too large to send (over 4.5 MB). Remove measures or tracks, or send part of it as new material."
+      );
+    }
+    const target = state.source && !a.as_new ? state.source : null;
+    await cloud.sendToInbox({
+      doc,
+      label: a.label ?? "",
+      target: target ? { tabId: target.tabId, baseUpdatedAt: target.baseUpdatedAt } : null
+    });
+    return text(
+      target ? `Sent to the EZTab inbox as a revision of "${target.title}". The user applies it in the app and saves.` : `Sent ${doc.measures.length} measure(s) to the EZTab inbox. The user can insert them at the cursor or open them as a new tab.`
+    );
+  })
+);
 server.tool(
   "set_title",
   "Set the document title.",
@@ -545,30 +969,27 @@ server.tool(
 );
 server.tool(
   "set_cells",
-  "Set tab cells. value: a fret number (0-24), 'rest' (stops a sustaining note), 'mute' (a muted/dead 'x' stroke for cutting), or 'clear' (empty = previous note sustains through). Optional `bend` (0.5, 1, or 1.5 semitones) chokes a fret-number note. Optional `tie` (boolean) ties/slurs a fret-number note to the previous note on the same string \u2014 a matching pitch just sustains (no re-pick), a different pitch is a slur. measure/string/column are all 0-based (measure 0 = the first measure, string 0 = the top line).",
+  "Set tab cells. value: a fret number (0-24), 'rest' (stops a sustaining note), 'mute' (a muted/dead 'x' stroke for cutting), or 'clear' (empty = previous note sustains through). Optional `bend` (0.5, 1, or 1.5 semitones) chokes a fret-number note. Optional `tie` (boolean) ties/slurs a fret-number note to the previous note on the same string \u2014 a matching pitch just sustains (no re-pick), a different pitch is a slur. Optional `pm` (boolean) palm-mutes (bridge-mutes) a fret-number note. measure/string/column are all 0-based (measure 0 = the first measure, string 0 = the top line).",
   {
     edits: z.array(
       z.object({
         measure: z.number().int(),
         string: z.number().int(),
         column: z.number().int(),
-        value: z.union([
-          z.number().int().min(0).max(24),
-          z.enum(["rest", "mute", "clear"])
-        ]),
+        value: z.union([z.number().int().min(0).max(24), z.enum(["rest", "mute", "clear"])]),
         bend: z.union([z.literal(0.5), z.literal(1), z.literal(1.5)]).optional(),
-        tie: z.boolean().optional()
+        tie: z.boolean().optional(),
+        pm: z.boolean().optional()
       })
-    )
+    ),
+    track: trackParam
   },
   async (a) => applyEdit((doc) => {
     for (const e of a.edits) {
       assertMeasure(doc, e.measure);
       const m = doc.measures[e.measure];
       if (e.string < 0 || e.string >= doc.tuning.length) {
-        throw new Error(
-          `string ${e.string} out of range (0..${doc.tuning.length - 1})`
-        );
+        throw new Error(`string ${e.string} out of range (0..${doc.tuning.length - 1})`);
       }
       const cols = columnCount(m);
       if (e.column < 0 || e.column >= cols) {
@@ -577,25 +998,80 @@ server.tool(
         );
       }
       let value = e.value === "clear" ? null : e.value;
-      if (typeof e.value === "number" && (e.bend != null || e.tie)) {
+      if (typeof e.value === "number" && (e.bend != null || e.tie || e.pm)) {
         value = {
           fret: e.value,
           ...e.bend != null ? { bend: e.bend } : {},
-          ...e.tie ? { tie: true } : {}
+          ...e.tie ? { tie: true } : {},
+          ...e.pm ? { pm: true } : {}
         };
       }
       m.cells[e.string][e.column] = value;
     }
-  })
+  }, a.track)
+);
+server.tool(
+  "write_measures",
+  'Write whole measures, one text string per beat \u2014 the easiest way to transcribe a score. Each listed measure is replaced entirely (notes, chords, per-beat subdivisions). `measure` is the 0-based index; using the current measure count appends, so a transcription can be written in order without add_measures. `time` (e.g. "4/4", "6/8") is optional: it defaults to the measure being replaced, or the previous measure when appending. `beats` has exactly one string per beat of the time signature.\n\nA beat string is space-separated slots; the slot count is that beat\'s subdivision (1 = quarter, 2 = eighths, 3 = eighth triplet, 4 = sixteenths, 6 = sixteenth triplet \u2026). Pick the smallest count that puts every onset of the beat on a slot (a dotted eighth + sixteenth = 4 slots: note - - note). A slot is "-" (nothing starts there; the previous note rings on) or items joined by "+":\n  S:F    string S (1 = top line of the TAB, as printed) at fret F\n  S:~F   tied / slurred from the previous note on that string (hammer-on, pull-off, slide into F, or a tie when F is the same fret)\n  S:Fb / S:FB / S:F^   choke (bend) \xBD / 1 / 1\xBD steps\n  S:Fp   palm (bridge) mute; combines, e.g. S:~5p, S:7Bp\n  S:x    muted dead-note stroke (brushing)\n  S:r    rest: stops the note ringing on that string\n  @Name  chord name onset for the chord row (e.g. @Am7, @N.C.)\nExamples: ["6:5 6:7", "5:5 5:7", "4:5 - 4:7", "@F+4:3+3:2+2:1+1:1"].',
+  {
+    measures: z.array(
+      z.object({
+        measure: z.number().int().min(0),
+        time: z.string().optional(),
+        beats: z.array(z.string()).min(1)
+      })
+    ).min(1),
+    track: trackParam.describe(
+      "0-based track (part) to write; default 0. On a track other than 0, chord items (@Name) are rejected (chords belong to track 0) and `time` may not change an existing measure's time signature (it is shared by all tracks \u2014 change it on track 0). Appending adds the measure to every track."
+    )
+  },
+  async (a) => applyEditRange((doc) => {
+    let lo = Infinity;
+    let hi = -1;
+    for (const spec of a.measures) {
+      const i = spec.measure;
+      if (i > doc.measures.length) {
+        throw new Error(
+          `measure ${i} would leave a gap: there are ${doc.measures.length} measures, so append at ${doc.measures.length}`
+        );
+      }
+      const ref = doc.measures[i] ?? doc.measures[i - 1];
+      const fallback = { beats: ref?.beats ?? 4, beatUnit: ref?.beatUnit ?? 4 };
+      const built = buildMeasure(
+        spec,
+        doc.tuning.length,
+        fallback,
+        `measure ${i}`
+      );
+      const existing = doc.measures[i];
+      if (a.track) {
+        if (built.chords?.some((c) => c)) {
+          throw new Error(
+            `measure ${i}: chord items (@Name) can only be written on track 0, which carries the chords`
+          );
+        }
+        if (existing && (existing.beats !== built.beats || existing.beatUnit !== built.beatUnit)) {
+          throw new Error(
+            `measure ${i}: the time signature is shared by all tracks; change it on track 0 (time "${existing.beats}/${existing.beatUnit}" here)`
+          );
+        }
+      }
+      if (!existing) doc.measures.push(built);
+      else doc.measures[i] = built;
+      lo = Math.min(lo, i);
+      hi = Math.max(hi, i);
+    }
+    return [lo, hi];
+  }, a.track)
 );
 server.tool(
   "set_chords",
-  "Set chord labels per beat. `measure` and `beat` are 0-based (measure 0 = the first measure, beat 0 = the first beat). An empty label clears that beat's chord.",
+  'Set chord-name onsets per column of track 0 (chords belong to the main track; the same time grid as its tab cells, so chords can sit on any subdivision). `measure` and `column` are 0-based; column = the sum of earlier beats\' subdivisions + slot-within-beat (see get_tab\'s ruler). A label of "rest" (or "N.C.") places a chord rest that stops the previous chord (rendered as N.C.). An empty label clears that column\'s chord.',
   {
     edits: z.array(
       z.object({
         measure: z.number().int(),
-        beat: z.number().int(),
+        column: z.number().int(),
         label: z.string()
       })
     )
@@ -604,13 +1080,15 @@ server.tool(
     for (const e of a.edits) {
       assertMeasure(doc, e.measure);
       const m = doc.measures[e.measure];
-      if (e.beat < 0 || e.beat >= m.beats) {
+      const cols = columnCount(m);
+      if (e.column < 0 || e.column >= cols) {
         throw new Error(
-          `beat ${e.beat} out of range for measure ${e.measure} (0..${m.beats - 1})`
+          `column ${e.column} out of range for measure ${e.measure} (0..${cols - 1})`
         );
       }
-      if (!m.chords) m.chords = Array.from({ length: m.beats }, () => null);
-      m.chords[e.beat] = e.label.trim() || null;
+      if (!m.chords) m.chords = Array.from({ length: cols }, () => null);
+      const label = e.label.trim();
+      m.chords[e.column] = /^(rest|n\.?c\.?)$/i.test(label) ? CHORD_REST : label || null;
     }
   })
 );
@@ -667,7 +1145,7 @@ server.tool(
 );
 server.tool(
   "set_time_signature",
-  "Set a measure's time signature, e.g. beats=6 beatUnit=8 for 6/8. Resizes the measure, preserving cells/chords by index.",
+  "Set a measure's time signature, e.g. beats=6 beatUnit=8 for 6/8. Shared by all tracks: every track's measure is resized, preserving cells/chords by index.",
   {
     measure: z.number().int(),
     beats: z.number().int().min(1).max(32),
@@ -686,19 +1164,33 @@ server.tool(
 );
 server.tool(
   "set_resolution",
-  "Set a measure's subdivisions per beat (1=quarter, 2=eighth, 4=sixteenth, 3=eighth triplet, 6=sixteenth triplet). Existing notes are remapped.",
-  { measure: z.number().int(), subdivisions: z.number().int().min(1).max(12) },
+  "Set subdivisions per beat (1=quarter, 2=eighth, 4=sixteenth, 3=eighth triplet, 6=sixteenth triplet, 5=sixteenth quintuplet, 10=32nd quintuplet). Without `beat`, applies to every beat of the measure; with `beat` (0-based) only that beat changes, so straight and tuplet beats can mix in one measure. Existing notes are remapped.",
+  {
+    measure: z.number().int(),
+    subdivisions: z.number().int().min(1).max(12),
+    beat: z.number().int().min(0).optional(),
+    track: trackParam.describe(
+      "0-based track whose grid to change; default 0. Each track has its own subdivisions."
+    )
+  },
   async (a) => applyEdit((doc) => {
     assertMeasure(doc, a.measure);
-    doc.measures[a.measure] = setMeasureSubdivisions(
-      doc.measures[a.measure],
-      a.subdivisions
-    );
-  })
+    const m = doc.measures[a.measure];
+    if (a.beat != null) {
+      if (a.beat >= m.beats) {
+        throw new Error(
+          `beat ${a.beat} out of range for measure ${a.measure} (0..${m.beats - 1})`
+        );
+      }
+      doc.measures[a.measure] = setBeatSubdivision(m, a.beat, a.subdivisions);
+    } else {
+      doc.measures[a.measure] = setMeasureSubdivisions(m, a.subdivisions);
+    }
+  }, a.track)
 );
 server.tool(
   "add_measures",
-  "Insert `count` empty measures. Without `at`, appends; otherwise inserts before index `at`.",
+  "Insert `count` empty measures into every track. Without `at`, appends; otherwise inserts before index `at`.",
   {
     count: z.number().int().min(1).max(256).optional(),
     at: z.number().int().optional()
@@ -715,7 +1207,7 @@ server.tool(
 );
 server.tool(
   "remove_measure",
-  "Remove the measure at index `measure` (at least one is kept).",
+  "Remove the measure at index `measure` from every track (at least one is kept).",
   { measure: z.number().int() },
   async (a) => applyEdit((doc) => {
     assertMeasure(doc, a.measure);
@@ -728,14 +1220,78 @@ server.tool(
 server.tool(
   "set_tuning",
   "Replace the tuning / string count. Existing frets are preserved where strings overlap. Order is top (highest) to bottom (lowest).",
-  { tuning: z.array(z.string()).min(1) },
+  { tuning: z.array(z.string()).min(1), track: trackParam },
   async (a) => applyEdit((doc) => {
     doc.tuning = [...a.tuning];
-    doc.measures = doc.measures.map(
-      (m) => resizeMeasureStrings(m, a.tuning.length)
-    );
+    doc.measures = doc.measures.map((m) => resizeMeasureStrings(m, a.tuning.length));
+  }, a.track)
+);
+var TRACK_PRESETS = [
+  "Guitar (6)",
+  "Guitar (7)",
+  "Bass (4)",
+  "Bass (5)",
+  "Bass (6)",
+  "Ukulele (4)"
+];
+server.tool(
+  "add_track",
+  "Add a track (part) to the tab, e.g. a bass line or a second guitar \u2014 up to 4 tracks including the main one. It starts empty, on track 0's measures and grid; write it with write_measures / set_cells using the new `track` index.",
+  {
+    name: z.string().min(1).describe("Shown in the app, e.g. 'Bass' or 'Guitar 2'."),
+    preset: z.enum(TRACK_PRESETS).optional(),
+    tuning: z.array(z.string()).min(1).optional().describe("Top (highest) to bottom; overrides preset.")
+  },
+  async (a) => {
+    const before = trackMetas(requireDoc()).length;
+    const tuning = a.tuning ?? PRESET_TUNINGS[a.preset ?? "Bass (4)"];
+    const doc = edit(0, () => {
+    });
+    const next = addTrack(doc, a.name, tuning);
+    if (trackMetas(next).length === before) {
+      throw new Error("a tab can hold at most 4 tracks");
+    }
+    state.doc = next;
+    return text(`Added track ${before} "${a.name}".
+
+${render(next)}`);
+  }
+);
+server.tool(
+  "remove_track",
+  "Remove a track (part) and its notes. Track 0 (the main track) cannot be removed.",
+  { track: z.number().int().min(1) },
+  async (a) => {
+    const doc = edit(0, () => {
+    });
+    onTrack(doc, a.track);
+    state.doc = removeTrack(doc, a.track);
+    return text(render(state.doc));
+  }
+);
+server.prompt(
+  "import_tab_from_image",
+  "Transcribe a TAB score from attached image(s) into an EZTab document.",
+  {
+    part: z.string().optional().describe("Which part to take from a band score, e.g. 'Guitar II' or 'Bass'."),
+    notes: z.string().optional().describe("Anything else to know (tuning, which bars, \u2026).")
+  },
+  (a) => ({
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: IMPORT_TAB_FROM_IMAGE + (a.part ? `
+
+Part to transcribe: ${a.part}` : "") + (a.notes ? `
+
+Notes from the user: ${a.notes}` : "")
+        }
+      }
+    ]
   })
 );
 var transport = new StdioServerTransport();
 await server.connect(transport);
-console.error(`eztab MCP server running (stdio) + live hub on ws://127.0.0.1:${PORT}`);
+console.error("eztab MCP server running (stdio)");