@hidechae/eztab-mcp 0.2.0 → 0.4.0

package/README.md

@@ -47,11 +47,16 @@ npm versions are immutable, so publishing is deliberate (tag-driven):
 
 ```sh
 # bump mcp/package.json "version", commit, then:
-git tag mcp-v0.1.3 && git push --tags
+git tag mcp-vX.Y.Z origin/main && git push origin mcp-vX.Y.Z
 ```
 
-The `Publish MCP to npm` GitHub Action builds and publishes on `mcp-v*` tags
-(needs the `NPM_TOKEN` repo secret).
+The `Publish MCP to npm` GitHub Action builds and publishes on `mcp-v*` tags.
+認証は npm の Trusted Publishing(GitHub Actions の OIDC)で、トークンの Secret は不要。
+npmjs.com のパッケージ設定で `hidechae/eztab` の `publish-mcp.yml` を Trusted Publisher に
+登録してある前提。タグ名と `mcp/package.json` の version が一致しないと公開しない。
+公開に失敗したタグをやり直すときは、失敗した run の re-run ではなく(古いワークフローのまま
+再実行される)、`Publish MCP to npm` を workflow_dispatch し、`tag` にそのタグを指定する
+(`gh workflow run publish-mcp.yml -f tag=mcp-vX.Y.Z`)。指定したタグの中身が公開される。
 
 ## Setup (local dev)
 
@@ -87,7 +92,7 @@ Run standalone for testing: `task mcp` (or `npx tsx mcp/server.ts`).
 | `set_title` | Set the document title |
 | `set_artist` | Set the document artist |
 | `write_measures` | 小節単位の一括入力。1拍を1文字列で書き(`"6:5 6:~7"` など)、列番号への割り付けはサーバ側で行う。譜面・画像からの書き起こし向け |
-| `set_cells` | Set tab cells: a fret number, `rest`, `mute` (cutting "x"), or `clear` (empty = sustain). Optional `bend` (0.5/1/1.5) chokes a fret note; optional `tie` ties/slurs it to the previous note (same pitch = just sustain); optional `pm` palm-mutes it |
+| `set_cells` | Set tab cells: a fret number, `rest`, `mute` (cutting "x"), or `clear` (empty = sustain). Optional `bend` (0.5/1/1.5) chokes a fret note; optional `tie` ties/slurs it to the previous note (same pitch = just sustain); optional `pm` palm-mutes it; optional `harm` (`natural` / `artificial` / `pinch` / `none`) + `harmAt` writes a harmonic |
 | `set_chords` | Set chord labels per column |
 | `set_key` / `remove_key` | Set/add or remove a key (key change) at a measure |
 | `set_section` | Set/remove a section marker (e.g. "Verse", "Chorus") |
@@ -95,7 +100,21 @@ Run standalone for testing: `task mcp` (or `npx tsx mcp/server.ts`).
 | `set_time_signature` | Set a measure's time signature |
 | `set_resolution` | Set a measure's subdivisions per beat (8th/16th/triplets/quintuplets) |
 | `add_measures` / `remove_measure` | Insert/remove measures (keys & sections re-anchored) |
-| `set_tuning` | Replace tuning / string count |
+| `set_tuning` | Replace tuning / string count (`track` で対象パートを指定) |
+| `add_track` / `remove_track` | パート(ベース・2本目のギターなど)の追加・削除。メインを含めて最大4、track 0(メイン)は削除不可 |
+
+### 複数パート(トラック)
+
+1つのタブにメインを含めて最大4パートを持てる(docs/design/0001-multiple-tracks.md)。
+
+- `set_cells` / `write_measures` / `set_resolution` / `set_tuning` は任意の `track`(0 始まり、既定 0 = メイン)を取る
+- 小節と拍子は全パート共通。`add_measures` / `remove_measure` / `set_time_signature` は全パートに作用し、
+  `write_measures` で末尾に書き足すと全パートに小節が増える。分割(subdivisions)はパートごと
+- コードは track 0 のもの(`set_chords` は track 0 の列で指定)。`write_measures(track > 0)` ではコード指定と、
+  既存小節の拍子を変える `time` を拒否する
+- `get_tab` は全パートを小節ごとに並べて表示する(`track` で1パートに絞れる)
+- `send_to_eztab` は `x-eztab-format-revision: 2` を付けて送る。0.2.0 以前の MCP は複数パートのタブを
+  送り返せない(サーバが 409 で拒否する)。新しい形式のタブ(リビジョン 3 以降)は読めるが編集・送信できない
 
 These cover the editor's current model: variable string count, per-beat chords,
 keys with mid-piece changes, section markers, per-measure resolution, time

