@ugfoundation/swaralipi-js 0.1.0

package/dist/cli.cjs

@@ -0,0 +1,913 @@
+#!/usr/bin/env node
+'use strict';
+
+var zod = require('zod');
+var promises = require('fs/promises');
+var path = require('path');
+var util = require('util');
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var octaveSchema, svaraLetterSchema, svaraSchema, microtoneSchema, barSchema, bracketSchema, noteSchema, rowSchema, partSchema, taalSchema, metaSchema, swaralipiSchema;
+var init_schema = __esm({
+  "src/spec/schema.ts"() {
+    octaveSchema = zod.z.enum([
+      "ati-mandra",
+      // very low
+      "mandra",
+      // low (dot below)
+      "madhyam",
+      // middle
+      "taar",
+      // high (ref/dot above)
+      "ati-taar"
+      // very high
+    ]);
+    svaraLetterSchema = zod.z.enum(["s", "r", "g", "m", "p", "d", "n"]);
+    svaraSchema = zod.z.tuple([octaveSchema, svaraLetterSchema]);
+    microtoneSchema = zod.z.enum(["alpakomal", "atikomal"]);
+    barSchema = zod.z.enum(["dari", "single", "double", "quad"]);
+    bracketSchema = zod.z.object({
+      kind: zod.z.enum(["repeat", "skip", "alt"]),
+      edge: zod.z.enum(["open", "close"])
+    });
+    noteSchema = zod.z.lazy(
+      () => zod.z.object({
+        svara: svaraSchema.optional(),
+        komal: zod.z.boolean().optional(),
+        tivra: zod.z.boolean().optional(),
+        microtone: microtoneSchema.optional(),
+        durationMatra: zod.z.number().positive().optional(),
+        sustain: zod.z.boolean().optional(),
+        rest: zod.z.boolean().optional(),
+        kan: svaraSchema.optional(),
+        meend: zod.z.enum(["start", "end"]).optional(),
+        bar: barSchema.optional(),
+        brackets: zod.z.array(bracketSchema).optional(),
+        lyric: zod.z.string().optional(),
+        raw: zod.z.string().optional(),
+        above: zod.z.array(noteSchema).optional(),
+        below: zod.z.array(noteSchema).optional()
+      }).refine(
+        (n) => n.svara !== void 0 || n.rest === true || n.sustain === true || n.bar !== void 0 || n.raw !== void 0 || n.brackets !== void 0 && n.brackets.length > 0 || n.above !== void 0 && n.above.length > 0 || n.below !== void 0 && n.below.length > 0 || n.lyric !== void 0,
+        {
+          message: "note must carry one of: svara, rest, sustain, bar, raw, lyric, brackets, or a non-empty above/below"
+        }
+      )
+    );
+    rowSchema = zod.z.object({
+      /** Optional line label (e.g. a tuk/section marker). */
+      label: zod.z.string().optional(),
+      notes: zod.z.array(noteSchema)
+    });
+    partSchema = zod.z.object({
+      name: zod.z.string().optional(),
+      rows: zod.z.array(rowSchema)
+    });
+    taalSchema = zod.z.object({
+      /** Player sample key, e.g. `dadra`, `teentaal`. */
+      id: zod.z.string(),
+      numBeats: zod.z.number().int().positive(),
+      /** Vibhag groupings; if given, they sum to numBeats. */
+      bhaags: zod.z.array(zod.z.number().int().positive()).optional(),
+      /** Sam (cycle start) beat index, 0-based. */
+      sam: zod.z.number().int().nonnegative().optional(),
+      /** Khaali (wave) beat indices, 0-based. */
+      khaali: zod.z.array(zod.z.number().int().nonnegative()).optional()
+    }).refine((t) => t.bhaags === void 0 || t.bhaags.reduce((a, b) => a + b, 0) === t.numBeats, {
+      message: "bhaags must sum to numBeats"
+    });
+    metaSchema = zod.z.object({
+      title: zod.z.string(),
+      /** Cross-reference to a gitabitan.io song content id (filename, immutable). */
+      songId: zod.z.string().optional(),
+      /** Source NLTR node/song id. */
+      nltrId: zod.z.number().int().optional(),
+      taal: taalSchema.optional(),
+      /**
+       * The taal name exactly as printed in the source (e.g. `তালমুক্ত`,
+       * `ষষ্ঠী(২/৪)`). Always set by the NLTR converter; `taal` is set only
+       * when the name resolves to a known definition.
+       */
+      taalName: zod.z.string().optional(),
+      /** Base pitch for playback, e.g. `C`, `C#`, or the player's `cs` form. */
+      tonic: zod.z.string().optional(),
+      /** Default playback tempo in matra/min. Player-only — the viewer ignores it.
+       * The player adopts it on `load()` (precedence: constructor `bpm` → `setBpm`
+       * tweak → this → 90). `null` is the converter's blank placeholder = unset. */
+      bpm: zod.z.number().positive().nullable().optional(),
+      raag: zod.z.string().optional(),
+      /** আবর্তন: number of taal cycles, when the source states it. */
+      avartan: zod.z.number().int().positive().optional(),
+      /** স্বরলিপিকার (notation author). */
+      notationBy: zod.z.string().optional(),
+      /** Provenance note or URL. */
+      source: zod.z.string().optional()
+    });
+    swaralipiSchema = zod.z.object({
+      /** Spec version this document targets (see SPEC_VERSION in ./index). */
+      version: zod.z.string(),
+      meta: metaSchema,
+      parts: zod.z.array(partSchema)
+    });
+  }
+});
+
+// src/spec/taals.ts
+var TAALS;
+var init_taals = __esm({
+  "src/spec/taals.ts"() {
+    TAALS = {
+      dadra: { id: "dadra", numBeats: 6, bhaags: [3, 3], sam: 0, khaali: [3] },
+      kehrwa: { id: "kehrwa", numBeats: 8, bhaags: [4, 4], sam: 0, khaali: [4] },
+      rupak: { id: "rupak", numBeats: 7, bhaags: [3, 2, 2], sam: 0, khaali: [0] },
+      jhaptaal: { id: "jhaptaal", numBeats: 10, bhaags: [2, 3, 2, 3], sam: 0, khaali: [5] },
+      ektaal: { id: "ektaal", numBeats: 12, bhaags: [2, 2, 2, 2, 2, 2], sam: 0, khaali: [2, 6] },
+      adachautaal: { id: "adachautaal", numBeats: 14, sam: 0 },
+      teentaal: { id: "teentaal", numBeats: 16, bhaags: [4, 4, 4, 4], sam: 0, khaali: [8] }
+    };
+  }
+});
+
+// src/spec/index.ts
+var SPEC_VERSION;
+var init_spec = __esm({
+  "src/spec/index.ts"() {
+    init_schema();
+    init_taals();
+    SPEC_VERSION = "0.1.0";
+  }
+});
+
+// src/convert/codec.ts
+function decodeBarRun(body) {
+  const m = body.match(BAR_RUN_RE);
+  if (!m || !/[lLA]/.test(m[2])) return void 0;
+  const notes = [];
+  if (m[1]) notes.push({ sustain: true });
+  const run = m[2];
+  let i = 0;
+  while (i < run.length) {
+    const ch = run[i];
+    if (ch === "l" || ch === "L") {
+      let j = i;
+      while (j < run.length && run[j] === ch) j++;
+      const strokes = (j - i) * (ch === "L" ? 2 : 1);
+      notes.push({ bar: strokes >= 4 ? "quad" : strokes >= 2 ? "double" : "single" });
+      i = j;
+    } else if (ch === "A") {
+      notes.push({ bar: "dari" });
+      i++;
+    } else {
+      notes.push({ brackets: [{ kind: "alt", edge: ch === "[" ? "open" : "close" }] });
+      i++;
+    }
+  }
+  return notes;
+}
+function octaveOf(mark) {
+  if (mark === "f" || mark === "F") return "taar";
+  if (mark === "h" || mark === "H") return "mandra";
+  return "madhyam";
+}
+function decodeChunk(chunk) {
+  const opens = [];
+  const closes = [];
+  let body = chunk;
+  while (body.length > 0) {
+    const kind = OPEN_BRACKETS[body[0]];
+    if (kind === void 0) break;
+    opens.push(kind);
+    body = body.slice(1);
+  }
+  while (body.length > 0) {
+    const kind = CLOSE_BRACKETS[body[body.length - 1]];
+    if (kind === void 0) break;
+    closes.unshift(kind);
+    body = body.slice(0, -1);
+  }
+  const finish = (notes, kind) => {
+    if (notes.length === 0) notes.push({});
+    const first = notes[0];
+    const last = notes[notes.length - 1];
+    if (opens.length > 0) first.brackets = [...opens.map((kind_) => ({ kind: kind_, edge: "open" })), ...first.brackets ?? []];
+    if (closes.length > 0) last.brackets = [...last.brackets ?? [], ...closes.map((kind_) => ({ kind: kind_, edge: "close" }))];
+    return { notes, kind };
+  };
+  if (body === "") return finish([{}], "decoded");
+  const barRun = decodeBarRun(body);
+  if (barRun) return finish(barRun, "decoded");
+  const structural = STRUCTURALS[body];
+  if (structural) return finish([structural()], "decoded");
+  if (KNOWN_RAW_RE.some((re) => re.test(body))) return finish([{}], "known");
+  const m = body.match(BODY_RE);
+  if (m) {
+    const [, , , hyphen, , kanLetter, kanOct, unitsStr, aakar, postOct, , trailKan, trailKanOct] = m;
+    const attachKan = (note, letter, oct) => {
+      const def = LETTERS[letter.toLowerCase()];
+      note.kan = [octaveOf(oct?.toLowerCase()), def.letter];
+    };
+    if (unitsStr) {
+      const units = unitsStr.match(/[srgmpqndtkuv][fh]?/g) ?? [];
+      const notes = units.map((unit) => {
+        const def = LETTERS[unit[0]];
+        const note = { svara: [octaveOf(unit[1]), def.letter] };
+        if (def.komal) note.komal = true;
+        if (def.tivra) note.tivra = true;
+        if (units.length > 1) note.durationMatra = 1 / units.length;
+        return note;
+      });
+      const last = notes[notes.length - 1];
+      if (postOct && last.svara[0] === "madhyam") {
+        last.svara = [octaveOf(postOct), last.svara[1]];
+      }
+      if (hyphen) notes[0].sustain = true;
+      if (kanLetter) attachKan(notes[0], kanLetter, kanOct);
+      if (trailKan && last.kan === void 0) attachKan(last, trailKan, trailKanOct);
+      return finish(notes, "decoded");
+    }
+    if (aakar) {
+      const note = hyphen ? { sustain: true } : { rest: true };
+      if (trailKan) attachKan(note, trailKan, trailKanOct);
+      else if (kanLetter) attachKan(note, kanLetter, kanOct);
+      return finish([note], "decoded");
+    }
+    if (hyphen && !kanLetter && !trailKan) {
+      return finish([{ sustain: true }], "decoded");
+    }
+  }
+  return finish([{}], "unknown");
+}
+function decodeCell(text) {
+  const chunks = text.split(/\s+/).filter((c) => c.length > 0);
+  const out = { notes: [], unknownTokens: [], knownRawTokens: [], decoded: false };
+  for (const chunk of chunks) {
+    const { notes, kind } = decodeChunk(chunk);
+    notes[0].raw = chunk;
+    if (kind === "decoded") out.decoded = true;
+    else if (kind === "known") out.knownRawTokens.push(chunk);
+    else out.unknownTokens.push(chunk);
+    out.notes.push(...notes);
+  }
+  return out;
+}
+var LETTERS, STRUCTURALS, BAR_RUN_RE, KNOWN_RAW_RE, OPEN_BRACKETS, CLOSE_BRACKETS, BODY_RE;
+var init_codec = __esm({
+  "src/convert/codec.ts"() {
+    LETTERS = {
+      s: { letter: "s" },
+      r: { letter: "r" },
+      g: { letter: "g" },
+      m: { letter: "m" },
+      p: { letter: "p" },
+      q: { letter: "d" },
+      // ধ — shuddha dha
+      n: { letter: "n" },
+      d: { letter: "d", komal: true },
+      // দ
+      t: { letter: "g", komal: true },
+      // জ্ঞ
+      k: { letter: "m", tivra: true },
+      // ক্ষ
+      u: { letter: "n", komal: true },
+      // ণ
+      v: { letter: "r", komal: true }
+      // ঋ
+    };
+    STRUCTURALS = {
+      "%": () => ({ svara: ["madhyam", "s"] }),
+      // precomposed সা
+      "&": () => ({ svara: ["madhyam", "n"] })
+      // precomposed নি
+    };
+    BAR_RUN_RE = /^(-)?([lLA[\]]+)$/;
+    KNOWN_RAW_RE = [
+      /^[wxyjEJ$<>=_]+$/,
+      // arc & line drawing segments
+      /^\|+$/,
+      // thin yugal-dari stop mark
+      /^[0-9!@#]{1,2}[fF]?:?$/,
+      // beat-number labels incl. 10–16 (sam tick = f/F, e.g. 1f / 1F / 2:)
+      /^[oOe`+,.;:iI~^*bcBCWXYFHZz'"?]$/
+      // dots, ticks, duration marks, legacy forms
+    ];
+    OPEN_BRACKETS = {
+      "{": "repeat",
+      "(": "skip",
+      "[": "alt"
+    };
+    CLOSE_BRACKETS = {
+      "}": "repeat",
+      ")": "skip",
+      "]": "alt"
+    };
+    BODY_RE = /^([0-9!@][fF]?)?([zj]*)(-)?([i:])?(?:([SRGMPQNDTKUV])([fFhH])?)?((?:[srgmpqndtkuv][fh]?[i:]?)+)?(a)?([fh])?([i:])?(?:([SRGMPQNDTKUV])([fFhH])?)?([0-9!@][fF]?)?(-)?$/;
+  }
+});
+
+// src/convert/grid.ts
+function buildSystems(page) {
+  const warnings = [];
+  const byIndex = /* @__PURE__ */ new Map();
+  let styleMismatches = 0;
+  for (const cell of page.cells) {
+    if (cell.text === "") continue;
+    const role = ROLES[cell.row % 4];
+    const expected = role === "lyric" ? "style2" : "style1";
+    if (cell.style !== expected) styleMismatches++;
+    const index = Math.floor(cell.row / 4);
+    let system = byIndex.get(index);
+    if (!system) {
+      system = {
+        index,
+        above: /* @__PURE__ */ new Map(),
+        notation: /* @__PURE__ */ new Map(),
+        below: /* @__PURE__ */ new Map(),
+        lyric: /* @__PURE__ */ new Map(),
+        maxCol: 0
+      };
+      byIndex.set(index, system);
+    }
+    system[role].set(cell.col, cell.text);
+    if (cell.col > system.maxCol) system.maxCol = cell.col;
+  }
+  if (styleMismatches > 0) {
+    warnings.push(`${styleMismatches} cell(s) had an unexpected style class for their row role`);
+  }
+  const systems = [...byIndex.values()].sort((a, b) => a.index - b.index);
+  return { systems, warnings };
+}
+var ROLES;
+var init_grid = __esm({
+  "src/convert/grid.ts"() {
+    ROLES = ["above", "notation", "below", "lyric"];
+  }
+});
+
+// src/convert/taal-map.ts
+function bnInt(s) {
+  if (s === void 0) return void 0;
+  const ascii = s.trim().replace(/[০-৯]/g, (d) => BN_DIGIT_MAP[d] ?? d);
+  return /^\d+$/.test(ascii) ? Number(ascii) : void 0;
+}
+function deriveGeometry(systems) {
+  let numCols = 0;
+  for (const system of systems) {
+    if (system.notation.size === 0) continue;
+    const cols = [...system.notation.keys()].sort((a, b) => a - b);
+    numCols = Math.max(numCols, cols.length);
+    const barCols = cols.filter((c) => BAR_TOKENS.has(system.notation.get(c)));
+    if (barCols.length < 2) continue;
+    const from = barCols[0];
+    const to = barCols[1];
+    const inner = cols.filter((c) => c > from && c < to);
+    if (inner.length === 0) continue;
+    const bhaags = [];
+    let run = 0;
+    for (const c of inner) {
+      if (system.notation.get(c) === DARI_TOKEN) {
+        if (run > 0) bhaags.push(run);
+        run = 0;
+      } else {
+        run++;
+      }
+    }
+    if (run > 0) bhaags.push(run);
+    const numBeats = bhaags.reduce((a, b) => a + b, 0);
+    if (numBeats === 0) continue;
+    return { numCols: cols.length, numBeats, bhaags: bhaags.length > 1 ? bhaags : void 0 };
+  }
+  return numCols > 0 ? { numCols } : void 0;
+}
+function resolveTaal(nameRaw, avartanRaw, geometry) {
+  const warnings = [];
+  const avartan = bnInt(avartanRaw);
+  const taalName = nameRaw?.trim() || void 0;
+  if (!taalName || taalName === TAAL_FREE) {
+    return { taalName, avartan, matched: "none", warnings };
+  }
+  const parenMatch = taalName.match(/^(.*?)\s*\(([০-৯\d/\s]+)\)\s*$/);
+  const base = (parenMatch ? parenMatch[1] : taalName).trim();
+  let hintBhaags;
+  if (parenMatch) {
+    const parts = parenMatch[2].split("/").map((p) => bnInt(p));
+    if (parts.every((p) => p !== void 0) && parts.length > 0) {
+      hintBhaags = parts;
+    }
+  }
+  const akhandaMatch = base.match(/^অখন্ড\s+([০-৯\d]+)\s*মাত্রা$/);
+  let taal;
+  let matched = "none";
+  const mappedId = BN_TAAL_MAP[base];
+  if (mappedId) {
+    taal = { ...TAALS[mappedId] };
+    matched = "taals";
+  } else if (BN_TAAL_DEFS[base]) {
+    taal = { ...BN_TAAL_DEFS[base] };
+    matched = "table";
+  } else if (akhandaMatch) {
+    const beats = bnInt(akhandaMatch[1]);
+    if (beats) {
+      taal = { id: `akhanda-${beats}`, numBeats: beats, sam: 0 };
+      matched = "table";
+    }
+  }
+  const hintBeats = hintBhaags?.reduce((a, b) => a + b, 0);
+  if (taal) {
+    if (hintBeats !== void 0 && hintBeats !== taal.numBeats) {
+      warnings.push(
+        `taal ${taal.id}: name declares ${hintBeats} beats (${hintBhaags.join("/")}), table says ${taal.numBeats} \u2014 using the name's`
+      );
+      taal = { id: taal.id, numBeats: hintBeats, sam: 0 };
+      if (hintBhaags.length > 1) taal.bhaags = hintBhaags;
+    } else if (hintBhaags && hintBhaags.length > 1) {
+      const tableBhaags = taal.bhaags?.join("/");
+      if (tableBhaags && tableBhaags !== hintBhaags.join("/")) {
+        warnings.push(
+          `taal ${taal.id}: name declares bhaags ${hintBhaags.join("/")}, table says ${tableBhaags} \u2014 using the name's`
+        );
+        const { khaali: _khaali, ...rest } = taal;
+        taal = { ...rest, bhaags: hintBhaags };
+      }
+    }
+  } else if (hintBeats !== void 0 || geometry?.numBeats !== void 0) {
+    const evidenceBeats = hintBeats ?? geometry?.numBeats;
+    const evidenceBhaags = hintBhaags ?? geometry?.bhaags;
+    taal = { id: BN_TAAL_IDS[base] ?? base, numBeats: evidenceBeats, sam: 0 };
+    if (evidenceBhaags && evidenceBhaags.length > 1) taal.bhaags = evidenceBhaags;
+    matched = "geometry";
+  } else {
+    warnings.push(`unresolved taal name: ${taalName}`);
+  }
+  if (taal && geometry?.numBeats !== void 0 && geometry.numBeats !== taal.numBeats) {
+    warnings.push(
+      `grid geometry says ${geometry.numBeats} beats per cycle but taal ${taal.id} has ${taal.numBeats}`
+    );
+  }
+  return { taal, taalName, avartan, matched, warnings };
+}
+var BN_DIGIT_MAP, BN_TAAL_MAP, BN_TAAL_DEFS, BN_TAAL_IDS, TAAL_FREE, BAR_TOKENS, DARI_TOKEN;
+var init_taal_map = __esm({
+  "src/convert/taal-map.ts"() {
+    init_spec();
+    BN_DIGIT_MAP = {
+      "\u09E6": "0",
+      "\u09E7": "1",
+      "\u09E8": "2",
+      "\u09E9": "3",
+      "\u09EA": "4",
+      "\u09EB": "5",
+      "\u09EC": "6",
+      "\u09ED": "7",
+      "\u09EE": "8",
+      "\u09EF": "9"
+    };
+    BN_TAAL_MAP = {
+      \u09A6\u09BE\u09A6\u09B0\u09BE: "dadra",
+      \u0995\u09BE\u09B9\u09BE\u09B0\u09AC\u09BE: "kehrwa",
+      \u098F\u0995\u09A4\u09BE\u09B2\u09BE: "ektaal",
+      \u098F\u0995\u09A4\u09BE\u09B2: "ektaal",
+      \u09A4\u09BF\u09A8\u09A4\u09BE\u09B2\u09BE: "teentaal",
+      \u09A4\u09CD\u09B0\u09BF\u09A4\u09BE\u09B2: "teentaal",
+      \u099D\u09BE\u0981\u09AA\u09A4\u09BE\u09B2: "jhaptaal",
+      \u099D\u09BE\u0981\u09AA: "jhaptaal",
+      \u09B0\u09C1\u09AA\u0995: "rupak",
+      \u09B0\u09C2\u09AA\u0995: "rupak",
+      \u0986\u09A1\u09BC\u09BE\u099A\u09CC\u09A4\u09BE\u09B2: "adachautaal"
+    };
+    BN_TAAL_DEFS = {
+      \u09A4\u09C7\u0993\u09A1\u09BC\u09BE: { id: "teora", numBeats: 7, bhaags: [3, 2, 2], sam: 0 },
+      \u09A4\u09C7\u0993\u09B0\u09BE: { id: "teora", numBeats: 7, bhaags: [3, 2, 2], sam: 0 },
+      \u099D\u09AE\u09CD\u09AA\u0995: { id: "jhampak", numBeats: 5, bhaags: [3, 2], sam: 0 },
+      \u09B7\u09B7\u09CD\u09A0\u09C0: { id: "shashthi", numBeats: 6, bhaags: [2, 4], sam: 0 },
+      \u09B0\u09C1\u09AA\u0995\u09A1\u09BC\u09BE: { id: "rupakda", numBeats: 8, bhaags: [3, 2, 3], sam: 0 },
+      \u09B0\u09C2\u09AA\u0995\u09A1\u09BC\u09BE: { id: "rupakda", numBeats: 8, bhaags: [3, 2, 3], sam: 0 },
+      \u09A8\u09AC\u09A4\u09BE\u09B2: { id: "nabataal", numBeats: 9, bhaags: [5, 4], sam: 0 },
+      \u098F\u0995\u09BE\u09A6\u09B6\u09C0: { id: "ekadashi", numBeats: 11, bhaags: [3, 4, 4], sam: 0 },
+      \u09A8\u09AC\u09AA\u099E\u09CD\u099A: { id: "nabapancha", numBeats: 18, bhaags: [2, 4, 4, 4, 4], sam: 0 },
+      \u09A7\u09BE\u09AE\u09BE\u09B0: { id: "dhamar", numBeats: 14, bhaags: [3, 2, 2, 3, 4], sam: 0 },
+      \u099A\u09CC\u09A4\u09BE\u09B2: { id: "choutaal", numBeats: 12, bhaags: [2, 2, 2, 2, 2, 2], sam: 0 },
+      \u09B8\u09C1\u09B0\u09AB\u09BE\u0981\u0995: { id: "surphank", numBeats: 10, sam: 0 }
+    };
+    BN_TAAL_IDS = {
+      \u0995\u09BE\u0993\u09AF\u09BC\u09BE\u09B2\u09BF: "kawali",
+      \u0996\u09C7\u09AE\u099F\u09BE: "khemta",
+      \u0986\u09A1\u09BC\u09BE\u09A0\u09C7\u0995\u09BE: "araatheka",
+      \u0995\u09BE\u09B6\u09CD\u09AE\u09C0\u09B0\u09BF: "kashmiri",
+      "\u09AF\u09CE": "yat",
+      \u09AE\u09A7\u09CD\u09AF\u09AE\u09BE\u09A8: "madhyaman",
+      \u0985\u09B0\u09CD\u09A6\u09CD\u09A7\u099D\u09BE\u0981\u09AA: "ardhajhanp",
+      \u0985\u09B0\u09CD\u09A7\u099D\u09BE\u0981\u09AA: "ardhajhanp",
+      "\u09AC\u09BF\u09B2\u09AE\u09CD\u09AC\u09BF\u09A4 \u09A4\u09CD\u09B0\u09BF\u09A4\u09BE\u09B2": "vilambit-teentaal"
+    };
+    TAAL_FREE = "\u09A4\u09BE\u09B2\u09AE\u09C1\u0995\u09CD\u09A4";
+    BAR_TOKENS = /* @__PURE__ */ new Set(["l", "ll", "lll", "llll", "L", "LL", "|"]);
+    DARI_TOKEN = "A";
+  }
+});
+
+// src/convert/assemble.ts
+function splitLyric(text) {
+  return [...segmenter.segment(text)].map((s) => s.segment);
+}
+function assemble(page, opts = {}) {
+  const { systems, warnings } = buildSystems(page);
+  const geometry = deriveGeometry(systems);
+  const resolved = resolveTaal(page.header.taalNameRaw, page.header.avartanRaw, geometry);
+  warnings.push(...resolved.warnings);
+  const report = {
+    nltrId: opts.nltrId,
+    title: page.header.title ?? "",
+    taalName: resolved.taalName,
+    taalId: resolved.taal?.id,
+    taalMatched: resolved.matched,
+    systems: 0,
+    notationCells: 0,
+    lyricCells: 0,
+    annotationCells: 0,
+    decodedCells: 0,
+    knownRawCells: 0,
+    unknownCells: 0,
+    unknownTokens: {},
+    lyricAlignMismatches: 0,
+    warnings
+  };
+  const countUnknown = (tokens) => {
+    for (const t of tokens) report.unknownTokens[t] = (report.unknownTokens[t] ?? 0) + 1;
+  };
+  const rows = [];
+  for (const system of systems) {
+    const notes = [];
+    for (let col = 0; col <= system.maxCol; col++) {
+      const notationText = system.notation.get(col);
+      const lyricText = system.lyric.get(col);
+      const aboveText = system.above.get(col);
+      const belowText = system.below.get(col);
+      if (notationText === void 0 && lyricText === void 0 && aboveText === void 0 && belowText === void 0) {
+        continue;
+      }
+      let cellNotes;
+      if (notationText !== void 0) {
+        report.notationCells++;
+        const decode = decodeCell(notationText);
+        countUnknown(decode.unknownTokens);
+        if (decode.unknownTokens.length > 0) report.unknownCells++;
+        else if (decode.decoded) report.decodedCells++;
+        else report.knownRawCells++;
+        cellNotes = decode.notes;
+      } else {
+        cellNotes = [{}];
+      }
+      if (lyricText !== void 0) {
+        report.lyricCells++;
+        attachLyric(cellNotes, lyricText, report);
+      }
+      if (aboveText !== void 0) {
+        report.annotationCells++;
+        const decode = decodeCell(aboveText);
+        countUnknown(decode.unknownTokens);
+        cellNotes[0].above = decode.notes;
+      }
+      if (belowText !== void 0) {
+        report.annotationCells++;
+        const decode = decodeCell(belowText);
+        countUnknown(decode.unknownTokens);
+        cellNotes[0].below = decode.notes;
+      }
+      notes.push(...cellNotes);
+    }
+    if (notes.length > 0) {
+      rows.push({ notes });
+      report.systems++;
+    }
+  }
+  const meta = { title: page.header.title ?? `NLTR ${opts.nltrId ?? "song"}` };
+  if (opts.nltrId !== void 0) meta.nltrId = opts.nltrId;
+  if (resolved.taal) meta.taal = resolved.taal;
+  if (resolved.taalName) meta.taalName = resolved.taalName;
+  if (resolved.avartan !== void 0) meta.avartan = resolved.avartan;
+  const source = opts.source ?? (opts.nltrId !== void 0 ? `https://rabindra-rachanabali.nltr.org/node/${opts.nltrId}` : page.header.printId !== void 0 ? `https://rabindra-rachanabali.nltr.org/node/${page.header.printId}` : void 0);
+  if (source) meta.source = source;
+  const doc = swaralipiSchema.parse({ version: SPEC_VERSION, meta, parts: [{ rows }] });
+  return { doc, report };
+}
+function attachLyric(cellNotes, lyricText, report) {
+  if (cellNotes.length > 1) {
+    const clusters = splitLyric(lyricText);
+    if (clusters.length === cellNotes.length) {
+      clusters.forEach((cluster, i) => {
+        cellNotes[i].lyric = cluster;
+      });
+      return;
+    }
+    report.lyricAlignMismatches++;
+  }
+  cellNotes[0].lyric = lyricText;
+}
+var segmenter;
+var init_assemble = __esm({
+  "src/convert/assemble.ts"() {
+    init_spec();
+    init_codec();
+    init_grid();
+    init_taal_map();
+    segmenter = new Intl.Segmenter("bn", { granularity: "grapheme" });
+  }
+});
+
+// src/convert/extract.ts
+function decodeEntities(s) {
+  return s.replace(/&(?:#x([0-9a-fA-F]+)|#(\d+)|([a-zA-Z]+));/g, (m, hex, dec, name) => {
+    if (hex) return String.fromCodePoint(parseInt(hex, 16));
+    if (dec) return String.fromCodePoint(parseInt(dec, 10));
+    return NAMED_ENTITIES[name] ?? m;
+  });
+}
+function normalizeCellText(s) {
+  return decodeEntities(s).replace(/\p{Cf}/gu, "").replace(/[\s ]+/gu, " ").trim().normalize("NFC");
+}
+function extractPage(html) {
+  const header = {};
+  for (const m of html.matchAll(META_ROW_RE)) {
+    const label = normalizeCellText(m[1]);
+    const value = normalizeCellText(m[2]);
+    if (label === "\u09A8\u09BE\u09AE") header.title = value;
+    else if (label === "\u09A4\u09BE\u09B2") header.taalNameRaw = value;
+    else if (label === "\u0986\u09AC\u09B0\u09CD\u09A4\u09A8") header.avartanRaw = value;
+  }
+  const printMatch = html.match(/\/print\/(\d+)/);
+  if (printMatch) header.printId = Number(printMatch[1]);
+  const cells = [];
+  let maxRow = 0;
+  for (const m of html.matchAll(CELL_RE)) {
+    const row = Number(m[1]);
+    const col = Number(m[2]);
+    cells.push({ row, col, style: m[3], text: normalizeCellText(m[4]) });
+    if (row > maxRow) maxRow = row;
+  }
+  const tdCount = (html.match(/<td width='auto' id=/g) ?? []).length;
+  if (cells.length !== tdCount) {
+    throw new ExtractError(
+      `grid cell mismatch: matched ${cells.length} cells but found ${tdCount} '<td width=' openers`
+    );
+  }
+  if (cells.length === 0) throw new ExtractError("no swaralipi grid cells found");
+  if (header.title === void 0) throw new ExtractError("no \u09A8\u09BE\u09AE metadata row found");
+  return { header, cells, maxRow };
+}
+var ExtractError, NAMED_ENTITIES, CELL_RE, META_ROW_RE;
+var init_extract = __esm({
+  "src/convert/extract.ts"() {
+    ExtractError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "ExtractError";
+      }
+    };
+    NAMED_ENTITIES = {
+      nbsp: "\xA0",
+      amp: "&",
+      lt: "<",
+      gt: ">",
+      quot: '"',
+      apos: "'"
+    };
+    CELL_RE = /<td width='auto' id=["']?(\d+)\.(\d+)["']?\s*>\s*<span class='(style\d)'><div align='(?:center|left|right)'>([\s\S]*?)<\/div><\/span><\/td>/g;
+    META_ROW_RE = /<tr><td><div align='left'><span class='style3'>([^<]*)<\/span><\/div><\/td><td><div align='left'><span class='style3'>:<\/span><\/div><\/td><td><div align='left'><span class='style3'>([^<]*)<\/span><\/div><\/td><\/tr>/g;
+  }
+});
+
+// src/convert/report.ts
+function aggregate(reports, failures) {
+  const out = {
+    files: reports.length + failures.length,
+    ok: reports.length,
+    failed: failures.length,
+    failures,
+    systems: 0,
+    notationCells: 0,
+    lyricCells: 0,
+    annotationCells: 0,
+    decodedCells: 0,
+    knownRawCells: 0,
+    unknownCells: 0,
+    decodeRate: 0,
+    unknownRate: 0,
+    unknownTokens: {},
+    lyricAlignMismatches: 0,
+    taals: {},
+    warningCounts: {}
+  };
+  const unknown = /* @__PURE__ */ new Map();
+  for (const r of reports) {
+    out.systems += r.systems;
+    out.notationCells += r.notationCells;
+    out.lyricCells += r.lyricCells;
+    out.annotationCells += r.annotationCells;
+    out.decodedCells += r.decodedCells;
+    out.knownRawCells += r.knownRawCells;
+    out.unknownCells += r.unknownCells;
+    out.lyricAlignMismatches += r.lyricAlignMismatches;
+    for (const [tok, n] of Object.entries(r.unknownTokens)) {
+      unknown.set(tok, (unknown.get(tok) ?? 0) + n);
+    }
+    const taalKey = r.taalName ?? "<none>";
+    const taalEntry = out.taals[taalKey] ??= { count: 0, taalId: r.taalId, matched: r.taalMatched };
+    taalEntry.count++;
+    for (const w of r.warnings) {
+      const shape = w.replace(/\d+/g, "N");
+      out.warningCounts[shape] = (out.warningCounts[shape] ?? 0) + 1;
+    }
+  }
+  out.unknownTokens = Object.fromEntries([...unknown.entries()].sort((a, b) => b[1] - a[1]));
+  if (out.notationCells > 0) {
+    out.decodeRate = out.decodedCells / out.notationCells;
+    out.unknownRate = out.unknownCells / out.notationCells;
+  }
+  return out;
+}
+function formatSummary(r) {
+  const pct = (x) => `${(x * 100).toFixed(2)}%`;
+  const lines = [
+    `files: ${r.ok}/${r.files} converted${r.failed ? ` (${r.failed} FAILED)` : ""}`,
+    `systems: ${r.systems}  notation cells: ${r.notationCells}  lyric cells: ${r.lyricCells}  annotation cells: ${r.annotationCells}`,
+    `decoded: ${r.decodedCells} (${pct(r.decodeRate)})  known-raw: ${r.knownRawCells}  unknown: ${r.unknownCells} (${pct(r.unknownRate)})`,
+    `lyric alignment fallbacks: ${r.lyricAlignMismatches}`
+  ];
+  const unknowns = Object.entries(r.unknownTokens);
+  if (unknowns.length > 0) {
+    lines.push(`unknown tokens (${unknowns.length} distinct, top 20):`);
+    for (const [tok, n] of unknowns.slice(0, 20)) lines.push(`  ${String(n).padStart(6)}  ${JSON.stringify(tok)}`);
+  }
+  const taalLines = Object.entries(r.taals).sort((a, b) => b[1].count - a[1].count);
+  lines.push(`taals (${taalLines.length} distinct):`);
+  for (const [name, info] of taalLines.slice(0, 15)) {
+    lines.push(`  ${String(info.count).padStart(5)}  ${name} \u2192 ${info.taalId ?? "\u2014"} [${info.matched}]`);
+  }
+  if (r.failed > 0) {
+    lines.push("failures:");
+    for (const f of r.failures.slice(0, 10)) lines.push(`  ${f.file}: ${f.error}`);
+  }
+  return lines.join("\n");
+}
+var init_report = __esm({
+  "src/convert/report.ts"() {
+  }
+});
+
+// src/convert/index.ts
+function convertNltrHtml(html, opts = {}) {
+  return assemble(extractPage(html), opts);
+}
+var init_convert = __esm({
+  "src/convert/index.ts"() {
+    init_assemble();
+    init_extract();
+  }
+});
+
+// src/convert/batch.ts
+var batch_exports = {};
+__export(batch_exports, {
+  runConvert: () => runConvert
+});
+async function runConvert(input, opts = {}) {
+  const log = opts.log ?? ((line) => process.stderr.write(line + "\n"));
+  const stats = await promises.stat(input);
+  const files = stats.isDirectory() ? (await promises.readdir(input)).filter((f) => f.endsWith(".html")).sort((a, b) => (nltrIdOf(a) ?? 0) - (nltrIdOf(b) ?? 0) || a.localeCompare(b)).map((f) => path.join(input, f)) : [input];
+  const isDir = stats.isDirectory();
+  if (isDir && !opts.out) throw new Error("directory input requires -o <outDir>");
+  if (isDir && opts.out) await promises.mkdir(opts.out, { recursive: true });
+  const reports = [];
+  const failures = [];
+  for (const file of files) {
+    try {
+      const html = await promises.readFile(file, "utf8");
+      const { doc, report: report2 } = convertNltrHtml(html, { nltrId: nltrIdOf(file) });
+      reports.push(report2);
+      const json = serialize(doc, opts.compact);
+      if (isDir) {
+        const name = `${nltrIdOf(file) ?? path.basename(file, ".html")}.json`;
+        await promises.writeFile(path.join(opts.out, name), json);
+      } else if (opts.out) {
+        await promises.writeFile(opts.out, json);
+      } else {
+        process.stdout.write(json);
+      }
+    } catch (err) {
+      failures.push({ file: path.basename(file), error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  const report = aggregate(reports, failures);
+  if (opts.reportPath) await promises.writeFile(opts.reportPath, serialize(report, false));
+  if (!opts.quiet) log(formatSummary(report));
+  return { exitCode: failures.length > 0 ? 1 : 0, report };
+}
+var nltrIdOf, serialize;
+var init_batch = __esm({
+  "src/convert/batch.ts"() {
+    init_convert();
+    init_report();
+    nltrIdOf = (file) => {
+      const m = path.basename(file).match(/^(\d+)\.html$/);
+      return m ? Number(m[1]) : void 0;
+    };
+    serialize = (doc, compact) => (compact ? JSON.stringify(doc) : JSON.stringify(doc, null, 2)) + "\n";
+  }
+});
+
+// src/cli.ts
+init_spec();
+var VERSION = "0.1.0";
+var HELP = `swaralipi \u2014 Rabindrasangeet swaralipi toolkit (v${VERSION}, spec v${SPEC_VERSION})
+
+Usage:
+  swaralipi convert <html|dir> [options]   NLTR HTML \u2192 spec JSON
+
+Options:
+  -o, --out <path>      output file (single input) or directory (dir input)
+      --report <path>   write the aggregate decode report JSON here
+      --compact         minified JSON output (default: pretty, 2-space)
+      --quiet           suppress the summary on stderr
+  -v, --version         print version
+  -h, --help            print this help
+
+Examples:
+  swaralipi convert 4270.html                  # JSON to stdout
+  swaralipi convert nltr/html -o out/ --report out/_report.json
+
+Spec + types are available programmatically:
+  import { parseSwaralipi } from '@ugfoundation/swaralipi-js/spec';
+  import { convertNltrHtml } from '@ugfoundation/swaralipi-js/convert'; // Node-only
+`;
+async function main(argv) {
+  let parsed;
+  try {
+    parsed = util.parseArgs({
+      args: argv.slice(2),
+      allowPositionals: true,
+      options: {
+        out: { type: "string", short: "o" },
+        report: { type: "string" },
+        compact: { type: "boolean" },
+        quiet: { type: "boolean" },
+        version: { type: "boolean", short: "v" },
+        help: { type: "boolean", short: "h" }
+      }
+    });
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    console.error(HELP);
+    return 2;
+  }
+  const { values, positionals } = parsed;
+  if (values.version) {
+    console.log(VERSION);
+    return 0;
+  }
+  if (values.help || positionals.length === 0) {
+    console.log(HELP);
+    return 0;
+  }
+  const [cmd, input] = positionals;
+  if (cmd !== "convert") {
+    console.error(`Unknown command: ${cmd}
+`);
+    console.error(HELP);
+    return 1;
+  }
+  if (!input) {
+    console.error("convert: missing <html|dir> input\n");
+    console.error(HELP);
+    return 2;
+  }
+  const { runConvert: runConvert2 } = await Promise.resolve().then(() => (init_batch(), batch_exports));
+  try {
+    const { exitCode } = await runConvert2(input, {
+      out: values.out,
+      reportPath: values.report,
+      compact: values.compact,
+      quiet: values.quiet
+    });
+    return exitCode;
+  } catch (err) {
+    console.error(`convert: ${err instanceof Error ? err.message : String(err)}`);
+    return 2;
+  }
+}
+main(process.argv).then(
+  (code) => process.exit(code),
+  (err) => {
+    console.error(err);
+    process.exit(2);
+  }
+);
+//# sourceMappingURL=cli.cjs.map
+//# sourceMappingURL=cli.cjs.map