@pixerate/editor 0.164.0 → 0.166.0

package/dist/chunk-HIDFL5LQ.js

@@ -0,0 +1,484 @@
+import {
+  parseSkillFrontmatter
+} from "./chunk-XZB3TJ6K.js";
+import {
+  readingTime
+} from "./chunk-6DXDUVSL.js";
+import {
+  validateJsonSchema
+} from "./chunk-V2ZCJRDM.js";
+import {
+  isUnsafeJsonKey,
+  stripPrototypeKeys
+} from "./chunk-HF5QZS7Z.js";
+
+// src/tools/script.ts
+function toolResultValue(result) {
+  if (result.structuredContent) return result.structuredContent;
+  const text = result.content.find((b) => b.type === "text");
+  if (!text?.text) return void 0;
+  try {
+    return JSON.parse(text.text);
+  } catch {
+    return text.text;
+  }
+}
+function toolResultError(result) {
+  const text = result.content.find((b) => b.type === "text");
+  return text?.text ?? "The tool failed.";
+}
+var realWait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function runToolScript(source, script, options = {}) {
+  const control = options.control ?? { speed: 1, stopped: false };
+  const wait = options.wait ?? realWait;
+  const pause = (ms) => Number.isFinite(control.speed) ? wait(ms / Math.max(0.1, control.speed)) : Promise.resolve();
+  const emit = options.onEvent ?? (() => {
+  });
+  const ctx = { results: {}, last: void 0 };
+  const finish = (ok) => {
+    if (control.stopped) options.playback?.stop();
+    emit({ type: "done", ok, stopped: control.stopped });
+    return { ok, ctx };
+  };
+  for (let i = 0; i < script.steps.length; i++) {
+    if (control.stopped) return finish(false);
+    const step = script.steps[i];
+    if (step.say) {
+      emit({ type: "say", step: i, text: step.say });
+      options.playback?.say(step.say, options.actor ? { actor: options.actor } : {});
+      await pause(readingTime(step.say));
+    }
+    if (!step.tool) continue;
+    if (control.stopped) return finish(false);
+    let args;
+    try {
+      args = typeof step.args === "function" ? step.args(ctx) : step.args ?? {};
+    } catch (error) {
+      emit({ type: "error", step: i, message: error instanceof Error ? error.message : String(error) });
+      return finish(false);
+    }
+    emit({ type: "call", step: i, tool: step.tool, args });
+    const result = await source.callTool(step.tool, args, options.actor ? { actor: options.actor } : {});
+    emit({ type: "result", step: i, tool: step.tool, result });
+    if (result.isError) {
+      emit({ type: "error", step: i, message: toolResultError(result) });
+      return finish(false);
+    }
+    ctx.last = toolResultValue(result);
+    if (step.as) ctx.results[step.as] = ctx.last;
+    await pause(350);
+  }
+  return finish(true);
+}
+
+// src/tools/style.ts
+var STYLE_SKILL_NAME = /^[a-z0-9][a-z0-9-]{0,63}$/;
+var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function parseStyleDomains(markdown) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(markdown);
+  const line = match?.[1].split(/\r?\n/).find((l) => /^domains:/.test(l));
+  if (!line) return void 0;
+  const raw = line.slice("domains:".length).trim().replace(/^\[|\]$/g, "");
+  return raw.split(",").map((d) => d.trim().replace(/^(['"])(.*)\1$/, "$2")).filter(Boolean);
+}
+function memoryStyleStore(initial = {}, state = {}) {
+  const files = /* @__PURE__ */ new Map();
+  const states = new Map(Object.entries(state));
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => listeners.forEach((l) => l());
+  for (const [path, text] of Object.entries(initial)) {
+    const [dir, ...rest] = path.replace(/\\/g, "/").replace(/^\.?\//, "").split("/");
+    if (!dir || !rest.length) continue;
+    if (!files.has(dir)) files.set(dir, /* @__PURE__ */ new Map());
+    files.get(dir).set(rest.join("/"), text);
+  }
+  return {
+    list: () => [.../* @__PURE__ */ new Set([...files.keys(), ...states.keys()])].sort().map((name) => ({ name, ...states.get(name) })),
+    read: (name, file) => files.get(name)?.get(file),
+    files: (name) => [...files.get(name)?.keys() ?? []].sort(),
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    set(name, skillFiles) {
+      files.set(name, new Map(Object.entries(skillFiles)));
+      notify();
+    },
+    remove(name) {
+      files.delete(name);
+      states.delete(name);
+      notify();
+    },
+    setState(name, next) {
+      if (next) states.set(name, next);
+      else states.delete(name);
+      notify();
+    }
+  };
+}
+function resolveTokens(value, tokens, path, errors) {
+  if (Array.isArray(value)) return value.map((v, i) => resolveTokens(v, tokens, `${path}[${i}]`, errors));
+  if (!isPlainObject(value)) return value;
+  if ("$token" in value) {
+    const token = value.$token;
+    const mode = value.mode;
+    if (typeof token !== "string" || !token || mode !== void 0 && typeof mode !== "string" || Object.keys(value).some((k) => k !== "$token" && k !== "mode")) {
+      errors.push(`${path || "profile"}: a token reference is { "$token": "<variable name or id>", "mode"?: "<mode>" }.`);
+      return void 0;
+    }
+    if (!tokens) {
+      errors.push(`${path}: "${token}" is a token reference, but this host has no design tokens to resolve it.`);
+      return void 0;
+    }
+    const resolved = tokens.resolve({ token, ...mode ? { mode } : {} });
+    if (!resolved.ok) errors.push(`${path}: ${resolved.message}`);
+    return resolved.ok ? resolved.value : void 0;
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(value)) out[k] = resolveTokens(v, tokens, path ? `${path}.${k}` : k, errors);
+  return out;
+}
+function checkListErrors(list, domain) {
+  if (list === void 0) return [];
+  if (!Array.isArray(list)) return ['checks: expected a list of check ids or { "id": ..., options } objects.'];
+  const errors = [];
+  list.forEach((entry, i) => {
+    const id = typeof entry === "string" ? entry : isPlainObject(entry) ? entry.id : void 0;
+    if (typeof id !== "string" || !id) {
+      errors.push(`checks[${i}]: expected a check id or { "id": ..., options }.`);
+      return;
+    }
+    const check = domain.checks.find((c) => c.id === id);
+    if (!check || typeof entry === "string") return;
+    const { id: _id, ...options } = entry;
+    const schema = check.optionsSchema ?? { type: "object", properties: {}, additionalProperties: false };
+    for (const e of validateJsonSchema(options, schema)) errors.push(`checks[${i}] (${id})${e.path}: ${e.message}`);
+  });
+  return errors;
+}
+function mergeProfile(target, value, layer, skill, sources, locked, issues, prefix = "") {
+  for (const [key, next] of Object.entries(value)) {
+    if (isUnsafeJsonKey(key) || next === void 0) continue;
+    const path = prefix ? `${prefix}.${key}` : key;
+    const lockedBy = [...locked.entries()].find(([p]) => p === path || path.startsWith(`${p}.`) || p.startsWith(`${path}.`));
+    if (isPlainObject(next)) {
+      if (!isPlainObject(target[key])) {
+        if (lockedBy && lockedBy[1] !== layer.id && target[key] !== void 0) {
+          issues.push({ skill, layer: layer.id, message: `"${path}" is locked by the ${lockedBy[1]} layer, so this skill's value is ignored.` });
+          continue;
+        }
+        target[key] = {};
+        delete sources[path];
+      }
+      mergeProfile(target[key], next, layer, skill, sources, locked, issues, path);
+      continue;
+    }
+    if (lockedBy && lockedBy[1] !== layer.id) {
+      issues.push({ skill, layer: layer.id, message: `"${path}" is locked by the ${lockedBy[1]} layer, so this skill's value is ignored.` });
+      continue;
+    }
+    target[key] = Array.isArray(next) ? structuredClone(next) : next;
+    for (const p of Object.keys(sources)) if (p.startsWith(`${path}.`)) delete sources[p];
+    sources[path] = layer.id;
+    if (layer.locked) locked.set(path, layer.id);
+  }
+}
+function createStyleResolver(options) {
+  const layers = [...options.layers];
+  const domains = [...options.domains];
+  const ids = /* @__PURE__ */ new Set();
+  for (const layer of layers) {
+    if (ids.has(layer.id)) throw new Error(`Two style layers are called "${layer.id}"; give each layer its own id.`);
+    ids.add(layer.id);
+  }
+  const domainIds = domains.map((d) => d.id);
+  const requireDomain = (id) => {
+    const domain = domains.find((d) => d.id === id);
+    if (!domain) throw new Error(`There is no house-style domain "${id}"; expected one of ${domainIds.map((d) => `"${d}"`).join(", ") || "(none registered)"}.`);
+    return domain;
+  };
+  async function load() {
+    const issues = [];
+    const entries = await Promise.all(layers.map(async (layer) => [...await layer.store.list()]));
+    const names = [...new Set(entries.flat().map((e) => e.name))];
+    const skills = [];
+    for (const name of names) {
+      if (!STYLE_SKILL_NAME.test(name)) {
+        issues.push({ skill: name, message: `"${name}" is not a valid skill name (lowercase letters, digits and hyphens, at most 64).` });
+        continue;
+      }
+      const copies = [];
+      for (let i = 0; i < layers.length; i++) {
+        const text = await layers[i].store.read(name, "SKILL.md");
+        if (text !== void 0) copies.push({ index: i, text });
+      }
+      if (!copies.length) continue;
+      const lockedCopy = copies.find((c) => layers[c.index].locked);
+      const winner = lockedCopy ?? copies[copies.length - 1];
+      const layer = layers[winner.index];
+      const skillIssues = [];
+      for (const c of copies) {
+        if (c.index > winner.index) skillIssues.push(`The ${layers[c.index].id} layer's copy is ignored: the ${layer.id} layer is locked.`);
+      }
+      let enabled = true;
+      let order = 0;
+      for (let i = 0; i < layers.length; i++) {
+        const entry = entries[i].find((e) => e.name === name);
+        if (!entry) continue;
+        if (i === winner.index && entry.order !== void 0) order = entry.order;
+        if (entry.enabled === void 0) continue;
+        if (layer.required && i !== winner.index) {
+          if (entry.enabled === false) skillIssues.push(`The ${layers[i].id} layer cannot switch it off: the ${layer.id} layer requires it.`);
+          continue;
+        }
+        enabled = entry.enabled;
+      }
+      const { description = "", body } = parseSkillFrontmatter(winner.text);
+      const named = parseStyleDomains(winner.text);
+      const applies = /* @__PURE__ */ new Set();
+      for (const d of named ?? domainIds) {
+        if (domainIds.includes(d)) applies.add(d);
+        else skillIssues.push(`It names an unknown domain "${d}"; the domains here are ${domainIds.join(", ")}.`);
+      }
+      const profiles = /* @__PURE__ */ new Map();
+      for (const domain of domains) {
+        const raw = await layer.store.read(name, `${domain.id}.json`);
+        if (raw === void 0) continue;
+        const file = `${domain.id}.json`;
+        if (!applies.has(domain.id)) {
+          skillIssues.push(`${file} is left out: the skill's domains do not include ${domain.id}.`);
+          continue;
+        }
+        let parsed;
+        try {
+          parsed = stripPrototypeKeys(JSON.parse(raw));
+        } catch (error) {
+          skillIssues.push(`${file} is not valid JSON: ${error.message}`);
+          continue;
+        }
+        if (!isPlainObject(parsed)) {
+          skillIssues.push(`${file} must hold a JSON object.`);
+          continue;
+        }
+        const errors = [];
+        const resolved = resolveTokens(parsed, options.tokens, "", errors);
+        const { checks, ...rest } = resolved;
+        errors.push(...validateJsonSchema(rest, domain.profileSchema).map((e) => `${e.path || "(profile)"}: ${e.message}`));
+        errors.push(...checkListErrors(checks, domain));
+        if (errors.length) {
+          skillIssues.push(`${file} is left out: ${errors.join(" ")}`);
+          continue;
+        }
+        profiles.set(domain.id, resolved);
+      }
+      skills.push({
+        info: {
+          name,
+          description,
+          layer: layer.id,
+          domains: [...applies],
+          profiles: [...profiles.keys()],
+          enabled,
+          order,
+          issues: skillIssues
+        },
+        layerIndex: winner.index,
+        body: body.trim(),
+        profiles,
+        applies
+      });
+    }
+    skills.sort((a, b) => a.layerIndex - b.layerIndex || a.info.order - b.info.order || a.info.name.localeCompare(b.info.name));
+    return { skills, issues };
+  }
+  async function resolve(domainId) {
+    requireDomain(domainId);
+    const { skills, issues: loadIssues } = await load();
+    const issues = [...loadIssues];
+    const profile = {};
+    const sources = {};
+    const locked = /* @__PURE__ */ new Map();
+    const applied = [];
+    for (const skill of skills) {
+      if (!skill.applies.has(domainId)) continue;
+      for (const message of skill.info.issues) issues.push({ skill: skill.info.name, layer: skill.info.layer, message });
+      if (!skill.info.enabled) continue;
+      applied.push({ name: skill.info.name, description: skill.info.description, layer: skill.info.layer, body: skill.body });
+      const own = skill.profiles.get(domainId);
+      if (own) mergeProfile(profile, own, layers[skill.layerIndex], skill.info.name, sources, locked, issues);
+    }
+    return { domain: domainId, skills: applied, profile, sources, issues };
+  }
+  async function winnerLayer(name) {
+    const copies = [];
+    for (let i = 0; i < layers.length; i++) if (await layers[i].store.read(name, "SKILL.md") !== void 0) copies.push(i);
+    if (!copies.length) return void 0;
+    return layers[copies.find((i) => layers[i].locked) ?? copies[copies.length - 1]];
+  }
+  return {
+    layers,
+    domains,
+    async list(opts = {}) {
+      if (opts.domain !== void 0) requireDomain(opts.domain);
+      const { skills } = await load();
+      return skills.filter((s) => opts.domain === void 0 || s.applies.has(opts.domain)).map((s) => s.info);
+    },
+    resolve,
+    async readFile(name, file) {
+      const layer = await winnerLayer(name);
+      return layer ? layer.store.read(name, file) : void 0;
+    },
+    async files(name) {
+      const layer = await winnerLayer(name);
+      return layer ? [...await layer.store.files(name)] : void 0;
+    },
+    async check(domainId, state) {
+      const domain = requireDomain(domainId);
+      const style = await resolve(domainId);
+      return { ...runStyleChecks(domain, state, style), style };
+    },
+    subscribe(listener) {
+      const offs = [...layers.map((l) => l.store.subscribe?.(listener)), options.tokens?.subscribe?.(listener)];
+      return () => offs.forEach((off) => off?.());
+    }
+  };
+}
+function runStyleChecks(domain, state, style) {
+  const report = { findings: [], ran: [], skipped: [] };
+  const list = Array.isArray(style.profile.checks) ? style.profile.checks : [];
+  const layer = style.sources.checks;
+  for (const entry of list) {
+    const id = typeof entry === "string" ? entry : isPlainObject(entry) && typeof entry.id === "string" ? entry.id : void 0;
+    if (!id) continue;
+    const check = domain.checks.find((c) => c.id === id);
+    if (!check) {
+      report.skipped.push({ check: id, reason: `There is no "${id}" check for ${domain.id}; it has ${domain.checks.map((c) => `"${c.id}"`).join(", ")}.` });
+      continue;
+    }
+    const { id: _id, ...options } = isPlainObject(entry) ? entry : { id };
+    try {
+      for (const f of check.run(state, style.profile, options)) report.findings.push({ ...f, check: id, ...layer ? { layer } : {} });
+      report.ran.push(id);
+    } catch (error) {
+      report.skipped.push({ check: id, reason: `The check could not run: ${error.message}` });
+    }
+  }
+  return report;
+}
+var escapeAttribute = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+function renderStyle(style) {
+  if (!style.skills.length) return `No house style applies to ${style.domain}.`;
+  const blocks = style.skills.map((s) => {
+    const body = s.body.replace(/<(\/?)style_skill/gi, "&lt;$1style_skill");
+    return `<style_skill name="${escapeAttribute(s.name)}" layer="${escapeAttribute(s.layer)}">
+${body}
+</style_skill>`;
+  });
+  const profile = Object.keys(style.profile).length ? `
+
+Merged ${style.domain} profile:
+${JSON.stringify(style.profile, null, 2)}` : "";
+  return `${blocks.join("\n\n")}${profile}`;
+}
+
+// src/tools/style-tools.ts
+var READ = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+function createStyleToolProvider(styles, options = {}) {
+  const domainIds = styles.domains.map((d) => d.id);
+  const DOMAIN = {
+    type: "string",
+    enum: domainIds,
+    description: `Editor domain: ${styles.domains.map((d) => `"${d.id}" (${d.title})`).join(", ")}.`
+  };
+  const listStyles = {
+    name: "list_styles",
+    title: "List house styles",
+    description: "Lists the house-style skills here, general layer first: name, description, layer (org, workspace, user, ...), the domains it applies to, which domains it has a profile for, whether it is on, and issues that leave all or part of it out. Read one domain with get_style.",
+    inputSchema: {
+      type: "object",
+      properties: { domain: { ...DOMAIN, description: `Only skills that apply to this domain (default: all). ${DOMAIN.description}` } },
+      additionalProperties: false
+    },
+    annotations: { title: "List house styles", ...READ },
+    handler: async ({ domain }) => {
+      const skills = await styles.list(domain ? { domain } : {});
+      return { skills, domains: domainIds };
+    }
+  };
+  const getStyle = {
+    name: "get_style",
+    title: "Get house style",
+    description: "Returns the house style for one editor domain: each applicable skill's preferences as a <style_skill> block naming its layer, the merged profile (structured rules such as the palette, with design-token references already resolved), which layer set each profile field, and issues. Call it before you make or change work in that domain, then check the result with the domain's check_<domain>_style tool. House style is a preference: the user's instructions and the domain skill come first.",
+    inputSchema: { type: "object", properties: { domain: DOMAIN }, required: ["domain"], additionalProperties: false },
+    annotations: { title: "Get house style", ...READ },
+    handler: async ({ domain }) => {
+      const style = await styles.resolve(domain);
+      return {
+        content: [{ type: "text", text: renderStyle(style) }],
+        structuredContent: { domain, skills: style.skills.map(({ name, description, layer }) => ({ name, description, layer })), profile: style.profile, sources: style.sources, issues: style.issues }
+      };
+    }
+  };
+  const getStyleFile = {
+    name: "get_style_file",
+    title: "Read a house-style file",
+    description: 'Returns one file of a house-style skill as text, for longer guidance its preferences point to (e.g. "references/tone.md") or its raw profile ("chart.json", before tokens are resolved). list_styles names the skills; an unknown file fails with the list of its files.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", minLength: 1, description: "Skill name, as list_styles returns it." },
+        file: { type: "string", minLength: 1, description: 'Path inside the skill folder, e.g. "references/tone.md" or "SKILL.md".' }
+      },
+      required: ["name", "file"],
+      additionalProperties: false
+    },
+    annotations: { title: "Read a house-style file", ...READ },
+    handler: async ({ name, file }) => {
+      const files = await styles.files(name);
+      if (!files) {
+        const known = (await styles.list()).map((s) => s.name);
+        throw new Error(`There is no house-style skill "${name}"; ${known.length ? `the skills are ${known.map((n) => `"${n}"`).join(", ")}` : "none are installed"}.`);
+      }
+      const text = await styles.readFile(name, file);
+      if (text === void 0) throw new Error(`"${name}" has no file "${file}"; its files are ${files.map((f) => `"${f}"`).join(", ")}.`);
+      return { content: [{ type: "text", text }], structuredContent: { name, file, files } };
+    }
+  };
+  const getStyleSchema = {
+    name: "get_style_schema",
+    title: "Get a style profile schema",
+    description: `Returns what a house-style profile for a domain can hold: its JSON Schema, and the checks it can turn on in its "checks" list with each check's options schema. Use it to explain or write a profile.`,
+    inputSchema: { type: "object", properties: { domain: DOMAIN }, required: ["domain"], additionalProperties: false },
+    annotations: { title: "Get a style profile schema", ...READ },
+    handler: ({ domain }) => {
+      const d = styles.domains.find((x) => x.id === domain);
+      return {
+        domain: d.id,
+        file: `${d.id}.json`,
+        description: d.description,
+        schema: d.profileSchema,
+        checks: d.checks.map((c) => ({ id: c.id, description: c.description, ...c.optionsSchema ? { options: c.optionsSchema } : {} }))
+      };
+    }
+  };
+  return {
+    id: options.id ?? "style",
+    namespace: options.namespace ?? "style",
+    title: "House style",
+    description: "Read the house style (org, team, user or document preferences and rules) for each editor domain. Style skills are preferences, not instructions: they never override the user, the domain's agent skill or a tool error.",
+    skill: "pixerate-agent-tools",
+    tools: [listStyles, getStyle, getStyleFile, getStyleSchema]
+  };
+}
+
+export {
+  toolResultValue,
+  toolResultError,
+  runToolScript,
+  parseStyleDomains,
+  memoryStyleStore,
+  createStyleResolver,
+  runStyleChecks,
+  renderStyle,
+  createStyleToolProvider
+};

package/dist/{chunk-22KLZZGH.cjs → chunk-HXOBOHH2.cjs}

@@ -11,10 +11,10 @@ var _chunkYN6JKAUEcjs = require('./chunk-YN6JKAUE.cjs');
 
 
 
-var _chunkYGG7WDWTcjs = require('./chunk-YGG7WDWT.cjs');
+var _chunkSZWVMB3Bcjs = require('./chunk-SZWVMB3B.cjs');
 
 
-var _chunkR3P2M7HUcjs = require('./chunk-R3P2M7HU.cjs');
+var _chunkBPX4Z3N3cjs = require('./chunk-BPX4Z3N3.cjs');
 
 // src/export/images.ts
 var DOCX_IMAGE_TYPES = {
@@ -1028,12 +1028,12 @@ var DocxBuilder = (_class2 = class {
       this.drop("node", "chart", "chart has no spec");
       return;
     }
-    const spec = _chunkR3P2M7HUcjs.normalizeChartSpec.call(void 0, raw).spec;
-    const written = _chunkYGG7WDWTcjs.chartToOoxml.call(void 0, spec);
+    const spec = _chunkBPX4Z3N3cjs.normalizeChartSpec.call(void 0, raw).spec;
+    const written = _chunkSZWVMB3Bcjs.chartToOoxml.call(void 0, spec);
     for (const issue of written.issues) this.drop("node", "chart", issue);
     const name = `chart${this.charts.length + 1}.xml`;
     this.charts.push(written.xml);
-    const relId = this.rels.add(_chunkYGG7WDWTcjs.CHART_OOXML_RELATIONSHIP, `charts/${name}`);
+    const relId = this.rels.add(_chunkSZWVMB3Bcjs.CHART_OOXML_RELATIONSHIP, `charts/${name}`);
     let width = _nullishCoalesce(pixelAttr(_optionalChain([node, 'access', _91 => _91.attrs, 'optionalAccess', _92 => _92.width])), () => ( MAX_IMAGE_WIDTH_PX));
     let height = _nullishCoalesce(pixelAttr(_optionalChain([node, 'access', _93 => _93.attrs, 'optionalAccess', _94 => _94.height])), () => ( 320));
     if (width > MAX_IMAGE_WIDTH_PX) {
@@ -1050,8 +1050,8 @@ var DocxBuilder = (_class2 = class {
     drawing.empty("wp:extent", { cx, cy }).empty("wp:effectExtent", { l: 0, t: 0, r: 0, b: 0 });
     drawing.empty("wp:docPr", { id, name: `Chart ${id}`, descr: title || void 0, title: title || void 0 });
     drawing.empty("wp:cNvGraphicFramePr");
-    drawing.open("a:graphic").open("a:graphicData", { uri: _chunkYGG7WDWTcjs.CHART_OOXML_NS });
-    drawing.empty("c:chart", { "xmlns:c": _chunkYGG7WDWTcjs.CHART_OOXML_NS, "r:id": relId });
+    drawing.open("a:graphic").open("a:graphicData", { uri: _chunkSZWVMB3Bcjs.CHART_OOXML_NS });
+    drawing.empty("c:chart", { "xmlns:c": _chunkSZWVMB3Bcjs.CHART_OOXML_NS, "r:id": relId });
     drawing.close("a:graphicData").close("a:graphic").close("wp:inline").close("w:drawing").close("w:r");
     this.report.written.paragraphs++;
     w.open("w:p");
@@ -1384,7 +1384,7 @@ var DocxBuilder = (_class2 = class {
     if (people) add("word/people.xml", people, `${CT_WML}people+xml`);
     parts.push({ name: "word/_rels/document.xml.rels", data: this.rels.xml() });
     for (const file of this.media) parts.push({ name: `word/media/${file.name}`, data: file.bytes });
-    this.charts.forEach((xml, i) => add(`word/charts/chart${i + 1}.xml`, xml, _chunkYGG7WDWTcjs.CHART_OOXML_CONTENT_TYPE));
+    this.charts.forEach((xml, i) => add(`word/charts/chart${i + 1}.xml`, xml, _chunkSZWVMB3Bcjs.CHART_OOXML_CONTENT_TYPE));
     add("docProps/core.xml", this.coreXml(now), "application/vnd.openxmlformats-package.core-properties+xml");
     const app = new XmlWriter();
     app.open("Properties", { xmlns: "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties" });

package/dist/{chunk-MKTDELCD.js → chunk-I5MRJW7B.js}

@@ -3,7 +3,7 @@ import {
   TOOL_BRIDGE_PROTOCOL,
   ToolRegistry,
   createMcpServer
-} from "./chunk-EVXQNQND.js";
+} from "./chunk-XZB3TJ6K.js";
 
 // src/bridge/index.ts
 import { createServer } from "http";