package/dist/server.js

@@ -7,6 +7,11 @@ import { z } from "zod";
 
 // ../src/types/tab.ts
 var TAB_FILE_VERSION = 1;
+var SUPPORTED_FORMAT_REVISION = 3;
+var MULTI_TRACK_FORMAT_REVISION = 2;
+var HARMONICS_FORMAT_REVISION = 3;
+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) {
@@ -37,9 +42,92 @@ function shiftKeysForDelete(keys, index) {
   }
   return next;
 }
+var HARMONIC_KINDS = ["natural", "artificial", "pinch"];
+var MAX_HARM_AT = 36;
+function checkHarmonic(fret, harm, harmAt) {
+  if (harm == null) {
+    if (harmAt != null) {
+      return { ok: false, field: "harmAt", reason: "a harmonic position needs a harmonic kind" };
+    }
+    return { ok: true, value: { fret } };
+  }
+  if (!HARMONIC_KINDS.includes(harm)) {
+    return { ok: false, field: "harm", reason: `unknown harmonic kind "${String(harm)}"` };
+  }
+  const kind = harm;
+  if (harmAt == null) {
+    if (kind === "natural" && !(fret > 0)) {
+      return { ok: false, field: "harm", reason: "a natural harmonic needs a fret above 0" };
+    }
+    return { ok: true, value: { fret, harm: kind } };
+  }
+  if (typeof harmAt !== "number" || !Number.isFinite(harmAt) || harmAt <= 0 || harmAt > MAX_HARM_AT) {
+    return {
+      ok: false,
+      field: "harmAt",
+      reason: `harmonic position must be a number above 0 and up to ${MAX_HARM_AT}`
+    };
+  }
+  if (Math.abs(harmAt * 10 - Math.round(harmAt * 10)) > 1e-6) {
+    return { ok: false, field: "harmAt", reason: "harmonic position has at most one decimal" };
+  }
+  const at = Math.round(harmAt * 10) / 10;
+  if (kind === "natural") {
+    const touch = Math.round(at);
+    if (touch > MAX_FRET) {
+      return { ok: false, field: "harmAt", reason: `natural harmonic above fret ${MAX_FRET}` };
+    }
+    return {
+      ok: true,
+      value: Number.isInteger(at) ? { fret: touch, harm: kind } : { fret: touch, harm: kind, harmAt: at }
+    };
+  }
+  if (at <= fret) {
+    return {
+      ok: false,
+      field: "harmAt",
+      reason: `the harmonic position (${at}) must be above the fretted note (${fret})`
+    };
+  }
+  return { ok: true, value: { fret, harm: kind, harmAt: at } };
+}
+function normalizeCell(c) {
+  if (typeof c !== "object" || c === null || !("harm" in c || "harmAt" in c)) return c;
+  const { harm, harmAt, ...rest } = c;
+  let r = checkHarmonic(c.fret, harm, harmAt);
+  if (!r.ok && r.field === "harmAt" && harm != null) r = checkHarmonic(c.fret, harm, void 0);
+  const h = r.ok ? r.value : { fret: c.fret };
+  return { ...rest, ...h };
+}
+function measuresHaveHarmonics(measures) {
+  return measures.some((m) => m.cells.some((row) => row.some((c) => cellHarm(c) != null)));
+}
+function cellFret(c) {
+  if (typeof c === "number") return c;
+  if (typeof c === "object" && c !== null) return c.fret;
+  return null;
+}
 function cellPalmMute(c) {
   return typeof c === "object" && c !== null && !!c.pm;
 }
