ooxml-ui 1.28.0 → 1.29.0

package/dist/pptx/chunk-IY7H76CZ.cjs

@@ -0,0 +1,874 @@
+'use strict';
+
+var chunkA5MANNJR_cjs = require('./chunk-A5MANNJR.cjs');
+var chunkY6DO6SVT_cjs = require('./chunk-Y6DO6SVT.cjs');
+var chunkPBZWDEXQ_cjs = require('./chunk-PBZWDEXQ.cjs');
+var pptx = require('ooxml-core/pptx');
+
+// src/pptx/ai/deck-data-diff.ts
+function deckDataFieldChanged(a, b) {
+  return JSON.stringify(a) !== JSON.stringify(b);
+}
+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 (!pptx.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) => chunkPBZWDEXQ_cjs.updateTextSegmentStyle(seg, textStyle));
+  }
+}
+function applyShapeStyleUpdate(el, u) {
+  if (u.fillColor === void 0 && u.strokeColor === void 0 && u.strokeWidth === void 0) {
+    return;
+  }
+  if (!pptx.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/bridge-factory.ts
+var TITLE_MAX_LENGTH = 120;
+function pptxAiDeckTitle(slides) {
+  for (const element of slides[0]?.elements ?? []) {
+    const text = "text" in element && typeof element.text === "string" ? element.text.trim() : "";
+    if (text) {
+      return text.slice(0, TITLE_MAX_LENGTH);
+    }
+  }
+  return void 0;
+}
+function copy(list) {
+  return list ? [...list] : void 0;
+}
+function readDeckData(port) {
+  const canvas = port.getCanvasSize();
+  return {
+    slides: [...port.getSlides()],
+    width: canvas.width,
+    height: canvas.height,
+    theme: port.getTheme(),
+    sections: copy(port.getSections()),
+    presentationProperties: port.getPresentationProperties(),
+    customProperties: copy(port.getCustomProperties()),
+    coreProperties: port.getCoreProperties(),
+    appProperties: port.getAppProperties(),
+    viewProperties: port.getViewProperties(),
+    tableStyleMap: port.getTableStyleMap(),
+    tableStylesDefaultId: port.getTableStylesDefaultId(),
+    tags: copy(port.getTagCollections())
+  };
+}
+function commitDocumentProperties(port, before, after) {
+  const differs = deckDataFieldChanged;
+  const core = after.coreProperties ?? before.coreProperties;
+  const app = after.appProperties ?? before.appProperties;
+  const custom = after.customProperties ?? before.customProperties ?? [];
+  const coreChanged = differs(before.coreProperties, core);
+  if (!coreChanged && !differs(before.appProperties, app) && !differs(before.customProperties, custom)) {
+    return false;
+  }
+  port.setDocumentProperties(core ?? {}, app ?? {}, custom);
+  if (coreChanged && core) {
+    port.onCorePropertiesChanged?.(core);
+  }
+  return true;
+}
+function commitDeckData(port, before, after, label) {
+  const differs = deckDataFieldChanged;
+  let changed = false;
+  if (differs(before.slides, after.slides)) {
+    port.updateSlides(() => after.slides, label);
+    changed = true;
+  }
+  if (before.width !== after.width || before.height !== after.height) {
+    port.setCanvasSize({ width: after.width, height: after.height });
+    changed = true;
+  }
+  const sections = after.sections ?? before.sections ?? [];
+  if (differs(before.sections, sections)) {
+    port.setSections(sections);
+    changed = true;
+  }
+  const presentation = after.presentationProperties ?? before.presentationProperties ?? {};
+  if (differs(before.presentationProperties, presentation)) {
+    port.setPresentationProperties(presentation);
+    changed = true;
+  }
+  changed = commitDocumentProperties(port, before, after) || changed;
+  if (differs(before.viewProperties, after.viewProperties)) {
+    port.setViewProperties(after.viewProperties);
+    changed = true;
+  }
+  if (differs(before.tableStyleMap, after.tableStyleMap)) {
+    port.setTableStyleMap(after.tableStyleMap ?? {});
+    changed = true;
+  }
+  if (differs(before.tableStylesDefaultId, after.tableStylesDefaultId)) {
+    port.setTableStylesDefaultId(after.tableStylesDefaultId);
+    changed = true;
+  }
+  const tags = after.tags ?? before.tags ?? [];
+  if (differs(before.tags, tags)) {
+    port.setTagCollections(tags);
+    changed = true;
+  }
+  return changed;
+}
+function createPptxAiBridge(port) {
+  const applySlidesUpdate = (updater, label) => {
+    port.updateSlides((current) => updater(structuredClone([...current])), label);
+  };
+  const bridge = {
+    getDeckMeta() {
+      const slides = port.getSlides();
+      const canvas = port.getCanvasSize();
+      return {
+        slideCount: slides.length,
+        activeSlideIndex: port.getActiveSlideIndex(),
+        title: port.getFileName?.() ?? pptxAiDeckTitle(slides),
+        width: canvas.width,
+        height: canvas.height
+      };
+    },
+    getSlides: () => [...port.getSlides()],
+    getActiveSlideIndex: () => port.getActiveSlideIndex(),
+    getTheme: () => port.getTheme(),
+    getHandler: () => port.getHandler() ?? void 0,
+    goToSlide: (index) => port.goToSlide(index),
+    selectElements: (slideIndex, elementIds) => port.selectElements(slideIndex, elementIds),
+    applySlidesUpdate,
+    updateElement(slideIndex, elementId, updates) {
+      applySlidesUpdate((slides) => {
+        const element = slides[slideIndex]?.elements.find((el) => el.id === elementId);
+        if (element) {
+          applyElementUpdate(element, updates);
+        }
+        return slides;
+      }, `Update element ${elementId}`);
+    },
+    applyTheme: (updates) => port.applyTheme(updates),
+    getDeckData: () => readDeckData(port),
+    applyDeckData(updater, label) {
+      const before = readDeckData(port);
+      const after = updater(structuredClone(before));
+      if (commitDeckData(port, before, after, label)) {
+        port.afterDeckUpdate?.();
+      }
+    }
+  };
+  if (port.getFocusedTargets) {
+    bridge.getFocusedTargets = () => port.getFocusedTargets?.() ?? [];
+  }
+  if (port.notify) {
+    bridge.notify = (message, level) => port.notify?.(message, level);
+  }
+  return bridge;
+}
+
+// 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((elementId) => ({ kind: "element", slideIndex: activeSlideIndex, elementId }));
+}
+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(slideIndex, elementIdA, elementIdB) {
+  return `Merge the two selected tables (elementIdA=${elementIdA}, elementIdB=${elementIdB}) on slide ${slideIndex + 1} using merge_tables; stage it now, do not ask me to confirm.`;
+}
+
+// src/pptx/ai/panel-controller.ts
+var AI_TOOL_FLASH_MS = 2600;
+function aiFixDirective(element, slideIndex) {
+  return `Review and fix any issues with this ${element.type} (id=${element.id}) on slide ${slideIndex + 1}.`;
+}
+function resolveAiEffectiveTargets(state, liveTargets) {
+  if (state.pickTargets.length > 0) {
+    return state.pickTargets;
+  }
+  if (state.pinnedFocus && state.pinnedFocus.length > 0) {
+    return state.pinnedFocus;
+  }
+  return liveTargets;
+}
+function isAiFocusPinned(state) {
+  return state.pickTargets.length === 0 && state.pinnedFocus !== null;
+}
+function buildHighlights(pickTargets, toolFocus) {
+  const out = [];
+  for (const target of pickTargets) {
+    if (target.kind === "element") {
+      out.push({ slideIndex: target.slideIndex, elementId: target.elementId, variant: "pick" });
+    }
+  }
+  for (const elementId of toolFocus?.elementIds ?? []) {
+    out.push({ slideIndex: toolFocus?.slideIndex ?? 0, elementId, variant: "active" });
+  }
+  return out;
+}
+var INITIAL_STATE = {
+  isOpen: false,
+  pinnedFocus: null,
+  prefill: { text: "", nonce: 0 },
+  pickMode: false,
+  pickTargets: [],
+  canvasHighlights: [],
+  canvasAnimating: false,
+  changeBatch: null
+};
+function createPptxAiPanelController(deps) {
+  const store = chunkY6DO6SVT_cjs.createControllerStore(INITIAL_STATE);
+  let toolFocus = null;
+  let flashing = false;
+  let flashTimer = null;
+  const update = (patch) => {
+    store.update((current) => {
+      const next = { ...current, ...patch };
+      const canvasHighlights = buildHighlights(next.pickTargets, toolFocus);
+      const sameHighlights = canvasHighlights.length === current.canvasHighlights.length && canvasHighlights.every((h, i) => {
+        const prev = current.canvasHighlights[i];
+        return prev?.elementId === h.elementId && prev.slideIndex === h.slideIndex && prev.variant === h.variant;
+      });
+      return {
+        ...next,
+        canvasHighlights: sameHighlights ? current.canvasHighlights : canvasHighlights,
+        canvasAnimating: flashing || canvasHighlights.length > 0
+      };
+    });
+  };
+  const liveTargets = () => computeFocusTargets(deps.getSelection());
+  const openPanel = (patch) => {
+    update({ ...patch, isOpen: true });
+    deps.onOpen?.();
+  };
+  const fixElement = (element, slideIndex) => {
+    const { prefill } = store.getSnapshot();
+    openPanel({
+      pinnedFocus: liveTargets(),
+      prefill: {
+        text: element ? aiFixDirective(element, slideIndex) : "",
+        nonce: prefill.nonce + 1
+      }
+    });
+  };
+  return {
+    getSnapshot: store.getSnapshot,
+    subscribe: store.subscribe,
+    open: () => openPanel({}),
+    close: () => update({ isOpen: false }),
+    toggle() {
+      if (store.getSnapshot().isOpen) {
+        update({ isOpen: false });
+      } else {
+        openPanel({});
+      }
+    },
+    getLiveTargets: liveTargets,
+    getEffectiveTargets: () => resolveAiEffectiveTargets(store.getSnapshot(), liveTargets()),
+    pinFocus: () => update({ pinnedFocus: liveTargets() }),
+    clearPinnedFocus: () => update({ pinnedFocus: null }),
+    askAboutSelection() {
+      const { prefill } = store.getSnapshot();
+      openPanel({ pinnedFocus: liveTargets(), prefill: { text: "", nonce: prefill.nonce + 1 } });
+    },
+    fixSelection() {
+      fixElement(deps.getSelectedElement?.(), deps.getSelection().activeSlideIndex);
+    },
+    fixElement,
+    startPicking: () => openPanel({ pickMode: true }),
+    stopPicking: () => update({ pickMode: false }),
+    addPick(slideIndex, elementId) {
+      const { pickTargets } = store.getSnapshot();
+      if (pickTargets.some((t) => t.kind === "element" && t.elementId === elementId)) {
+        return;
+      }
+      update({ pickTargets: [...pickTargets, { kind: "element", slideIndex, elementId }] });
+    },
+    clearPicks: () => update({ pickTargets: [], pickMode: false }),
+    flashToolTarget(target) {
+      toolFocus = target && target.slideIndex !== void 0 && target.elementIds.length > 0 ? { slideIndex: target.slideIndex, elementIds: target.elementIds } : null;
+      flashing = true;
+      if (flashTimer) {
+        clearTimeout(flashTimer);
+      }
+      flashTimer = setTimeout(() => {
+        toolFocus = null;
+        flashing = false;
+        flashTimer = null;
+        update({});
+      }, AI_TOOL_FLASH_MS);
+      update({});
+    },
+    showChangeBatch: (batch) => update({ changeBatch: batch }),
+    dispose() {
+      if (flashTimer) {
+        clearTimeout(flashTimer);
+        flashTimer = null;
+      }
+    }
+  };
+}
+
+// src/pptx/ai/change-diff.ts
+function bounds(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, slideIndex) => {
+    const beforeSlide = beforeById.get(afterSlide.id) ?? before[slideIndex];
+    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, elementId: el.id, kind: "added", to: bounds(el) });
+        continue;
+      }
+      const kind = classify(prev, el);
+      if (kind) {
+        changes.push({ slideIndex, elementId: el.id, kind, from: bounds(prev), to: bounds(el) });
+      }
+    }
+    for (const prev of beforeSlide?.elements ?? []) {
+      if (!afterIds.has(prev.id)) {
+        changes.push({
+          slideIndex,
+          elementId: prev.id,
+          kind: "removed",
+          from: bounds(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/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 = chunkA5MANNJR_cjs.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;
+}
+
+exports.AI_CHANGE_ATTR = AI_CHANGE_ATTR;
+exports.AI_TOOL_FLASH_MS = AI_TOOL_FLASH_MS;
+exports.aiChangeAnimationCss = aiChangeAnimationCss;
+exports.aiFixDirective = aiFixDirective;
+exports.applyElementUpdate = applyElementUpdate;
+exports.applyShapeStyleUpdate = applyShapeStyleUpdate;
+exports.applyTextUpdate = applyTextUpdate;
+exports.buildChatLogExport = buildChatLogExport;
+exports.buildChatLogMarkdown = buildChatLogMarkdown;
+exports.changeGhostStyle = changeGhostStyle;
+exports.collectStoredChats = collectStoredChats;
+exports.computeFocusTargets = computeFocusTargets;
+exports.createAiChangeAnimator = createAiChangeAnimator;
+exports.createPptxAiBridge = createPptxAiBridge;
+exports.createPptxAiPanelController = createPptxAiPanelController;
+exports.deckDataFieldChanged = deckDataFieldChanged;
+exports.diffChangedElements = diffChangedElements;
+exports.exportAiChatLogs = exportAiChatLogs;
+exports.extractReadyToolCalls = extractReadyToolCalls;
+exports.focusTargetChips = focusTargetChips;
+exports.isAiFocusPinned = isAiFocusPinned;
+exports.isTwoTableFocus = isTwoTableFocus;
+exports.mergeTablesDirective = mergeTablesDirective;
+exports.pptxAiDeckTitle = pptxAiDeckTitle;
+exports.resolveAiEffectiveTargets = resolveAiEffectiveTargets;
+exports.resolveChangeAnimationConfig = resolveChangeAnimationConfig;
+exports.toLogChat = toLogChat;
+exports.toRenderableParts = toRenderableParts;
+exports.toolCallLine = toolCallLine;