@restless-dreams/orbit 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1448 @@
+import {
+  renderToSVGString2
+} from "./chunk-7n00wx0t.js";
+import {
+  renderOrbitElement2,
+  renderOrbitMarkdownBlocks2,
+  defineOrbitMapElement2
+} from "./chunk-0gwh723s.js";
+import {
+  assignKey,
+  emitYaml,
+  nodeSlug,
+  nodesWithExplicitIds,
+  findNodeById2,
+  getNodePath2,
+  guardUrl,
+  DIAGNOSTIC_CODES2,
+  OrbitParseError2,
+  formatDiagnostic2,
+  reportParseDiagnostics,
+  suggest,
+  mediaExtras,
+  THEME_TOKENS2,
+  ORBIT_THEME_PRESETS2,
+  isOrbitThemePreset2,
+  registerTheme2,
+  isThemeName2,
+  themeNames2,
+  expandTheme,
+  themeTokens2,
+  documentToRendererOptions2,
+  isNodeLink,
+  findLinkedNode,
+  findIndexedLinkedNode,
+  indexNodes,
+  nodeLinksOf,
+  SUPPORTED_SCHEMA_VERSION2,
+  leadingEmoji,
+  parseOrbitMarkdown2,
+  parseOrbitYAML2,
+  parseOrbit2,
+  serializeOrbitMarkdown2,
+  newNodeFrom,
+  addToTree,
+  updateInTree,
+  removeFromTree,
+  moveInTree,
+  registerLanguage2,
+  languageTags2,
+  OrbitWords,
+  wordsFor,
+  parseColor,
+  toHex,
+  toOklch,
+  toneColor,
+  renderNoteMarkdown2,
+  statusTone,
+  registerNodeType2,
+  registerAction2,
+  registerStatus2,
+  upgradeNodeTypes2,
+  OrbitSVGRenderer2
+} from "./chunk-mtrnm0yc.js";
+// src/core/serializer-yaml.ts
+var serializeOrbitYAML = (doc) => {
+  const out = {};
+  const opts = doc.options;
+  if (opts.title) {
+    out.title = opts.title;
+  }
+  if (opts.theme) {
+    out.theme = opts.theme;
+  }
+  if (opts.viewMode) {
+    out.view = opts.viewMode;
+  }
+  if (opts.showRings !== undefined) {
+    out.showRings = opts.showRings;
+  }
+  if (opts.interactive !== undefined) {
+    out.interactive = opts.interactive;
+  }
+  if (opts.orbitAnimation !== undefined) {
+    out.animation = opts.orbitAnimation;
+  }
+  if (opts.orbitSpeed !== undefined) {
+    out.speed = opts.orbitSpeed;
+  }
+  if (opts.palette) {
+    out.palette = opts.palette;
+  }
+  if (opts.height !== undefined) {
+    out.height = opts.height;
+  }
+  if (opts.maxDepth !== undefined) {
+    out.maxDepth = opts.maxDepth;
+  }
+  if (opts.className) {
+    out.className = opts.className;
+  }
+  if (opts.baseUrl) {
+    out.baseUrl = opts.baseUrl;
+  }
+  if (opts.schemaVersion !== undefined) {
+    out.schemaVersion = opts.schemaVersion;
+  }
+  for (const [key, value] of Object.entries(doc.extra ?? {})) {
+    if (!Object.prototype.hasOwnProperty.call(out, key) && key !== "nodes") {
+      assignKey(out, key, value);
+    }
+  }
+  out.nodes = [serializeNode(doc.root, nodesWithExplicitIds(doc.root))];
+  return emitYaml(out);
+};
+var serializeNode = (n, explicitIds) => {
+  const obj = { text: n.text };
+  if (explicitIds.has(n)) {
+    obj.id = n.id;
+  }
+  if (n.icon) {
+    obj.icon = n.icon;
+  }
+  if (n.color) {
+    obj.color = n.color;
+  }
+  if (n.type) {
+    obj.type = n.typeVersion === undefined ? n.type : `${n.type}@${n.typeVersion}`;
+  }
+  if (n.link) {
+    obj.link = n.link;
+  }
+  if (n.tags) {
+    obj.tags = n.tags;
+  }
+  if (n.status) {
+    obj.status = n.status;
+  }
+  if (n.priority !== undefined) {
+    obj.priority = n.priority;
+  }
+  if (n.collapsed !== undefined) {
+    obj.collapsed = n.collapsed;
+  }
+  if (n.image) {
+    obj.image = { ...mediaExtras(n.image), ...n.image };
+  }
+  if (n.video) {
+    obj.video = { ...mediaExtras(n.video), ...n.video };
+  }
+  if (n.embed) {
+    obj.embed = { ...mediaExtras(n.embed), ...n.embed };
+  }
+  if (n.note) {
+    obj.note = n.note;
+    if (n.noteFormat && n.noteFormat !== "markdown") {
+      obj.noteFormat = n.noteFormat;
+    }
+  }
+  if (n.attrs) {
+    for (const [k, v] of Object.entries(n.attrs)) {
+      if (!RESERVED_NODE_KEYS.has(k) && !Object.prototype.hasOwnProperty.call(obj, k)) {
+        assignKey(obj, k, v);
+      }
+    }
+  }
+  if (n.children.length) {
+    obj.children = n.children.map((child) => serializeNode(child, explicitIds));
+  }
+  return obj;
+};
+var RESERVED_NODE_KEYS = new Set(["text", "children"]);
+// src/core/create.ts
+var createOrbitMap = (target, source, options = {}) => {
+  const { strict, ...rendererOptions } = options;
+  const renderer = new OrbitSVGRenderer2(target, rendererOptions);
+  if (typeof source === "string") {
+    const doc = parseOrbit2(source, { strict, untitled: wordsFor(rendererOptions.language, target, rendererOptions.strings).text("untitledMap") });
+    reportParseDiagnostics(doc);
+    renderer.render(doc);
+  } else {
+    renderer.render(source);
+  }
+  return renderer;
+};
+// src/core/web-page/page.ts
+var ORBIT_ICON = "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='18 18 72 72'%3E%3Cdefs%3E%3CradialGradient id='d' gradientUnits='userSpaceOnUse' cx='32.4' cy='23.76' r='102.6'%3E%3Cstop offset='0' stop-color='%234A35A8'/%3E%3Cstop offset='1' stop-color='%2318134A'/%3E%3C/radialGradient%3E%3C/defs%3E%3Crect x='18' y='18' width='72' height='72' rx='16' fill='url(%23d)'/%3E%3Cpath d='M67.53,35.36 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M69.84,37.38 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M71.86,39.69 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M76.52,57.07 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M75.92,60.08 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M74.93,62.99 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M62.21,75.71 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M59.3,76.7 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M56.29,77.3 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M38.91,72.64 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M36.6,70.62 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M34.58,68.31 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M29.92,50.93 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M30.52,47.92 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M31.51,45.01 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M44.23,32.29 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M47.14,31.3 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M50.15,30.7 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z' fill='%23E2E6FF' fill-opacity='.5'/%3E%3Ccircle cx='54' cy='54' r='11' fill='%23FAD86F'/%3E%3Ccircle cx='60.08' cy='31.3' r='6.4' fill='%23FF9E96'/%3E%3Ccircle cx='76.7' cy='47.92' r='6.4' fill='%23F8B478'/%3E%3Ccircle cx='70.62' cy='70.62' r='6.4' fill='%237FDAAB'/%3E%3Ccircle cx='47.92' cy='76.7' r='6.4' fill='%2386CDFF'/%3E%3Ccircle cx='31.3' cy='60.08' r='6.4' fill='%23C9B1FE'/%3E%3Ccircle cx='37.38' cy='37.38' r='6.4' fill='%23F7A3D4'/%3E%3C/svg%3E";
+var exportWebPage = (input, options) => {
+  const document = typeof input === "string" ? parseOrbit2(input) : input;
+  const source = typeof input === "string" ? input : serializeOrbitMarkdown2(input);
+  const words = new OrbitWords(options.language, options.strings);
+  const title = options.title ?? (document.options.title || document.root.text || "Orbit");
+  const data = {
+    source,
+    theme: options.theme,
+    viewMode: options.viewMode,
+    focus: options.focus,
+    language: options.language,
+    strings: options.strings,
+    media: options.media ?? {}
+  };
+  const theme = options.theme ?? document.options.theme;
+  return `<!doctype html>
+<html lang="${escapeAttribute(words.locale)}">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<meta name="generator" content="Orbit">
+<link rel="icon" href="${ORBIT_ICON}">
+<title>${escapeText(title)}</title>
+<style>
+${pageStyles(theme)}
+</style>
+</head>
+<body>
+<div class="page" id="page">
+  <div class="page__map" id="page-map" aria-label="${escapeAttribute(title)}"></div>
+  <button class="page__present" type="button" data-present><span aria-hidden="true">▶</span> ${escapeText(words.text("present"))}</button>
+  <section class="page__caption" id="page-caption" aria-live="polite" hidden>
+    <h1 class="page__title" id="page-title"></h1>
+    <div class="page__note" id="page-note"></div>
+  </section>
+  <nav class="page__controls" id="page-controls" hidden>
+    <button class="page__button" type="button" data-step="-1" aria-label="${escapeAttribute(words.text("previous"))}">‹</button>
+    <span class="page__count" id="page-count"></span>
+    <button class="page__button" type="button" data-step="1" aria-label="${escapeAttribute(words.text("next"))}">›</button>
+    <button class="page__button" type="button" data-close aria-label="${escapeAttribute(words.text("close"))}">✕</button>
+  </nav>
+</div>
+<script type="application/json" id="orbit-page">${scriptJson(data)}</script>
+<script type="application/json" id="orbit-script">${scriptJson(options.script)}</script>
+<script>
+  // Orbit runs from a script element made here: text inside one is never read as HTML.
+  (function () {
+    var script = document.createElement('script');
+    script.textContent = JSON.parse(document.getElementById('orbit-script').textContent);
+    document.body.appendChild(script);
+  })();
+</script>
+</body>
+</html>
+`;
+};
+var pageColors = (tokens) => {
+  const surface = tokens.surface === "transparent" ? "#ffffff" : tokens.surface;
+  return [
+    `--page-background: ${surface};`,
+    `--page-card: ${tokens["sheet-background"]};`,
+    `--page-text: ${tokens["sheet-text"]};`,
+    `--page-muted: ${tokens["sheet-muted-text"]};`,
+    `--page-border: ${tokens["sheet-border"]};`,
+    `--page-shadow: ${tokens["sheet-shadow"]};`
+  ].join(" ");
+};
+var tokensOf = (theme) => {
+  const expanded = expandTheme(theme);
+  const preset = typeof expanded === "string" ? expanded : expanded?.preset;
+  const base = themeTokens2(isOrbitThemePreset2(preset) ? preset : "paper");
+  return typeof expanded === "object" && expanded?.tokens ? { ...base, ...expanded.tokens } : base;
+};
+var pageStyles = (theme) => {
+  const automatic = (typeof theme === "string" ? theme : theme?.preset) === "auto";
+  const colors = automatic ? `:root { ${pageColors(themeTokens2("paper"))} }
+@media (prefers-color-scheme: dark) { :root { ${pageColors(themeTokens2("night"))} } }` : `:root { ${pageColors(tokensOf(theme))} }`;
+  return `${colors}
+html, body { margin: 0; height: 100%; background: var(--page-background); }
+body { font: 16px/1.5 system-ui, -apple-system, "Segoe UI", Roboto, sans-serif; color: var(--page-text); }
+.page__map { position: fixed; inset: 0; }
+.page__present, .page__controls {
+  position: fixed; left: 50%; bottom: max(16px, env(safe-area-inset-bottom)); transform: translateX(-50%);
+  display: inline-flex; align-items: center; gap: 8px; min-height: 44px; padding: 0 18px; border: 1px solid var(--page-border);
+  border-radius: 22px; background: var(--page-card); color: var(--page-text); box-shadow: var(--page-shadow); font: inherit; font-weight: 600;
+}
+.page__present { cursor: pointer; }
+.page__controls { padding: 0 6px; transition: opacity 200ms ease; }
+.page__button { min-width: 44px; min-height: 44px; border: 0; border-radius: 22px; background: none; color: inherit; font: inherit; font-size: 20px; cursor: pointer; }
+.page__button:focus-visible, .page__present:focus-visible { outline: 2px solid currentColor; outline-offset: 2px; }
+.page__count { min-width: 4em; text-align: center; color: var(--page-muted); font-variant-numeric: tabular-nums; }
+.page__caption {
+  position: fixed; left: 50%; bottom: calc(max(16px, env(safe-area-inset-bottom)) + 60px); transform: translateX(-50%);
+  box-sizing: border-box; width: min(720px, calc(100% - 32px)); max-height: 40vh; overflow: auto; padding: 16px 20px;
+  border: 1px solid var(--page-border); border-radius: 16px; background: var(--page-card); color: var(--page-text); box-shadow: var(--page-shadow);
+}
+.page__title { margin: 0; font-size: 20px; line-height: 1.3; }
+.page__note:not(:empty) { margin-top: 8px; }
+.page__note p { margin: 0 0 8px; }
+.page__note img { max-width: 100%; border-radius: 8px; }
+.page__note a { color: inherit; }
+.page--presenting .page__present { display: none; }
+.page--presenting:not(.page--controls) .page__controls { opacity: 0; }
+.page--presenting:not(.page--controls) { cursor: none; }
+[hidden] { display: none !important; }`;
+};
+var scriptJson = (value) => {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+};
+var escapeText = (text) => {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+};
+var escapeAttribute = (text) => {
+  return escapeText(text).replace(/"/g, "&quot;");
+};
+// src/core/map-tools/input.ts
+var schemaOf = (fields) => {
+  const required = Object.keys(fields).filter((name) => fields[name].required);
+  return {
+    type: "object",
+    properties: Object.fromEntries(Object.entries(fields).map(([name, field]) => [name, propertyOf(field)])),
+    ...required.length > 0 ? { required } : {}
+  };
+};
+var propertyOf = (field) => {
+  if (field.type === "list") {
+    return { type: "array", description: field.description, items: field.values ? { type: "string", enum: [...field.values] } : { type: "string" } };
+  }
+  if (field.type === "record") {
+    return { ...schemaOf(field.fields ?? {}), description: field.description };
+  }
+  return { type: field.type, description: field.description, ...field.minimum === undefined ? {} : { minimum: field.minimum } };
+};
+
+class InputError extends Error {
+}
+var readInput = (tool, fields, input, synonyms = {}) => {
+  const record = inputRecord(tool, fields, input);
+  const values = {};
+  const ignored = [];
+  const names = Object.keys(fields);
+  for (const [given, value] of Object.entries(record)) {
+    if (value === null || value === undefined) {
+      continue;
+    }
+    const name = owns(fields, given) ? given : synonymOf(given, names, synonyms);
+    if (name === undefined) {
+      const near = suggest(given, names);
+      if (near !== undefined) {
+        throw new InputError(`${tool} has no field "${given}". Did you mean "${near}"? It takes ${list(names)}.`);
+      }
+      ignored.push(given);
+      continue;
+    }
+    if (owns(values, name)) {
+      throw new InputError(`${tool} got ${name} twice, as "${name}" and as "${given}": give it once.`);
+    }
+    values[name] = readValue(name, fields[name], value);
+  }
+  for (const name of names) {
+    if (fields[name].required && !owns(values, name)) {
+      throw new InputError(`${tool} needs ${name}: ${lowerFirst(fields[name].description)}`);
+    }
+  }
+  return { values, ignored };
+};
+var inputRecord = (tool, fields, input) => {
+  let value = input;
+  if (typeof value === "string") {
+    if (value.trim() === "") {
+      return {};
+    }
+    try {
+      value = JSON.parse(value);
+    } catch (error) {
+      throw new InputError(`${tool}'s input isn't valid JSON (${error.message}). Send an object, like ${example(fields)}.`);
+    }
+  }
+  if (value === null || value === undefined) {
+    return {};
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new InputError(`${tool} takes an object, like ${example(fields)}, not ${describe(value)}.`);
+  }
+  return value;
+};
+var synonymOf = (given, names, synonyms) => {
+  const lowered = given.toLowerCase();
+  return names.find((name) => name.toLowerCase() === lowered) ?? (owns(synonyms, lowered) ? synonyms[lowered] : undefined);
+};
+var owns = (record, key) => {
+  return Object.prototype.hasOwnProperty.call(record, key);
+};
+var readValue = (name, field, value) => {
+  switch (field.type) {
+    case "string":
+      if (typeof value === "string") {
+        return value;
+      }
+      if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+      }
+      throw new InputError(`${name} takes text, not ${describe(value)}.`);
+    case "integer":
+    case "number": {
+      const number = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : Number.NaN;
+      if (!Number.isFinite(number) || field.type === "integer" && !Number.isInteger(number)) {
+        throw new InputError(`${name} takes ${field.type === "integer" ? "a whole number" : "a number"}, like ${field.minimum ?? 1}, not ${describe(value)}.`);
+      }
+      if (field.minimum !== undefined && number < field.minimum) {
+        throw new InputError(`${name} takes ${field.minimum} or more, not ${number}. ${field.description}`);
+      }
+      return number;
+    }
+    case "boolean": {
+      const word = typeof value === "string" ? value.trim().toLowerCase() : value;
+      if (word === true || word === "true" || word === "yes") {
+        return true;
+      }
+      if (word === false || word === "false" || word === "no") {
+        return false;
+      }
+      throw new InputError(`${name} takes true or false, not ${describe(value)}.`);
+    }
+    case "list": {
+      const items = Array.isArray(value) ? value : typeof value === "string" ? value.trim() === "" ? [] : value.split(",") : null;
+      if (!items || items.some((item) => typeof item !== "string" && typeof item !== "number")) {
+        throw new InputError(`${name} takes a list of words, like ["${field.values?.[0] ?? "design"}"], not ${describe(value)}.`);
+      }
+      const words = items.map((item) => String(item).trim()).filter((item) => item !== "");
+      for (const word of words) {
+        if (field.values && !field.values.includes(word)) {
+          const near = suggest(word, field.values);
+          throw new InputError(`${name} can't take "${word}".${near === undefined ? "" : ` Did you mean "${near}"?`} It takes ${list(field.values)}.`);
+        }
+      }
+      return words;
+    }
+    case "record": {
+      const fields = field.fields ?? {};
+      const first = Object.keys(fields)[0];
+      if (typeof value === "string") {
+        return { [first]: value };
+      }
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new InputError(`${name} takes an object, like {"${first}": "…"}, not ${describe(value)}.`);
+      }
+      return readInput(name, fields, value).values;
+    }
+  }
+};
+var describe = (value) => {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "a list";
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value.length > 40 ? `${value.slice(0, 40)}…` : value);
+  }
+  if (typeof value === "object") {
+    return "an object";
+  }
+  return String(value);
+};
+var list = (words) => {
+  return words.length <= 1 ? words.join("") : `${words.slice(0, -1).join(", ")} and ${words[words.length - 1]}`;
+};
+var example = (fields) => {
+  const name = Object.keys(fields).find((key) => fields[key].required) ?? Object.keys(fields)[0];
+  return name === undefined ? "{}" : `{"${name}": "…"}`;
+};
+var lowerFirst = (text) => {
+  return text.charAt(0).toLowerCase() + text.slice(1);
+};
+
+// src/core/map-tools/definitions.ts
+var PROVIDERS = ["anthropic", "openai", "openai-chat", "gemini"];
+var ATTRIBUTES = ["note", "status", "priority", "tags", "icon", "color", "link", "image", "video", "embed", "collapsed"];
+var NODE_ID = "node_id";
+var NODE_SYNONYMS = { id: NODE_ID, node: NODE_ID, nodeid: NODE_ID };
+var TOOL_SPECS = [
+  {
+    name: "read_map",
+    description: "Read the mind map as an outline: a line for each node (an idea), indented under its parent, with its id after a #, its attributes in parentheses, and the start of its note on the next line after >. Read it before changing the map: the other tools take these ids. A big map is cut short: read a branch with node_id, or search with find_nodes.",
+    fields: {
+      node_id: { type: "string", description: "Read only this node and the nodes under it. Leave out to read the whole map." },
+      depth: { type: "integer", minimum: 1, description: "How many levels under it to read: 1 for its children only. Leave out to read them all." }
+    },
+    synonyms: NODE_SYNONYMS,
+    readOnly: true,
+    destructive: false
+  },
+  {
+    name: "find_nodes",
+    description: "Search the map for nodes by the words in their titles, notes and tags, by status or by tag. Returns each match with its id and where it is in the map.",
+    fields: {
+      query: { type: "string", description: "Words to look for, in any case, with or without accents. A node matches when it has every word." },
+      status: { type: "string", description: "Only nodes with this status. todo, active, done and blocked also find the words that mean the same, such as planned, in progress, shipped or stuck." },
+      tag: { type: "string", description: "Only nodes with this tag." }
+    },
+    synonyms: { text: "query", search: "query", words: "query", tags: "tag" },
+    readOnly: true,
+    destructive: false
+  },
+  {
+    name: "read_node",
+    description: "Read everything about one node: its title, its whole note, its attributes, its picture, video or embedded page, where it is in the map, its children, and the nodes that link to it.",
+    fields: {
+      node_id: { type: "string", required: true, description: "The node to read, by the id read_map or find_nodes gave." }
+    },
+    synonyms: NODE_SYNONYMS,
+    readOnly: true,
+    destructive: false
+  },
+  {
+    name: "add_nodes",
+    description: "Add nodes under a node: one, several, or whole branches at once, written as a markdown list. Each item is a node, items indented under it are its children, at any depth, and indented lines under an item that aren't items are its note. On an item's line, [ ], [/] or [x] first sets its status to todo, active or done, an emoji first sets its icon, words after a # at the end are its tags, and <!-- orbit color: tomato, priority: 1 --> at the end sets other attributes. Returns the new nodes with their ids.",
+    fields: {
+      parent_id: { type: "string", required: true, description: "The node to add them under." },
+      outline: { type: "string", required: true, description: 'The nodes, as a markdown list: "- Social media\\n  - Instagram\\n- Newsletter".' },
+      index: { type: "integer", minimum: 0, description: "Where they go among the children of parent_id: 0 puts them first. Leave out to put them last." }
+    },
+    synonyms: { parent: "parent_id", parentid: "parent_id", under: "parent_id", markdown: "outline", nodes: "outline", items: "outline", children: "outline", text: "outline", position: "index" },
+    readOnly: false,
+    destructive: false
+  },
+  {
+    name: "update_node",
+    description: "Change a node's title or attributes. Only the fields you give change; to remove an attribute, name it in clear. A new title can give the node a new id, which the result says.",
+    fields: {
+      node_id: { type: "string", required: true, description: "The node to change." },
+      text: { type: "string", description: "Its title: plain text, a few words." },
+      note: { type: "string", description: "Its note, in markdown, for details and longer text. Replaces the note it has." },
+      status: { type: "string", description: "todo, active, done or blocked, which show a colored dot, or any other word." },
+      priority: { type: "number", description: "A number, such as 1 for the most important." },
+      tags: { type: "list", description: "All its tags, as words: they replace the ones it has." },
+      icon: { type: "string", description: "An emoji shown before its title." },
+      color: { type: "string", description: "A CSS color, such as #E8A33D or tomato: its children take shades of it. Nodes without one take the theme's colors, so set it only when asked." },
+      link: { type: "string", description: "A web address it links to, or #id to link to another node of the map." },
+      image: {
+        type: "record",
+        description: "A picture shown in the node.",
+        fields: {
+          src: { type: "string", required: true, description: "The picture's address." },
+          alt: { type: "string", description: "What the picture shows, for people who can't see it." },
+          caption: { type: "string", description: "A caption." }
+        }
+      },
+      video: {
+        type: "record",
+        description: "A video the node plays.",
+        fields: {
+          src: { type: "string", required: true, description: "The video's address: YouTube, Vimeo or a video file." },
+          caption: { type: "string", description: "A caption." }
+        }
+      },
+      embed: {
+        type: "record",
+        description: "A web page shown in a frame in the node's details.",
+        fields: {
+          src: { type: "string", required: true, description: "The page's address." },
+          caption: { type: "string", description: "A caption." }
+        }
+      },
+      collapsed: { type: "boolean", description: "true hides its children until the reader opens it." },
+      clear: { type: "list", values: ATTRIBUTES, description: 'Attributes to remove, such as ["status", "color"].' }
+    },
+    synonyms: {
+      ...NODE_SYNONYMS,
+      title: "text",
+      name: "text",
+      label: "text",
+      notes: "note",
+      description: "note",
+      details: "note",
+      state: "status",
+      tag: "tags",
+      labels: "tags",
+      emoji: "icon",
+      colour: "color",
+      url: "link",
+      href: "link",
+      picture: "image",
+      photo: "image",
+      remove: "clear",
+      unset: "clear",
+      delete: "clear"
+    },
+    readOnly: false,
+    destructive: true
+  },
+  {
+    name: "move_node",
+    description: "Move a node, with everything under it, under another node, or to another place among its siblings.",
+    fields: {
+      node_id: { type: "string", required: true, description: "The node to move." },
+      parent_id: { type: "string", description: "The node to move it under. Leave out to keep its parent and change only its place." },
+      index: { type: "integer", minimum: 0, description: "Its place among the children of its new parent: 0 puts it first. Leave out to put it last." }
+    },
+    synonyms: { ...NODE_SYNONYMS, parent: "parent_id", parentid: "parent_id", under: "parent_id", to: "parent_id", position: "index" },
+    readOnly: false,
+    destructive: false
+  },
+  {
+    name: "reorder_children",
+    description: "Put the children of a node in a new order, all at once: to sort them, or to group the ones that go together.",
+    fields: {
+      parent_id: { type: "string", required: true, description: "The node whose children to reorder." },
+      order: { type: "list", required: true, description: "The ids of all its children, in their new order." }
+    },
+    synonyms: { parent: "parent_id", parentid: "parent_id", node_id: "parent_id", id: "parent_id", ids: "order", children: "order", child_ids: "order" },
+    readOnly: false,
+    destructive: false
+  },
+  {
+    name: "remove_node",
+    description: "Remove a node and everything under it. Remove nodes only when asked to.",
+    fields: {
+      node_id: { type: "string", required: true, description: "The node to remove. The root can't be removed." }
+    },
+    synonyms: NODE_SYNONYMS,
+    readOnly: false,
+    destructive: true
+  },
+  {
+    name: "show_node",
+    description: "Show the reader a node: the map flies to it, with its children around it. Use it when they ask to see or go to something, or to show them what you changed.",
+    fields: {
+      node_id: { type: "string", required: true, description: "The node to show." }
+    },
+    synonyms: NODE_SYNONYMS,
+    readOnly: true,
+    destructive: false
+  }
+];
+var definitionOf = (spec) => {
+  return {
+    name: spec.name,
+    description: spec.description,
+    inputSchema: schemaOf(spec.fields),
+    annotations: { readOnlyHint: spec.readOnly, destructiveHint: spec.destructive }
+  };
+};
+var formatDefinitions = (definitions, provider) => {
+  const tools = definitions.map(({ name, description, inputSchema }) => ({ name, description, schema: structuredCopy(inputSchema) }));
+  switch (provider) {
+    case "anthropic":
+      return tools.map(({ name, description, schema }) => ({ name, description, input_schema: schema }));
+    case "openai":
+      return tools.map(({ name, description, schema }) => ({ type: "function", name, description, parameters: schema, strict: false }));
+    case "openai-chat":
+      return tools.map(({ name, description, schema }) => ({ type: "function", function: { name, description, parameters: schema } }));
+    case "gemini":
+      return [{ functionDeclarations: tools.map(({ name, description, schema }) => ({ name, description, parametersJsonSchema: schema })) }];
+    default:
+      throw new TypeError(`Map tools come in the shapes of ${PROVIDERS.map((name) => `"${name}"`).join(", ")}, not ${JSON.stringify(provider)}. For any other, build them from tools.definitions: each has a name, a description and an inputSchema (JSON Schema).`);
+  }
+};
+var structuredCopy = (value) => {
+  return JSON.parse(JSON.stringify(value));
+};
+
+// src/core/map-tools/reading.ts
+var NOTE_PREVIEW = 100;
+var MATCH_LIMIT = 50;
+var nameOf = (node) => {
+  return `"${node.text}" #${node.id}`;
+};
+var outlineLine = (node, depth) => {
+  const details = attributesOf(node);
+  return `${"  ".repeat(depth)}- ${node.text}  #${node.id}${details.length > 0 ? `  (${details.join("; ")})` : ""}`;
+};
+var attributesOf = (node) => {
+  const details = [];
+  if (node.icon) {
+    details.push(`icon: ${node.icon}`);
+  }
+  if (node.status) {
+    details.push(`status: ${node.status}`);
+  }
+  if (node.priority !== undefined) {
+    details.push(`priority: ${node.priority}`);
+  }
+  if (node.tags && node.tags.length > 0) {
+    details.push(`tags: ${node.tags.join(", ")}`);
+  }
+  if (node.color) {
+    details.push(`color: ${node.color}`);
+  }
+  if (node.link) {
+    details.push(`link: ${node.link}`);
+  }
+  for (const media of ["image", "video", "embed"]) {
+    if (node[media]) {
+      details.push(media);
+    }
+  }
+  if (node.type) {
+    details.push(`type: ${node.type}`);
+  }
+  if (node.collapsed) {
+    details.push("collapsed");
+  }
+  return details;
+};
+var notePreview = (note) => {
+  const text = note.trim().replace(/\s+/g, " ");
+  return text.length > NOTE_PREVIEW ? `${text.slice(0, NOTE_PREVIEW - 1).trimEnd()}…` : text;
+};
+var headOf = (node, depth) => {
+  const lines = [outlineLine(node, depth)];
+  if (node.note?.trim()) {
+    lines.push(`${"  ".repeat(depth + 1)}> ${notePreview(node.note)}`);
+  }
+  return lines;
+};
+var outlineOf = (node, depth = 0, levels = Infinity) => {
+  const lines = headOf(node, depth);
+  if (levels > 0) {
+    for (const child of node.children) {
+      lines.push(...outlineOf(child, depth + 1, levels - 1));
+    }
+  } else if (node.children.length > 0) {
+    lines.push(`${"  ".repeat(depth + 1)}- … ${count(node.children.length, "child", "children")}, ${count(descendants(node), "node")} in all under it`);
+  }
+  return lines;
+};
+var readOutline = (start, levels, limit) => {
+  let shown = 0;
+  let total = 1;
+  let level = [start];
+  while (shown < levels) {
+    const next = level.flatMap((node) => node.children);
+    if (next.length === 0 || total + next.length > limit) {
+      break;
+    }
+    total += next.length;
+    level = next;
+    shown += 1;
+  }
+  const complete = shown === levels || level.every((node) => node.children.length === 0);
+  if (shown === 0 && !complete) {
+    const children = start.children.slice(0, Math.max(1, limit - 1));
+    return {
+      lines: [
+        ...headOf(start, 0),
+        ...children.flatMap((child) => outlineOf(child, 1, 0)),
+        `  - … ${count(start.children.length - children.length, "more child", "more children")} of ${nameOf(start)}`
+      ],
+      complete
+    };
+  }
+  return { lines: outlineOf(start, 0, shown), complete };
+};
+var descendants = (node) => {
+  return node.children.reduce((sum, child) => sum + 1 + descendants(child), 0);
+};
+var count = (amount, one, many = `${one}s`) => {
+  return `${amount} ${amount === 1 ? one : many}`;
+};
+var nodeDetails = (root, node, path) => {
+  const lines = [nameOf(node)];
+  lines.push(path.length > 1 ? `Where: ${path.map((step) => step.text).join(" › ")}` : "Where: the root of the map");
+  const fields = [
+    ["Icon", node.icon],
+    ["Status", node.status],
+    ["Priority", node.priority],
+    ["Tags", node.tags && node.tags.length > 0 ? node.tags.join(", ") : undefined],
+    ["Color", node.color],
+    ["Link", node.link],
+    ["Picture", node.image && mediaLine(node.image.src, { alt: node.image.alt, caption: node.image.caption })],
+    ["Video", node.video && mediaLine(node.video.src, { caption: node.video.caption })],
+    ["Embedded page", node.embed && mediaLine(node.embed.src, { caption: node.embed.caption })],
+    ["Type", node.type],
+    ["Collapsed", node.collapsed ? "yes: its children are hidden until the reader opens it" : undefined]
+  ];
+  for (const [label, value] of fields) {
+    if (value !== undefined && value !== "") {
+      lines.push(`${label}: ${String(value)}`);
+    }
+  }
+  const custom = Object.entries(node.attrs ?? {});
+  if (custom.length > 0) {
+    lines.push(`Other attributes: ${custom.map(([key, value]) => `${key}: ${typeof value === "string" ? value : JSON.stringify(value)}`).join("; ")}`);
+  }
+  lines.push(node.note?.trim() ? `Note${node.noteFormat === "plain" ? " (plain text)" : ""}:
+${node.note.trim()}` : "Note: none");
+  lines.push(node.children.length > 0 ? `Children (${node.children.length}): ${node.children.map(nameOf).join(", ")}` : "Children: none");
+  const linking = nodesLinkingTo(root, node);
+  if (linking.length > 0) {
+    lines.push(`Linked from: ${linking.map(nameOf).join(", ")}`);
+  }
+  return lines.join(`
+`);
+};
+var mediaLine = (src, extras) => {
+  const described = Object.entries(extras).filter(([, value]) => value).map(([key, value]) => `${key}: ${value}`);
+  return described.length > 0 ? `${src} (${described.join("; ")})` : src;
+};
+var nodesLinkingTo = (root, target) => {
+  const nodes = indexNodes(root);
+  const linking = [];
+  const visit = (node) => {
+    if (nodeLinksOf(node).some((href) => findIndexedLinkedNode(nodes, href) === target)) {
+      linking.push(node);
+    }
+    node.children.forEach(visit);
+  };
+  visit(root);
+  return linking;
+};
+var searchable = (text) => {
+  return text.normalize("NFKD").replace(/\p{M}+/gu, "").toLowerCase();
+};
+var findNodes = (root, search) => {
+  const words = searchable(search.query ?? "").split(/\s+/).filter((word) => word !== "");
+  const status = search.status === undefined ? undefined : searchable(search.status.trim());
+  const tag = search.tag === undefined ? undefined : searchable(search.tag.trim().replace(/^#/, ""));
+  const statusMatches = (node) => {
+    if (status === undefined) {
+      return true;
+    }
+    if (!node.status) {
+      return false;
+    }
+    const own = searchable(node.status.trim());
+    const tone = statusTone(status);
+    return own === status || tone !== "neutral" && statusTone(own) === tone;
+  };
+  const matches = [];
+  const visit = (node, path) => {
+    const title = searchable([node.text, ...node.tags ?? []].join(" "));
+    const everything = `${title} ${searchable(node.note ?? "")}`;
+    if (words.every((word) => everything.includes(word)) && statusMatches(node) && (tag === undefined || (node.tags ?? []).some((own) => searchable(own) === tag))) {
+      matches.push({ node, path, inTitle: words.every((word) => title.includes(word)) });
+    }
+    node.children.forEach((child) => visit(child, [...path, node]));
+  };
+  visit(root, []);
+  if (matches.length === 0) {
+    return "No node matches. Try fewer or other words, or read the map with read_map.";
+  }
+  matches.sort((first, second) => Number(second.inTitle) - Number(first.inTitle));
+  const shown = matches.slice(0, MATCH_LIMIT);
+  const lines = [`${count(matches.length, "node matches", "nodes match")}${matches.length > shown.length ? `; the first ${shown.length}` : ""}:`];
+  for (const { node, path } of shown) {
+    lines.push(`${outlineLine(node, 0)}${path.length > 0 ? `  in ${path.map((step) => step.text).join(" › ")}` : "  (the root)"}`);
+  }
+  if (matches.length > shown.length) {
+    lines.push("Narrow the search to see the others.");
+  }
+  return lines.join(`
+`);
+};
+
+// src/core/map-tools/tools.ts
+var READ_LIMIT = 250;
+var LONG_TITLE = 60;
+var COLOR_SYNTAX = /^(?:#(?:[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})|[a-z]+|(?:rgba?|hsla?|hwb|lab|lch|oklab|oklch|color|color-mix|light-dark|var)\(.+\))$/i;
+var OUTLINE_CODES_LEFT_OUT = new Set(["synthetic-root", "no-structure", "unknown-link-target"]);
+
+class CallError extends Error {
+}
+var createMapTools = (map, options = {}) => {
+  const target = targetOf(map);
+  const readLimit = typeof options.readLimit === "number" && Number.isFinite(options.readLimit) ? Math.max(10, Math.trunc(options.readLimit)) : READ_LIMIT;
+  const specs = TOOL_SPECS.filter((spec) => (spec.name !== "show_node" || target.live !== null) && (spec.readOnly || !options.readOnly));
+  const definitions = specs.map(definitionOf);
+  const renamed = new Map;
+  const removed = new Map;
+  const notes = [];
+  const resolve = (root, given, field) => {
+    const id = given.trim().replace(/^#/, "");
+    const direct = findNodeById2(root, id);
+    if (direct) {
+      return direct;
+    }
+    let current = id;
+    const seen = new Set;
+    while (renamed.has(current) && !seen.has(current)) {
+      seen.add(current);
+      current = renamed.get(current);
+    }
+    const followed = current === id ? null : findNodeById2(root, current);
+    if (followed) {
+      notes.push(`#${id} is ${nameOf(followed)} now.`);
+      return followed;
+    }
+    if (removed.has(id)) {
+      throw new CallError(`${field} names #${id}, but "${removed.get(id)}" was removed.`);
+    }
+    const wanted = searchable(id);
+    const titled = allNodes(root).filter((node) => searchable(node.text.trim()) === wanted || node.id === nodeSlug(id));
+    if (titled.length === 1) {
+      notes.push(`${field} takes ids: the id of "${titled[0].text}" is #${titled[0].id}.`);
+      return titled[0];
+    }
+    if (titled.length > 1) {
+      throw new CallError(`${titled.length} nodes are called "${given}": ${titled.map((node) => `${nameOf(node)}${node.parent ? ` under "${node.parent.text}"` : ""}`).join(", ")}. Give ${field} one of their ids.`);
+    }
+    const near = suggest(id, allNodes(root).map((node) => node.id));
+    const nearNode = near === undefined ? null : findNodeById2(root, near);
+    throw new CallError(`No node has the id "${id}".${nearNode ? ` Did you mean ${nameOf(nearNode)}?` : ""} read_map and find_nodes give every node's id.`);
+  };
+  const calls = {
+    read_map: (values, root, document) => {
+      const start = typeof values.node_id === "string" ? resolve(root, values.node_id, "node_id") : root;
+      const levels = typeof values.depth === "number" ? values.depth : Infinity;
+      const { lines, complete } = readOutline(start, levels, readLimit);
+      const header = [];
+      if (start === root) {
+        const title = document.options.title ?? root.text;
+        header.push(`The map "${title}" has ${count(1 + descendants(root), "node")}.`);
+      } else {
+        const path = getNodePath2(root, start.id);
+        header.push(`${nameOf(start)}, in ${path.slice(0, -1).map((node) => node.text).join(" › ")}, has ${count(descendants(start), "node")} under it.`);
+      }
+      const live = target.live;
+      if (live) {
+        const focused = live.getFocusedNode();
+        header.push(live.getViewMode() === "all" || !focused ? "The reader is looking at the whole map." : `The reader is looking at ${nameOf(focused)}.`);
+      }
+      const footer = complete ? [] : ["Nodes further down aren't shown: read a branch with read_map and its node_id, or search with find_nodes."];
+      return { text: [header.join(" "), ...lines, ...footer].join(`
+`), changed: false };
+    },
+    find_nodes: (values, root) => {
+      if (values.query === undefined && values.status === undefined && values.tag === undefined) {
+        throw new CallError("find_nodes needs something to look for: query, status, tag, or more than one.");
+      }
+      return { text: findNodes(root, values), changed: false };
+    },
+    read_node: (values, root) => {
+      const node = resolve(root, values.node_id, "node_id");
+      return { text: nodeDetails(root, node, getNodePath2(root, node.id)), changed: false };
+    },
+    add_nodes: (values, root) => {
+      const parent = resolve(root, values.parent_id, "parent_id");
+      const nodes = readNewNodes(values.outline);
+      const index = values.index;
+      const added = [];
+      nodes.forEach((input, offset) => {
+        const node = target.add(parent.id, input, index === undefined ? undefined : index + offset);
+        if (node) {
+          added.push(node);
+        }
+      });
+      if (added.length === 0) {
+        throw new CallError(`Nothing could be added under ${nameOf(parent)}.`);
+      }
+      for (const node of added) {
+        const twin = parent.children.find((sibling) => sibling !== node && !added.includes(sibling) && searchable(sibling.text) === searchable(node.text));
+        if (twin) {
+          notes.push(`${nameOf(node)} has the same title as ${nameOf(twin)} beside it. If it's there twice by mistake, remove one with remove_node.`);
+        }
+      }
+      const all = added.flatMap(allNodes);
+      const long = all.filter((node) => node.text.length > LONG_TITLE);
+      if (long.length > 0) {
+        notes.push(`${long.map(nameOf).join(", ")} ${long.length === 1 ? "has a long title" : "have long titles"}: a few words read best on the map, with the rest in the note.`);
+      }
+      notes.push(...brokenLinks(target.document()?.root ?? root, all));
+      return {
+        text: [`Added ${count(all.length, "node")} under ${nameOf(parent)}${placeOf(added, parent)}:`, ...added.flatMap((node) => outlineOf(node))].join(`
+`),
+        changed: added.length > 0
+      };
+    },
+    update_node: (values, root) => {
+      const node = resolve(root, values.node_id, "node_id");
+      const previousId = node.id;
+      const { changes, set, cleared, absent } = readChanges(values, root, node);
+      if (set.length === 0 && cleared.length === 0) {
+        if (absent.length === 0) {
+          throw new CallError(`update_node needs something to change: ${list(["text", ...ATTRIBUTES])}, or clear to remove attributes.`);
+        }
+        return { text: `${nameOf(node)} has no ${list(absent)} to remove: nothing changed.`, changed: false };
+      }
+      const updated = target.update(node.id, changes);
+      if (!updated) {
+        throw new CallError(`${nameOf(node)} couldn't be changed.`);
+      }
+      if (changes.note !== undefined) {
+        notes.push(...brokenLinks(root, [updated]));
+      }
+      const described = [set.length > 0 ? `set its ${list(set)}` : "", cleared.length > 0 ? `removed its ${list(cleared)}` : ""].filter((part) => part !== "").join("; ");
+      let text = `Changed ${nameOf(updated)}: ${described}.`;
+      if (updated.id !== previousId) {
+        renamed.set(previousId, updated.id);
+        text += ` Its id is #${updated.id} now: it was #${previousId}.`;
+      }
+      return { text, changed: true };
+    },
+    move_node: (values, root) => {
+      const node = resolve(root, values.node_id, "node_id");
+      if (values.parent_id === undefined && values.index === undefined) {
+        throw new CallError("move_node needs where to move the node: parent_id, index, or both.");
+      }
+      const path = getNodePath2(root, node.id);
+      if (path.length < 2) {
+        throw new CallError(`${nameOf(node)} is the root: it can't move, as every other node is under it.`);
+      }
+      const parent = values.parent_id === undefined ? path[path.length - 2] : resolve(root, values.parent_id, "parent_id");
+      if (parent === node) {
+        throw new CallError(`${nameOf(node)} can't go under itself. Give parent_id another node.`);
+      }
+      if (getNodePath2(root, parent.id).includes(node)) {
+        throw new CallError(`${nameOf(node)} can't go under ${nameOf(parent)}, which is inside it. Move ${nameOf(parent)} out of it first, or choose another parent.`);
+      }
+      const under = descendants(node);
+      const moved = target.move(node.id, parent.id, values.index);
+      if (!moved) {
+        throw new CallError(`${nameOf(node)} couldn't be moved.`);
+      }
+      return { text: `Moved ${nameOf(moved)}${under > 0 ? `, with the ${count(under, "node")} under it,` : ""} under ${nameOf(parent)}${placeOf([moved], parent)}.`, changed: true };
+    },
+    reorder_children: (values, root) => {
+      const parent = resolve(root, values.parent_id, "parent_id");
+      const children = [...parent.children];
+      if (children.length === 0) {
+        throw new CallError(`${nameOf(parent)} has no children to reorder.`);
+      }
+      const order = values.order.map((given) => childNamed(parent, given));
+      const twice = order.find((child, position) => order.indexOf(child) !== position);
+      if (twice) {
+        throw new CallError(`order lists ${nameOf(twice)} twice: list each child once.`);
+      }
+      const missing = children.filter((child) => !order.includes(child));
+      if (missing.length > 0) {
+        throw new CallError(`order needs all ${children.length} children of ${nameOf(parent)}, and leaves out ${missing.map(nameOf).join(", ")}.`);
+      }
+      if (order.every((child, position) => children[position] === child)) {
+        return { text: `The children of ${nameOf(parent)} are in that order already.`, changed: false };
+      }
+      order.forEach((child, position) => {
+        const current = findNodeById2(target.document()?.root ?? root, parent.id) ?? parent;
+        if (current.children[position]?.id !== child.id) {
+          target.move(child.id, parent.id, position);
+        }
+      });
+      return { text: `The children of ${nameOf(parent)} are in this order now: ${order.map(nameOf).join(", ")}.`, changed: true };
+    },
+    remove_node: (values, root) => {
+      const node = resolve(root, values.node_id, "node_id");
+      if (node === root) {
+        throw new CallError(`${nameOf(node)} is the root, and the map is all under it: it can't be removed. Remove the nodes under it one by one, or give it a new title with update_node.`);
+      }
+      const gone = allNodes(node);
+      if (!target.remove(node.id)) {
+        throw new CallError(`${nameOf(node)} couldn't be removed.`);
+      }
+      for (const each of gone) {
+        removed.set(each.id, each.text);
+      }
+      return { text: `Removed ${nameOf(node)}${gone.length > 1 ? ` and the ${count(gone.length - 1, "node")} under it` : ""}.`, changed: true };
+    },
+    show_node: (values, root) => {
+      const node = resolve(root, values.node_id, "node_id");
+      target.live?.flyTo(node.id);
+      return { text: `The map shows ${nameOf(node)} now, with its children around it.`, changed: false };
+    }
+  };
+  const childNamed = (parent, given) => {
+    const id = given.trim().replace(/^#/, "");
+    const child = parent.children.find((each) => each.id === id || each.id === renamed.get(id)) ?? parent.children.find((each) => searchable(each.text.trim()) === searchable(id));
+    if (!child) {
+      throw new CallError(`${given} isn't a child of ${nameOf(parent)}. Its children: ${parent.children.map(nameOf).join(", ")}.`);
+    }
+    return child;
+  };
+  const run = (name, input) => {
+    notes.length = 0;
+    const spec = TOOL_SPECS.find((each) => each.name === name);
+    const offered = specs.find((each) => each.name === name);
+    if (!offered) {
+      if (spec?.name === "show_node") {
+        return failure("show_node only works on a map on screen.");
+      }
+      if (spec) {
+        return failure(`${name} isn't available: this map can only be read.`);
+      }
+      const near = suggest(String(name), specs.map((each) => each.name));
+      return failure(`There's no tool "${String(name)}".${near === undefined ? "" : ` Did you mean ${near}?`} The tools are ${list(specs.map((each) => each.name))}.`);
+    }
+    const document = target.document();
+    if (!document) {
+      return failure("There's no map to read yet: it hasn't been drawn.");
+    }
+    if (!offered.readOnly && target.newer) {
+      return failure("This map was written for a newer version of Orbit, and changing it here could lose what this version doesn't read. It can be read, but not changed.");
+    }
+    try {
+      const { values, ignored } = readInput(offered.name, offered.fields, input, offered.synonyms);
+      const outcome = calls[offered.name](values, document.root, document);
+      if (ignored.length > 0) {
+        notes.push(`${offered.name} doesn't take ${list(ignored.map((key) => `"${key}"`))}, so ${ignored.length === 1 ? "it was" : "they were"} left out. It takes ${list(Object.keys(offered.fields))}.`);
+      }
+      return { ok: true, text: [outcome.text, ...notes.map((note) => `Note: ${note}`)].join(`
+`), changed: outcome.changed };
+    } catch (error) {
+      if (error instanceof CallError || error instanceof InputError) {
+        return failure(error.message, offered);
+      }
+      throw error;
+    }
+  };
+  return {
+    definitions,
+    instructions: instructionsFor(target.live !== null, options.readOnly === true),
+    for: (provider) => formatDefinitions(definitions, provider),
+    run,
+    get document() {
+      return target.document();
+    }
+  };
+};
+var failure = (message, spec) => {
+  return { ok: false, text: spec && !spec.readOnly ? `${message} Nothing changed.` : message, changed: false };
+};
+var targetOf = (map) => {
+  if (isLiveMap(map)) {
+    return {
+      document: () => map.getDocument(),
+      add: (parentId, input, index) => map.addNode(parentId, input, index),
+      update: (id, changes) => map.updateNode(id, changes),
+      move: (id, parentId, index) => map.moveNode(id, parentId, index),
+      remove: (id) => map.removeNode(id),
+      live: map,
+      newer: false
+    };
+  }
+  const document = typeof map === "string" ? parseOrbit2(map) : map;
+  if (!document || typeof document !== "object" || !document.root || !Array.isArray(document.root.children)) {
+    throw new TypeError(`createMapTools() takes a map on screen (createOrbitMap's result, or <orbit-map>'s renderer), a parsed document, or a map's markdown or YAML, but got ${map === null ? "null" : typeof map}.`);
+  }
+  return {
+    document: () => document,
+    add: (parentId, input, index) => addToTree(document.root, parentId, input, index)?.node ?? null,
+    update: (id, changes) => updateInTree(document.root, id, changes)?.node ?? null,
+    move: (id, parentId, index) => moveInTree(document.root, id, parentId, index)?.node ?? null,
+    remove: (id) => removeFromTree(document.root, id)?.node ?? null,
+    live: null,
+    newer: (document.diagnostics ?? []).some((diagnostic) => diagnostic.code === "unsupported-schema-version")
+  };
+};
+var isLiveMap = (map) => {
+  const candidate = map;
+  return typeof candidate === "object" && candidate !== null && typeof candidate.getDocument === "function" && typeof candidate.addNode === "function";
+};
+var instructionsFor = (live, readOnly) => {
+  const lines = readOnly ? [
+    "You can read the mind map with the map tools. Each node is an idea, with an id.",
+    "- read_map shows the map as an outline, with every node's id; find_nodes searches a big one, and read_node shows everything about one node, its whole note included.",
+    "- Answer from what the map says, and say when it doesn't say."
+  ] : [
+    "You can read and change the mind map with the map tools. Each node is an idea, with an id.",
+    "- Read the map before you change it: read_map shows it as an outline with every node's id, and find_nodes searches a big one. The other tools take those ids.",
+    "- Keep titles to a few words, and put details and longer text in the note.",
+    "- Write in the language the map is written in.",
+    "- Add several nodes, or whole branches, with one add_nodes call.",
+    "- A new title can give a node a new id: use the ids the latest results give.",
+    "- Remove nodes only when asked to."
+  ];
+  if (live) {
+    lines.push(readOnly ? "- show_node takes the reader to a node." : "- The reader sees each change on the map as you make it, and show_node takes them to a node.");
+  }
+  return lines.join(`
+`);
+};
+var allNodes = (root) => {
+  return [root, ...root.children.flatMap(allNodes)];
+};
+var placeOf = (nodes, parent) => {
+  const first = parent.children.indexOf(nodes[0]);
+  const last = parent.children.indexOf(nodes[nodes.length - 1]);
+  if (first > 0) {
+    return `, after ${nameOf(parent.children[first - 1])}`;
+  }
+  if (first === 0 && last < parent.children.length - 1) {
+    return `, first, before ${nameOf(parent.children[last + 1])}`;
+  }
+  return "";
+};
+var brokenLinks = (root, nodes) => {
+  const index = indexNodes(root);
+  const ids = [...index.keys()];
+  return nodes.flatMap((node) => nodeLinksOf(node).filter((href) => !findIndexedLinkedNode(index, href)).map((href) => {
+    const near = suggest(href.slice(1), ids);
+    return `${nameOf(node)} links to ${href}, but no node has that id.${near === undefined ? "" : ` Did you mean #${near}?`}`;
+  }));
+};
+var readNewNodes = (outline) => {
+  let source = outline.replace(/\r\n?/g, `
+`);
+  if (/^\s*---\s*\n/.test(source)) {
+    throw new CallError("outline takes the nodes to add as a markdown list, without frontmatter.");
+  }
+  let document = parseOrbitMarkdown2(source);
+  if (document.diagnostics.some((diagnostic) => diagnostic.code === "no-structure")) {
+    source = source.split(`
+`).map((line) => line.trim()).filter((line) => line !== "").map((line) => `- ${line}`).join(`
+`);
+    document = parseOrbitMarkdown2(source);
+  }
+  const roots = document.diagnostics.some((diagnostic) => diagnostic.code === "synthetic-root") ? document.root.children : [document.root];
+  const untitled = roots.flatMap(allNodes).find((node) => node.text.trim() === "");
+  if (roots.length === 0 || untitled) {
+    throw new CallError(untitled?.source ? `Line ${untitled.source.line} of outline has an item without a title.` : 'outline has no nodes: write them as a markdown list, like "- Social media\\n- Newsletter".');
+  }
+  const problems = document.diagnostics.filter((diagnostic) => !OUTLINE_CODES_LEFT_OUT.has(diagnostic.code)).map((diagnostic) => formatDiagnostic2(diagnostic).replace(/[,;] kept as (?:a custom attribute|written)(?:, but not used)?/, ""));
+  if (problems.length > 0) {
+    throw new CallError(`outline doesn't read cleanly. Fix ${problems.length === 1 ? "this" : "these"}, and send it again:
+${problems.map((problem) => `- ${problem}`).join(`
+`)}
+Lines count from the outline's first line.`);
+  }
+  return roots.map(newNodeFrom);
+};
+var readChanges = (values, root, node) => {
+  const changes = {};
+  const set = [];
+  const clear = new Set(values.clear ?? []);
+  const cleared = [];
+  const absent = [];
+  const remove = (name) => {
+    if (node[name] === undefined) {
+      absent.push(name);
+      return;
+    }
+    changes[name] = undefined;
+    cleared.push(name);
+  };
+  for (const name of clear) {
+    if (values[name] !== undefined) {
+      throw new CallError(`${name} is both given and in clear: give it a value, or clear it.`);
+    }
+    remove(name);
+  }
+  if (values.text !== undefined) {
+    let text = String(values.text).replace(/\s+/g, " ").trim();
+    if (text === "") {
+      throw new CallError("text can't be empty: every node has a title. To take the node out of the map, use remove_node.");
+    }
+    const emoji = leadingEmoji(text);
+    if (emoji && values.icon === undefined && !clear.has("icon")) {
+      changes.icon = emoji.icon;
+      text = emoji.text;
+      set.push("icon");
+    }
+    changes.text = text;
+    set.push("title");
+  }
+  const text = (name) => {
+    const value = values[name];
+    if (value === undefined) {
+      return;
+    }
+    const written = name === "note" ? String(value).trim() : String(value).replace(/\s+/g, " ").trim();
+    if (written === "") {
+      remove(name);
+      return;
+    }
+    set.push(name);
+    return written;
+  };
+  const note = text("note");
+  if (note !== undefined) {
+    changes.note = note;
+  }
+  const status = text("status");
+  if (status !== undefined) {
+    changes.status = status;
+  }
+  if (values.priority !== undefined) {
+    changes.priority = values.priority;
+    set.push("priority");
+  }
+  if (values.tags !== undefined) {
+    const tags = [...new Set(values.tags.map((tag) => tag.replace(/^#/, "").trim()).filter((tag) => tag !== ""))];
+    if (tags.length === 0) {
+      remove("tags");
+    } else {
+      changes.tags = tags;
+      set.push("tags");
+    }
+  }
+  const icon = text("icon");
+  if (icon !== undefined) {
+    if (/^[\p{L}\p{N}][\p{L}\p{N}\s'-]+$/u.test(icon) || Array.from(icon).length > 8) {
+      throw new CallError(`icon takes an emoji, such as \uD83D\uDE80, not ${JSON.stringify(icon)}.`);
+    }
+    changes.icon = icon;
+  }
+  const color = text("color");
+  if (color !== undefined) {
+    const supports = typeof CSS !== "undefined" && typeof CSS.supports === "function" ? CSS.supports("color", color) : true;
+    if (!COLOR_SYNTAX.test(color) || !supports) {
+      throw new CallError(`"${color}" isn't a CSS color. Use a color name, such as tomato, or a code, such as #E8A33D.`);
+    }
+    changes.color = color;
+  }
+  const link = text("link");
+  if (link !== undefined) {
+    if (isNodeLink(link)) {
+      if (!findLinkedNode(root, link)) {
+        const near = suggest(link.slice(1), allNodes(root).map((each) => each.id));
+        throw new CallError(`link ${link} points at no node.${near === undefined ? "" : ` Did you mean #${near}?`} Node links are # and a node's id.`);
+      }
+    } else if (guardUrl(link, "link", false) === null) {
+      throw new CallError(`"${link}" isn't an address the map can open: use a web address, such as https://example.com.`);
+    }
+    changes.link = link;
+  }
+  for (const name of ["image", "video", "embed"]) {
+    const media = values[name];
+    if (media === undefined) {
+      continue;
+    }
+    const src = media.src.trim();
+    if (src === "") {
+      remove(name);
+      continue;
+    }
+    if (guardUrl(src, name, false) === null) {
+      throw new CallError(`${name} can't show "${src}": use a web address, such as https://example.com/${name === "image" ? "photo.jpg" : name === "video" ? "video.mp4" : "page"}.`);
+    }
+    const extras = Object.fromEntries(Object.entries(media).filter(([key, value]) => key !== "src" && value.trim() !== "").map(([key, value]) => [key, value.trim()]));
+    changes[name] = { src, ...extras };
+    set.push(name === "image" ? "picture" : name === "embed" ? "embedded page" : "video");
+  }
+  if (values.collapsed !== undefined) {
+    if (values.collapsed === true) {
+      changes.collapsed = true;
+      set.push("collapsed");
+    } else {
+      remove("collapsed");
+    }
+  }
+  return { changes, set, cleared, absent };
+};
+// src/core/material.ts
+var MATERIAL_SEED = "#6750A4";
+var BRANCH_HUES = [0, 3, 6, 2, 5, 1, 4].map((step) => step * 360 / 7);
+var MOST_CHROMA = 0.16;
+var BRANCH_CHROMA = 0.11;
+var ERROR = { hue: 25, chroma: 0.19 };
+var SUCCESS = { hue: 145, chroma: 0.13 };
+var materialTheme = (seed, options = {}) => {
+  const dark = options.dark === true;
+  return { preset: dark ? "material-night" : "material", tokens: materialColors(seed, dark) };
+};
+var materialColors = (seed, dark) => {
+  const parsed = parseColor(seed);
+  if (!parsed) {
+    throw new Error(`A Material theme needs a color Orbit can read, such as "#0B57D0" or "oklch(0.55 0.15 260)": got "${seed}".`);
+  }
+  const { hue, chroma } = toOklch(parsed);
+  const primaryChroma = Math.min(chroma, MOST_CHROMA);
+  const palette = (paletteHue, paletteChroma) => (tone) => toHex(toneColor(paletteHue, paletteChroma, tone));
+  const primary = palette(hue, primaryChroma);
+  const secondary = palette(hue, Math.min(primaryChroma / 3, 0.05));
+  const neutral = palette(hue, Math.min(primaryChroma / 10, 0.012));
+  const neutralVariant = palette(hue, Math.min(primaryChroma / 5, 0.024));
+  const error = palette(ERROR.hue, ERROR.chroma);
+  const success = palette(SUCCESS.hue, SUCCESS.chroma);
+  const branches = BRANCH_HUES.map((offset) => palette((hue + offset) % 360, BRANCH_CHROMA));
+  const [accent, container, onContainer] = dark ? [80, 30, 90] : [40, 90, 10];
+  const branchTone = dark ? 32 : 88;
+  const [colorRoot, ...colors] = [primary(accent), ...branches.map((branch) => branch(branchTone))];
+  return {
+    surface: neutral(dark ? 6 : 98),
+    text: neutral(dark ? 90 : 10),
+    "muted-text": neutralVariant(dark ? 80 : 30),
+    "root-text": neutral(10),
+    "node-text": neutral(10),
+    "node-text-inverse": neutral(dark ? 90 : 100),
+    "color-root": colorRoot,
+    "color-1": colors[0],
+    "color-2": colors[1],
+    "color-3": colors[2],
+    "color-4": colors[3],
+    "color-5": colors[4],
+    "color-6": colors[5],
+    "color-7": colors[6],
+    "shade-light": dark ? neutral(40) : neutralVariant(80),
+    "shade-dark": dark ? neutral(12) : neutralVariant(50),
+    "node-stroke": neutralVariant(dark ? 30 : 80),
+    "badge-stroke": neutral(dark ? 6 : 98),
+    "sun-halo": primary(accent),
+    "ring-stroke": neutralVariant(dark ? 30 : 80),
+    "link-stroke": neutralVariant(dark ? 60 : 50),
+    "focus-ring": primary(accent),
+    "note-indicator": primary(accent),
+    "control-background": neutral(dark ? 12 : 94),
+    "control-text": neutral(dark ? 90 : 10),
+    "control-muted-text": neutralVariant(dark ? 80 : 30),
+    "control-active-background": secondary(container),
+    "control-active-text": secondary(onContainer),
+    "tooltip-background": neutral(dark ? 90 : 20),
+    "tooltip-text": neutral(dark ? 20 : 95),
+    "action-background": neutral(dark ? 17 : 92),
+    "action-text": neutral(dark ? 90 : 10),
+    "sheet-background": neutral(dark ? 10 : 96),
+    "sheet-text": neutral(dark ? 90 : 10),
+    "sheet-muted-text": neutralVariant(dark ? 80 : 30),
+    "sheet-border": neutralVariant(dark ? 30 : 80),
+    "chip-background": secondary(container),
+    "chip-text": secondary(onContainer),
+    "link-text": primary(accent),
+    "status-active": primary(accent),
+    "status-done": success(accent),
+    "status-blocked": error(accent),
+    "status-todo": neutralVariant(60),
+    "status-neutral": neutralVariant(dark ? 70 : 50),
+    "error-background": error(container),
+    "error-border": error(accent),
+    "error-text": error(onContainer)
+  };
+};
+export {
+  DIAGNOSTIC_CODES2 as DIAGNOSTIC_CODES,
+  MATERIAL_SEED,
+  ORBIT_THEME_PRESETS2 as ORBIT_THEME_PRESETS,
+  OrbitParseError2 as OrbitParseError,
+  OrbitSVGRenderer2 as OrbitSVGRenderer,
+  SUPPORTED_SCHEMA_VERSION2 as SUPPORTED_SCHEMA_VERSION,
+  THEME_TOKENS2 as THEME_TOKENS,
+  createMapTools,
+  createOrbitMap,
+  defineOrbitMapElement2 as defineOrbitMapElement,
+  documentToRendererOptions2 as documentToRendererOptions,
+  exportWebPage,
+  findNodeById2 as findNodeById,
+  formatDiagnostic2 as formatDiagnostic,
+  getNodePath2 as getNodePath,
+  isOrbitThemePreset2 as isOrbitThemePreset,
+  isThemeName2 as isThemeName,
+  languageTags2 as languageTags,
+  materialTheme,
+  parseOrbit2 as parseOrbit,
+  parseOrbitMarkdown2 as parseOrbitMarkdown,
+  parseOrbitYAML2 as parseOrbitYAML,
+  registerAction2 as registerAction,
+  registerLanguage2 as registerLanguage,
+  registerNodeType2 as registerNodeType,
+  registerStatus2 as registerStatus,
+  registerTheme2 as registerTheme,
+  renderNoteMarkdown2 as renderNoteMarkdown,
+  renderOrbitElement2 as renderOrbitElement,
+  renderOrbitMarkdownBlocks2 as renderOrbitMarkdownBlocks,
+  renderToSVGString2 as renderToSVGString,
+  serializeOrbitMarkdown2 as serializeOrbitMarkdown,
+  serializeOrbitYAML,
+  themeNames2 as themeNames,
+  themeTokens2 as themeTokens,
+  upgradeNodeTypes2 as upgradeNodeTypes
+};
+
+//# debugId=DE40EE65BFF35E2264756E2164756E21
+//# sourceMappingURL=index.js.map