+function cellHarm(c) {
+  return typeof c === "object" && c !== null ? c.harm : void 0;
+}
+function cellHarmAt(c) {
+  return typeof c === "object" && c !== null && c.harm ? c.harmAt : void 0;
+}
+function makeNoteCell(fret, bend, tie, pm, harmonic) {
+  const harm = harmonic?.harm;
+  if (!(bend > 0 || tie || pm || harm)) return fret;
+  return {
+    fret,
+    ...bend > 0 ? { bend } : {},
+    ...tie ? { tie: true } : {},
+    ...pm ? { pm: true } : {},
+    ...harm ? { harm } : {},
+    ...harm && harmonic?.harmAt != null ? { harmAt: harmonic.harmAt } : {}
+  };
+}
 var CHORD_REST = "rest";
 var CHORD_REST_LABEL = "N.C.";
 function chordDisplay(label) {
@@ -111,7 +199,7 @@ function normalizeDocument(data) {
     });
     const cols = subdivisions.reduce((a, b) => a + b, 0);
     const cells = (m.cells ?? []).map(
-      (row) => Array.from({ length: cols }, (_, c) => row?.[c] ?? null)
+      (row) => Array.from({ length: cols }, (_, c) => normalizeCell(row?.[c] ?? null))
     );
     const rawChords = Array.isArray(m.chords) ? m.chords : typeof m.chord === "string" && m.chord ? [m.chord] : [];
     const chords = normalizeChords(rawChords, subdivisions);
@@ -126,9 +214,59 @@ function normalizeDocument(data) {
   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) => normalizeCell(rows[s]?.[c] ?? null))
