@mathvoice/react 0.1.0

package/dist/index.mjs

@@ -0,0 +1,777 @@
+// src/StudioEditor.tsx
+import { useCallback as useCallback2, useEffect, useRef, useState as useState2 } from "react";
+import katex from "katex";
+
+// src/lib/mathSpeak.ts
+function extractBraceGroup(s, pos) {
+  if (s[pos] !== "{") return null;
+  let depth = 1;
+  let i = pos + 1;
+  while (i < s.length && depth > 0) {
+    if (s[i] === "{") depth++;
+    else if (s[i] === "}") depth--;
+    i++;
+  }
+  if (depth !== 0) return null;
+  return [s.slice(pos + 1, i - 1), i];
+}
+function extractFrac(s) {
+  if (!s.startsWith("\\frac{")) return null;
+  const r1 = extractBraceGroup(s, 5);
+  if (!r1) return null;
+  const [num, p2] = r1;
+  if (s[p2] !== "{") return null;
+  const r2 = extractBraceGroup(s, p2);
+  if (!r2) return null;
+  return [num, r2[0], s.slice(r2[1])];
+}
+function extractSqrt(s) {
+  if (!s.startsWith("\\sqrt")) return null;
+  let pos = 5;
+  let index = null;
+  if (s[pos] === "[") {
+    const end = s.indexOf("]", pos + 1);
+    if (end === -1) return null;
+    index = s.slice(pos + 1, end);
+    pos = end + 1;
+  }
+  if (s[pos] !== "{") return null;
+  const r = extractBraceGroup(s, pos);
+  if (!r) return null;
+  return [index, r[0], s.slice(r[1])];
+}
+function processMathSpeakFrac(s) {
+  let result = "";
+  let i = 0;
+  while (i < s.length) {
+    if (s.startsWith("\\frac{", i)) {
+      const frac = extractFrac(s.slice(i));
+      if (frac) {
+        const [num, den, rest] = frac;
+        result += `start fraction ${latexToMathSpeak(num)} over ${latexToMathSpeak(den)} end fraction`;
+        i += s.slice(i).length - rest.length;
+        continue;
+      }
+    }
+    result += s[i];
+    i++;
+  }
+  return result;
+}
+function processMathSpeakSqrt(s) {
+  let result = "";
+  let i = 0;
+  while (i < s.length) {
+    if (s.startsWith("\\sqrt", i)) {
+      const sq = extractSqrt(s.slice(i));
+      if (sq) {
+        const [index, radicand, rest] = sq;
+        const spoken = index ? `${index} root of ${latexToMathSpeak(radicand)} end root` : `square root of ${latexToMathSpeak(radicand)} end root`;
+        result += spoken;
+        i += s.slice(i).length - rest.length;
+        continue;
+      }
+    }
+    result += s[i];
+    i++;
+  }
+  return result;
+}
+function latexToMathSpeak(latex) {
+  let s = latex;
+  s = processMathSpeakFrac(s);
+  s = processMathSpeakSqrt(s);
+  s = s.replace(
+    /\{([^{}]*)\}\^\{([^{}]*)\}/g,
+    (_m, b, e) => `${latexToMathSpeak(b)} to the power ${latexToMathSpeak(e)}`
+  );
+  s = s.replace(/([a-zA-Z0-9])\^\{2\}/g, "$1 squared");
+  s = s.replace(/([a-zA-Z0-9])\^\{3\}/g, "$1 cubed");
+  s = s.replace(/([a-zA-Z0-9])\^\{([^{}]*)\}/g, "$1 to the $2");
+  s = s.replace(/\\pm/g, " plus or minus ");
+  s = s.replace(/\\cdot|\\times/g, " times ");
+  s = s.replace(/\\infty/g, " infinity ");
+  s = s.replace(/\\pi/g, " pi ");
+  s = s.replace(/\\left\(|\\right\)/g, "");
+  s = s.replace(/\\[a-zA-Z]+/g, (m) => m.slice(1));
+  s = s.replace(/[{}]/g, " ");
+  s = s.replace(/\s+/g, " ").trim();
+  return s;
+}
+function parseLatexStructure(latex) {
+  const roles = {};
+  const frac = extractFrac(latex);
+  if (frac) {
+    const [num, den, rest] = frac;
+    roles.numerator = num;
+    roles.denominator = den;
+    return { type: "FRACTION", roles, rest };
+  }
+  const eqSplit = splitAtTopLevelEquals(latex);
+  if (eqSplit) {
+    roles.lhs = eqSplit[0].trim();
+    roles.rhs = eqSplit[1].trim();
+    return { type: "EQUALITY", roles };
+  }
+  const powM = latex.match(/^(\{[^{}]*\}|[a-zA-Z0-9\\]+)\^\{([^{}]*)\}(.*)$/);
+  if (powM) {
+    roles.base = powM[1].replace(/^\{|\}$/g, "");
+    roles.exponent = powM[2];
+    return { type: "POWER", roles, rest: powM[3] };
+  }
+  const sq = extractSqrt(latex);
+  if (sq) {
+    const [index, radicand, rest] = sq;
+    roles.index = index;
+    roles.radicand = radicand;
+    return { type: "SQRT", roles, rest };
+  }
+  return { type: "OPAQUE", roles };
+}
+function splitAtTopLevelEquals(latex) {
+  let depth = 0;
+  for (let i = 0; i < latex.length; i++) {
+    if (latex[i] === "{") depth++;
+    else if (latex[i] === "}") depth--;
+    else if (latex[i] === "=" && depth === 0) {
+      return [latex.slice(0, i), latex.slice(i + 1)];
+    }
+  }
+  return null;
+}
+
+// src/lib/mutateLatex.ts
+function splitAtTopLevelEquals2(latex) {
+  let depth = 0;
+  for (let i = 0; i < latex.length; i++) {
+    if (latex[i] === "{") depth++;
+    else if (latex[i] === "}") depth--;
+    else if (latex[i] === "=" && depth === 0) {
+      return [latex.slice(0, i), latex.slice(i + 1)];
+    }
+  }
+  return null;
+}
+function setRole(latex, role, newVal) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const struct = parseLatexStructure(latex);
+  const rest = (_a = struct.rest) != null ? _a : "";
+  if (struct.type === "FRACTION" && (role === "numerator" || role === "denominator")) {
+    const n = role === "numerator" ? newVal : (_b = struct.roles.numerator) != null ? _b : "";
+    const d = role === "denominator" ? newVal : (_c = struct.roles.denominator) != null ? _c : "";
+    return `\\frac{${n}}{${d}}${rest}`;
+  }
+  if (struct.type === "EQUALITY" && (role === "lhs" || role === "rhs")) {
+    const l = role === "lhs" ? newVal : (_d = struct.roles.lhs) != null ? _d : "";
+    const r = role === "rhs" ? newVal : (_e = struct.roles.rhs) != null ? _e : "";
+    return `${l} = ${r}`;
+  }
+  if (struct.type === "POWER" && (role === "base" || role === "exponent")) {
+    const b = role === "base" ? newVal : (_f = struct.roles.base) != null ? _f : "";
+    const e = role === "exponent" ? newVal : (_g = struct.roles.exponent) != null ? _g : "";
+    return `{${b}}^{${e}}${rest}`;
+  }
+  if (struct.type === "SQRT" && (role === "radicand" || role === "index")) {
+    const idx = role === "index" ? newVal : struct.roles.index;
+    const rad = role === "radicand" ? newVal : (_h = struct.roles.radicand) != null ? _h : "";
+    return idx ? `\\sqrt[${idx}]{${rad}}${rest}` : `\\sqrt{${rad}}${rest}`;
+  }
+  const frac = extractFrac(latex);
+  if (frac && (role === "numerator" || role === "denominator")) {
+    const [num, den, rest2] = frac;
+    const n = role === "numerator" ? newVal : num;
+    const d = role === "denominator" ? newVal : den;
+    return `\\frac{${n}}{${d}}${rest2}`;
+  }
+  throw new Error(`Cannot set role "${role}" in formula: ${latex}`);
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function removeTermFromSum(sum, term) {
+  const s = sum.replace(/\s+/g, " ").trim();
+  const t = term.replace(/\s+/g, " ").trim();
+  if (s === t) return "0";
+  const patterns = [
+    new RegExp(`^${escapeRegex(t)}\\s*\\+\\s*(.+)$`),
+    new RegExp(`^${escapeRegex(t)}\\s*-\\s*(.+)$`),
+    new RegExp(`^(.+)\\s*\\+\\s*${escapeRegex(t)}$`),
+    new RegExp(`^(.+)\\s*-\\s*${escapeRegex(t)}$`)
+  ];
+  for (const p of patterns) {
+    const m = s.match(p);
+    if (m) return m[1].trim() || "0";
+  }
+  return null;
+}
+function applyReplace(latex, intent) {
+  var _a, _b, _c, _d;
+  const role = (_a = intent.target) == null ? void 0 : _a.role;
+  const newVal = (_b = intent.value) == null ? void 0 : _b.raw;
+  if (!role || newVal === void 0) {
+    throw new Error("REPLACE_VALUE needs target.role and value.raw");
+  }
+  const struct = parseLatexStructure(latex);
+  const oldVal = (_d = (_c = struct.roles) == null ? void 0 : _c[role]) != null ? _d : "";
+  const after = setRole(latex, role, newVal);
+  return { after, diff: { op: "REPLACE_VALUE", role, before: oldVal, after: newVal } };
+}
+function applyDelete(latex, intent) {
+  var _a, _b, _c;
+  const role = (_a = intent.target) == null ? void 0 : _a.role;
+  if (!role) throw new Error("DELETE_NODE needs target.role");
+  const struct = parseLatexStructure(latex);
+  const oldVal = (_c = (_b = struct.roles) == null ? void 0 : _b[role]) != null ? _c : "?";
+  const after = setRole(latex, role, "");
+  return { after, diff: { op: "DELETE_NODE", role, before: oldVal != null ? oldVal : void 0 } };
+}
+function applyReparent(latex, intent) {
+  var _a, _b, _c, _d;
+  const srcRole = (_a = intent.source) == null ? void 0 : _a.role;
+  const tgtRole = (_b = intent.target) == null ? void 0 : _b.role;
+  if (!srcRole || !tgtRole) throw new Error("REPARENT_NODE needs source.role and target.role");
+  const struct = parseLatexStructure(latex);
+  const srcVal = (_c = struct.roles) == null ? void 0 : _c[srcRole];
+  const tgtVal = (_d = struct.roles) == null ? void 0 : _d[tgtRole];
+  if (!srcVal || !tgtVal) throw new Error(`Cannot find roles ${srcRole}, ${tgtRole}`);
+  let after = setRole(latex, srcRole, tgtVal);
+  after = setRole(after, tgtRole, srcVal);
+  return { after, diff: { op: "REPARENT_NODE", srcRole, tgtRole, srcVal, tgtVal } };
+}
+function applyNegate(latex, intent) {
+  var _a, _b;
+  const role = (_a = intent.target) == null ? void 0 : _a.role;
+  if (!role) throw new Error("NEGATE_NODE needs target.role");
+  const struct = parseLatexStructure(latex);
+  const val = (_b = struct.roles) == null ? void 0 : _b[role];
+  if (val === null || val === void 0) throw new Error(`Cannot find role ${role}`);
+  const negated = val.startsWith("-") ? val.slice(1) : `-${val}`;
+  const after = setRole(latex, role, negated);
+  return { after, diff: { op: "NEGATE_NODE", role, before: val, after: negated } };
+}
+function applyWrap(latex, intent) {
+  var _a, _b;
+  const role = (_a = intent.target) == null ? void 0 : _a.role;
+  if (!role) throw new Error("WRAP_NODE needs target.role");
+  const struct = parseLatexStructure(latex);
+  const val = (_b = struct.roles) == null ? void 0 : _b[role];
+  if (!val) throw new Error(`Cannot find role ${role}`);
+  let wrapped;
+  if (intent.wrapper === "SQRT") wrapped = `\\sqrt{${val}}`;
+  else if (intent.wrapper === "FRACTION") wrapped = `\\frac{${val}}{1}`;
+  else throw new Error("Unknown wrapper");
+  const after = setRole(latex, role, wrapped);
+  return { after, diff: { op: "WRAP_NODE", role, wrapper: intent.wrapper } };
+}
+function applyInverse(latex, intent) {
+  var _a, _b;
+  const eqSplit = splitAtTopLevelEquals2(latex);
+  if (!eqSplit) throw new Error("APPLY_INVERSE: no equation found (missing =)");
+  const [lhs, rhs] = eqSplit;
+  const val = (_b = (_a = intent.value) == null ? void 0 : _a.raw) != null ? _b : "1";
+  const op = intent.operation;
+  const applyOp = (side) => {
+    switch (op) {
+      case "ADD":
+        return `${side} + ${val}`;
+      case "SUBTRACT":
+        return `${side} - ${val}`;
+      case "MULTIPLY":
+        return `\\left(${side}\\right) \\cdot ${val}`;
+      case "DIVIDE":
+        return `\\frac{${side}}{${val}}`;
+      default:
+        throw new Error(`Unknown operation: ${op}`);
+    }
+  };
+  const newLhs = applyOp(lhs.trim());
+  const newRhs = applyOp(rhs.trim());
+  const after = `${newLhs} = ${newRhs}`;
+  return {
+    after,
+    diff: {
+      op: "APPLY_INVERSE",
+      operation: op,
+      value: val,
+      lhsBefore: lhs.trim(),
+      lhsAfter: newLhs,
+      rhsBefore: rhs.trim(),
+      rhsAfter: newRhs
+    }
+  };
+}
+function transposeTerm(latex, intent) {
+  var _a;
+  const eqSplit = splitAtTopLevelEquals2(latex);
+  if (!eqSplit) throw new Error("TRANSPOSE_TERM: no equation found");
+  const [lhs, rhs] = eqSplit.map((s) => s.trim());
+  const term = (_a = intent.term) == null ? void 0 : _a.raw;
+  if (!term) throw new Error("TRANSPOSE_TERM: term is required");
+  const removedFromLhs = removeTermFromSum(lhs, term);
+  if (removedFromLhs !== null) {
+    const negated = term.startsWith("-") ? term.slice(1).trim() : `-${term}`;
+    const newRhs = `${rhs} ${negated}`;
+    return {
+      after: `${removedFromLhs} = ${newRhs}`,
+      diff: { op: "TRANSPOSE_TERM", term, from: "lhs", to: "rhs", note: `Transposed: ${term} \u2192 ${negated}` }
+    };
+  }
+  const removedFromRhs = removeTermFromSum(rhs, term);
+  if (removedFromRhs !== null) {
+    const negated = term.startsWith("-") ? term.slice(1).trim() : `-${term}`;
+    const newLhs = `${lhs} ${negated}`;
+    return {
+      after: `${newLhs} = ${removedFromRhs}`,
+      diff: { op: "TRANSPOSE_TERM", term, from: "rhs", to: "lhs", note: `Transposed: ${term} \u2192 ${negated}` }
+    };
+  }
+  throw new Error(`Term "${term}" not found in either side of the equation`);
+}
+function mutateLatex(latex, intent, editMode) {
+  const before = latex;
+  try {
+    switch (intent.type) {
+      case "REPLACE_VALUE": {
+        const { after, diff } = applyReplace(latex, intent);
+        return { success: after !== before, before, after, diff };
+      }
+      case "DELETE_NODE": {
+        const { after, diff } = applyDelete(latex, intent);
+        return { success: true, before, after, diff };
+      }
+      case "REPARENT_NODE": {
+        const { after, diff } = applyReparent(latex, intent);
+        return { success: after !== before, before, after, diff };
+      }
+      case "NEGATE_NODE": {
+        const { after, diff } = applyNegate(latex, intent);
+        return { success: true, before, after, diff };
+      }
+      case "WRAP_NODE": {
+        const { after, diff } = applyWrap(latex, intent);
+        return { success: true, before, after, diff };
+      }
+      case "INSERT_NODE": {
+        const { after, diff } = applyReplace(latex, intent);
+        return { success: after !== before, before, after, diff };
+      }
+      case "APPLY_INVERSE": {
+        if (editMode !== "ALGEBRA") throw new Error("APPLY_INVERSE requires ALGEBRA mode");
+        const { after, diff } = applyInverse(latex, intent);
+        return { success: true, before, after, diff };
+      }
+      case "TRANSPOSE_TERM": {
+        if (editMode !== "ALGEBRA") throw new Error("TRANSPOSE_TERM requires ALGEBRA mode");
+        const { after, diff } = transposeTerm(latex, intent);
+        return { success: true, before, after, diff };
+      }
+      default:
+        throw new Error(`Unknown intent: ${intent.type}`);
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { success: false, before, after: before, diff: null, error: msg };
+  }
+}
+function formatDiff(d) {
+  var _a;
+  switch (d.op) {
+    case "REPLACE_VALUE":
+      return `${d.role}: ${d.before || "\u2205"} \u2192 ${d.after}`;
+    case "DELETE_NODE":
+      return `${d.role} deleted (was: ${d.before})`;
+    case "REPARENT_NODE":
+      return `Swapped ${d.srcRole} \u2194 ${d.tgtRole}`;
+    case "APPLY_INVERSE":
+      return `${d.operation} ${d.value} on both sides`;
+    case "TRANSPOSE_TERM":
+      return (_a = d.note) != null ? _a : "";
+    case "NEGATE_NODE":
+      return `Negated ${d.role}: ${d.before} \u2192 ${d.after}`;
+    case "WRAP_NODE":
+      return `Wrapped ${d.role} in ${d.wrapper}`;
+    default:
+      return JSON.stringify(d);
+  }
+}
+
+// src/lib/intent.ts
+var PATTERNS = [
+  {
+    p: /REPLACE\s+(?:the\s+)?(\w+)\s+(?:TO|with)\s+(.+)/i,
+    fn: (m) => ({ type: "REPLACE_VALUE", target: { role: m[1].toLowerCase() }, value: { raw: m[2].trim() } })
+  },
+  {
+    p: /(?:change|set|make|update|let)\s+(?:the\s+)?(\w+)\s+(?:to|be|equal(?:\s+to)?)\s+(.+)/i,
+    fn: (m) => ({ type: "REPLACE_VALUE", target: { role: m[1].toLowerCase() }, value: { raw: m[2].trim() } })
+  },
+  {
+    p: /(?:DELETE|remove|drop|erase)\s+(?:the\s+)?(\w+)/i,
+    fn: (m) => ({ type: "DELETE_NODE", target: { role: m[1].toLowerCase() } })
+  },
+  {
+    p: /(?:MOVE|move)\s+(.+?)\s+to\s+(?:the\s+)?OTHER_SIDE/i,
+    fn: (m) => ({ type: "TRANSPOSE_TERM", term: { raw: m[1].trim() } })
+  },
+  {
+    p: /(?:MOVE|move)\s+(?:the\s+)?(\w+)\s+TO\s+(?:the\s+)?(\w+)/i,
+    fn: (m) => ({ type: "REPARENT_NODE", source: { role: m[1].toLowerCase() }, target: { role: m[2].toLowerCase() } })
+  },
+  {
+    p: /negate\s+(?:the\s+)?(\w+)/i,
+    fn: (m) => ({ type: "NEGATE_NODE", target: { role: m[1].toLowerCase() } })
+  },
+  {
+    p: /wrap\s+(?:the\s+)?(\w+)\s+in\s+(?:a\s+)?(?:square\s+)?root/i,
+    fn: (m) => ({ type: "WRAP_NODE", target: { role: m[1].toLowerCase() }, wrapper: "SQRT" })
+  },
+  {
+    p: /SUBTRACT\s+(.+?)\s+from\s+BOTH_SIDES/i,
+    fn: (m) => ({ type: "APPLY_INVERSE", operation: "SUBTRACT", value: { raw: m[1].trim() } })
+  },
+  {
+    p: /DIVIDE\s+BOTH_SIDES\s+BY\s+(.+)/i,
+    fn: (m) => ({ type: "APPLY_INVERSE", operation: "DIVIDE", value: { raw: m[1].trim() } })
+  },
+  {
+    p: /MULTIPLY\s+BOTH_SIDES\s+BY\s+(.+)/i,
+    fn: (m) => ({ type: "APPLY_INVERSE", operation: "MULTIPLY", value: { raw: m[1].trim() } })
+  },
+  {
+    p: /ADD_BOTH\s+(.+)/i,
+    fn: (m) => ({ type: "APPLY_INVERSE", operation: "ADD", value: { raw: m[1].trim() } })
+  }
+];
+function parseIntentRegex(normalized) {
+  for (const { p, fn } of PATTERNS) {
+    const m = normalized.match(p);
+    if (m) {
+      return { intent: { ...fn(m), source_tier: "regex" }, confidence: 0.9 };
+    }
+  }
+  return { intent: null, confidence: 0 };
+}
+
+// src/lib/normalizeSpeech.ts
+var SUBS = [
+  [/\b(the\s+)?(top|upper)\b/g, "numerator"],
+  [/\b(the\s+)?(bottom|lower)\b/g, "denominator"],
+  [/\b(the\s+)?power\b/g, "exponent"],
+  [/\braised\s+to(\s+the)?\b/g, "exponent"],
+  [/\b(the\s+)?index\b/g, "exponent"],
+  [/\bradicand\b/g, "radicand"],
+  [/\bunder\s+the\s+root\b/g, "radicand"],
+  [/\b(the\s+)?left\s+side\b/g, "lhs"],
+  [/\b(the\s+)?right\s+side\b/g, "rhs"],
+  [/\b(the\s+)?base\b/g, "base"],
+  [/\b(set|change|replace|make|update|let)\b/g, "REPLACE"],
+  [/\b(delete|remove|drop|erase|take\s+out)\b/g, "DELETE"],
+  [/\b(add|insert|put|place)\b/g, "INSERT"],
+  [/\b(move|shift|transfer)\b/g, "MOVE"],
+  [/\bboth\s+sides?\b/g, "BOTH_SIDES"],
+  [/\b(subtract|minus)\b/g, "SUBTRACT"],
+  [/\bdivide(\s+both\s+sides?\s+by)?\b/g, "DIVIDE"],
+  [/\bmultiply(\s+both\s+sides?\s+by)?\b/g, "MULTIPLY"],
+  [/\badd\s+to\s+both\s+sides?\b/g, "ADD_BOTH"],
+  [/\b(\w+)\s+over\s+(\w+)\b/g, (_m, a, b) => `\\frac{${a}}{${b}}`],
+  [/\b(\w+)\s+squared\b/g, (_m, a) => `${a}^{2}`],
+  [/\b(\w+)\s+cubed\b/g, (_m, a) => `${a}^{3}`],
+  [/\bsquare\s+root\s+of\b/g, "\\sqrt"],
+  [/\bcube\s+root\s+of\b/g, "\\sqrt[3]"],
+  [/\bpi\b/g, "\\pi"],
+  [/\binfinity\b/g, "\\infty"],
+  [/\btheta\b/g, "\\theta"],
+  [/\balpha\b/g, "\\alpha"],
+  [/\bbeta\b/g, "\\beta"],
+  [/\blambda\b/g, "\\lambda"],
+  [/\bplus\s+or\s+minus\b/g, "\\pm"],
+  [/\bplus\b/g, "+"],
+  [/\bminus\b/g, "-"],
+  [/\btimes\b/g, "\\cdot"],
+  [/\bdivided\s+by\b/g, "/"],
+  [/\bequals?\b/g, "="],
+  [/\bto\b/g, "TO"],
+  [/\bwith\b/g, "WITH"],
+  [/\bby\b/g, "BY"],
+  [/\b(other|opposite)\s+side\b/g, "OTHER_SIDE"]
+];
+var KNOWN_TOKENS = /* @__PURE__ */ new Set([
+  "REPLACE",
+  "DELETE",
+  "INSERT",
+  "MOVE",
+  "SUBTRACT",
+  "DIVIDE",
+  "MULTIPLY",
+  "ADD_BOTH",
+  "BOTH_SIDES",
+  "numerator",
+  "denominator",
+  "exponent",
+  "radicand",
+  "lhs",
+  "rhs",
+  "base",
+  "TO"
+]);
+function normalizeSpeech(raw) {
+  let t = raw.toLowerCase().trim();
+  for (const [pattern, replacement] of SUBS) {
+    t = t.replace(pattern, replacement);
+  }
+  const tokens = t.split(/\s+/).filter((x) => x.length > 0);
+  const matched = tokens.filter((x) => KNOWN_TOKENS.has(x)).length;
+  const confidence = Math.min(0.95, 0.3 + matched / Math.max(tokens.length, 1) * 0.7);
+  return { normalized: t, tokens, confidence, raw };
+}
+
+// src/lib/intentProxy.ts
+async function callIntentProxy(opts) {
+  const { rawText, normalizedText, formulaContext, editMode, apiEndpoint } = opts;
+  const res = await fetch(apiEndpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ rawText, normalizedText, formulaContext, editMode })
+  });
+  if (!res.ok) throw new Error(`Intent API error: ${res.status}`);
+  return res.json();
+}
+
+// src/hooks/useUndoStack.ts
+import { useCallback, useState } from "react";
+var MAX = 50;
+function useUndoStack(initial) {
+  const [value, setValueState] = useState(initial);
+  const [undoStack, setUndo] = useState([]);
+  const [redoStack, setRedo] = useState([]);
+  const push = useCallback((next) => {
+    setUndo((prev) => {
+      const stack = [...prev, value];
+      return stack.length > MAX ? stack.slice(-MAX) : stack;
+    });
+    setRedo([]);
+    setValueState(next);
+  }, [value]);
+  const set = useCallback((next) => setValueState(next), []);
+  const undo = useCallback(() => {
+    setUndo((prev) => {
+      if (prev.length === 0) return prev;
+      const last = prev[prev.length - 1];
+      setRedo((r) => [...r, value]);
+      setValueState(last);
+      return prev.slice(0, -1);
+    });
+  }, [value]);
+  const redo = useCallback(() => {
+    setRedo((prev) => {
+      if (prev.length === 0) return prev;
+      const last = prev[prev.length - 1];
+      setUndo((u) => [...u, value]);
+      setValueState(last);
+      return prev.slice(0, -1);
+    });
+  }, [value]);
+  return {
+    value,
+    set,
+    push,
+    undo,
+    redo,
+    canUndo: undoStack.length > 0,
+    canRedo: redoStack.length > 0
+  };
+}
+
+// src/StudioEditor.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function StudioEditor({
+  initialLatex = "\\frac{-b}{2a}",
+  latex: controlledLatex,
+  onMutation,
+  editMode = "CORRECT",
+  voiceEnabled = true,
+  onModeChange,
+  apiEndpoint = "/api/intent",
+  className,
+  style
+}) {
+  const isControlled = controlledLatex !== void 0;
+  const undoStack = useUndoStack(initialLatex);
+  const internalLatex = undoStack.value;
+  const latex = isControlled ? controlledLatex : internalLatex;
+  const [internalMode, setInternalMode] = useState2(editMode);
+  const activeMode = onModeChange ? editMode : internalMode;
+  const formulaRef = useRef(null);
+  const [command, setCommand] = useState2("");
+  const [status, setStatus] = useState2("");
+  const [processing, setProcessing] = useState2(false);
+  const [srAnnounce, setSrAnnounce] = useState2("");
+  useEffect(() => {
+    if (!formulaRef.current) return;
+    try {
+      katex.render(latex, formulaRef.current, {
+        throwOnError: false,
+        displayMode: true,
+        output: "htmlAndMathml"
+      });
+    } catch {
+      formulaRef.current.textContent = latex;
+    }
+  }, [latex]);
+  const runPipeline = useCallback2(async (raw) => {
+    var _a;
+    const cmd = raw.trim();
+    if (!cmd || processing) return;
+    setProcessing(true);
+    setStatus("Parsing\u2026");
+    try {
+      const norm = normalizeSpeech(cmd);
+      let intent = null;
+      const regexResult = parseIntentRegex(norm.normalized);
+      if (regexResult.intent && regexResult.confidence >= 0.85) {
+        intent = regexResult.intent;
+      } else {
+        try {
+          intent = await callIntentProxy({
+            rawText: cmd,
+            normalizedText: norm.normalized,
+            formulaContext: { latex },
+            editMode: activeMode,
+            apiEndpoint
+          });
+        } catch {
+          setStatus("Network error \u2014 command not sent to server");
+          return;
+        }
+      }
+      if (!intent || intent.type === "UNKNOWN") {
+        setStatus(`Not understood: "${cmd}"`);
+        return;
+      }
+      if ((intent.type === "APPLY_INVERSE" || intent.type === "TRANSPOSE_TERM") && activeMode !== "ALGEBRA") {
+        setStatus("Switch to ALGEBRA mode for this operation");
+        return;
+      }
+      const result = mutateLatex(latex, intent, activeMode);
+      if (result.success) {
+        if (!isControlled) undoStack.push(result.after);
+        const detail = result.diff ? formatDiff(result.diff) : result.after;
+        setStatus(`\u2713 ${detail}`);
+        setSrAnnounce(`Formula updated: ${latexToMathSpeak(result.after)}`);
+        onMutation == null ? void 0 : onMutation(result);
+      } else {
+        setStatus((_a = result.error) != null ? _a : "Mutation failed");
+      }
+    } finally {
+      setProcessing(false);
+    }
+  }, [activeMode, apiEndpoint, isControlled, latex, onMutation, processing, undoStack]);
+  const handleSubmit = useCallback2((e) => {
+    e.preventDefault();
+    runPipeline(command);
+    setCommand("");
+  }, [command, runPipeline]);
+  const handleModeChange = useCallback2((m) => {
+    if (onModeChange) {
+      onModeChange(m);
+    } else {
+      setInternalMode(m);
+    }
+  }, [onModeChange]);
+  const ariaLabel = latexToMathSpeak(latex);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className,
+      style,
+      "data-mathvoice-editor": true,
+      children: [
+        /* @__PURE__ */ jsx(
+          "span",
+          {
+            role: "status",
+            "aria-live": "polite",
+            "aria-atomic": "true",
+            style: { position: "absolute", width: 1, height: 1, overflow: "hidden", clip: "rect(0,0,0,0)" },
+            children: srAnnounce
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            ref: formulaRef,
+            role: "img",
+            tabIndex: 0,
+            "aria-label": ariaLabel,
+            "data-mathvoice-formula": true
+          }
+        ),
+        !onModeChange && /* @__PURE__ */ jsx("nav", { "aria-label": "Edit mode", "data-mathvoice-modes": true, children: ["CORRECT", "ALGEBRA", "ASK"].map((m) => /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            "aria-pressed": activeMode === m,
+            onClick: () => handleModeChange(m),
+            "data-mode": m,
+            children: m
+          },
+          m
+        )) }),
+        /* @__PURE__ */ jsxs("form", { onSubmit: handleSubmit, "data-mathvoice-command": true, children: [
+          /* @__PURE__ */ jsx("label", { htmlFor: "mathvoice-cmd", style: { position: "absolute", width: 1, height: 1, overflow: "hidden" }, children: "Voice command" }),
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              id: "mathvoice-cmd",
+              type: "text",
+              value: command,
+              onChange: (e) => setCommand(e.target.value),
+              placeholder: 'Try: "change the denominator to n"',
+              "aria-label": "Type a voice command",
+              autoComplete: "off",
+              disabled: processing
+            }
+          ),
+          /* @__PURE__ */ jsx("button", { type: "submit", disabled: processing, "aria-label": "Run command", children: "Run" }),
+          voiceEnabled && /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              "aria-label": "Voice input (connect ASR in host app)",
+              "aria-pressed": false,
+              title: "Implement onStartListening prop to connect your ASR provider",
+              disabled: true,
+              children: "\u{1F3A4}"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx("div", { role: "status", "aria-live": "polite", "data-mathvoice-status": true, children: status }),
+        !isControlled && /* @__PURE__ */ jsxs("div", { "data-mathvoice-history": true, children: [
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              onClick: () => undoStack.undo(),
+              disabled: !undoStack.canUndo,
+              "aria-label": "Undo last edit",
+              children: "\u21A9 Undo"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              onClick: () => undoStack.redo(),
+              disabled: !undoStack.canRedo,
+              "aria-label": "Redo",
+              children: "\u21AA Redo"
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+export {
+  StudioEditor
+};