ooxml-ui 0.30.0 → 0.31.0

package/dist/pptx/ai/index.mjs

@@ -0,0 +1,2493 @@
+import { createChatHistoryStore } from '../chunk-LVDF75JU.mjs';
+export { createChatHistoryStore } from '../chunk-LVDF75JU.mjs';
+import { updateTextSegmentStyle } from '../chunk-CENGE3TZ.mjs';
+import { ThemePresets, PptxMarkdownConverter, hasTextProperties, hasShapeProperties } from 'ooxml-core/pptx';
+import { z } from 'zod';
+import { mergeTableElements } from 'ooxml-core/pptx/editor/ai/table-merge';
+export { mergeTableElements } from 'ooxml-core/pptx/editor/ai/table-merge';
+import * as mcp from 'ooxml-core/pptx/automation';
+import * as mcpSchemas from 'ooxml-core/pptx/automation/schemas';
+
+// src/pptx/ai/loader.ts
+var cached;
+async function loadAiSdk() {
+  if (cached !== void 0) {
+    return cached;
+  }
+  try {
+    cached = await import('ai');
+  } catch {
+    cached = null;
+  }
+  return cached;
+}
+async function isAiAvailable() {
+  return await loadAiSdk() !== null;
+}
+function resetAiSdkCache() {
+  cached = void 0;
+}
+
+// src/pptx/ai/deck-data-diff.ts
+function deckDataFieldChanged(a, b) {
+  return JSON.stringify(a) !== JSON.stringify(b);
+}
+
+// src/pptx/ai/config.ts
+function resolveChatTransport(options) {
+  const { sdk, connection } = options;
+  switch (connection.kind) {
+    case "endpoint": {
+      return new sdk.DefaultChatTransport({
+        api: connection.api,
+        headers: connection.headers,
+        body: connection.body,
+        credentials: connection.credentials,
+        fetch: connection.fetch
+      });
+    }
+    case "model": {
+      const agent = new sdk.ToolLoopAgent({
+        model: connection.model,
+        instructions: options.system ?? connection.system,
+        tools: options.toolsWithExecute ?? {},
+        stopWhen: sdk.stepCountIs(connection.maxSteps ?? options.maxSteps ?? 16)
+      });
+      return new sdk.DirectChatTransport({
+        agent
+      });
+    }
+    case "transport": {
+      return connection.transport;
+    }
+    default: {
+      const exhaustive = connection;
+      throw new Error(`Unknown AI connection kind: ${JSON.stringify(exhaustive)}`);
+    }
+  }
+}
+var CHARS_PER_TOKEN = 4;
+var NULL_FS = {
+  async writeFile() {
+  },
+  async writeBinaryFile() {
+  },
+  async createFolder() {
+  }
+};
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function clampToTokenBudget(text, maxTokens) {
+  const maxChars = maxTokens * CHARS_PER_TOKEN;
+  if (text.length <= maxChars) {
+    return text;
+  }
+  return `${text.slice(0, maxChars)}
+...[truncated to fit context budget]`;
+}
+function slideTitle(slide) {
+  for (const el of slide.elements) {
+    if ("text" in el && typeof el.text === "string" && el.text.trim()) {
+      return el.text.trim().split("\n")[0].slice(0, 80);
+    }
+  }
+  return void 0;
+}
+function elementBreakdown(elements) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const el of elements) {
+    counts.set(el.type, (counts.get(el.type) ?? 0) + 1);
+  }
+  return [...counts.entries()].map(([type, n]) => `${n} ${type}`).join(", ") || "empty";
+}
+function buildDeckOutline(slides, meta, options = {}) {
+  const limit = Math.min(options.maxSlides ?? slides.length, slides.length);
+  const header = `Deck: ${meta.title ?? "Untitled"} - ${meta.slideCount} slide(s), ${Math.round(
+    meta.width
+  )}x${Math.round(meta.height)}px. Active slide: ${meta.activeSlideIndex + 1}.`;
+  const lines = [header, ""];
+  for (let i = 0; i < limit; i++) {
+    const slide = slides[i];
+    const title = slideTitle(slide) ?? "(no title)";
+    const hidden = slide.hidden ? " [hidden]" : "";
+    lines.push(`Slide ${i + 1}${hidden}: ${title} - ${elementBreakdown(slide.elements)}`);
+  }
+  if (limit < slides.length) {
+    lines.push(`...and ${slides.length - limit} more slide(s).`);
+  }
+  return clampToTokenBudget(lines.join("\n"), options.maxTokens ?? 2e3);
+}
+async function buildSlideMarkdown(slides, slideIndex2, meta, options = {}) {
+  const slide = slides[slideIndex2];
+  if (!slide) {
+    throw new Error(`Slide index ${slideIndex2} out of range.`);
+  }
+  const data = {
+    slides: [slide],
+    width: meta.width,
+    height: meta.height
+  };
+  let markdown;
+  try {
+    const converter = new PptxMarkdownConverter(
+      "",
+      {
+        sourceName: meta.title ?? "deck.pptx",
+        includeSpeakerNotes: options.includeSpeakerNotes ?? true,
+        mediaFolderName: "media",
+        includeMetadata: false,
+        semanticMode: true
+      },
+      NULL_FS
+    );
+    markdown = await converter.convert(data);
+  } catch {
+    markdown = fallbackSlideText(slide, slideIndex2);
+  }
+  return clampToTokenBudget(markdown, options.maxTokens ?? 4e3);
+}
+function fallbackSlideText(slide, slideIndex2) {
+  const parts = [`# Slide ${slideIndex2 + 1}`];
+  for (const el of slide.elements) {
+    if ("text" in el && typeof el.text === "string" && el.text.trim()) {
+      parts.push(el.text.trim());
+    }
+  }
+  if (slide.notes) {
+    parts.push(`> Notes: ${slide.notes}`);
+  }
+  return parts.join("\n\n");
+}
+
+// src/pptx/ai/focused-context.ts
+function bounds(el) {
+  return `(${Math.round(el.x)},${Math.round(el.y)} ${Math.round(el.width)}x${Math.round(el.height)})`;
+}
+function elementLine(el) {
+  const text = "text" in el && typeof el.text === "string" ? el.text.trim().replace(/\s+/gu, " ") : "";
+  const snippet2 = text ? `: "${text.slice(0, 60)}"` : "";
+  return `  - ${el.type}#${el.id} ${bounds(el)}${snippet2}`;
+}
+function describeTable(el, maxCells) {
+  if (el.type !== "table" || !el.tableData) {
+    return [];
+  }
+  const rows = el.tableData.rows;
+  const cols = rows.reduce((max, row) => Math.max(max, row.cells.length), 0);
+  const lines = [`  ${rows.length}x${cols} table cells:`];
+  let rendered = 0;
+  for (let r = 0; r < rows.length; r++) {
+    if (rendered >= maxCells) {
+      lines.push("  ...[table truncated to fit context budget]");
+      break;
+    }
+    const cells = [];
+    for (const cell of rows[r].cells) {
+      if (rendered >= maxCells) {
+        cells.push("...");
+        break;
+      }
+      cells.push(cell.text.replace(/\s+/gu, " ").trim());
+      rendered += 1;
+    }
+    lines.push(`    R${r}: ${cells.join(" | ")}`);
+  }
+  return lines;
+}
+function describeElementTarget(slides, target, maxCells) {
+  const slide = slides[target.slideIndex];
+  const el = slide?.elements.find((e) => e.id === target.elementId);
+  if (!el) {
+    return `Element ${target.elementId} on slide ${target.slideIndex + 1} (not found).`;
+  }
+  const header = `Element ${el.type}#${el.id} on slide ${target.slideIndex + 1} ${bounds(el)}`;
+  const tableLines = describeTable(el, maxCells);
+  if (tableLines.length > 0) {
+    return [header, ...tableLines].join("\n");
+  }
+  if ("text" in el && typeof el.text === "string" && el.text.trim()) {
+    return `${header}
+  text: "${el.text.trim().replace(/\s+/gu, " ").slice(0, 200)}"`;
+  }
+  return header;
+}
+function describeSlideTarget(slides, target) {
+  const slide = slides[target.slideIndex];
+  if (!slide) {
+    return `Slide ${target.slideIndex + 1} (not found).`;
+  }
+  const title = slideTitle(slide) ?? "(no title)";
+  const lines = [`Slide ${target.slideIndex + 1}: ${title}`];
+  for (const el of slide.elements) {
+    lines.push(elementLine(el));
+  }
+  return lines.join("\n");
+}
+function buildFocusedTargetsContext(bridge, options = {}) {
+  const targets = bridge.getFocusedTargets?.() ?? [];
+  if (targets.length === 0) {
+    return void 0;
+  }
+  const slides = bridge.getSlides();
+  const maxCells = options.maxTableCells ?? 60;
+  const blocks = targets.map(
+    (target) => target.kind === "slide" ? describeSlideTarget(slides, target) : describeElementTarget(slides, target, maxCells)
+  );
+  const body = [
+    "The user has selected the following to focus on. Scope your work to these unless asked otherwise:",
+    "",
+    ...blocks
+  ].join("\n");
+  return clampToTokenBudget(body, options.maxTokens ?? 1500);
+}
+async function buildDeckContext(bridge, options) {
+  const meta = bridge.getDeckMeta();
+  const slides = bridge.getSlides();
+  const parts = [];
+  if (options.strategy === "outline") {
+    parts.push(buildDeckOutline(slides, meta, { maxTokens: options.maxTokens }));
+  } else if (options.strategy === "current-slide") {
+    parts.push(
+      await buildSlideMarkdown(slides, meta.activeSlideIndex, meta, {
+        maxTokens: options.maxTokens
+      })
+    );
+  }
+  const focus = buildFocusedTargetsContext(bridge, options.focus);
+  if (focus) {
+    parts.push(focus);
+  }
+  return parts.filter((part) => part.trim()).join("\n\n");
+}
+
+// src/pptx/ai/proposals-diff.ts
+function elementLabel(el) {
+  const text = "text" in el && typeof el.text === "string" ? el.text.trim() : "";
+  const snippet2 = text ? `: "${text.slice(0, 24)}${text.length > 24 ? "..." : ""}"` : "";
+  return `${el.type} ${el.id}${snippet2}`;
+}
+function diffElements(index, before, after, out) {
+  const beforeById = new Map(before.map((e) => [e.id, e]));
+  const afterById = new Map(after.map((e) => [e.id, e]));
+  for (const el of after) {
+    if (!beforeById.has(el.id)) {
+      out.push(`Slide ${index + 1}: add ${elementLabel(el)}`);
+    }
+  }
+  for (const el of before) {
+    if (!afterById.has(el.id)) {
+      out.push(`Slide ${index + 1}: remove ${elementLabel(el)}`);
+    }
+  }
+  for (const el of after) {
+    const prev = beforeById.get(el.id);
+    if (prev && JSON.stringify(prev) !== JSON.stringify(el)) {
+      out.push(`Slide ${index + 1}: modify ${elementLabel(el)}`);
+    }
+  }
+}
+function diffSlides(before, after) {
+  const out = [];
+  if (after.length > before.length) {
+    out.push(`Add ${after.length - before.length} slide(s) (total ${after.length}).`);
+  } else if (after.length < before.length) {
+    out.push(`Remove ${before.length - after.length} slide(s) (total ${after.length}).`);
+  }
+  const beforeById = new Map(before.map((s) => [s.id, s]));
+  const pairCount = Math.min(before.length, after.length);
+  for (let i = 0; i < pairCount; i++) {
+    const nextSlide = after[i];
+    const prevSlide = beforeById.get(nextSlide.id) ?? before[i];
+    if (!prevSlide) {
+      continue;
+    }
+    diffElements(i, prevSlide.elements, nextSlide.elements, out);
+    if ((prevSlide.notes ?? "") !== (nextSlide.notes ?? "")) {
+      out.push(`Slide ${i + 1}: update speaker notes`);
+    }
+    if (prevSlide.backgroundColor !== nextSlide.backgroundColor) {
+      out.push(`Slide ${i + 1}: change background`);
+    }
+  }
+  if (out.length === 0) {
+    out.push("No detectable changes.");
+  }
+  return out;
+}
+function humanizeDiffLine(line) {
+  return line.replace(
+    /\b(add|remove|modify) (\w+) [^\s:]+(: )?/gu,
+    (_match, verb, type, colon) => {
+      const article = verb === "add" ? "a" : "the";
+      const friendlyVerb = verb === "modify" ? "update" : verb;
+      return `${friendlyVerb} ${article} ${type}${colon ? " " : ""}`;
+    }
+  );
+}
+
+// src/pptx/ai/proposals.ts
+var counter = 0;
+function nextId() {
+  counter += 1;
+  return `proposal-${Date.now().toString(36)}-${counter}`;
+}
+function cloneSlides(slides) {
+  return structuredClone(slides);
+}
+var ProposalStore = class {
+  constructor(bridge, animator) {
+    this.bridge = bridge;
+    this.animator = animator;
+  }
+  bridge;
+  animator;
+  proposals = /* @__PURE__ */ new Map();
+  /** Apply an updater to the deck and animate the resulting element changes. */
+  applyAndAnimate(updater, label) {
+    const before = this.bridge.getSlides();
+    const after = this.animator ? updater(cloneSlides(before)) : null;
+    this.bridge.applySlidesUpdate(updater, label);
+    if (after) {
+      this.animator?.publish(before, after);
+    }
+  }
+  /**
+   * Stage an updater. Runs it against a clone of the current slides to compute
+   * a diff summary, but does NOT apply it to the live deck.
+   */
+  stage(label, updater) {
+    const before = this.bridge.getSlides();
+    const after = updater(cloneSlides(before));
+    const proposal = {
+      id: nextId(),
+      label,
+      summary: diffSlides(before, after),
+      createdAt: Date.now(),
+      updater
+    };
+    this.proposals.set(proposal.id, proposal);
+    return proposal;
+  }
+  /** List staged proposals (oldest first), without their updater closures. */
+  list() {
+    return [...this.proposals.values()].sort((a, b) => a.createdAt - b.createdAt).map(({ updater: _updater, ...view }) => view);
+  }
+  /** Number of staged proposals. */
+  get size() {
+    return this.proposals.size;
+  }
+  /** Look up one proposal's serialisable view. */
+  get(id) {
+    const p = this.proposals.get(id);
+    if (!p) {
+      return void 0;
+    }
+    const { updater: _updater, ...view } = p;
+    return view;
+  }
+  /**
+   * Apply a staged proposal to the live deck as a single history entry, then
+   * remove it. Returns `false` when the id is unknown.
+   */
+  apply(id) {
+    const p = this.proposals.get(id);
+    if (!p) {
+      return false;
+    }
+    this.applyAndAnimate(p.updater, p.label);
+    this.proposals.delete(id);
+    return true;
+  }
+  /** Drop a staged proposal without applying it. */
+  revert(id) {
+    return this.proposals.delete(id);
+  }
+  /**
+   * Apply every staged proposal in staged order. Each becomes its own history
+   * entry. Returns the number of proposals applied.
+   */
+  acceptAll() {
+    const ordered = [...this.proposals.values()].sort((a, b) => a.createdAt - b.createdAt);
+    for (const p of ordered) {
+      this.applyAndAnimate(p.updater, p.label);
+    }
+    const applied = ordered.length;
+    this.proposals.clear();
+    return applied;
+  }
+  /** Drop all staged proposals without applying them. */
+  clear() {
+    this.proposals.clear();
+  }
+};
+
+// src/pptx/ai/system-prompt.ts
+var BASE_SYSTEM_PROMPT = `You are the AI assistant embedded inside a PowerPoint (.pptx) viewer and editor.
+You help the user understand and edit the presentation that is open in front of them.
+
+Your tools are the same tools the "pptx-viewer-tools" (pptx-viewer-mcp) server
+exposes, run directly against the open deck (there is no file path; you never
+ask for one). They are grouped as:
+- Read/inspect: get_deck_overview (whole-deck outline), get_slide (one slide as
+  markdown + an element inventory with ids, types, bounds, z-order), get_element,
+  get_speaker_notes, find_text, get_theme, get_metadata, get_layouts,
+  find_placeholders, get_presentation_properties, run_accessibility_check,
+  convert_to_markdown, export_to_json (portable pptx-viewer-json document).
+- Navigate the user's view: go_to_slide, select_elements (highlights elements for
+  the user).
+- Edit elements: update_element, update_element_style, move/resize via
+  update_element, add_element, delete_elements, arrange_elements, clone_element,
+  group_elements/ungroup_elements, batch_update_elements, set_element_animation,
+  set_element_lock, replace_geometry, manage_hyperlinks.
+- Text, tables, charts, SmartArt: replace_text, manage_comments,
+  update_table_cells, manage_table_structure, merge_tables, create_chart,
+  update_chart, add_chart_series, remove_chart_series, update_chart_series_data,
+  manage_smart_art, apply_template.
+- Slides: add_slide, duplicate_slide, delete_slides, reorder_slides,
+  update_slide_properties (background/notes/visibility), set_slide_transition.
+- Theme + presentation: apply_theme_preset, update_theme_colors,
+  update_theme_fonts, set_canvas_size, update_metadata, manage_sections,
+  update_presentation_properties, apply_layout, import_from_json (replace the
+  whole deck from a pptx-viewer-json document; destructive, confirm first).
+
+Working with the user's SELECTION (focus):
+- The user can scope you to specific slides or elements: by selecting them on the
+  canvas, or with the chat's "point at an element" pick mode. When they do, each
+  turn includes a "The user has selected the following to focus on" block listing
+  those targets with their exact ids, types, and bounds.
+- Treat that focus as the scope of the request. Prefer the ids GIVEN there over
+  ids you guess or remember; act on those elements unless the user clearly asks
+  about something else. Example: two tables are focused and the user says "merge
+  these" -> call merge_tables with those two ids.
+- When no focus block is present, work from the active slide and the user's
+  words, inspecting first to find the right ids.
+
+How to work:
+- Before editing, inspect the relevant slide(s) with get_slide / get_element so
+  you use correct element ids and coordinates. Coordinates and sizes are in CSS
+  pixels; rotation is in degrees; colours are hex strings such as #1a1a1a.
+- Prefer the most specific tool for a change, and make one focused edit per tool
+  call. Use batch_update_elements when applying the same change to several
+  elements.
+- After acting, briefly tell the user what you did or are proposing, in plain
+  language, and cite slide numbers 1-based for the user (tool indexes are 0-based).
+- If a request is ambiguous or destructive (e.g. deleting slides), ask a short
+  clarifying question first.
+- Theme changes are the exception to staging: apply_theme_preset,
+  update_theme_colors, and update_theme_fonts take effect IMMEDIATELY and are
+  undoable. Say you HAVE applied them (e.g. "I've set the accent colour to red"),
+  never that you are proposing them.
+- Some viewers cannot apply presentation-level changes (metadata, sections,
+  layout, canvas size); if such a tool reports it is unavailable, tell the user
+  plainly instead of retrying.`;
+var WRITE_POLICY_NOTES = {
+  stage: `Write etiquette: your document edits are STAGED as proposals, not applied
+immediately. Describe each proposed change plainly so the user can review and
+accept or reject it. Do not claim a change is done; say it is proposed. (Theme
+changes are the exception noted above and apply immediately.)`,
+  approve: `Write etiquette: edits require explicit user approval before they take
+effect. Present each change and wait for confirmation. Deleting slides always
+requires approval.`,
+  auto: `Write etiquette: your edits are applied to the deck immediately and are
+undoable by the user. Still confirm what you changed. Deleting slides always
+requires the user's explicit approval.`
+};
+function buildSystemPrompt(options) {
+  const policy = options.writePolicy ?? "stage";
+  const parts = [BASE_SYSTEM_PROMPT, WRITE_POLICY_NOTES[policy]];
+  if (options.extras && options.extras.trim()) {
+    parts.push(options.extras.trim());
+  }
+  return parts.join("\n\n");
+}
+
+// src/pptx/ai/tools/executor-base.ts
+function routeWrite(ctx, label, updater, forceApproval = false) {
+  if (ctx.writePolicy === "auto" && !forceApproval) {
+    const before = ctx.bridge.getSlides();
+    const after = ctx.animator ? updater(structuredClone(before)) : null;
+    ctx.bridge.applySlidesUpdate(updater, label);
+    if (after) {
+      ctx.animator?.publish(before, after);
+    }
+    return { applied: true, summary: [label] };
+  }
+  const proposal = ctx.proposals.stage(label, updater);
+  return {
+    staged: true,
+    proposalId: proposal.id,
+    requiresApproval: forceApproval || ctx.writePolicy === "approve",
+    summary: proposal.summary
+  };
+}
+function requireSlide(slides, slideIndex2) {
+  if (!Number.isInteger(slideIndex2) || slideIndex2 < 0 || slideIndex2 >= slides.length) {
+    throw new Error(`Slide index ${slideIndex2} out of range (0-${slides.length - 1}).`);
+  }
+  return slides[slideIndex2];
+}
+function requireElement(slide, elementId2) {
+  const el = slide.elements.find((e) => e.id === elementId2);
+  if (!el) {
+    throw new Error(`Element '${elementId2}' not found on slide ${slide.slideNumber}.`);
+  }
+  return el;
+}
+function newElementId() {
+  return `el-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// src/pptx/ai/tools/merge-tools.ts
+var mergeTables = (ctx, input) => {
+  const p = input;
+  const mergedId = newElementId();
+  const result = routeWrite(ctx, `Merge tables on slide ${p.slideIndex + 1}`, (slides) => {
+    const slide = requireSlide(slides, p.slideIndex);
+    const elA = requireElement(slide, p.elementIdA);
+    const elB = requireElement(slide, p.elementIdB);
+    if (elA.type !== "table") {
+      throw new Error(`Element '${p.elementIdA}' is not a table.`);
+    }
+    if (elB.type !== "table") {
+      throw new Error(`Element '${p.elementIdB}' is not a table.`);
+    }
+    const merged = mergeTableElements(elA, elB, { direction: p.direction, id: mergedId });
+    const remove = /* @__PURE__ */ new Set([p.elementIdA, p.elementIdB]);
+    slide.elements = slide.elements.filter((e) => !remove.has(e.id));
+    slide.elements.push(merged);
+    return slides;
+  });
+  return { ...result, mergedElementId: mergedId };
+};
+var mergeExecutors = {
+  merge_tables: mergeTables
+};
+
+// src/pptx/ai/tools/nav-tools.ts
+var goToSlide = (ctx, input) => {
+  const p = input;
+  requireSlide(ctx.bridge.getSlides(), p.slideIndex);
+  ctx.bridge.goToSlide(p.slideIndex);
+  return { slideIndex: p.slideIndex, navigated: true };
+};
+var selectElements = (ctx, input) => {
+  const p = input;
+  const slide = requireSlide(ctx.bridge.getSlides(), p.slideIndex);
+  const known = new Set(slide.elements.map((e) => e.id));
+  const unknownIds = p.elementIds.filter((id) => !known.has(id));
+  if (unknownIds.length > 0) {
+    throw new Error(`Elements not found on slide ${p.slideIndex}: ${unknownIds.join(", ")}`);
+  }
+  ctx.bridge.selectElements(p.slideIndex, p.elementIds);
+  return { slideIndex: p.slideIndex, selectedCount: p.elementIds.length };
+};
+var navExecutors = {
+  go_to_slide: goToSlide,
+  select_elements: selectElements
+};
+function inventory(elements) {
+  return elements.map((el, z2) => ({
+    id: el.id,
+    type: el.type,
+    x: Math.round(el.x),
+    y: Math.round(el.y),
+    width: Math.round(el.width),
+    height: Math.round(el.height),
+    z: z2,
+    ...el.hidden ? { hidden: true } : {},
+    ..."text" in el && typeof el.text === "string" && el.text ? { text: el.text.slice(0, 120) } : {}
+  }));
+}
+var getDeckOverview = (ctx, input) => {
+  const p = input;
+  const meta = ctx.bridge.getDeckMeta();
+  const outline = buildDeckOutline(ctx.bridge.getSlides(), meta, { maxSlides: p.maxSlides });
+  return { meta, outline };
+};
+var getSlide = async (ctx, input) => {
+  const p = input;
+  const slides = ctx.bridge.getSlides();
+  const slide = requireSlide(slides, p.slideIndex);
+  const markdown = await buildSlideMarkdown(slides, p.slideIndex, ctx.bridge.getDeckMeta());
+  return { slideIndex: p.slideIndex, markdown, elements: inventory(slide.elements) };
+};
+var getElement = (ctx, input) => {
+  const p = input;
+  const slide = requireSlide(ctx.bridge.getSlides(), p.slideIndex);
+  const el = slide.elements.find((e) => e.id === p.elementId);
+  if (!el) {
+    throw new Error(`Element '${p.elementId}' not found on slide ${p.slideIndex}.`);
+  }
+  return el;
+};
+var getSpeakerNotes = (ctx, input) => {
+  const p = input;
+  const slide = requireSlide(ctx.bridge.getSlides(), p.slideIndex);
+  return { slideIndex: p.slideIndex, notes: slide.notes ?? "" };
+};
+function searchRegex(query, useRegex, caseSensitive) {
+  if (useRegex && (query.length > 200 || /\([^)]*[+*]\)[+*]/u.test(query))) {
+    return null;
+  }
+  const source = useRegex ? query : query.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+  try {
+    return new RegExp(source, caseSensitive ? "g" : "gi");
+  } catch {
+    return null;
+  }
+}
+var findText = (ctx, input) => {
+  const p = input;
+  const regex = searchRegex(p.query, p.useRegex === true, p.caseSensitive === true);
+  const matches = [];
+  if (!regex) {
+    return { query: p.query, matchCount: 0, matches };
+  }
+  ctx.bridge.getSlides().forEach((slide, slideIndex2) => {
+    for (const el of slide.elements) {
+      if ("text" in el && typeof el.text === "string" && regex.test(el.text)) {
+        matches.push({ slideIndex: slideIndex2, elementId: el.id, text: el.text.slice(0, 120) });
+      }
+      regex.lastIndex = 0;
+    }
+    if (slide.notes && regex.test(slide.notes)) {
+      matches.push({ slideIndex: slideIndex2, elementId: "notes", text: slide.notes.slice(0, 120) });
+    }
+    regex.lastIndex = 0;
+  });
+  return { query: p.query, matchCount: matches.length, matches };
+};
+var getTheme = (ctx) => {
+  const theme = ctx.bridge.getTheme();
+  return {
+    name: theme?.name,
+    colorScheme: theme?.colorScheme,
+    fontScheme: theme?.fontScheme,
+    availablePresets: Object.keys(ThemePresets)
+  };
+};
+var readExecutors = {
+  get_deck_overview: getDeckOverview,
+  get_slide: getSlide,
+  get_element: getElement,
+  get_speaker_notes: getSpeakerNotes,
+  find_text: findText,
+  get_theme: getTheme
+};
+
+// src/pptx/ai/tools/bespoke-registry.ts
+var slideIndex = z.number().int().min(0).describe("Zero-based slide index.");
+var elementId = z.string().describe("Target element id.");
+var BESPOKE_TOOL_ENTRIES = {
+  get_deck_overview: {
+    description: "Summarise the deck: slide count, dimensions, and a per-slide outline.",
+    schema: z.object({
+      maxSlides: z.number().int().min(1).optional().describe("Cap the number of slides listed.")
+    }),
+    executor: readExecutors.get_deck_overview
+  },
+  get_slide: {
+    description: "Return one slide as markdown plus an inventory of its elements (ids, types, bounds, z-order).",
+    schema: z.object({ slideIndex }),
+    executor: readExecutors.get_slide
+  },
+  get_element: {
+    description: "Return the full properties of a single element.",
+    schema: z.object({ slideIndex, elementId }),
+    executor: readExecutors.get_element
+  },
+  get_speaker_notes: {
+    description: "Return the speaker notes for a slide.",
+    schema: z.object({ slideIndex }),
+    executor: readExecutors.get_speaker_notes
+  },
+  find_text: {
+    description: "Find text across all slides and speaker notes.",
+    schema: z.object({
+      query: z.string().describe("Text or regular expression to search for."),
+      useRegex: z.boolean().optional().describe("Treat the query as a regular expression."),
+      caseSensitive: z.boolean().optional().describe("Match case exactly.")
+    }),
+    executor: readExecutors.find_text
+  },
+  get_theme: {
+    description: "Return the current theme name, colour scheme, font scheme, and available presets.",
+    schema: z.object({}),
+    executor: readExecutors.get_theme
+  },
+  go_to_slide: {
+    description: "Navigate the viewer to a slide by zero-based index.",
+    schema: z.object({ slideIndex }),
+    executor: navExecutors.go_to_slide
+  },
+  select_elements: {
+    description: "Select and highlight elements on a slide for the user (an empty list clears selection).",
+    schema: z.object({
+      slideIndex,
+      elementIds: z.array(z.string()).describe("Element ids to select.")
+    }),
+    executor: navExecutors.select_elements
+  },
+  merge_tables: {
+    description: "Merge two table elements on a slide into one, removing the originals.",
+    schema: z.object({
+      slideIndex,
+      elementIdA: z.string().describe("First table element id."),
+      elementIdB: z.string().describe("Second table element id."),
+      direction: z.enum(["vertical", "horizontal"]).optional().describe("Stack rows (vertical, default) or columns (horizontal).")
+    }),
+    executor: mergeExecutors.merge_tables
+  }
+};
+function noFile(schema) {
+  return "filePath" in schema.shape ? schema.omit({ filePath: true }) : schema;
+}
+function entry(description, schema, fn, commit, label, forceApproval = false) {
+  const spec = { fn, commit, label, forceApproval };
+  return { description, schema: noFile(schema), spec };
+}
+var MCP_TOOL_ENTRIES = {
+  // ── reads ────────────────────────────────────────────────────────────────
+  // (get_slide / find_text / get_theme are served by the viewer-optimised
+  // bespoke readers, which read live edited state and return model-friendly
+  // markdown / outlines; the MCP-only reads below have no bespoke equivalent.)
+  get_metadata: entry(
+    "Get presentation metadata (title, author, keywords, custom properties).",
+    mcpSchemas.GetMetadataSchema,
+    mcp.getMetadata,
+    "read",
+    "Get metadata"
+  ),
+  get_layouts: entry(
+    "List available slide layouts from the presentation masters.",
+    mcpSchemas.GetLayoutsSchema,
+    mcp.getLayouts,
+    "read",
+    "Get layouts"
+  ),
+  find_placeholders: entry(
+    "Discover all {{placeholder}} tokens in the presentation.",
+    mcpSchemas.FindPlaceholdersSchema,
+    mcp.findPlaceholdersT,
+    "read",
+    "Find placeholders"
+  ),
+  get_presentation_properties: entry(
+    "Get slideshow properties (show type, loop, advance mode, slide range).",
+    mcpSchemas.GetPresentationPropertiesSchema,
+    mcp.getPresentationProperties,
+    "read",
+    "Get presentation properties"
+  ),
+  run_accessibility_check: entry(
+    "Audit the presentation for accessibility issues (alt text, contrast, reading order).",
+    mcpSchemas.AccessibilityCheckSchema,
+    mcp.runAccessibilityCheck,
+    "read",
+    "Accessibility check"
+  ),
+  convert_to_markdown: entry(
+    "Convert the presentation to Markdown.",
+    mcpSchemas.ConvertToMarkdownSchema,
+    mcp.convertToMarkdown,
+    "read",
+    "Convert to markdown"
+  ),
+  export_to_json: entry(
+    "Export the presentation to the portable pptx-viewer-json document format.",
+    mcpSchemas.ExportToJsonSchema,
+    mcp.exportToJson,
+    "read",
+    "Export to JSON"
+  ),
+  // ── slide structure ────────────────────────────────────────────────────────
+  add_slide: entry(
+    "Add a new blank slide.",
+    mcpSchemas.AddSlideSchema,
+    mcp.addSlide,
+    "slides",
+    "Add slide"
+  ),
+  delete_slides: entry(
+    "Delete one or more slides by index.",
+    mcpSchemas.DeleteSlidesSchema,
+    mcp.deleteSlides,
+    "slides",
+    "Delete slides",
+    true
+  ),
+  reorder_slides: entry(
+    "Reorder slides by providing a new index order.",
+    mcpSchemas.ReorderSlidesSchema,
+    mcp.reorderSlides,
+    "slides",
+    "Reorder slides"
+  ),
+  duplicate_slide: entry(
+    "Duplicate a slide with fresh element ids.",
+    mcpSchemas.DuplicateSlideSchema,
+    mcp.duplicateSlide,
+    "slides",
+    "Duplicate slide"
+  ),
+  update_slide_properties: entry(
+    "Update a slide background, speaker notes, or visibility.",
+    mcpSchemas.UpdateSlidePropertiesSchema,
+    mcp.updateSlideProperties,
+    "slides",
+    "Update slide"
+  ),
+  set_slide_transition: entry(
+    "Set or remove a slide transition effect.",
+    mcpSchemas.SetSlideTransitionSchema,
+    mcp.setSlideTransition,
+    "slides",
+    "Set transition"
+  ),
+  // ── elements ────────────────────────────────────────────────────────────────
+  add_element: entry(
+    "Add a text, shape, image, table, or connector element.",
+    mcpSchemas.AddElementSchema,
+    mcp.addElement,
+    "slides",
+    "Add element"
+  ),
+  update_element: entry(
+    "Update an element position, size, rotation, text, or basic style.",
+    mcpSchemas.UpdateElementSchema,
+    mcp.updateElement,
+    "slides",
+    "Update element"
+  ),
+  rename_element: entry(
+    "Rename an element (the name shown in the selection pane).",
+    mcpSchemas.RenameElementSchema,
+    mcp.renameElement,
+    "slides",
+    "Rename element"
+  ),
+  delete_elements: entry(
+    "Delete one or more elements by id.",
+    mcpSchemas.DeleteElementsSchema,
+    mcp.deleteElements,
+    "slides",
+    "Delete elements"
+  ),
+  arrange_elements: entry(
+    "Align elements or change their z-order (layer).",
+    mcpSchemas.ArrangeElementsSchema,
+    mcp.arrangeElements,
+    "slides",
+    "Arrange elements"
+  ),
+  clone_element: entry(
+    "Clone an element within or across slides.",
+    mcpSchemas.CloneElementSchema,
+    mcp.cloneElement,
+    "slides",
+    "Clone element"
+  ),
+  set_element_animation: entry(
+    "Set an entrance/exit/emphasis animation on an element.",
+    mcpSchemas.SetElementAnimationSchema,
+    mcp.setElementAnimation,
+    "slides",
+    "Set animation"
+  ),
+  group_elements: entry(
+    "Group multiple elements into a group.",
+    mcpSchemas.GroupElementsSchema,
+    mcp.groupElements,
+    "slides",
+    "Group elements"
+  ),
+  ungroup_elements: entry(
+    "Ungroup a group back into individual elements.",
+    mcpSchemas.UngroupElementsSchema,
+    mcp.ungroupElements,
+    "slides",
+    "Ungroup elements"
+  ),
+  batch_update_elements: entry(
+    "Apply the same property changes to multiple elements at once.",
+    mcpSchemas.BatchUpdateElementsSchema,
+    mcp.batchUpdateElements,
+    "slides",
+    "Update elements"
+  ),
+  update_element_style: entry(
+    "Update fill, stroke, shadow, glow, reflection, or image effects on an element.",
+    mcpSchemas.UpdateElementStyleSchema,
+    mcp.updateElementStyle,
+    "slides",
+    "Update style"
+  ),
+  replace_geometry: entry(
+    "Replace a shape geometry with a preset or custom path.",
+    mcpSchemas.ReplaceGeometrySchema,
+    mcp.replaceGeometry,
+    "slides",
+    "Replace geometry"
+  ),
+  set_element_lock: entry(
+    "Lock or unlock an element (move, resize, rotate, select, or text edit).",
+    mcpSchemas.SetElementLockSchema,
+    mcp.setElementLockT,
+    "slides",
+    "Set element lock"
+  ),
+  manage_hyperlinks: entry(
+    "List, set, or remove hyperlinks/actions on elements.",
+    mcpSchemas.ManageHyperlinksSchema,
+    mcp.manageHyperlinks,
+    "slides",
+    "Manage hyperlinks"
+  ),
+  // ── text / tables / charts / smartart ───────────────────────────────────────
+  replace_text: entry(
+    "Find and replace text across slides.",
+    mcpSchemas.ReplaceTextSchema,
+    mcp.replaceText,
+    "slides",
+    "Replace text"
+  ),
+  manage_comments: entry(
+    "List, add, delete, or resolve slide comments.",
+    mcpSchemas.ManageCommentsSchema,
+    mcp.manageComments,
+    "slides",
+    "Manage comments"
+  ),
+  update_table_cells: entry(
+    "Update the text of specific table cells.",
+    mcpSchemas.UpdateTableCellsSchema,
+    mcp.updateTableCells,
+    "slides",
+    "Update table cells"
+  ),
+  manage_table_structure: entry(
+    "Insert or delete table rows and columns.",
+    mcpSchemas.ManageTableStructureSchema,
+    mcp.manageTableStructure,
+    "slides",
+    "Change table structure"
+  ),
+  create_chart: entry(
+    "Create a new chart element on a slide.",
+    mcpSchemas.CreateChartSchema,
+    mcp.createChart,
+    "slides",
+    "Create chart"
+  ),
+  update_chart: entry(
+    "Update chart type, title, legend, data labels, axis, or categories.",
+    mcpSchemas.UpdateChartSchema,
+    mcp.updateChart,
+    "slides",
+    "Update chart"
+  ),
+  add_chart_series: entry(
+    "Add a data series to an existing chart.",
+    mcpSchemas.AddChartSeriesSchema,
+    mcp.addChartSeriesT,
+    "slides",
+    "Add chart series"
+  ),
+  remove_chart_series: entry(
+    "Remove a data series from a chart by index.",
+    mcpSchemas.RemoveChartSeriesSchema,
+    mcp.removeChartSeriesT,
+    "slides",
+    "Remove chart series"
+  ),
+  update_chart_series_data: entry(
+    "Update the data values of a chart series.",
+    mcpSchemas.UpdateChartSeriesDataSchema,
+    mcp.updateChartSeriesData,
+    "slides",
+    "Update chart data"
+  ),
+  chart_user_shape_list: entry(
+    "List a chart's drawing-overlay shapes (c:userShapes).",
+    mcpSchemas.ListChartUserShapesSchema,
+    mcp.listChartUserShapesT,
+    "read",
+    "List chart overlay shapes"
+  ),
+  chart_user_shape_add: entry(
+    "Add a drawing-overlay shape (text box or connector) to a chart's c:userShapes.",
+    mcpSchemas.AddChartUserShapeSchema,
+    mcp.addChartUserShapeT,
+    "slides",
+    "Add chart overlay shape"
+  ),
+  chart_user_shape_update: entry(
+    "Move, resize, or restyle one of a chart's drawing-overlay shapes by index.",
+    mcpSchemas.UpdateChartUserShapeSchema,
+    mcp.updateChartUserShapeT,
+    "slides",
+    "Update chart overlay shape"
+  ),
+  chart_user_shape_remove: entry(
+    "Remove one of a chart's drawing-overlay shapes by index.",
+    mcpSchemas.RemoveChartUserShapeSchema,
+    mcp.removeChartUserShapeT,
+    "slides",
+    "Remove chart overlay shape"
+  ),
+  manage_smart_art: entry(
+    "Manage SmartArt: get, add, remove, reorder, promote/demote nodes, or decompose to shapes.",
+    mcpSchemas.ManageSmartArtSchema,
+    mcp.manageSmartArt,
+    "slides",
+    "Edit SmartArt"
+  ),
+  ole_get_content: entry(
+    "Read an embedded OLE object's editable content: a spreadsheet grid, document paragraphs, or nested-deck slide titles, depending on its kind.",
+    mcpSchemas.GetOleContentSchema,
+    mcp.getOleContent,
+    "read",
+    "Read OLE content"
+  ),
+  ole_set_sheet_cell: entry(
+    "Edit one cell of an embedded Excel object's first worksheet.",
+    mcpSchemas.SetOleSheetCellSchema,
+    mcp.setOleSheetCell,
+    "slides",
+    "Edit spreadsheet cell"
+  ),
+  ole_set_document_paragraph: entry(
+    "Replace one paragraph's text in an embedded Word document object.",
+    mcpSchemas.SetOleDocumentParagraphSchema,
+    mcp.setOleDocumentParagraph,
+    "slides",
+    "Edit document paragraph"
+  ),
+  ole_set_deck_slide_title: entry(
+    "Edit one text-bearing shape on one slide of an embedded nested-presentation object (call ole_get_content first for its elementId).",
+    mcpSchemas.SetOleDeckSlideTitleSchema,
+    mcp.setOleDeckSlideTitle,
+    "slides",
+    "Edit nested slide text"
+  ),
+  ole_replace_file: entry(
+    "Replace an embedded OLE object's entire payload with a new file (works for any object kind, including a packaged/unsupported one).",
+    mcpSchemas.ReplaceOleFileSchema,
+    mcp.replaceOleFileT,
+    "slides",
+    "Replace OLE file"
+  ),
+  ole_set_object_name: entry(
+    "Rename an embedded OLE object's Object Name (p:oleObj/@name), regenerating the icon caption when shown as an icon.",
+    mcpSchemas.SetOleObjectNameSchema,
+    mcp.setOleObjectNameT,
+    "slides",
+    "Rename OLE object"
+  ),
+  apply_template: entry(
+    "Replace {{placeholder}} tokens with provided values (mail merge).",
+    mcpSchemas.ApplyTemplateSchema,
+    mcp.applyTemplateT,
+    "slides",
+    "Apply template"
+  ),
+  apply_layout: entry(
+    "Apply a slide layout to a specific slide.",
+    mcpSchemas.ApplyLayoutSchema,
+    mcp.applyLayout,
+    "slides",
+    "Apply layout"
+  ),
+  // ── theme (applied immediately, undoable) ────────────────────────────────────
+  apply_theme_preset: entry(
+    "Apply a built-in theme preset.",
+    mcpSchemas.ApplyThemePresetSchema,
+    mcp.applyThemePreset,
+    "theme",
+    "Apply theme preset"
+  ),
+  update_theme_colors: entry(
+    "Update individual theme colours (accent1-6, dk1/2, lt1/2, hlink, folHlink).",
+    mcpSchemas.UpdateThemeColorsSchema,
+    mcp.updateThemeColors,
+    "theme",
+    "Update theme colours"
+  ),
+  update_theme_fonts: entry(
+    "Update the theme heading (major) and body (minor) fonts.",
+    mcpSchemas.UpdateThemeFontsSchema,
+    mcp.updateThemeFonts,
+    "theme",
+    "Update theme fonts"
+  ),
+  // ── presentation-level (needs applyDeckData) ─────────────────────────────────
+  set_canvas_size: entry(
+    "Change the presentation canvas dimensions.",
+    mcpSchemas.SetCanvasSizeSchema,
+    mcp.setCanvasSize,
+    "deck",
+    "Set canvas size"
+  ),
+  update_metadata: entry(
+    "Update presentation metadata (title, author, company, custom properties).",
+    mcpSchemas.UpdateMetadataSchema,
+    mcp.updateMetadata,
+    "deck",
+    "Update metadata"
+  ),
+  manage_sections: entry(
+    "List, add, remove, reorder sections, or move slides between sections.",
+    mcpSchemas.ManageSectionsSchema,
+    mcp.manageSections,
+    "deck",
+    "Manage sections"
+  ),
+  update_presentation_properties: entry(
+    "Update slideshow properties (show type, loop, advance mode, pen colour).",
+    mcpSchemas.UpdatePresentationPropertiesSchema,
+    mcp.updatePresentationProperties,
+    "deck",
+    "Update presentation properties"
+  ),
+  import_from_json: entry(
+    "Replace the whole presentation with a deck imported from a pptx-viewer-json document.",
+    mcpSchemas.ImportFromJsonSchema,
+    mcp.importFromJson,
+    "deck",
+    "Import from JSON",
+    true
+  )
+};
+
+// src/pptx/ai/tools/shared-tool-runner.ts
+function buildWorkingData(ctx) {
+  const meta = ctx.bridge.getDeckMeta();
+  const base = ctx.bridge.getDeckData?.();
+  const working = base ? structuredClone(base) : { slides: [], width: meta.width, height: meta.height };
+  working.slides = structuredClone(ctx.bridge.getSlides());
+  working.theme = ctx.bridge.getTheme() ?? working.theme;
+  working.width = meta.width;
+  working.height = meta.height;
+  return working;
+}
+function asObject(value) {
+  return value && typeof value === "object" ? value : { result: value };
+}
+async function runSharedTool(ctx, spec, input) {
+  const working = buildWorkingData(ctx);
+  const toolCtx = { pptxData: working };
+  const res = await spec.fn(toolCtx, input);
+  if (spec.commit === "read" || !res.dirty) {
+    return res.result;
+  }
+  const next = res.pptxData;
+  if (spec.commit === "theme") {
+    if (next.theme) {
+      ctx.bridge.applyTheme(next.theme);
+    }
+    return { ...asObject(res.result), applied: true };
+  }
+  if (spec.commit === "deck") {
+    if (!ctx.bridge.applyDeckData) {
+      throw new Error(
+        "This change affects presentation-level data (metadata, sections, layout, or canvas size), which this viewer cannot apply yet."
+      );
+    }
+    ctx.bridge.applyDeckData(() => structuredClone(next), spec.label);
+    return { ...asObject(res.result), applied: true };
+  }
+  const nextSlides = next.slides;
+  const write = routeWrite(ctx, spec.label, () => structuredClone(nextSlides), spec.forceApproval);
+  return { ...asObject(res.result), ...write };
+}
+
+// src/pptx/ai/tools/registry.ts
+function buildAllTools() {
+  const map = {};
+  for (const [name, e] of Object.entries(MCP_TOOL_ENTRIES)) {
+    map[name] = {
+      description: e.description,
+      schema: e.schema,
+      run: (ctx, input) => runSharedTool(ctx, e.spec, input)
+    };
+  }
+  for (const [name, e] of Object.entries(BESPOKE_TOOL_ENTRIES)) {
+    map[name] = { description: e.description, schema: e.schema, run: e.executor };
+  }
+  return map;
+}
+var ALL_TOOLS = buildAllTools();
+function allToolNames() {
+  return Object.keys(ALL_TOOLS);
+}
+function enabledToolNames(config) {
+  const allowed = config.tools?.enabled ? new Set(config.tools.enabled) : null;
+  const denied = new Set(config.tools?.disabled ?? []);
+  return allToolNames().filter((name) => (allowed ? allowed.has(name) : true) && !denied.has(name));
+}
+function buildToolExecutors(bridge, proposals, config, animator) {
+  const ctx = {
+    bridge,
+    proposals,
+    writePolicy: config.writePolicy ?? "stage",
+    animator
+  };
+  const map = /* @__PURE__ */ new Map();
+  for (const name of enabledToolNames(config)) {
+    const tool = ALL_TOOLS[name];
+    if (tool) {
+      map.set(name, async (input) => tool.run(ctx, input));
+    }
+  }
+  return map;
+}
+function buildToolSet(sdk, config, executors, options) {
+  const tools = {};
+  for (const name of enabledToolNames(config)) {
+    const tool = ALL_TOOLS[name];
+    if (!tool) {
+      continue;
+    }
+    const base = { description: tool.description, inputSchema: tool.schema };
+    const execute = options.withExecute ? executors.get(name) : void 0;
+    tools[name] = execute ? sdk.tool({ ...base, execute }) : sdk.tool(base);
+  }
+  return { ...tools, ...config.tools?.extra ?? {} };
+}
+
+// src/pptx/ai/change-diff.ts
+function bounds2(el) {
+  return { x: el.x, y: el.y, width: el.width, height: el.height };
+}
+function moved(a, b) {
+  return Math.abs(a.x - b.x) > 0.5 || Math.abs(a.y - b.y) > 0.5;
+}
+function resized(a, b) {
+  return Math.abs(a.width - b.width) > 0.5 || Math.abs(a.height - b.height) > 0.5;
+}
+function textOf(el) {
+  return "text" in el && typeof el.text === "string" ? el.text : void 0;
+}
+function styleSignature(el) {
+  const rest = { ...el };
+  delete rest["x"];
+  delete rest["y"];
+  delete rest["width"];
+  delete rest["height"];
+  delete rest["id"];
+  delete rest["rotation"];
+  return JSON.stringify(rest);
+}
+function classify(before, after) {
+  if (moved(before, after)) {
+    return "moved";
+  }
+  if (resized(before, after)) {
+    return "resized";
+  }
+  if (textOf(before) !== textOf(after)) {
+    return "text";
+  }
+  if (styleSignature(before) !== styleSignature(after)) {
+    return "restyled";
+  }
+  return null;
+}
+function diffChangedElements(before, after) {
+  const changes = [];
+  const beforeById = new Map(before.map((s) => [s.id, s]));
+  after.forEach((afterSlide, slideIndex2) => {
+    const beforeSlide = beforeById.get(afterSlide.id) ?? before[slideIndex2];
+    const beforeEls = new Map((beforeSlide?.elements ?? []).map((e) => [e.id, e]));
+    const afterIds = new Set(afterSlide.elements.map((e) => e.id));
+    for (const el of afterSlide.elements) {
+      const prev = beforeEls.get(el.id);
+      if (!prev) {
+        changes.push({ slideIndex: slideIndex2, elementId: el.id, kind: "added", to: bounds2(el) });
+        continue;
+      }
+      const kind = classify(prev, el);
+      if (kind) {
+        changes.push({ slideIndex: slideIndex2, elementId: el.id, kind, from: bounds2(prev), to: bounds2(el) });
+      }
+    }
+    for (const prev of beforeSlide?.elements ?? []) {
+      if (!afterIds.has(prev.id)) {
+        changes.push({
+          slideIndex: slideIndex2,
+          elementId: prev.id,
+          kind: "removed",
+          from: bounds2(prev)
+        });
+      }
+    }
+  });
+  return changes;
+}
+
+// src/pptx/ai/change-animator.ts
+var DEFAULTS = {
+  enabled: true,
+  durationMs: 900,
+  glow: true,
+  tween: true,
+  color: "rgba(59,130,246,1)"
+};
+function resolveChangeAnimationConfig(config) {
+  return {
+    enabled: config?.enabled ?? DEFAULTS.enabled,
+    durationMs: config?.durationMs ?? DEFAULTS.durationMs,
+    glow: config?.glow ?? DEFAULTS.glow,
+    tween: config?.tween ?? DEFAULTS.tween,
+    color: config?.color ?? DEFAULTS.color
+  };
+}
+var defaultSchedule = (fn, ms) => {
+  const id = setTimeout(fn, ms);
+  return () => clearTimeout(id);
+};
+function createAiChangeAnimator(config, schedule = defaultSchedule) {
+  let resolved = resolveChangeAnimationConfig(config);
+  let batch = null;
+  let nonce = 0;
+  let cancelClear = null;
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = () => {
+    for (const l of listeners) {
+      l(batch);
+    }
+  };
+  return {
+    publish(before, after) {
+      if (!resolved.enabled) {
+        return null;
+      }
+      const changes = diffChangedElements(before, after);
+      if (changes.length === 0) {
+        return null;
+      }
+      cancelClear?.();
+      nonce += 1;
+      batch = { changes, slideIndex: changes[0].slideIndex, nonce, config: resolved };
+      emit();
+      cancelClear = schedule(() => {
+        batch = null;
+        cancelClear = null;
+        emit();
+      }, resolved.durationMs + 250);
+      return batch;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    current: () => batch,
+    configure(next) {
+      resolved = resolveChangeAnimationConfig(next);
+    },
+    dispose() {
+      cancelClear?.();
+      cancelClear = null;
+      listeners.clear();
+      batch = null;
+    }
+  };
+}
+
+// src/pptx/ai/session.ts
+async function createAiChatSession(bridge, config) {
+  const sdk = await loadAiSdk();
+  if (!sdk) {
+    throw new Error(
+      'The optional "ai" SDK is not installed. Install `ai` (>=6 <8) to enable the assistant.'
+    );
+  }
+  const changeAnimator = createAiChangeAnimator(config.changeAnimation);
+  const proposals = new ProposalStore(bridge, changeAnimator);
+  const executors = buildToolExecutors(bridge, proposals, config, changeAnimator);
+  const tools = buildToolSet(sdk, config, executors, { withExecute: false });
+  const systemPrompt = buildSystemPrompt({
+    writePolicy: config.writePolicy ?? "stage",
+    extras: config.systemPromptExtras
+  });
+  const connection = config.connection;
+  const toolsWithExecute = connection.kind === "model" ? buildToolSet(sdk, config, executors, { withExecute: true }) : void 0;
+  const transport = resolveChatTransport({
+    sdk,
+    connection,
+    toolsWithExecute,
+    system: systemPrompt
+  });
+  return {
+    transport,
+    tools,
+    systemPrompt,
+    proposals,
+    changeAnimator,
+    sendAutomaticallyWhen: sdk.lastAssistantMessageIsCompleteWithToolCalls,
+    // The in-process `model` agent runs tools itself; every other connection
+    // needs the binding to run them client-side. See the field doc above.
+    clientExecutesTools: connection.kind !== "model",
+    async executeToolCall(toolName, input) {
+      const executor = executors.get(toolName);
+      if (!executor) {
+        throw new Error(`Unknown tool: ${toolName}`);
+      }
+      return executor(input);
+    }
+  };
+}
+
+// src/pptx/ai/change-animation-css.ts
+var AI_CHANGE_ATTR = "data-pptx-ai-changed";
+function aiChangeAnimationCss(config) {
+  const { color, durationMs } = config;
+  return `
+@keyframes pptx-ai-change-glow {
+	0% { box-shadow: 0 0 0 0 ${color}, 0 0 0 0 ${color}; }
+	50% { box-shadow: 0 0 0 4px transparent, 0 0 16px 5px ${color}; }
+	100% { box-shadow: 0 0 0 0 transparent, 0 0 10px 2px transparent; }
+}
+[${AI_CHANGE_ATTR}] {
+	animation: pptx-ai-change-glow ${durationMs}ms ease-out;
+	outline: 2px solid ${color};
+	outline-offset: 1px;
+	border-radius: 3px;
+	transition: color ${Math.round(durationMs / 2)}ms ease, fill ${Math.round(durationMs / 2)}ms ease,
+		stroke ${Math.round(durationMs / 2)}ms ease, background-color ${Math.round(durationMs / 2)}ms ease;
+}
+`;
+}
+var PAD = 3;
+function changeGhostStyle(change, phase, config) {
+  const at = phase === "start" ? change.from ?? change.to : change.to ?? change.from;
+  const box = at ?? { x: 0, y: 0, width: 0, height: 0 };
+  const ms = config.durationMs;
+  const tween = config.tween;
+  let opacity = 1;
+  let transform = "scale(1)";
+  if (change.kind === "added") {
+    opacity = phase === "start" ? 0 : 1;
+    transform = phase === "start" ? "scale(0.92)" : "scale(1)";
+  } else if (change.kind === "removed") {
+    opacity = phase === "start" ? 0.9 : 0;
+    transform = phase === "start" ? "scale(1)" : "scale(0.92)";
+  } else {
+    opacity = phase === "start" ? 0.85 : 0;
+  }
+  const transition = tween ? `left ${ms}ms ease, top ${ms}ms ease, width ${ms}ms ease, height ${ms}ms ease, opacity ${ms}ms ease, transform ${ms}ms ease` : `opacity ${ms}ms ease`;
+  return {
+    position: "absolute",
+    left: box.x - PAD,
+    top: box.y - PAD,
+    width: box.width + PAD * 2,
+    height: box.height + PAD * 2,
+    opacity,
+    transform,
+    transition,
+    boxShadow: config.glow ? `0 0 14px 3px ${config.color}` : "none",
+    border: `2px solid ${config.color}`,
+    borderRadius: "4px",
+    pointerEvents: "none",
+    zIndex: 9997
+  };
+}
+
+// src/pptx/ai/ui-parts.ts
+function isTextPart(part) {
+  return part.type === "text";
+}
+function isToolPart(part) {
+  return typeof part.type === "string" && part.type.startsWith("tool-");
+}
+function isDynamicToolPart(part) {
+  return part.type === "dynamic-tool";
+}
+function toolNameOf(part) {
+  if (isDynamicToolPart(part)) {
+    return part.toolName ?? "tool";
+  }
+  return typeof part.type === "string" ? part.type.slice("tool-".length) : "tool";
+}
+var READY_TOOL_STATES = /* @__PURE__ */ new Set([
+  "input-available",
+  "output-available",
+  "output-error"
+]);
+function extractReadyToolCalls(messages) {
+  const out = [];
+  for (const message of messages) {
+    for (const rawPart of message.parts) {
+      const part = rawPart;
+      if (!isToolPart(part) && !isDynamicToolPart(part)) {
+        continue;
+      }
+      const toolCallId = part.toolCallId ?? "";
+      if (toolCallId.length === 0 || part.input === void 0) {
+        continue;
+      }
+      if (!READY_TOOL_STATES.has(part.state ?? "")) {
+        continue;
+      }
+      out.push({ toolName: toolNameOf(part), toolCallId, input: part.input });
+    }
+  }
+  return out;
+}
+function toRenderableParts(message) {
+  const out = [];
+  for (const rawPart of message.parts) {
+    const part = rawPart;
+    if (isTextPart(part)) {
+      const text = part.text ?? "";
+      if (text.trim().length > 0) {
+        out.push({ kind: "text", text });
+      }
+      continue;
+    }
+    if (isToolPart(part) || isDynamicToolPart(part)) {
+      out.push({
+        kind: "tool",
+        toolName: toolNameOf(part),
+        toolCallId: part.toolCallId ?? "",
+        state: part.state ?? "input-streaming",
+        input: part.input,
+        output: part.output,
+        errorText: part.errorText
+      });
+    }
+  }
+  return out;
+}
+
+// src/pptx/ai/chat-log-export.ts
+function isoOf(ms) {
+  const n = Number.isFinite(ms) ? ms : 0;
+  return new Date(n).toISOString();
+}
+function toLogChat(chat, detailed) {
+  const messages = chat.messages.map((message) => {
+    const parts = toRenderableParts(message);
+    const textRuns = [];
+    const toolCalls = [];
+    for (const part of parts) {
+      if (part.kind === "text") {
+        textRuns.push(part.text);
+        continue;
+      }
+      toolCalls.push({
+        toolName: part.toolName,
+        toolCallId: part.toolCallId,
+        state: part.state,
+        input: detailed ? part.input : void 0,
+        output: detailed ? part.output : void 0,
+        errorText: part.errorText
+      });
+    }
+    return {
+      role: message.role,
+      text: textRuns.join("\n\n"),
+      toolCalls
+    };
+  });
+  return {
+    id: chat.id,
+    title: chat.title,
+    deckId: chat.deckId,
+    createdAt: chat.createdAt,
+    updatedAt: chat.updatedAt,
+    createdAtIso: isoOf(chat.createdAt),
+    updatedAtIso: isoOf(chat.updatedAt),
+    messageCount: chat.messages.length,
+    messages
+  };
+}
+function buildChatLogExport(chats, options) {
+  const detailed = options?.detailed ?? true;
+  const now = options?.now ?? Date.now();
+  return {
+    format: "pptx-ai-chat-log",
+    version: 1,
+    exportedAt: isoOf(now),
+    detailed,
+    chatCount: chats.length,
+    chats: chats.map((chat) => toLogChat(chat, detailed))
+  };
+}
+function toolCallLine(call, detailed) {
+  const lines = [`- Tool \`${call.toolName}\` (${call.state})`];
+  if (call.errorText) {
+    lines.push(`  - error: ${call.errorText}`);
+  }
+  if (detailed) {
+    lines.push("  - input:");
+    lines.push("    ```json");
+    lines.push(JSON.stringify(call.input ?? null, null, 2));
+    lines.push("    ```");
+    lines.push("  - output:");
+    lines.push("    ```json");
+    lines.push(JSON.stringify(call.output ?? null, null, 2));
+    lines.push("    ```");
+  }
+  return lines.join("\n");
+}
+function buildChatLogMarkdown(doc) {
+  const out = [
+    `# AI chat logs`,
+    "",
+    `Exported: ${doc.exportedAt}`,
+    `Chats: ${doc.chatCount}`,
+    ""
+  ];
+  for (const chat of doc.chats) {
+    out.push(`## ${chat.title || chat.id}`);
+    out.push("");
+    out.push(`- id: ${chat.id}`);
+    if (chat.deckId) {
+      out.push(`- deck: ${chat.deckId}`);
+    }
+    out.push(`- created: ${chat.createdAtIso}`);
+    out.push(`- updated: ${chat.updatedAtIso}`);
+    out.push(`- messages: ${chat.messageCount}`);
+    out.push("");
+    for (const message of chat.messages) {
+      out.push(`### ${message.role}`);
+      out.push("");
+      if (message.text) {
+        out.push(message.text);
+        out.push("");
+      }
+      for (const call of message.toolCalls) {
+        out.push(toolCallLine(call, doc.detailed));
+        out.push("");
+      }
+    }
+  }
+  return out.join("\n");
+}
+async function collectStoredChats(store = createChatHistoryStore()) {
+  const summaries = await store.listChats();
+  const chats = [];
+  for (const summary of summaries) {
+    const chat = await store.loadChat(summary.id);
+    if (chat) {
+      chats.push(chat);
+    }
+  }
+  return chats;
+}
+function timestampSlug(now) {
+  const d = new Date(now);
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+}
+function exportAiChatLogs(chats, meta, save) {
+  if (chats.length === 0) {
+    return 0;
+  }
+  const now = meta?.now ?? Date.now();
+  const doc = buildChatLogExport(chats, { detailed: meta?.detailed ?? true, now });
+  const slug = timestampSlug(now);
+  const format = meta?.format ?? "json";
+  if (format === "markdown") {
+    save(`pptx-ai-chats-${slug}.md`, buildChatLogMarkdown(doc), "text/markdown");
+  } else {
+    save(`pptx-ai-chats-${slug}.json`, JSON.stringify(doc, null, 2), "application/json");
+  }
+  return chats.length;
+}
+
+// src/pptx/ai/focus-targets.ts
+function computeFocusTargets(input) {
+  const { activeSlideIndex, selectedElementIds, selectedElementId } = input;
+  const ids = selectedElementIds.length > 0 ? [...selectedElementIds] : selectedElementId ? [selectedElementId] : [];
+  if (ids.length === 0) {
+    return [{ kind: "slide", slideIndex: activeSlideIndex }];
+  }
+  return ids.map((elementId2) => ({ kind: "element", slideIndex: activeSlideIndex, elementId: elementId2 }));
+}
+function elementTypeLabel(type) {
+  if (type === "smartArt") {
+    return "SmartArt";
+  }
+  if (type === "ole") {
+    return "OLE";
+  }
+  return type.charAt(0).toUpperCase() + type.slice(1);
+}
+function shortElementId(id) {
+  const trimmed = id.trimEnd();
+  let start = trimmed.length;
+  while (start > 0 && isAsciiDigit(trimmed.charCodeAt(start - 1))) {
+    start -= 1;
+  }
+  if (start < trimmed.length) {
+    return trimmed.slice(start);
+  }
+  const separator = Math.max(id.lastIndexOf("/"), id.lastIndexOf("."), id.lastIndexOf("-"));
+  const tail = separator === -1 ? id : id.slice(separator + 1);
+  return tail || id;
+}
+function isAsciiDigit(code) {
+  return code >= 48 && code <= 57;
+}
+function focusTargetChips(targets, slides) {
+  return targets.map((target, index) => {
+    if (target.kind === "slide") {
+      const label2 = `Slide ${target.slideIndex + 1}`;
+      return { key: `slide-${target.slideIndex}-${index}`, label: label2, title: label2 };
+    }
+    const el = slides[target.slideIndex]?.elements.find((e) => e.id === target.elementId);
+    const typeLabel = el ? elementTypeLabel(el.type) : "Element";
+    const label = el ? `${typeLabel} ${shortElementId(target.elementId)}` : `${typeLabel} (missing)`;
+    return {
+      key: `el-${target.elementId}-${index}`,
+      label,
+      title: `${typeLabel}: ${target.elementId}`
+    };
+  });
+}
+function isTwoTableFocus(targets, slides) {
+  if (targets.length !== 2 || targets.some((target) => target.kind !== "element")) {
+    return false;
+  }
+  const [a, b] = targets;
+  if (a.slideIndex !== b.slideIndex) {
+    return false;
+  }
+  const slide = slides[a.slideIndex];
+  const elA = slide?.elements.find((e) => e.id === a.elementId);
+  const elB = slide?.elements.find((e) => e.id === b.elementId);
+  if (elA?.type !== "table" || elB?.type !== "table") {
+    return false;
+  }
+  return { slideIndex: a.slideIndex, elementIdA: a.elementId, elementIdB: b.elementId };
+}
+function mergeTablesDirective(slideIndex2, elementIdA, elementIdB) {
+  return `Merge the two selected tables (elementIdA=${elementIdA}, elementIdB=${elementIdB}) on slide ${slideIndex2 + 1} using merge_tables; stage it now, do not ask me to confirm.`;
+}
+
+// src/pptx/ai/chat-history-controller.ts
+var SAVE_DEBOUNCE_MS = 800;
+var TITLE_MAX = 40;
+function newChatId() {
+  return `chat-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function deriveChatTitle(messages) {
+  for (const message of messages) {
+    if (message.role !== "user") {
+      continue;
+    }
+    const text = message.parts.filter((p) => p.type === "text").map((p) => p.text).join(" ").trim();
+    if (text) {
+      return text.length > TITLE_MAX ? `${text.slice(0, TITLE_MAX).trimEnd()}\u2026` : text;
+    }
+  }
+  return "";
+}
+function deckIdFromBridge(bridge) {
+  const meta = bridge.getDeckMeta();
+  const title = (meta.title ?? "deck").trim().toLowerCase().replace(/\s+/gu, "-").slice(0, 60);
+  return `${title || "deck"}::${meta.slideCount}`;
+}
+function createAiChatHistoryController(deps) {
+  const store = deps.store ?? createChatHistoryStore();
+  let chats = [];
+  let activeChatId = newChatId();
+  let createdAt = Date.now();
+  let saveTimer = null;
+  let disposed = false;
+  const clearTimer = () => {
+    if (saveTimer) {
+      clearTimeout(saveTimer);
+      saveTimer = null;
+    }
+  };
+  const refresh = async () => {
+    const list = await store.listChats({ deckId: deps.deckId });
+    if (disposed) {
+      return;
+    }
+    chats = list;
+    deps.onChatsChanged?.(list);
+  };
+  void refresh();
+  const startNewChat = () => {
+    clearTimer();
+    activeChatId = newChatId();
+    createdAt = Date.now();
+  };
+  return {
+    chats: () => chats,
+    activeChatId: () => activeChatId,
+    refresh,
+    notifyMessagesChanged() {
+      clearTimer();
+      if (disposed || deps.getMessages().length === 0) {
+        return;
+      }
+      saveTimer = setTimeout(() => {
+        saveTimer = null;
+        const messages = deps.getMessages();
+        if (disposed || messages.length === 0) {
+          return;
+        }
+        void (async () => {
+          await store.saveChat({
+            id: activeChatId,
+            title: deriveChatTitle(messages) || (deps.untitledLabel ?? "Untitled chat"),
+            deckId: deps.deckId,
+            // JSON round-trip: the binding's transcript may be a framework
+            // reactive proxy (Vue deep ref / Svelte $state), which the store's
+            // structuredClone would reject with a DataCloneError.
+            messages: JSON.parse(JSON.stringify(messages)),
+            createdAt,
+            updatedAt: Date.now()
+          });
+          await refresh();
+        })();
+      }, SAVE_DEBOUNCE_MS);
+    },
+    newChat() {
+      startNewChat();
+      deps.setMessages([]);
+    },
+    async resumeChat(id) {
+      const chat = await store.loadChat(id);
+      if (!chat || disposed) {
+        return;
+      }
+      clearTimer();
+      activeChatId = chat.id;
+      createdAt = chat.createdAt;
+      deps.setMessages(chat.messages);
+    },
+    async deleteChat(id) {
+      await store.deleteChat(id);
+      if (id === activeChatId) {
+        startNewChat();
+        deps.setMessages([]);
+      }
+      await refresh();
+    },
+    clearCurrent() {
+      clearTimer();
+      deps.setMessages([]);
+    },
+    dispose() {
+      disposed = true;
+      clearTimer();
+    }
+  };
+}
+
+// src/pptx/ai/vanilla-chat.ts
+async function createVanillaChat(options) {
+  const sdk = await loadAiSdk();
+  if (!sdk) {
+    throw new Error('The optional "ai" SDK is not installed.');
+  }
+  const session = await createAiChatSession(options.bridge, options.config);
+  const listeners = /* @__PURE__ */ new Set();
+  let messages = [];
+  let status = "ready";
+  let error;
+  const emit = () => {
+    const snapshot = { messages: [...messages], status, error };
+    for (const listener of listeners) {
+      listener(snapshot);
+    }
+  };
+  const state = {
+    get status() {
+      return status;
+    },
+    set status(next) {
+      status = next;
+      emit();
+    },
+    get error() {
+      return error;
+    },
+    set error(next) {
+      error = next;
+      emit();
+    },
+    get messages() {
+      return messages;
+    },
+    set messages(next) {
+      messages = next;
+      emit();
+    },
+    pushMessage: (message) => {
+      messages.push(message);
+      emit();
+    },
+    popMessage: () => {
+      messages.pop();
+      emit();
+    },
+    replaceMessage: (index, message) => {
+      messages[index] = message;
+      emit();
+    },
+    snapshot: (thing) => structuredClone(thing)
+  };
+  const ChatCtor = sdk.AbstractChat;
+  const init = {
+    transport: session.transport,
+    state,
+    onError: (err) => {
+      options.config.onError?.(err);
+    }
+  };
+  if (session.clientExecutesTools) {
+    init.sendAutomaticallyWhen = session.sendAutomaticallyWhen;
+    init.onToolCall = async (args) => {
+      const { toolName, toolCallId, input } = args.toolCall;
+      const addOutput = chat.addToolOutput;
+      try {
+        const output = await session.executeToolCall(toolName, input);
+        addOutput({ tool: toolName, toolCallId, output });
+      } catch (err) {
+        addOutput({
+          tool: toolName,
+          toolCallId,
+          state: "output-error",
+          errorText: err instanceof Error ? err.message : String(err)
+        });
+      }
+    };
+  }
+  const chat = new ChatCtor(init);
+  return {
+    sendMessage: (text) => chat.sendMessage({ text }),
+    regenerate: () => chat.regenerate(),
+    stop: () => chat.stop(),
+    clearError: () => chat.clearError(),
+    setMessages: (next) => {
+      state.messages = [...next];
+    },
+    getSnapshot: () => ({ messages: [...messages], status, error }),
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    proposals: session.proposals,
+    changeAnimator: session.changeAnimator
+  };
+}
+
+// src/pptx/ai/server.ts
+async function buildPptxAiTools(config = {}) {
+  const sdk = await loadAiSdk();
+  if (!sdk) {
+    throw new Error('The optional "ai" SDK is not installed on the server.');
+  }
+  return buildToolSet(sdk, config, /* @__PURE__ */ new Map(), { withExecute: false });
+}
+function buildPptxAiSystemPrompt(options = {}) {
+  return buildSystemPrompt(options);
+}
+function applyElementUpdate(el, u) {
+  if (u.x !== void 0) {
+    el.x = u.x;
+  }
+  if (u.y !== void 0) {
+    el.y = u.y;
+  }
+  if (u.width !== void 0) {
+    el.width = u.width;
+  }
+  if (u.height !== void 0) {
+    el.height = u.height;
+  }
+  if (u.rotation !== void 0) {
+    el.rotation = u.rotation;
+  }
+  if (u.opacity !== void 0) {
+    el.opacity = u.opacity;
+  }
+  if (u.hidden !== void 0) {
+    el.hidden = u.hidden;
+  }
+  if (u.flipHorizontal !== void 0) {
+    el.flipHorizontal = u.flipHorizontal;
+  }
+  if (u.flipVertical !== void 0) {
+    el.flipVertical = u.flipVertical;
+  }
+  applyTextUpdate(el, u);
+  applyShapeStyleUpdate(el, u);
+}
+function applyTextUpdate(el, u) {
+  if (!hasTextProperties(el)) {
+    return;
+  }
+  const textEl = el;
+  if (u.text !== void 0) {
+    textEl.text = u.text;
+    if (textEl.textSegments && textEl.textSegments.length > 0) {
+      textEl.textSegments[0].text = u.text;
+    } else {
+      textEl.textSegments = [{ text: u.text, style: {} }];
+    }
+  }
+  if (u.fontSize === void 0 && u.fontFamily === void 0 && u.fontColor === void 0 && u.bold === void 0 && u.italic === void 0 && u.underline === void 0 && u.align === void 0) {
+    return;
+  }
+  const textStyle = {};
+  if (u.fontSize !== void 0) {
+    textStyle.fontSize = u.fontSize;
+  }
+  if (u.fontFamily !== void 0) {
+    textStyle.fontFamily = u.fontFamily;
+  }
+  if (u.fontColor !== void 0) {
+    textStyle.color = u.fontColor;
+  }
+  if (u.bold !== void 0) {
+    textStyle.bold = u.bold;
+  }
+  if (u.italic !== void 0) {
+    textStyle.italic = u.italic;
+  }
+  if (u.underline !== void 0) {
+    textStyle.underline = u.underline;
+  }
+  if (u.align !== void 0) {
+    textStyle.align = u.align;
+  }
+  textEl.textStyle = { ...textEl.textStyle, ...textStyle };
+  if (textEl.textSegments) {
+    textEl.textSegments = textEl.textSegments.map((seg) => updateTextSegmentStyle(seg, textStyle));
+  }
+}
+function applyShapeStyleUpdate(el, u) {
+  if (u.fillColor === void 0 && u.strokeColor === void 0 && u.strokeWidth === void 0) {
+    return;
+  }
+  if (!hasShapeProperties(el)) {
+    return;
+  }
+  const holder = el;
+  holder.shapeStyle ??= {};
+  const style = holder.shapeStyle;
+  if (u.fillColor !== void 0) {
+    style.fillColor = u.fillColor;
+  }
+  if (u.strokeColor !== void 0) {
+    style.strokeColor = u.strokeColor;
+  }
+  if (u.strokeWidth !== void 0) {
+    style.strokeWidth = u.strokeWidth;
+  }
+}
+
+// src/pptx/ai/tool-summary.ts
+function toolLabel(toolName) {
+  if (!toolName) {
+    return "Tool";
+  }
+  const words = toolName.replace(/[_-]+/gu, " ").trim().split(/\s+/u);
+  return words.map((w, i) => i === 0 ? w.charAt(0).toUpperCase() + w.slice(1) : w).join(" ");
+}
+function formatValue(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value.length > 32 ? `"${value.slice(0, 32)}..."` : `"${value}"`;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.length}]`;
+  }
+  return "{...}";
+}
+function summarizeToolArgs(input) {
+  if (input === null || typeof input !== "object") {
+    return "";
+  }
+  const entries = Object.entries(input).filter(
+    ([, v]) => v !== void 0 && v !== null && v !== ""
+  );
+  if (entries.length === 0) {
+    return "";
+  }
+  const parts = [];
+  for (const [key, value] of entries.slice(0, 4)) {
+    if (key === "slideIndex" && typeof value === "number") {
+      parts.push(`slide ${value + 1}`);
+      continue;
+    }
+    parts.push(`${key}: ${formatValue(value)}`);
+  }
+  if (entries.length > 4) {
+    parts.push("...");
+  }
+  return parts.join(", ");
+}
+function asRecord(input) {
+  return input && typeof input === "object" ? input : {};
+}
+function slideNumber(input) {
+  const v = input.slideIndex;
+  return typeof v === "number" && Number.isFinite(v) ? v + 1 : void 0;
+}
+function onSlide(input) {
+  const n = slideNumber(input);
+  return n === void 0 ? "" : ` on slide ${n}`;
+}
+function snippet(value) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return "";
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 24 ? `"${trimmed.slice(0, 24)}..."` : `"${trimmed}"`;
+}
+var TOOL_PHRASES = {
+  // ── read ─────────────────────────────────────────────────────────────────
+  get_deck_overview: {
+    icon: "view",
+    present: () => "Reviewing the deck",
+    past: () => "Reviewed the deck"
+  },
+  get_slide: {
+    icon: "view",
+    present: (i) => `Looking at slide ${slideNumber(i) ?? ""}`.trim(),
+    past: (i) => `Looked at slide ${slideNumber(i) ?? ""}`.trim()
+  },
+  get_element: {
+    icon: "view",
+    present: (i) => `Inspecting an element${onSlide(i)}`,
+    past: (i) => `Inspected an element${onSlide(i)}`
+  },
+  get_speaker_notes: {
+    icon: "notes",
+    present: (i) => `Reading the notes${onSlide(i)}`,
+    past: (i) => `Read the notes${onSlide(i)}`
+  },
+  find_text: {
+    icon: "search",
+    present: (i) => `Searching for ${snippet(i.query) || "text"}`,
+    past: (i) => `Searched for ${snippet(i.query) || "text"}`
+  },
+  get_theme: {
+    icon: "theme",
+    present: () => "Checking the theme",
+    past: () => "Checked the theme"
+  },
+  // ── navigation ───────────────────────────────────────────────────────────
+  go_to_slide: {
+    icon: "nav",
+    present: (i) => `Going to slide ${slideNumber(i) ?? ""}`.trim(),
+    past: (i) => `Went to slide ${slideNumber(i) ?? ""}`.trim()
+  },
+  select_elements: {
+    icon: "view",
+    present: (i) => `Selecting elements${onSlide(i)}`,
+    past: (i) => `Selected elements${onSlide(i)}`
+  },
+  // ── MCP reads (no bespoke equivalent) ────────────────────────────────────────
+  get_metadata: {
+    icon: "view",
+    present: () => "Checking the file details",
+    past: () => "Checked the file details"
+  },
+  get_layouts: {
+    icon: "view",
+    present: () => "Looking at the layouts",
+    past: () => "Looked at the layouts"
+  },
+  find_placeholders: {
+    icon: "search",
+    present: () => "Finding placeholders",
+    past: () => "Found placeholders"
+  },
+  get_presentation_properties: {
+    icon: "view",
+    present: () => "Checking the slideshow settings",
+    past: () => "Checked the slideshow settings"
+  },
+  run_accessibility_check: {
+    icon: "view",
+    present: () => "Running an accessibility check",
+    past: () => "Ran an accessibility check"
+  },
+  convert_to_markdown: {
+    icon: "view",
+    present: () => "Exporting to Markdown",
+    past: () => "Exported to Markdown"
+  },
+  export_to_json: {
+    icon: "view",
+    present: () => "Exporting to JSON",
+    past: () => "Exported to JSON"
+  },
+  import_from_json: {
+    icon: "slide",
+    present: () => "Importing deck from JSON",
+    past: () => "Imported deck from JSON"
+  },
+  // ── element editing ────────────────────────────────────────────────────────
+  update_element: {
+    icon: "move",
+    present: (i) => `Updating an element${onSlide(i)}`,
+    past: (i) => `Updated an element${onSlide(i)}`
+  },
+  update_element_style: {
+    icon: "shape",
+    present: (i) => `Restyling an element${onSlide(i)}`,
+    past: (i) => `Restyled an element${onSlide(i)}`
+  },
+  add_element: {
+    icon: "shape",
+    present: (i) => `Adding a ${typeof i.type === "string" ? i.type : "element"}${onSlide(i)}`,
+    past: (i) => `Added a ${typeof i.type === "string" ? i.type : "element"}${onSlide(i)}`
+  },
+  delete_elements: {
+    icon: "delete",
+    present: (i) => `Deleting ${countLabel(i.elementIds, "element")}${onSlide(i)}`,
+    past: (i) => `Deleted ${countLabel(i.elementIds, "element")}${onSlide(i)}`
+  },
+  arrange_elements: {
+    icon: "move",
+    present: (i) => `Rearranging elements${onSlide(i)}`,
+    past: (i) => `Rearranged elements${onSlide(i)}`
+  },
+  clone_element: {
+    icon: "shape",
+    present: (i) => `Cloning an element${onSlide(i)}`,
+    past: (i) => `Cloned an element${onSlide(i)}`
+  },
+  group_elements: {
+    icon: "shape",
+    present: (i) => `Grouping elements${onSlide(i)}`,
+    past: (i) => `Grouped elements${onSlide(i)}`
+  },
+  ungroup_elements: {
+    icon: "shape",
+    present: (i) => `Ungrouping a group${onSlide(i)}`,
+    past: (i) => `Ungrouped a group${onSlide(i)}`
+  },
+  batch_update_elements: {
+    icon: "move",
+    present: (i) => `Updating several elements${onSlide(i)}`,
+    past: (i) => `Updated several elements${onSlide(i)}`
+  },
+  replace_geometry: {
+    icon: "shape",
+    present: (i) => `Reshaping an element${onSlide(i)}`,
+    past: (i) => `Reshaped an element${onSlide(i)}`
+  },
+  set_element_lock: {
+    icon: "shape",
+    present: (i) => `Locking an element${onSlide(i)}`,
+    past: (i) => `Locked an element${onSlide(i)}`
+  },
+  manage_hyperlinks: {
+    icon: "text",
+    present: (i) => `Updating a link${onSlide(i)}`,
+    past: (i) => `Updated a link${onSlide(i)}`
+  },
+  set_element_animation: {
+    icon: "animation",
+    present: (i) => `Adding an animation${onSlide(i)}`,
+    past: (i) => `Added an animation${onSlide(i)}`
+  },
+  // ── text / tables / charts / smartart ────────────────────────────────────────
+  replace_text: {
+    icon: "search",
+    present: () => "Replacing text across the deck",
+    past: () => "Replaced text across the deck"
+  },
+  manage_comments: {
+    icon: "notes",
+    present: (i) => `Updating comments${onSlide(i)}`,
+    past: (i) => `Updated comments${onSlide(i)}`
+  },
+  update_table_cells: {
+    icon: "table",
+    present: (i) => `Editing table cells${onSlide(i)}`,
+    past: (i) => `Edited table cells${onSlide(i)}`
+  },
+  manage_table_structure: {
+    icon: "table",
+    present: (i) => `Changing a table${onSlide(i)}`,
+    past: (i) => `Changed a table${onSlide(i)}`
+  },
+  merge_tables: {
+    icon: "table",
+    present: (i) => `Merging two tables${onSlide(i)}`,
+    past: (i) => `Merged two tables${onSlide(i)}`
+  },
+  create_chart: {
+    icon: "chart",
+    present: (i) => `Adding a ${chartKind(i.chartType)}chart${onSlide(i)}`,
+    past: (i) => `Added a ${chartKind(i.chartType)}chart${onSlide(i)}`
+  },
+  update_chart: {
+    icon: "chart",
+    present: (i) => `Updating a chart${onSlide(i)}`,
+    past: (i) => `Updated a chart${onSlide(i)}`
+  },
+  add_chart_series: {
+    icon: "chart",
+    present: (i) => `Adding a chart series${onSlide(i)}`,
+    past: (i) => `Added a chart series${onSlide(i)}`
+  },
+  remove_chart_series: {
+    icon: "chart",
+    present: (i) => `Removing a chart series${onSlide(i)}`,
+    past: (i) => `Removed a chart series${onSlide(i)}`
+  },
+  update_chart_series_data: {
+    icon: "chart",
+    present: (i) => `Updating chart data${onSlide(i)}`,
+    past: (i) => `Updated chart data${onSlide(i)}`
+  },
+  manage_smart_art: {
+    icon: "shape",
+    present: (i) => `Editing SmartArt${onSlide(i)}`,
+    past: (i) => `Edited SmartArt${onSlide(i)}`
+  },
+  apply_template: {
+    icon: "text",
+    present: () => "Filling in placeholders",
+    past: () => "Filled in placeholders"
+  },
+  // ── slide structure ──────────────────────────────────────────────────────────
+  add_slide: {
+    icon: "slide",
+    present: () => "Adding a slide",
+    past: () => "Added a slide"
+  },
+  duplicate_slide: {
+    icon: "slide",
+    present: (i) => `Duplicating slide ${slideNumber(i) ?? ""}`.trim(),
+    past: (i) => `Duplicated slide ${slideNumber(i) ?? ""}`.trim()
+  },
+  delete_slides: {
+    icon: "delete",
+    present: (i) => `Deleting ${countLabel(i.slideIndexes, "slide")}`,
+    past: (i) => `Deleted ${countLabel(i.slideIndexes, "slide")}`
+  },
+  reorder_slides: {
+    icon: "slide",
+    present: () => "Reordering the slides",
+    past: () => "Reordered the slides"
+  },
+  update_slide_properties: {
+    icon: "slide",
+    present: (i) => `Updating slide ${slideNumber(i) ?? ""}`.trim(),
+    past: (i) => `Updated slide ${slideNumber(i) ?? ""}`.trim()
+  },
+  set_slide_transition: {
+    icon: "animation",
+    present: (i) => `Setting a transition${onSlide(i)}`,
+    past: (i) => `Set a transition${onSlide(i)}`
+  },
+  // ── theme (applied immediately) ──────────────────────────────────────────────
+  apply_theme_preset: {
+    icon: "theme",
+    present: (i) => typeof i.presetName === "string" ? `Applying the ${i.presetName} theme` : "Applying a theme",
+    past: (i) => typeof i.presetName === "string" ? `Applied the ${i.presetName} theme` : "Applied a theme"
+  },
+  update_theme_colors: {
+    icon: "theme",
+    present: () => "Changing the theme colours",
+    past: () => "Changed the theme colours"
+  },
+  update_theme_fonts: {
+    icon: "theme",
+    present: () => "Changing the theme fonts",
+    past: () => "Changed the theme fonts"
+  },
+  // ── presentation-level ────────────────────────────────────────────────────────
+  set_canvas_size: {
+    icon: "slide",
+    present: () => "Resizing the slides",
+    past: () => "Resized the slides"
+  },
+  update_metadata: {
+    icon: "tool",
+    present: () => "Updating the file details",
+    past: () => "Updated the file details"
+  },
+  manage_sections: {
+    icon: "slide",
+    present: () => "Organising the sections",
+    past: () => "Organised the sections"
+  },
+  update_presentation_properties: {
+    icon: "tool",
+    present: () => "Updating the slideshow settings",
+    past: () => "Updated the slideshow settings"
+  },
+  apply_layout: {
+    icon: "slide",
+    present: (i) => `Applying a layout${onSlide(i)}`,
+    past: (i) => `Applied a layout${onSlide(i)}`
+  }
+};
+function chartKind(value) {
+  return typeof value === "string" && /^[a-z]+$/iu.test(value) ? `${value} ` : "";
+}
+function countLabel(value, noun) {
+  const n = Array.isArray(value) ? value.length : 0;
+  if (n <= 1) {
+    return `${n || 1} ${noun}`;
+  }
+  return `${n} ${noun}s`;
+}
+function describeToolActivity(toolName, input, tense = "past") {
+  const phrase = TOOL_PHRASES[toolName];
+  const record = asRecord(input);
+  if (!phrase) {
+    return { icon: "tool", label: toolLabel(toolName) };
+  }
+  return { icon: phrase.icon, label: phrase[tense](record) };
+}
+
+// src/pptx/ai/tool-target.ts
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function pushId(ids, value) {
+  if (typeof value === "string" && value.length > 0) {
+    ids.push(value);
+  }
+}
+function toolCanvasTarget(toolName, input) {
+  const o = input && typeof input === "object" ? input : {};
+  const elementIds = [];
+  pushId(elementIds, o.elementId);
+  pushId(elementIds, o.elementIdA);
+  pushId(elementIds, o.elementIdB);
+  if (Array.isArray(o.elementIds)) {
+    for (const value of o.elementIds) {
+      pushId(elementIds, value);
+    }
+  }
+  let slideIndex2 = isFiniteNumber(o.slideIndex) ? o.slideIndex : void 0;
+  if (slideIndex2 === void 0 && Array.isArray(o.slideIndexes) && isFiniteNumber(o.slideIndexes[0])) {
+    slideIndex2 = o.slideIndexes[0];
+  }
+  if (slideIndex2 === void 0 && Array.isArray(o.newOrder) && isFiniteNumber(o.newOrder[0])) {
+    slideIndex2 = o.newOrder[0];
+  }
+  if (slideIndex2 === void 0 && toolName === "duplicate_slide" && isFiniteNumber(o.slideIndex)) {
+    slideIndex2 = o.slideIndex;
+  }
+  if (slideIndex2 === void 0 && elementIds.length === 0) {
+    return null;
+  }
+  return { slideIndex: slideIndex2, elementIds };
+}
+
+export { AI_CHANGE_ATTR, BASE_SYSTEM_PROMPT, BESPOKE_TOOL_ENTRIES, MCP_TOOL_ENTRIES, ProposalStore, aiChangeAnimationCss, allToolNames, applyElementUpdate, applyShapeStyleUpdate, applyTextUpdate, buildChatLogExport, buildChatLogMarkdown, buildDeckContext, buildDeckOutline, buildFocusedTargetsContext, buildPptxAiSystemPrompt, buildPptxAiTools, buildSlideMarkdown, buildSystemPrompt, buildToolExecutors, buildToolSet, changeGhostStyle, clampToTokenBudget, collectStoredChats, computeFocusTargets, createAiChangeAnimator, createAiChatHistoryController, createAiChatSession, createVanillaChat, deckDataFieldChanged, deckIdFromBridge, deriveChatTitle, describeToolActivity, diffChangedElements, diffSlides, enabledToolNames, estimateTokens, exportAiChatLogs, extractReadyToolCalls, focusTargetChips, humanizeDiffLine, isAiAvailable, isTwoTableFocus, loadAiSdk, mergeTablesDirective, newChatId, requireElement, requireSlide, resetAiSdkCache, resolveChangeAnimationConfig, resolveChatTransport, routeWrite, runSharedTool, slideTitle, summarizeToolArgs, toLogChat, toRenderableParts, toolCallLine, toolCanvasTarget, toolLabel };