+  );
+  return { subdivisions, cells };
+}
 var MAX_SUBDIVISION = 12;
 var PRESET_TUNING_GROUPS = [
   {
@@ -248,6 +386,202 @@ function setBeatSubdivision(measure, beat, subdivision) {
   return remapToSubdivisions(measure, subs);
 }
 
+// ../src/lib/tracks.ts
+function newUid() {
+  return newTabId();
+}
+function storedMeasure(m) {
+  const { uid: _uid, beatWidthOverride: _w, ...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;
+  let required = 1;
+  if (extras.length > 0) required = MULTI_TRACK_FORMAT_REVISION;
+  if (bodies.some((b) => measuresHaveHarmonics(b.measures))) required = HARMONICS_FORMAT_REVISION;
+  const revision = formatRevision != null && formatRevision > HARMONICS_FORMAT_REVISION ? formatRevision : required;
+  if (revision > 1) out.formatRevision = revision;
+  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 };
+    }
+    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";
 
@@ -293,69 +627,17 @@ var cloud = {
   async sendToInbox(payload) {
     await req("/inbox", {
       method: "POST",
-      headers: { "content-type": "application/json" },
+      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 "--";
-  if (cell === "rest") return "-R";
-  if (cell === "mute") return "-x";
-  if (typeof cell === "object") {
-    const bend = cell.bend ?? 0;
-    if (cell.tie) return `~${cell.fret}`.padStart(2, "-").slice(-2);
-    const mark = bend === 0.5 ? "b" : bend === 1.5 ? "^" : bend === 1 ? "B" : "";
-    return `${cell.fret}${mark}`.padStart(2, "-").slice(-2);
-  }
-  return String(cell).padStart(2, "-");
-}
-function render(doc, from = 0, to = doc.measures.length - 1) {
-  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}`);
-  const ann = [];
-  doc.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}: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) => {
-    if (mi < from || mi > to) return;
-    const key = activeKeyAt(doc.keys, mi);
-    const sub = uniformSubdivision(m);
-    const subText = sub != null ? `${sub}/beat` : `[${m.subdivisions.join(",")}]/beat`;
-    lines.push("");
-    lines.push(
-      `--- measure ${mi} (bar ${mi + 1})  (${m.beats}/${m.beatUnit}, ${subText}, ${columnCount(m)} cols, key ${key.tonic} ${key.mode}) ---`
-    );
-    const chordRow = (m.chords ?? []).map((label, c) => label ? `c${c}:${chordDisplay(label)}` : null).filter(Boolean).join("  ");
-    lines.push(`chords: ${chordRow || "(none)"}`);
-    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} ${doc.tuning[s] ?? "?"}`.padEnd(6, " ");
-      const cells = row.map(cellText).join(" ");
-      lines.push(`${label}| ${cells}`);
-    });
-    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(" ")}`);
-  });
-  return lines.join("\n");
-}
-
 // notation.ts
 var BEAT_UNITS2 = [2, 4, 8, 16];
 var BENDS = { b: 0.5, B: 1, "^": 1.5 };
@@ -371,18 +653,44 @@ function parseTime(text2) {
 function parseValue(raw, where) {
   if (raw === "x") return "mute";
   if (raw === "r") return "rest";
-  const m = /^(~?)(\d+)([bB^p]*)$/.exec(raw);
+  const m = /^(~?)(?:<(\d+(?:\.\d+)?)>|(\d+)(?:<(\d+(?:\.\d+)?)>)?)([bB^pah]*)$/.exec(raw);
   if (!m) throw new Error(`${where}: bad value "${raw}"`);
-  const fret = Number(m[2]);
+  const natural = m[2] != null;
+  const at = natural ? Number(m[2]) : m[4] != null ? Number(m[4]) : void 0;
+  const fret = natural ? Math.round(Number(m[2])) : Number(m[3]);
   if (fret > MAX_FRET) throw new Error(`${where}: fret ${fret} is above ${MAX_FRET}`);
-  const mods = m[3];
+  const mods = m[5];
   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;
+  const a = mods.includes("a");
+  const h = mods.includes("h");
+  if (a && h) throw new Error(`${where}: "a" and "h" cannot be combined in "${raw}"`);
+  if (natural && (a || h)) {
+    throw new Error(`${where}: a natural harmonic <pos> takes no "a"/"h" in "${raw}"`);
+  }
+  if (a && at != null) {
+    throw new Error(`${where}: "${raw}" \u2014 a position <pos> already means artificial; drop "a"`);
+  }
+  const harm = natural ? "natural" : h ? "pinch" : a || at != null ? "artificial" : void 0;
+  const checked = checkHarmonic(fret, harm, at);
+  if (!checked.ok) throw new Error(`${where}: ${checked.reason} in "${raw}"`);
+  const bend = bendMarks.length ? BENDS[bendMarks[0]] : 0;
+  return makeNoteCell(checked.value.fret, bend, !!m[1], mods.includes("p"), checked.value);
+}
+function noteText(cell) {
+  if (typeof cell === "number") return String(cell);
+  const bend = cell.bend ?? 0;
+  const bendMark = bend === 0.5 ? "b" : bend === 1.5 ? "^" : bend === 1 ? "B" : "";
+  let body;
+  let harmMark = "";
+  if (cell.harm === "natural") {
+    body = `<${cell.harmAt ?? cell.fret}>`;
+  } else {
+    body = cell.harm && cell.harmAt != null ? `${cell.fret}<${cell.harmAt}>` : String(cell.fret);
+    if (cell.harm === "pinch") harmMark = "h";
+    else if (cell.harm === "artificial" && cell.harmAt == null) harmMark = "a";
+  }
+  return `${cell.tie ? "~" : ""}${body}${bendMark}${harmMark}${cell.pm ? "p" : ""}`;
 }
 function parseBeat(text2, stringCount, where) {
   const slots = text2.trim().split(/\s+/);
@@ -441,6 +749,105 @@ function buildMeasure(spec, stringCount, fallback, where = "measure") {
   }
   return measure;
 }
+function setCellNote(prev, e, where) {
+  if (e.harm === "none" && e.harmAt != null) {
+    throw new Error(`${where}: harmAt cannot be set with harm "none"`);
+  }
+  const sameNote = cellFret(prev) === e.fret;
+  const harm = e.harm === "none" ? void 0 : e.harm ?? (sameNote ? cellHarm(prev) : void 0);
+  const keptAt = e.harmAt == null && harm != null && sameNote ? cellHarmAt(prev) : void 0;
+  let checked = checkHarmonic(e.fret, harm, e.harmAt ?? keptAt);
+  if (!checked.ok && keptAt != null) checked = checkHarmonic(e.fret, harm, void 0);
+  if (!checked.ok) throw new Error(`${where}: ${checked.reason}`);
+  return makeNoteCell(checked.value.fret, e.bend ?? 0, !!e.tie, !!e.pm, checked.value);
+}
+
+// eztab.ts
+function normalize(data) {
+  return normalizeDocument(data);
+}
+function cellText(cell) {
+  if (cell === null) return "";
+  if (cell === "rest") return "R";
+  if (cell === "mute") return "x";
+  return noteText(cell);
+}
+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}`);
+  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 = [];
+  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}:key=${k.tonic} ${k.mode}`);
+    if (s && s.label) ann.push(`m${m}:section="${s.label}"`);
+  });
+  if (ann.length) lines.push(`Markers: ${ann.join(", ")}`);
+  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} (bar ${mi + 1})  (${m.beats}/${m.beatUnit}, key ${key.tonic} ${key.mode}) ---`
+    );
+    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");
+}
+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 texts = m.cells.map((row) => row.map(cellText));
+  const width = Math.max(2, ...texts.flat().map((t) => t.length));
+  const ruler = Array.from(
+    { length: columnCount(m) },
+    (_, c) => String(c).padStart(width, " ")
+  ).join(" ");
+  lines.push(`col:    ${ruler}`);
+  texts.forEach((row, s) => {
+    const label = `${s + 1} ${tuning[s] ?? "?"}`.padEnd(6, " ");
+    lines.push(`${label}| ${row.map((t) => t.padStart(width, "-")).join(" ")}`);
+  });
+  const pm = Array.from(
+    { length: columnCount(m) },
+    (_, c) => (m.cells.some((row) => cellPalmMute(row[c] ?? null)) ? "PM" : "").padStart(width, " ")
+  );
+  if (pm.some((x) => x.trim() !== "")) lines.push(`pm:     ${pm.join(" ")}`);
+}
 
 // prompts.ts
 var IMPORT_TAB_FROM_IMAGE = `Transcribe the TAB in the attached image(s) into an EZTab document with the eztab tools.
@@ -449,6 +856,7 @@ var IMPORT_TAB_FROM_IMAGE = `Transcribe the TAB in the attached image(s) into an
 - 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
