data-navigator 2.4.0 → 3.0.0

package/dist/index.js

@@ -17,6 +17,28 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -55,8 +77,8 @@ var defaultKeyBindings = {
   ArrowDown: "down",
   Period: "forward",
   Comma: "backward",
-  Escape: "parent",
-  Enter: "child"
+  Escape: "drill-out",
+  Enter: "drill-in"
 };
 var TypicallyUnreservedKeys = ["KeyW", "KeyJ", "LeftBracket", "RightBracket", "Slash", "Backslash"];
 var TypicallyUnreservedKeyPairs = [
@@ -80,11 +102,11 @@ var GenericFullNavigationRules = {
     key: "ArrowDown",
     direction: "target"
   },
-  child: {
+  "drill-in": {
     key: "Enter",
     direction: "target"
   },
-  parent: {
+  "drill-out": {
     key: "Backspace",
     direction: "source"
   },
@@ -140,11 +162,11 @@ var GenericLimitedNavigationRules = {
     key: "ArrowUp",
     direction: "source"
   },
-  child: {
+  "drill-in": {
     key: "Enter",
     direction: "target"
   },
-  parent: {
+  "drill-out": {
     key: "Backspace",
     direction: "source"
   },
@@ -187,6 +209,26 @@ var NodeElementDefaults = {
     spatialProperties: void 0
   }
 };
+var GenericNavigationRuleCommands = {
+  "drill-in": { label: "Enter", description: "Drill in" },
+  "drill-out": { label: "Backspace", description: "Drill out" },
+  exit: { label: "Esc", description: "Exit" },
+  left: { label: "\u2190", description: "Previous data point" },
+  right: { label: "\u2192", description: "Next data point" },
+  up: { label: "\u2191", description: "Previous data point" },
+  down: { label: "\u2193", description: "Next data point" },
+  backward: { label: ",", description: "Move backward" },
+  forward: { label: ".", description: "Move forward" },
+  previous: { label: ";", description: "Previous" },
+  next: { label: "'", description: "Next" },
+  undo: { label: "Z", description: "Undo" },
+  help: { label: "Y", description: "Help" },
+  legend: { label: "L", description: "Legend" }
+};
+var commandsTableDefaultColumns = [
+  { label: "Command", id: "description" },
+  { label: "Key", id: "label" }
+];
 
 // src/utilities.ts
 var describeNode = (d, descriptionOptions) => {
@@ -201,6 +243,12 @@ var describeNode = (d, descriptionOptions) => {
 var createValidId = (s) => {
   return "_" + s.replace(/[^a-zA-Z0-9_-]+/g, "_");
 };
+function getGenericCommandsFromNavRules(navigationRules) {
+  if (!navigationRules) {
+    return [];
+  }
+  return Object.keys(navigationRules).map((navId) => GenericNavigationRuleCommands[navId]).filter(Boolean);
+}
 
 // src/structure.ts
 var structure_default = (options) => {
@@ -277,7 +325,7 @@ var buildNodeStructureFromVegaLite = (options) => {
           edges[firstChildEdge] = {
             source: node.id,
             target: firstChildId,
-            navigationRules: ["parent", "child"]
+            navigationRules: ["drill-out", "drill-in"]
           };
         }
       }
@@ -290,7 +338,7 @@ var buildNodeStructureFromVegaLite = (options) => {
           edges[parentEdge] = {
             source: parentId,
             target: node.id,
-            navigationRules: ["parent", "child"]
+            navigationRules: ["drill-out", "drill-in"]
           };
         }
       }
@@ -491,7 +539,7 @@ var scaffoldDimensions = (options, nodes) => {
               },
               navigationRules: dim.navigationRules || {
                 sibling_sibling: rules.length ? [...rules.shift()] : ["previous_" + dim.dimensionKey, "next_" + dim.dimensionKey],
-                parent_child: ["parent_" + dim.dimensionKey, "child"]
+                parent_child: ["drill-out_" + dim.dimensionKey, "drill-in"]
               }
             };
             nodes[id2] = {
@@ -604,7 +652,8 @@ var scaffoldDimensions = (options, nodes) => {
             let node = values[valueKeys[index]];
             let value = node[s];
             if (value <= i) {
-              dimension.divisions[divisionId].values[node.id] = node;
+              const leafId = typeof options.idKey === "function" ? options.idKey(node) : node[options.idKey];
+              dimension.divisions[divisionId].values[leafId] = node;
               index++;
             } else {
               limit = true;
@@ -616,11 +665,12 @@ var scaffoldDimensions = (options, nodes) => {
         if (lastDivisionId && index < valueKeys.length) {
           while (index < valueKeys.length) {
             let node = values[valueKeys[index]];
-            dimension.divisions[lastDivisionId].values[node.id] = node;
+            const leafId = typeof options.idKey === "function" ? options.idKey(node) : node[options.idKey];
+            dimension.divisions[lastDivisionId].values[leafId] = node;
             index++;
           }
         }
-        delete divisions[s];
+        delete divisions[dimension.nodeId];
       }
     } else if (typeof ((_e = dimension.operations) == null ? void 0 : _e.sortFunction) === "function") {
       dimension.divisions = Object.fromEntries(
@@ -719,7 +769,7 @@ var buildEdges = (options, nodes, dimensions) => {
     let po = ((_d = options.dimensions) == null ? void 0 : _d.parentOptions) || {};
     let extents = ((_f = (_e = po.level1Options) == null ? void 0 : _e.behavior) == null ? void 0 : _f.extents) || "terminal";
     let level0 = po.addLevel0;
-    let parentRules = level0 ? ((_h = (_g = po.level1Options) == null ? void 0 : _g.navigationRules) == null ? void 0 : _h.parent_child) || ["parent", "child"] : [];
+    let parentRules = level0 ? ((_h = (_g = po.level1Options) == null ? void 0 : _g.navigationRules) == null ? void 0 : _h.parent_child) || ["drill-out", "drill-in"] : [];
     let siblingRules = ((_j = (_i = po.level1Options) == null ? void 0 : _i.navigationRules) == null ? void 0 : _j.sibling_sibling) || ["left", "right"];
     let firstLevel1Node = typeof order[0] === "string" ? hasOrder ? nodes[order[0]] : nodes[dimensions[order[0]].nodeId] : order[0];
     if (level0) {
@@ -786,6 +836,22 @@ var buildEdges = (options, nodes, dimensions) => {
           "source"
         );
       }
+      const findNextNonEmptyDivIdx = (fromIdx) => {
+        for (let step = 1; step < divisionKeys.length; step++) {
+          const idx = (fromIdx + step) % divisionKeys.length;
+          if (Object.keys(dimension.divisions[divisionKeys[idx]].values).length > 0)
+            return idx;
+        }
+        return null;
+      };
+      const findPrevNonEmptyDivIdx = (fromIdx) => {
+        for (let step = 1; step < divisionKeys.length; step++) {
+          const idx = (fromIdx - step + divisionKeys.length) % divisionKeys.length;
+          if (Object.keys(dimension.divisions[divisionKeys[idx]].values).length > 0)
+            return idx;
+        }
+        return null;
+      };
       let j = 0;
       divisionKeys.forEach((d) => {
         let division = dimension.divisions[d];
@@ -837,22 +903,13 @@ var buildEdges = (options, nodes, dimensions) => {
                   dimension.navigationRules.sibling_sibling
                 );
               } else if (i === valueKeys.length - 1 && extents2 === "bridgedCousins") {
-                if (j !== divisionKeys.length - 1) {
-                  const targetId = typeof options.idKey === "function" ? options.idKey(
-                    dimension.divisions[divisionKeys[j + 1]].values[valueKeys[0]]
-                  ) : options.idKey;
-                  createEdge(
-                    v[id],
-                    dimension.divisions[divisionKeys[j + 1]].values[valueKeys[0]][targetId],
-                    dimension.navigationRules.sibling_sibling
-                  );
-                } else {
-                  const targetId = typeof options.idKey === "function" ? options.idKey(dimension.divisions[divisionKeys[0]].values[valueKeys[0]]) : options.idKey;
-                  createEdge(
-                    v[id],
-                    dimension.divisions[divisionKeys[0]].values[valueKeys[0]][targetId],
-                    dimension.navigationRules.sibling_sibling
-                  );
+                const nextIdx = findNextNonEmptyDivIdx(j);
+                if (nextIdx !== null) {
+                  const nextDivValues = dimension.divisions[divisionKeys[nextIdx]].values;
+                  const nextDivValueKeys = Object.keys(nextDivValues);
+                  const targetDatum = nextDivValues[nextDivValueKeys[0]];
+                  const targetId = typeof options.idKey === "function" ? options.idKey(targetDatum) : options.idKey;
+                  createEdge(v[id], targetDatum[targetId], dimension.navigationRules.sibling_sibling);
                 }
               } else if (i === valueKeys.length - 1 && extents2 === "bridgedCustom") {
                 createEdge(
@@ -869,24 +926,13 @@ var buildEdges = (options, nodes, dimensions) => {
                 );
               }
               if (!i && extents2 === "bridgedCousins") {
-                if (j !== 0) {
-                  const targetId = typeof options.idKey === "function" ? options.idKey(
-                    dimension.divisions[divisionKeys[j - 1]].values[valueKeys[valueKeys.length - 1]]
-                  ) : options.idKey;
-                  createEdge(
-                    dimension.divisions[divisionKeys[j - 1]].values[valueKeys[valueKeys.length - 1]][targetId],
-                    v[id],
-                    dimension.navigationRules.sibling_sibling
-                  );
-                } else {
-                  const targetId = typeof options.idKey === "function" ? options.idKey(
-                    dimension.divisions[divisionKeys[divisionKeys.length - 1]].values[valueKeys[valueKeys.length - 1]]
-                  ) : options.idKey;
-                  createEdge(
-                    dimension.divisions[divisionKeys[divisionKeys.length - 1]].values[valueKeys[valueKeys.length - 1]][targetId],
-                    v[id],
-                    dimension.navigationRules.sibling_sibling
-                  );
+                const prevIdx = findPrevNonEmptyDivIdx(j);
+                if (prevIdx !== null) {
+                  const prevDivValues = dimension.divisions[divisionKeys[prevIdx]].values;
+                  const prevDivValueKeys = Object.keys(prevDivValues);
+                  const targetDatum = prevDivValues[prevDivValueKeys[prevDivValueKeys.length - 1]];
+                  const targetId = typeof options.idKey === "function" ? options.idKey(targetDatum) : options.idKey;
+                  createEdge(targetDatum[targetId], v[id], dimension.navigationRules.sibling_sibling);
                 }
               } else if (!i && extents2 === "bridgedCustom") {
                 createEdge(
@@ -1035,8 +1081,8 @@ var buildRules = (options, edges, dimensions) => {
     if (dimKeys.length) {
       if ((_b = (_a = options.dimensions) == null ? void 0 : _a.parentOptions) == null ? void 0 : _b.addLevel0) {
         let rules2 = ((_d = (_c = options.dimensions.parentOptions.level1Options) == null ? void 0 : _c.navigationRules) == null ? void 0 : _d.parent_child) || [
-          "parent",
-          "child"
+          "drill-out",
+          "drill-in"
         ];
         checkKeys(rules2[0], rules2[1]);
       }
@@ -1192,6 +1238,124 @@ var input_default = (options) => {
   return inputHandler;
 };
 
+// src/commands-table.ts
+var _commands, _columns, _kbdColumn, _connected, _render, render_fn;
+var CommandsTable = class extends HTMLElement {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _render);
+    __privateAdd(this, _commands, []);
+    __privateAdd(this, _columns, commandsTableDefaultColumns);
+    __privateAdd(this, _kbdColumn, "label");
+    __privateAdd(this, _connected, false);
+  }
+  static get observedAttributes() {
+    return ["title"];
+  }
+  set commands(value) {
+    __privateSet(this, _commands, value);
+    if (!__privateGet(this, _connected))
+      return;
+    __privateMethod(this, _render, render_fn).call(this);
+  }
+  get commands() {
+    return __privateGet(this, _commands);
+  }
+  set columns(value) {
+    __privateSet(this, _columns, value);
+    if (!__privateGet(this, _connected))
+      return;
+    __privateMethod(this, _render, render_fn).call(this);
+  }
+  get columns() {
+    return __privateGet(this, _columns);
+  }
+  /** Column id whose cells are wrapped in <kbd>. Defaults to 'label'. Set to null to disable. */
+  set kbdColumn(value) {
+    __privateSet(this, _kbdColumn, value);
+    if (!__privateGet(this, _connected))
+      return;
+    __privateMethod(this, _render, render_fn).call(this);
+  }
+  get kbdColumn() {
+    return __privateGet(this, _kbdColumn);
+  }
+  attributeChangedCallback() {
+    if (!__privateGet(this, _connected))
+      return;
+    __privateMethod(this, _render, render_fn).call(this);
+  }
+  connectedCallback() {
+    __privateSet(this, _connected, true);
+    __privateMethod(this, _render, render_fn).call(this);
+  }
+  disconnectedCallback() {
+    __privateSet(this, _connected, false);
+  }
+};
+_commands = new WeakMap();
+_columns = new WeakMap();
+_kbdColumn = new WeakMap();
+_connected = new WeakMap();
+_render = new WeakSet();
+render_fn = function() {
+  this.replaceChildren();
+  const headerCells = [];
+  for (const column of __privateGet(this, _columns)) {
+    const headerCell = document.createElement("th");
+    headerCell.classList.add("dn-commands-table-th");
+    headerCell.textContent = column.label;
+    headerCells.push(headerCell);
+  }
+  const headerRow = document.createElement("tr");
+  headerRow.classList.add("dn-commands-table-thead-tr");
+  for (const headerCell of headerCells) {
+    headerRow.appendChild(headerCell);
+  }
+  const thead = document.createElement("thead");
+  thead.classList.add("dn-commands-table-thead");
+  thead.appendChild(headerRow);
+  const tbody = document.createElement("tbody");
+  tbody.classList.add("dn-commands-table-tbody");
+  for (const command of __privateGet(this, _commands)) {
+    const rowCells = [];
+    for (const column of __privateGet(this, _columns)) {
+      const cellValue = command[column.id];
+      const rowCell = document.createElement("td");
+      rowCell.classList.add("dn-commands-table-td");
+      if (__privateGet(this, _kbdColumn) !== null && column.id === __privateGet(this, _kbdColumn) && cellValue) {
+        const kbd = document.createElement("kbd");
+        kbd.classList.add("dn-commands-table-td-kbd");
+        kbd.textContent = cellValue;
+        rowCell.append(kbd);
+      } else {
+        rowCell.textContent = cellValue;
+      }
+      rowCells.push(rowCell);
+    }
+    const row = document.createElement("tr");
+    row.classList.add("dn-commands-table-tbody-tr");
+    for (const rowCell of rowCells) {
+      row.appendChild(rowCell);
+    }
+    tbody.appendChild(row);
+  }
+  const table = document.createElement("table");
+  table.classList.add("dn-commands-table");
+  const title = this.getAttribute("title");
+  if (title) {
+    const caption = document.createElement("caption");
+    caption.classList.add("dn-commands-table-caption");
+    caption.textContent = title;
+    table.appendChild(caption);
+  } else {
+    table.setAttribute("aria-label", "Commands table");
+  }
+  table.appendChild(thead);
+  table.appendChild(tbody);
+  this.appendChild(table);
+};
+
 // src/rendering.ts
 var rendering_default = (options) => {
   const setActiveDescendant = (e) => {
@@ -1217,7 +1381,7 @@ var rendering_default = (options) => {
     defaults.existingElement = options.defaults.existingElement ? __spreadValues(__spreadValues({}, defaults.existingElement), options.defaults.existingElement) : defaults.existingElement;
   }
   renderer.initialize = () => {
-    var _a;
+    var _a, _b;
     if (initialized) {
       console.error(
         `The renderer wrapper has already been initialized successfully, RenderingOptions.suffixId is: ${options.suffixId}. No further action was taken.`
@@ -1248,6 +1412,9 @@ var rendering_default = (options) => {
     if (options.root && options.root.height) {
       renderer.wrapper.style.height = options.root.height;
     }
+    if ((_a = options.commandsElement) == null ? void 0 : _a.include) {
+      renderer.initializeCommands(options.commandsElement);
+    }
     if (options.entryButton && options.entryButton.include) {
       renderer.entryButton = document.createElement("button");
       renderer.entryButton.id = "dn-entry-button-" + options.suffixId;
@@ -1262,7 +1429,7 @@ var rendering_default = (options) => {
       renderer.wrapper.appendChild(renderer.entryButton);
     }
     renderer.root.appendChild(renderer.wrapper);
-    if ((_a = options.exitElement) == null ? void 0 : _a.include) {
+    if ((_b = options.exitElement) == null ? void 0 : _b.include) {
       renderer.exitElement = document.createElement("div");
       renderer.exitElement.id = "dn-exit-" + options.suffixId;
       renderer.exitElement.classList.add("dn-exit-position");
@@ -1272,17 +1439,17 @@ var rendering_default = (options) => {
       renderer.exitElement.setAttribute("tabindex", "-1");
       renderer.exitElement.style.display = "none";
       renderer.exitElement.addEventListener("focus", (e) => {
-        var _a2, _b;
+        var _a2, _b2;
         renderer.exitElement.style.display = "block";
         renderer.clearStructure();
-        if ((_b = (_a2 = options.exitElement) == null ? void 0 : _a2.callbacks) == null ? void 0 : _b.focus) {
+        if ((_b2 = (_a2 = options.exitElement) == null ? void 0 : _a2.callbacks) == null ? void 0 : _b2.focus) {
           options.exitElement.callbacks.focus(e);
         }
       });
       renderer.exitElement.addEventListener("blur", (e) => {
-        var _a2, _b;
+        var _a2, _b2;
         renderer.exitElement.style.display = "none";
-        if ((_b = (_a2 = options.exitElement) == null ? void 0 : _a2.callbacks) == null ? void 0 : _b.blur) {
+        if ((_b2 = (_a2 = options.exitElement) == null ? void 0 : _a2.callbacks) == null ? void 0 : _b2.blur) {
           options.exitElement.callbacks.blur(e);
         }
       });
@@ -1395,6 +1562,31 @@ var rendering_default = (options) => {
       }
     });
   };
+  renderer.initializeCommands = (commandOptions) => {
+    const root = document.getElementById(commandOptions == null ? void 0 : commandOptions.rootId);
+    if (!root) {
+      console.error("Commands root element not found in document.");
+      return;
+    }
+    const optionsCommands = commandOptions.commands;
+    const genericCommandsFromRules = getGenericCommandsFromNavRules(commandOptions.navigationRules);
+    const commands = optionsCommands ? typeof optionsCommands === "function" ? optionsCommands(genericCommandsFromRules) : optionsCommands : genericCommandsFromRules;
+    if (!customElements.get("dn-commands-table")) {
+      customElements.define("dn-commands-table", CommandsTable);
+    }
+    const commandsElement = document.createElement("dn-commands-table");
+    if (commandOptions == null ? void 0 : commandOptions.title) {
+      commandsElement.setAttribute("title", commandOptions.title);
+    }
+    commandsElement.commands = commands;
+    if (commandOptions.columns) {
+      commandsElement.columns = commandOptions.columns;
+    }
+    root.appendChild(commandsElement);
+    return commandsElement;
+  };
+  renderer.getGenericCommandsFromNavRules = getGenericCommandsFromNavRules;
+  renderer.CommandsTable = CommandsTable;
   return renderer;
 };
 
@@ -1484,9 +1676,7 @@ var fuzzyMatch = (input, candidates, labels = {}) => {
   const exactName = candidates.find((c) => c.toLowerCase() === lower);
   if (exactName)
     return { match: exactName, ambiguous: [] };
-  const exactLabel = candidates.find(
-    (c) => labels[c] && labels[c].toLowerCase() === lower
-  );
+  const exactLabel = candidates.find((c) => labels[c] && labels[c].toLowerCase() === lower);
   if (exactLabel)
     return { match: exactLabel, ambiguous: [] };
   const namePrefix = candidates.filter((c) => c.toLowerCase().startsWith(lower));
@@ -1746,8 +1936,12 @@ var text_chat_default = (options) => {
     }
   });
   if (llm) {
-    addSystemMessage('Text navigation ready. Type "enter" to begin navigating, "help" for commands, or ask a question about the data.');
-    addSystemMessage('Note: AI-generated answers may be inaccurate. You can ask the model to "verify" any answer \u2014 it will attempt to provide a Python script that checks the claim against the dataset. If a claim cannot be verified with code, it should be verified externally.');
+    addSystemMessage(
+      'Text navigation ready. Type "enter" to begin navigating, "help" for commands, or ask a question about the data.'
+    );
+    addSystemMessage(
+      'Note: AI-generated answers may be inaccurate. You can ask the model to "verify" any answer \u2014 it will attempt to provide a Python script that checks the claim against the dataset. If a claim cannot be verified with code, it should be verified externally.'
+    );
   } else {
     addSystemMessage('Text navigation ready. Type "enter" to begin or "help" for available commands.');
   }
@@ -1816,9 +2010,7 @@ var text_chat_default = (options) => {
         const node = structure.nodes[currentNodeId];
         const available = getAvailableRules(currentNodeId, node, structure);
         const formatted = available.map((r) => formatRule(r, commandLabels));
-        addResponse(
-          `Available: ${formatted.join(", ")}, move to <search>.` + interactionSuffix + llmHint
-        );
+        addResponse(`Available: ${formatted.join(", ")}, move to <search>.` + interactionSuffix + llmHint);
       }
       return;
     }
@@ -1832,9 +2024,7 @@ var text_chat_default = (options) => {
         onClick(node);
         addResponse(`Clicked: ${describeNode2(node)}`);
       } else {
-        addResponse(
-          onClick ? "Nothing to click here." : "Click interaction is not enabled for this chart."
-        );
+        addResponse(onClick ? "Nothing to click here." : "Click interaction is not enabled for this chart.");
       }
       return;
     }
@@ -1887,7 +2077,9 @@ var text_chat_default = (options) => {
           return;
       }
       const llmHint = llm ? " Enter an API key above to ask questions about the data." : "";
-      addResponse('Type "enter" to begin navigating the structure, or "move to <search>" to jump to a node.' + llmHint);
+      addResponse(
+        'Type "enter" to begin navigating the structure, or "move to <search>" to jump to a node.' + llmHint
+      );
       return;
     }
     const allRules = getAllRuleNames(structure);
@@ -1951,8 +2143,201 @@ var text_chat_default = (options) => {
   };
 };
 
+// src/geometry.ts
+function grahamScan(points) {
+  if (points.length < 3)
+    return [...points];
+  let pivot = points[0];
+  for (const p of points) {
+    if (p.y < pivot.y || p.y === pivot.y && p.x < pivot.x)
+      pivot = p;
+  }
+  const sorted = [...points].sort((a, b) => {
+    const ax = a.x - pivot.x, ay = a.y - pivot.y;
+    const bx = b.x - pivot.x, by = b.y - pivot.y;
+    const cross2 = ax * by - ay * bx;
+    if (cross2 !== 0)
+      return -cross2;
+    return ax * ax + ay * ay - (bx * bx + by * by);
+  });
+  const hull = [];
+  for (const p of sorted) {
+    while (hull.length >= 2 && cross(hull[hull.length - 2], hull[hull.length - 1], p) <= 0) {
+      hull.pop();
+    }
+    hull.push(p);
+  }
+  return hull;
+}
+function cross(O, A, B) {
+  return (A.x - O.x) * (B.y - O.y) - (A.y - O.y) * (B.x - O.x);
+}
+function convexHullPath(points) {
+  if (points.length === 0)
+    return "";
+  if (points.length === 1) {
+    const p = points[0];
+    return `M${p.x},${p.y}Z`;
+  }
+  const hull = grahamScan(points);
+  if (hull.length === 0)
+    return "";
+  const [first, ...rest] = hull;
+  return `M${fmt(first.x)},${fmt(first.y)}` + rest.map((p) => `L${fmt(p.x)},${fmt(p.y)}`).join("") + "Z";
+}
+function expandHull(hullPoints, padPx) {
+  if (padPx === 0 || hullPoints.length === 0)
+    return hullPoints;
+  const cx = hullPoints.reduce((s, p) => s + p.x, 0) / hullPoints.length;
+  const cy = hullPoints.reduce((s, p) => s + p.y, 0) / hullPoints.length;
+  return hullPoints.map((p) => {
+    const dx = p.x - cx;
+    const dy = p.y - cy;
+    const dist = Math.hypot(dx, dy);
+    if (dist === 0)
+      return p;
+    return { x: p.x + dx / dist * padPx, y: p.y + dy / dist * padPx };
+  });
+}
+function rectCorners(r) {
+  return [
+    { x: r.x, y: r.y },
+    { x: r.x + r.width, y: r.y },
+    { x: r.x + r.width, y: r.y + r.height },
+    { x: r.x, y: r.y + r.height }
+  ];
+}
+function padRect(r, pad) {
+  return { x: r.x - pad, y: r.y - pad, width: r.width + pad * 2, height: r.height + pad * 2 };
+}
+function convexHullOfRects(rects, padPx = 0) {
+  if (rects.length === 0)
+    return "";
+  const corners = rects.flatMap(rectCorners);
+  const hull = grahamScan(corners);
+  const expanded = padPx > 0 ? expandHull(hull, padPx) : hull;
+  return hullToPath(expanded);
+}
+function unionOfRectPaths(rects, padPx = 0) {
+  if (rects.length === 0)
+    return "";
+  return rects.map((r) => {
+    const pr = padPx > 0 ? padRect(r, padPx) : r;
+    const { x, y, width: w, height: h } = pr;
+    return `M${fmt(x)},${fmt(y)}L${fmt(x + w)},${fmt(y)}L${fmt(x + w)},${fmt(y + h)}L${fmt(x)},${fmt(y + h)}Z`;
+  }).join("");
+}
+function boundingRectPath(rects, padPx = 0) {
+  if (rects.length === 0)
+    return "";
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const r of rects) {
+    minX = Math.min(minX, r.x);
+    minY = Math.min(minY, r.y);
+    maxX = Math.max(maxX, r.x + r.width);
+    maxY = Math.max(maxY, r.y + r.height);
+  }
+  minX -= padPx;
+  minY -= padPx;
+  maxX += padPx;
+  maxY += padPx;
+  return `M${fmt(minX)},${fmt(minY)}L${fmt(maxX)},${fmt(minY)}L${fmt(maxX)},${fmt(maxY)}L${fmt(minX)},${fmt(maxY)}Z`;
+}
+function convexHullOfCircles(circles, padPx = 0) {
+  if (circles.length === 0)
+    return "";
+  const SAMPLES = 16;
+  const points = [];
+  for (const { x, y, r } of circles) {
+    const effectiveR = r + padPx;
+    for (let i = 0; i < SAMPLES; i++) {
+      const angle = 2 * Math.PI * i / SAMPLES;
+      points.push({
+        x: x + effectiveR * Math.cos(angle),
+        y: y + effectiveR * Math.sin(angle)
+      });
+    }
+  }
+  return convexHullPath(points);
+}
+function offsetLinePath(points, offsetPx) {
+  if (points.length < 2) {
+    if (points.length === 1) {
+      const p = points[0];
+      return convexHullOfCircles([{ x: p.x, y: p.y, r: offsetPx }]);
+    }
+    return "";
+  }
+  const normals = [];
+  for (let i = 0; i < points.length - 1; i++) {
+    const dx = points[i + 1].x - points[i].x;
+    const dy = points[i + 1].y - points[i].y;
+    const len = Math.hypot(dx, dy);
+    normals.push(len === 0 ? { x: 0, y: -1 } : { x: -dy / len, y: dx / len });
+  }
+  const vertexNormals = [];
+  for (let i = 0; i < points.length; i++) {
+    if (i === 0) {
+      vertexNormals.push(normals[0]);
+    } else if (i === points.length - 1) {
+      vertexNormals.push(normals[normals.length - 1]);
+    } else {
+      const n1 = normals[i - 1];
+      const n2 = normals[i];
+      const avg = { x: (n1.x + n2.x) / 2, y: (n1.y + n2.y) / 2 };
+      const len = Math.hypot(avg.x, avg.y);
+      vertexNormals.push(len === 0 ? n1 : { x: avg.x / len, y: avg.y / len });
+    }
+  }
+  const left = points.map((p, i) => ({
+    x: p.x + vertexNormals[i].x * offsetPx,
+    y: p.y + vertexNormals[i].y * offsetPx
+  }));
+  const right = points.map((p, i) => ({
+    x: p.x - vertexNormals[i].x * offsetPx,
+    y: p.y - vertexNormals[i].y * offsetPx
+  })).reverse();
+  const firstLeft = left[0];
+  let d = `M${fmt(firstLeft.x)},${fmt(firstLeft.y)}`;
+  for (let i = 1; i < left.length; i++) {
+    d += `L${fmt(left[i].x)},${fmt(left[i].y)}`;
+  }
+  const lastLeft = left[left.length - 1];
+  const firstRight = right[0];
+  d += arcCap(lastLeft, firstRight, offsetPx);
+  for (let i = 1; i < right.length; i++) {
+    d += `L${fmt(right[i].x)},${fmt(right[i].y)}`;
+  }
+  const lastRight = right[right.length - 1];
+  d += arcCap(lastRight, firstLeft, offsetPx);
+  d += "Z";
+  return d;
+}
+function arcCap(from, to, r) {
+  return `A${fmt(r)},${fmt(r)},0,0,0,${fmt(to.x)},${fmt(to.y)}`;
+}
+function fmt(n) {
+  return Math.round(n * 100) / 100 + "";
+}
+function hullToPath(hull) {
+  if (hull.length === 0)
+    return "";
+  const [first, ...rest] = hull;
+  return `M${fmt(first.x)},${fmt(first.y)}` + rest.map((p) => `L${fmt(p.x)},${fmt(p.y)}`).join("") + "Z";
+}
+
 // src/index.ts
 var src_default = { structure: structure_default, input: input_default, rendering: rendering_default, textChat: text_chat_default };
 export {
-  src_default as default
+  boundingRectPath,
+  convexHullOfCircles,
+  convexHullOfRects,
+  convexHullPath,
+  createValidId,
+  src_default as default,
+  describeNode,
+  expandHull,
+  grahamScan,
+  offsetLinePath,
+  unionOfRectPaths
 };