@@ -464,7 +872,12 @@ Read each bar's rhythm first (beams, flags, dots, tuplet brackets, rests), then
 - 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.
+- Harmonics:
+  - Natural harmonic (fret in angle brackets <12>, <7>, "Harm.", "N.H.", a diamond notehead): S:<12>. Between frets (<2.4>, <3.2>, <5.8>): S:<2.4> as printed.
+  - Artificial harmonic (7<19>, "A.H.", "T.H." with the fretted note and the touch point): S:7<19>. Only the fretted note printed with "A.H." / "T.H.": S:7a.
+  - Pinch harmonic ("P.H." bracket, like P.M.): add h to every note under it, S:7h; with a printed position, S:7<19>h.
+  - "AH" / "A.H." is used for both artificial and pinch harmonics. Decide from context: a picked note under a P.H.-like bracket or marked over a distorted riff is pinch (h); a tapped / touched octave (typically +12) on a clean part is artificial. If unsure, choose one and list those bars in the report.
+- 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.
 
@@ -480,9 +893,9 @@ var state = {
   source: null
 };
 var server = new McpServer(
-  { name: "eztab", version: "0.2.0" },
+  { name: "eztab", version: "0.4.0" },
   {
-    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."
+    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) {
@@ -494,24 +907,44 @@ function requireDoc() {
   }
   return state.doc;
 }
-function applyEdit(mutate) {
-  const doc = requireDoc();
+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`);
+  }
+  return switchTrack(doc, track);
+}
+function edit(track, mutate) {
+  const current = requireDoc();
+  if ((current.formatRevision ?? 1) > SUPPORTED_FORMAT_REVISION) {
+    throw new Error(
+      "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)."
+    );
+  }
+  const before = onTrack(current, track);
+  const doc = structuredClone(before);
   mutate(doc);
+  state.doc = reconcileTracks(before, doc);
   state.version += 1;
-  return text(render(doc));
+  return state.doc;
 }
-function applyEditRange(mutate) {
-  const doc = structuredClone(requireDoc());
-  const [from, to] = mutate(doc);
-  state.doc = doc;
-  state.version += 1;
-  return text(render(doc, from, to));
+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) {
-  state.doc = doc;
+  state.doc = openWorkspace(doc);
   state.version += 1;
-  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})`);
@@ -522,10 +955,14 @@ server.tool(
   "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()
+    to: z.number().int().min(0).optional(),
+    track: trackParam.describe("Show only this track (default: all tracks).")
   },
   async (a) => {
-    if (state.doc) return text(render(state.doc, a.from, a.to));
+    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.");
   }
 );
@@ -585,7 +1022,17 @@ server.tool(
     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 };
-    return setDoc(doc);
+    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(
@@ -593,12 +1040,30 @@ server.tool(
   "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 () => {
-    const doc = requireDoc();
+    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,
@@ -628,7 +1093,7 @@ 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. 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).",
+  "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. Optional `harm` makes it a harmonic: 'natural' (touch the open string at `harmAt`, or at the fret when omitted \u2014 `harmAt` may be between frets, e.g. 2.4, and then the fret is its rounded value), 'artificial' / 'pinch' (fret the note, harmonic at `harmAt` above it; pinch without `harmAt` = wherever it is picked), or 'none' to remove it. When `harm` is omitted and the cell already holds a harmonic at the same fret, the harmonic is kept. measure/string/column are all 0-based (measure 0 = the first measure, string 0 = the top line).",
   {
     edits: z.array(
       z.object({
@@ -638,9 +1103,12 @@ server.tool(
         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(),
-        pm: z.boolean().optional()
+        pm: z.boolean().optional(),
+        harm: z.enum(["natural", "artificial", "pinch", "none"]).optional(),
+        harmAt: z.number().optional()
       })
-    )
+    ),
+    track: trackParam
   },
   async (a) => applyEdit((doc) => {
     for (const e of a.edits) {
@@ -655,22 +1123,25 @@ server.tool(
           `column ${e.column} out of range for measure ${e.measure} (0..${cols - 1})`
         );
       }
-      let value = e.value === "clear" ? null : e.value;
-      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.pm ? { pm: true } : {}
-        };
+      const where = `measure ${e.measure} string ${e.string} column ${e.column}`;
+      if (typeof e.value !== "number") {
+        if (e.harm != null || e.harmAt != null) {
+          throw new Error(`${where}: harm / harmAt need a fret-number value`);
+        }
+        m.cells[e.string][e.column] = e.value === "clear" ? null : e.value;
+        continue;
       }
-      m.cells[e.string][e.column] = value;
+      m.cells[e.string][e.column] = setCellNote(
+        m.cells[e.string][e.column],
+        { fret: e.value, bend: e.bend, tie: e.tie, pm: e.pm, harm: e.harm, harmAt: e.harmAt },
+        where
+      );
     }
-  })
+  }, 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"].',
+  '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:<P>  natural harmonic touched at fret P (S:<12>, S:<7>; between frets S:<2.4>)\n  S:F<P> artificial harmonic: fret F, harmonic at P (S:7<19>); S:Fa = artificial, position not written\n  S:Fh   pinch harmonic (P.H.); S:F<P>h = pinch harmonic at P (S:7<19>h)\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({
@@ -678,7 +1149,10 @@ server.tool(
         time: z.string().optional(),
         beats: z.array(z.string()).min(1)
       })
-    ).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;
@@ -698,17 +1172,30 @@ server.tool(
         fallback,
         `measure ${i}`
       );
-      if (i === doc.measures.length) doc.measures.push(built);
+      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-name onsets per column (the same time grid as 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.',
+  '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({
@@ -787,7 +1274,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),
@@ -810,7 +1297,10 @@ server.tool(
   {
     measure: z.number().int(),
     subdivisions: z.number().int().min(1).max(12),
-    beat: z.number().int().min(0).optional()
+    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);
@@ -825,11 +1315,11 @@ server.tool(
     } 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()
@@ -846,7 +1336,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);
@@ -859,11 +1349,54 @@ 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));
-  })
+  }, 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",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hidechae/eztab-mcp",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "MCP server for EZTab \u2014 lets an AI agent build and edit guitar/bass tablature.",
   "type": "module",
   "bin": {