@graphty/graphty-element 2.6.1 → 3.0.0

package/dist/chunks/{AiManager-4iQpsJW1.js → AiManager-Bhh0rR_p.js}

@@ -1,17 +1,17 @@
-import { l as Y } from "./VoiceInputAdapter-Cc6mHXTI.js";
-import { G as J } from "./GraphtyLogger-B_O67a6c.js";
-import { z as c } from "zod";
-import { k as Q, A as x, B as P } from "./optionsFromZod-CKMYSwTz.js";
-import { N as ee, e as te, C as se, d as re } from "./algorithms-BJ6DQMOe.js";
-import ae from "jmespath";
+import { l as ee } from "./VoiceInputAdapter-CdLsJ_nG.js";
+import { G as te } from "./GraphtyLogger-BtcBJQPL.js";
+import { z as d } from "zod";
+import { t as se, A as M, U as E } from "./fields-5uVC1Pll.js";
+import { k as re, N as ae, f as oe, C as ne, e as ie } from "./algorithms-qij74zEN.js";
+import le from "jmespath";
+import { i as _ } from "./pluginRegistry-Ddfl6Mv2.js";
 import { inferSchema as A } from "@jsonhero/schema-infer";
-import { i as oe } from "./pluginRegistry-Bs8bEkz9.js";
-import { createAnthropic as ne } from "@ai-sdk/anthropic";
-import { createGoogleGenerativeAI as ie } from "@ai-sdk/google";
-import { createOpenAI as le } from "@ai-sdk/openai";
-import { generateText as ce, streamText as ue } from "ai";
-import { A as de } from "./ApiKeyManager-C0ac91dE.js";
-class F {
+import { createAnthropic as ce } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI as ue } from "@ai-sdk/google";
+import { createOpenAI as de } from "@ai-sdk/openai";
+import { generateText as me, streamText as pe } from "ai";
+import { A as he } from "./ApiKeyManager-C0ac91dE.js";
+class K {
   /**
    * Creates a new AiStatusManager instance.
    */
@@ -112,13 +112,13 @@ class F {
    * @param result - Optional result data
    */
   updateToolCallStatus(e, t, s) {
-    const { toolCalls: r } = this.status;
-    if (!r)
+    const { toolCalls: a } = this.status;
+    if (!a)
       return;
-    const o = r.findIndex((l) => l.name === e);
+    const o = a.findIndex((l) => l.name === e);
     if (o === -1)
       return;
-    const n = [...r];
+    const n = [...a];
     n[o] = {
       ...n[o],
       status: t,
@@ -186,14 +186,19 @@ class F {
     };
   }
 }
-const f = J.getLogger(["graphty", "ai"]);
-class me {
+const f = te.getLogger(["graphty", "ai"]);
+class T extends Error {
+  constructor(e) {
+    super(e.message), this.result = e;
+  }
+}
+class ge {
   /**
    * Creates a new AiController instance.
    * @param options - Configuration options for the controller
    */
   constructor(e) {
-    this.abortController = null, this.disposed = !1, this.currentInput = null, this.startTime = null, this.lastInput = null, this.lastError = null, this.provider = e.provider, this.commandRegistry = e.commandRegistry, this.graph = e.graph, this.statusManager = new F(), this.schemaManager = e.schemaManager ?? null, this.emitEvent = e.emitEvent, this.statusManager.subscribe((t) => {
+    this.abortController = null, this.disposed = !1, this.currentInput = null, this.startTime = null, this.lastInput = null, this.lastError = null, this.provider = e.provider, this.commandRegistry = e.commandRegistry, this.graph = e.graph, this.statusManager = new K(), this.schemaManager = e.schemaManager ?? null, this.emitEvent = e.emitEvent, this.statusManager.subscribe((t) => {
       this.emitAiEvent({
         type: "ai-status-change",
         status: t
@@ -224,41 +229,26 @@ class me {
       timestamp: this.startTime
     }), this.statusManager.submit();
     try {
-      const t = this.buildMessages(e), s = this.commandRegistry.toToolDefinitions();
-      f.debug("Request", { messages: t, tools: s.map((n) => n.name) }), this.statusManager.startStreaming();
-      const r = await this.provider.generate(t, s, { signal: this.abortController.signal });
-      if (f.debug("Response", {
-        text: r.text || "(no text)",
-        toolCalls: r.toolCalls.map((n) => ({ name: n.name, arguments: n.arguments }))
-      }), r.text && (this.statusManager.appendStreamedText(r.text), this.emitAiEvent({
-        type: "ai-stream-chunk",
-        text: r.text,
-        accumulated: r.text
-      })), r.toolCalls.length === 0) {
-        this.statusManager.complete();
-        const n = {
-          success: !0,
-          message: r.text || "No response from AI",
-          llmText: r.text
-        };
-        return this.emitAiEvent({
-          type: "ai-command-complete",
-          result: n,
-          duration: Date.now() - this.startTime
-        }), n;
+      let t;
+      try {
+        t = await this.graph.getSession().transaction(e, (s, a) => this.converse(e, s, a), {
+          provenance: { via: "assistant" }
+        });
+      } catch (s) {
+        if (!(s instanceof T))
+          throw s;
+        ({ result: t } = s);
       }
-      this.statusManager.startExecuting();
-      const o = await this.executeToolCalls(r.toolCalls, r.text);
       return this.statusManager.complete(), this.emitAiEvent({
         type: "ai-command-complete",
-        result: o,
+        result: t,
         duration: Date.now() - this.startTime
-      }), o;
+      }), t;
     } catch (t) {
-      const s = t instanceof Error ? t.message : String(t), r = t instanceof Error ? t : new Error(s);
-      return this.lastError = r, this.statusManager.setError(r, !0), this.emitAiEvent({
+      const s = t instanceof Error ? t.message : String(t), a = t instanceof Error ? t : new Error(s);
+      return this.lastError = a, this.statusManager.setError(a, !0), this.emitAiEvent({
         type: "ai-command-error",
-        error: r,
+        error: a,
         input: e,
         canRetry: !0
       }), {
@@ -320,87 +310,128 @@ When the user asks you to perform an action, use the appropriate tool. If no too
 ${this.schemaManager.getFormattedSchema()}
 `;
   }
+  /**
+   * One message, inside its transaction: ask the model, then run the tools it calls.
+   * @param input - The user's natural language input
+   * @param tx - The message's transaction, which the tools write through
+   * @param signal - Fires when the message is cancelled or its transaction aborted
+   * @returns The execution result
+   */
+  async converse(e, t, s) {
+    const { abortController: a } = this;
+    s.addEventListener(
+      "abort",
+      () => {
+        a?.abort(s.reason);
+      },
+      { once: !0 }
+    );
+    const o = a?.signal ?? s, n = this.buildMessages(e), l = this.commandRegistry.toToolDefinitions();
+    f.debug("Request", { messages: n, tools: l.map((c) => c.name) }), this.statusManager.startStreaming();
+    const i = await this.provider.generate(n, l, { signal: o });
+    return f.debug("Response", {
+      text: i.text || "(no text)",
+      toolCalls: i.toolCalls.map((c) => ({ name: c.name, arguments: c.arguments }))
+    }), i.text && (this.statusManager.appendStreamedText(i.text), this.emitAiEvent({
+      type: "ai-stream-chunk",
+      text: i.text,
+      accumulated: i.text
+    })), i.toolCalls.length === 0 ? {
+      success: !0,
+      message: i.text || "No response from AI",
+      llmText: i.text
+    } : (this.statusManager.startExecuting(), this.executeToolCalls(i.toolCalls, t, o, i.text));
+  }
   /**
    * Execute a list of tool calls.
    * @param toolCalls - Tool calls to execute
+   * @param tx - The message's transaction
+   * @param signal - Fires when the message is cancelled
    * @param llmText - Text response from LLM (if any)
    * @returns Combined execution result
+   * @throws MessageRolledBack when a tool threw, so the message's transaction rolls back.
    */
-  async executeToolCalls(e, t) {
-    const s = [];
-    for (const r of e) {
-      this.statusManager.addToolCall(r.name), this.statusManager.updateToolCallStatus(r.name, "executing"), this.emitAiEvent({
+  async executeToolCalls(e, t, s, a) {
+    const o = [];
+    let n = !1;
+    for (const i of e) {
+      s.throwIfAborted(), this.statusManager.addToolCall(i.name), this.statusManager.updateToolCallStatus(i.name, "executing"), this.emitAiEvent({
         type: "ai-stream-tool-call",
-        name: r.name,
-        params: r.arguments
+        name: i.name,
+        params: i.arguments
       });
       try {
-        const o = await this.executeToolCall(r);
-        if (s.push(o), this.statusManager.updateToolCallStatus(
-          r.name,
-          o.success ? "complete" : "error",
-          o.data ?? { message: o.message }
+        const c = await this.executeToolCall(i, t);
+        if (o.push(c), this.statusManager.updateToolCallStatus(
+          i.name,
+          c.success ? "complete" : "error",
+          c.data ?? { message: c.message }
         ), this.emitAiEvent({
           type: "ai-stream-tool-result",
-          name: r.name,
-          result: o.data ?? { message: o.message },
-          success: o.success
-        }), !o.success)
+          name: i.name,
+          result: c.data ?? { message: c.message },
+          success: c.success
+        }), !c.success)
           break;
-      } catch (o) {
-        const n = o instanceof Error ? o.message : String(o), l = {
+      } catch (c) {
+        const u = c instanceof Error ? c.message : String(c), p = {
           success: !1,
-          message: `Error executing ${r.name}: ${n}`
+          message: `Error executing ${i.name}: ${u}`
         };
-        s.push(l), this.statusManager.updateToolCallStatus(r.name, "error", { error: n }), this.emitAiEvent({
+        o.push(p), this.statusManager.updateToolCallStatus(i.name, "error", { error: u }), this.emitAiEvent({
           type: "ai-stream-tool-result",
-          name: r.name,
-          result: { error: n },
+          name: i.name,
+          result: { error: u },
           success: !1
-        });
+        }), n = !0;
         break;
       }
     }
-    return this.combineResults(s, t);
+    const l = this.combineResults(o, a);
+    if (n)
+      throw new T(l);
+    return l;
   }
   /**
    * Execute a single tool call.
    * @param toolCall - The tool call to execute
+   * @param tx - The message's transaction, handed to the command as `ctx.tx`
    * @returns Command result
    */
-  async executeToolCall(e) {
+  async executeToolCall(e, t) {
     f.debug("Executing command", { name: e.name, arguments: e.arguments });
-    const t = this.commandRegistry.get(e.name);
-    if (!t)
+    const s = this.commandRegistry.get(e.name);
+    if (!s)
       return f.debug("Command result: FAILED - Unknown command", { name: e.name }), {
         success: !1,
         message: `Unknown command: ${e.name}. Command not found in registry.`
       };
-    let s;
+    let a;
     try {
-      s = t.parameters.parse(e.arguments), f.debug("Validated arguments", { arguments: s });
-    } catch (n) {
-      const l = n instanceof Error ? n.message : String(n);
-      return f.debug("Command result: FAILED - Invalid arguments", { error: l }), {
+      a = s.parameters.parse(e.arguments), f.debug("Validated arguments", { arguments: a });
+    } catch (l) {
+      const i = l instanceof Error ? l.message : String(l);
+      return f.debug("Command result: FAILED - Invalid arguments", { error: i }), {
         success: !1,
-        message: `Invalid arguments for ${e.name}: ${l}`
+        message: `Invalid arguments for ${e.name}: ${i}`
       };
     }
-    const r = {
+    const o = {
       graph: this.graph,
+      tx: t,
       abortSignal: this.abortController?.signal ?? new AbortController().signal,
-      emitEvent: (n, l) => {
-        f.debug("Command emitted event", { type: n, data: l });
+      emitEvent: (l, i) => {
+        f.debug("Command emitted event", { type: l, data: i });
       },
-      updateStatus: (n) => {
-        n.stageMessage && this.statusManager.setStage("executing", n.stageMessage);
+      updateStatus: (l) => {
+        l.stageMessage && this.statusManager.setStage("executing", l.stageMessage);
       }
-    }, o = await t.execute(this.graph, s, r);
+    }, n = await s.execute(this.graph, a, o);
     return f.debug("Command result", {
-      success: o.success,
-      message: o.message,
-      data: o.data
-    }), o;
+      success: n.success,
+      message: n.message,
+      data: n.data
+    }), n;
   }
   /**
    * Combine multiple command results into a single result.
@@ -415,12 +446,12 @@ ${this.schemaManager.getFormattedSchema()}
         message: t ?? "No commands executed",
         llmText: t
       };
-    const s = e.every((i) => i.success), r = e.map((i) => i.message);
-    t && r.unshift(t);
+    const s = e.every((i) => i.success), a = e.map((i) => i.message);
+    t && a.unshift(t);
     const o = [...new Set(e.flatMap((i) => i.affectedNodes ?? []))], n = [...new Set(e.flatMap((i) => i.affectedEdges ?? []))], l = e.filter((i) => i.success).pop() ?? e[e.length - 1];
     return {
       success: s,
-      message: r.join(`
+      message: a.join(`
 `),
       data: l.data,
       affectedNodes: o.length > 0 ? o : void 0,
@@ -460,7 +491,7 @@ ${this.schemaManager.getFormattedSchema()}
     this.disposed = !0, this.cancel(), this.statusManager.reset();
   }
 }
-class pe {
+class fe {
   constructor() {
     this.commands = /* @__PURE__ */ new Map();
   }
@@ -529,7 +560,7 @@ class pe {
     }));
   }
 }
-const he = {
+const ye = {
   maxSampleSize: 1e3,
   maxDepth: 3,
   enumMaxAbsoluteUnique: 10,
@@ -537,7 +568,7 @@ const he = {
   enumMaxStringLength: 64,
   enumMinSampleSize: 25
 };
-class ge {
+class ve {
   constructor(e) {
     this.values = /* @__PURE__ */ new Map(), this.options = e;
   }
@@ -559,10 +590,10 @@ class ge {
    */
   trackObject(e, t = "", s = 0) {
     if (!(s >= this.options.maxDepth))
-      for (const [r, o] of Object.entries(e)) {
-        if (t === "" && r === "id")
+      for (const [a, o] of Object.entries(e)) {
+        if (t === "" && a === "id")
           continue;
-        const n = t ? `${t}.${r}` : r;
+        const n = t ? `${t}.${a}` : a;
         typeof o == "string" ? this.trackValue(n, o) : o !== null && typeof o == "object" && !Array.isArray(o) && this.trackObject(o, n, s + 1);
       }
   }
@@ -581,27 +612,27 @@ class ge {
     const t = this.values.get(e);
     if (!t || t.length < this.options.enumMinSampleSize)
       return { isEnum: !1 };
-    const s = [...new Set(t)], r = s.length / t.length, o = s.length <= this.options.enumMaxAbsoluteUnique || r <= this.options.enumMaxUniqueRatio, n = s.every((l) => l.length <= this.options.enumMaxStringLength);
+    const s = [...new Set(t)], a = s.length / t.length, o = s.length <= this.options.enumMaxAbsoluteUnique || a <= this.options.enumMaxUniqueRatio, n = s.every((l) => l.length <= this.options.enumMaxStringLength);
     return o && n ? { isEnum: !0, values: s.sort() } : { isEnum: !1 };
   }
 }
-class O {
+class W {
   /**
    * Creates a new SchemaExtractor instance.
    * @param graph - The graph to extract schema from
    * @param options - Optional extraction options
    */
   constructor(e, t = {}) {
-    this.graph = e, this.options = { ...he, ...t };
+    this.graph = e, this.options = { ...ye, ...t };
   }
   /**
    * Extract schema from the graph.
    * @returns SchemaSummary with node and edge property information
    */
   extract() {
-    const e = this.graph.getDataManager(), t = this.graph.getNodeCount(), s = this.graph.getEdgeCount(), r = Array.from(e.nodes.values()).map((n) => n.data).filter((n) => n !== void 0), o = Array.from(e.edges.values()).map((n) => n.data).filter((n) => n !== void 0);
+    const e = this.graph.getDataManager(), t = this.graph.getNodeCount(), s = this.graph.getEdgeCount(), a = Array.from(e.nodes.values()).map((n) => n.data).filter((n) => n !== void 0), o = Array.from(e.edges.values()).map((n) => n.data).filter((n) => n !== void 0);
     return {
-      nodeProperties: this.extractFromCollection(r),
+      nodeProperties: this.extractFromCollection(a),
       edgeProperties: this.extractFromCollection(o),
       nodeCount: t,
       edgeCount: s
@@ -615,14 +646,14 @@ class O {
   extractFromCollection(e) {
     if (e.length === 0)
       return [];
-    const t = e.length <= this.options.maxSampleSize ? e : this.sampleEvenly(e, this.options.maxSampleSize), [s, ...r] = t;
+    const t = e.length <= this.options.maxSampleSize ? e : this.sampleEvenly(e, this.options.maxSampleSize), [s, ...a] = t;
     let o = A(s);
-    for (const i of r)
+    for (const i of a)
       o = A(
         i,
         o
       );
-    const n = o.toSnapshot(), l = new ge(this.options);
+    const n = o.toSnapshot(), l = new ve(this.options);
     for (const i of t)
       l.trackObject(i, "", 0);
     return this.mergeResults(n, l);
@@ -636,12 +667,12 @@ class O {
   mergeResults(e, t) {
     const s = [];
     if (e.type === "object" && e.properties) {
-      for (const [r, o] of Object.entries(e.properties.required))
-        this.extractProperties(r, o, t, "", !1, s);
-      for (const [r, o] of Object.entries(e.properties.optional))
-        this.extractProperties(r, o, t, "", !0, s);
+      for (const [a, o] of Object.entries(e.properties.required))
+        this.extractProperties(a, o, t, "", !1, s);
+      for (const [a, o] of Object.entries(e.properties.optional))
+        this.extractProperties(a, o, t, "", !0, s);
     }
-    return s.sort((r, o) => r.name.localeCompare(o.name));
+    return s.sort((a, o) => a.name.localeCompare(o.name));
   }
   /**
    * Recursively extract properties, handling nested objects with dot notation.
@@ -653,19 +684,19 @@ class O {
    * @param properties - Array to accumulate property summaries
    * @param depth - Current recursion depth
    */
-  extractProperties(e, t, s, r, o, n, l = 0) {
-    const i = r ? `${r}.${e}` : e;
-    if (r === "" && e === "id" || l >= this.options.maxDepth)
+  extractProperties(e, t, s, a, o, n, l = 0) {
+    const i = a ? `${a}.${e}` : e;
+    if (a === "" && e === "id" || l >= this.options.maxDepth)
       return;
-    let u = o, d = t;
-    if (t.type === "nullable" && t.schema && (u = !0, d = t.schema), d.type === "object" && d.properties) {
-      for (const [m, h] of Object.entries(d.properties.required))
+    let c = o, u = t;
+    if (t.type === "nullable" && t.schema && (c = !0, u = t.schema), u.type === "object" && u.properties) {
+      for (const [m, h] of Object.entries(u.properties.required))
         this.extractProperties(m, h, s, i, !1, n, l + 1);
-      for (const [m, h] of Object.entries(d.properties.optional))
+      for (const [m, h] of Object.entries(u.properties.optional))
         this.extractProperties(m, h, s, i, !0, n, l + 1);
       return;
     }
-    const p = this.schemaToSummary(i, d, s, u);
+    const p = this.schemaToSummary(i, u, s, c);
     p && n.push(p);
   }
   /**
@@ -676,11 +707,11 @@ class O {
    * @param nullable - Whether the property can be null
    * @returns Property summary or null if not convertible
    */
-  schemaToSummary(e, t, s, r) {
+  schemaToSummary(e, t, s, a) {
     const o = {
       name: e,
       type: this.inferredTypeToPropertyType(t),
-      nullable: r
+      nullable: a
     };
     switch (t.type) {
       case "string": {
@@ -735,19 +766,19 @@ class O {
    * @returns Array of evenly distributed samples
    */
   sampleEvenly(e, t) {
-    const s = [], r = e.length / t;
+    const s = [], a = e.length / t;
     for (let o = 0; o < t; o++) {
-      const n = Math.floor(o * r);
+      const n = Math.floor(o * a);
       s.push(e[n]);
     }
     return s;
   }
 }
-const fe = c.enum(["nodeCount", "edgeCount", "currentLayout", "all", "summary"]).describe("Type of information to query about the graph"), ye = {
+const be = d.enum(["nodeCount", "edgeCount", "currentLayout", "all", "summary"]).describe("Type of information to query about the graph"), we = {
   name: "queryGraph",
   description: "Query information about the graph structure, including node count, edge count, current layout, and overall statistics.",
-  parameters: c.object({
-    query: fe
+  parameters: d.object({
+    query: be
   }),
   examples: [
     { input: "How many nodes are there?", params: { query: "nodeCount" } },
@@ -756,12 +787,12 @@ const fe = c.enum(["nodeCount", "edgeCount", "currentLayout", "all", "summary"])
     { input: "Show me the graph summary", params: { query: "summary" } },
     { input: "Give me all the graph stats", params: { query: "all" } }
   ],
-  execute(a, e) {
+  execute(r, e) {
     const { query: t } = e;
     try {
       switch (t) {
         case "nodeCount": {
-          const s = a.getNodeCount();
+          const s = r.getNodeCount();
           return Promise.resolve({
             success: !0,
             message: `The graph has ${s} node${s !== 1 ? "s" : ""}.`,
@@ -769,7 +800,7 @@ const fe = c.enum(["nodeCount", "edgeCount", "currentLayout", "all", "summary"])
           });
         }
         case "edgeCount": {
-          const s = a.getEdgeCount();
+          const s = r.getEdgeCount();
           return Promise.resolve({
             success: !0,
             message: `The graph has ${s} edge${s !== 1 ? "s" : ""}.`,
@@ -777,37 +808,37 @@ const fe = c.enum(["nodeCount", "edgeCount", "currentLayout", "all", "summary"])
           });
         }
         case "currentLayout": {
-          const r = a.getLayoutManager().layoutEngine?.type ?? "unknown";
+          const a = r.getLayoutManager().layoutEngine?.type ?? "unknown";
           return Promise.resolve({
             success: !0,
-            message: `The current layout is "${r}".`,
-            data: { layout: r }
+            message: `The current layout is "${a}".`,
+            data: { layout: a }
           });
         }
         case "all":
         case "summary": {
-          const s = a.getNodeCount(), r = a.getEdgeCount(), n = a.getLayoutManager().layoutEngine?.type ?? "unknown", l = a.getViewMode() === "2d";
+          const s = r.getNodeCount(), a = r.getEdgeCount(), n = r.getLayoutManager().layoutEngine?.type ?? "unknown", l = r.getViewMode() === "2d";
           return Promise.resolve({
             success: !0,
             message: `Graph Summary:
 - Nodes: ${s}
-- Edges: ${r}
+- Edges: ${a}
 - Layout: ${n}
 - Mode: ${l ? "2D" : "3D"}`,
             data: {
               nodeCount: s,
-              edgeCount: r,
+              edgeCount: a,
               layout: n,
               is2D: l
             }
           });
         }
         default: {
-          const s = a.getNodeCount(), r = a.getEdgeCount();
+          const s = r.getNodeCount(), a = r.getEdgeCount();
           return Promise.resolve({
             success: !0,
-            message: `Unknown query type "${String(t)}". The graph has ${s} nodes and ${r} edges.`,
-            data: { nodeCount: s, edgeCount: r }
+            message: `Unknown query type "${String(t)}". The graph has ${s} nodes and ${a} edges.`,
+            data: { nodeCount: s, edgeCount: a }
           });
         }
       }
@@ -818,44 +849,44 @@ const fe = c.enum(["nodeCount", "edgeCount", "currentLayout", "all", "summary"])
       });
     }
   }
-}, ve = 50, be = {
+}, Se = 50, Ce = {
   name: "findNodes",
   description: "Find nodes in the graph that match specific criteria. Returns the total number of matches and at most `limit` matching node IDs (50 when no limit is given), with `truncated` true when the list was cut. Note: selectors search within node data directly, so use 'type' not 'data.type'.",
-  parameters: c.object({
-    selector: c.string().describe(
+  parameters: d.object({
+    selector: d.string().describe(
       `Simple selector to match nodes (e.g., 'type == "server"'). Search is performed on node data directly, so use property names like 'type' not 'data.type'.`
     ),
-    limit: c.number().optional().describe("Maximum number of node IDs to return (default 50)")
+    limit: d.number().optional().describe("Maximum number of node IDs to return (default 50)")
   }),
   examples: [
     { input: "Find all server nodes", params: { selector: "type == 'server'" } },
     { input: "Find nodes with high degree", params: { selector: "degree > 5" } },
     { input: "Get first 10 nodes", params: { selector: "", limit: 10 } }
   ],
-  execute(a, e) {
+  execute(r, e) {
     const { selector: t, limit: s } = e;
     try {
-      const r = a.getDataManager(), o = Array.from(r.nodes.values());
+      const a = r.getDataManager(), o = Array.from(a.nodes.values());
       let n;
       !t || t === "" || t === "*" ? n = o : n = o.filter((p) => {
         try {
           const m = /^(\w+)\s*==\s*['"](.+)['"]$/.exec(t);
           if (m) {
-            const [, g, b] = m, v = p.data[g];
-            return typeof v == "boolean" ? v === (b === "true") : v === b;
+            const [, g, v] = m, w = p.data[g];
+            return typeof w == "boolean" ? w === (v === "true") : w === v;
           }
           const h = /^(\w+)\s*(>|<|>=|<=)\s*(\d+)$/.exec(t);
           if (h) {
-            const [, g, b, v] = h, w = Number(p.data[g]), S = Number(v);
-            switch (b) {
+            const [, g, v, w] = h, S = Number(p.data[g]), C = Number(w);
+            switch (v) {
               case ">":
-                return w > S;
+                return S > C;
               case "<":
-                return w < S;
+                return S < C;
               case ">=":
-                return w >= S;
+                return S >= C;
               case "<=":
-                return w <= S;
+                return S <= C;
               default:
                 return !1;
             }
@@ -865,31 +896,31 @@ const fe = c.enum(["nodeCount", "edgeCount", "currentLayout", "all", "summary"])
           return !1;
         }
       });
-      const l = n.length, i = n.slice(0, s !== void 0 && s > 0 ? s : ve).map((p) => String(p.id)), u = i.length, d = l > u;
+      const l = n.length, i = n.slice(0, s !== void 0 && s > 0 ? s : Se).map((p) => String(p.id)), c = i.length, u = l > c;
       return Promise.resolve({
         success: !0,
-        message: `Found ${l} matching node${l !== 1 ? "s" : ""}${d ? ` (showing ${u})` : ""}.`,
+        message: `Found ${l} matching node${l !== 1 ? "s" : ""}${u ? ` (showing ${c})` : ""}.`,
         data: {
           total: l,
-          returned: u,
-          count: u,
-          truncated: d,
+          returned: c,
+          count: c,
+          truncated: u,
           nodeIds: i
         },
         affectedNodes: i
       });
-    } catch (r) {
+    } catch (a) {
       return Promise.resolve({
         success: !1,
-        message: `Failed to find nodes: ${r.message}`
+        message: `Failed to find nodes: ${a.message}`
       });
     }
   }
-}, we = c.enum(["nodeTypes", "edgeTypes", "nodeProperties", "edgeProperties", "all"]).describe("Type of schema information to retrieve"), Se = {
+}, $e = d.enum(["nodeTypes", "edgeTypes", "nodeProperties", "edgeProperties", "all"]).describe("Type of schema information to retrieve"), xe = {
   name: "getSchema",
   description: "Get schema information about the graph data including node types, edge types, and available properties. Use this to discover what types of nodes exist or what properties are available for filtering.",
-  parameters: c.object({
-    query: we
+  parameters: d.object({
+    query: $e
   }),
   examples: [
     { input: "What types of nodes are there?", params: { query: "nodeTypes" } },
@@ -898,21 +929,21 @@ const fe = c.enum(["nodeCount", "edgeCount", "currentLayout", "all", "summary"])
     { input: "What edge properties are available?", params: { query: "edgeProperties" } },
     { input: "Show me the data schema", params: { query: "all" } }
   ],
-  execute(a, e) {
+  execute(r, e) {
     const { query: t } = e;
     try {
-      const r = new O(a).extract(), o = a.getDataManager(), n = (l, i, u = 20) => {
-        const d = /* @__PURE__ */ new Set();
+      const a = new W(r).extract(), o = r.getDataManager(), n = (l, i, c = 20) => {
+        const u = /* @__PURE__ */ new Set();
         for (const p of l) {
           const m = p.data?.[i];
-          if (typeof m == "string" && (d.add(m), d.size > u))
+          if (typeof m == "string" && (u.add(m), u.size > c))
             return [];
         }
-        return Array.from(d).sort();
+        return Array.from(u).sort();
       };
       switch (t) {
         case "nodeTypes": {
-          let i = r.nodeProperties.find((u) => u.name === "type")?.enumValues ?? [];
+          let i = a.nodeProperties.find((c) => c.name === "type")?.enumValues ?? [];
           return i.length === 0 && (i = n(o.nodes.values(), "type")), i.length === 0 ? Promise.resolve({
             success: !0,
             message: "No distinct node types found. Nodes may not have a 'type' property, or there are too many unique values to categorize.",
@@ -924,7 +955,7 @@ const fe = c.enum(["nodeCount", "edgeCount", "currentLayout", "all", "summary"])
           });
         }
         case "edgeTypes": {
-          let i = r.edgeProperties.find((u) => u.name === "type")?.enumValues ?? [];
+          let i = a.edgeProperties.find((c) => c.name === "type")?.enumValues ?? [];
           return i.length === 0 && (i = n(o.edges.values(), "type")), i.length === 0 ? Promise.resolve({
             success: !0,
             message: "No distinct edge types found. Edges may not have a 'type' property, or there are too many unique values to categorize.",
@@ -936,22 +967,22 @@ const fe = c.enum(["nodeCount", "edgeCount", "currentLayout", "all", "summary"])
           });
         }
         case "nodeProperties": {
-          const l = r.nodeProperties.map((i) => {
-            let u = `${i.name}: ${i.type}`;
-            return i.enumValues && i.enumValues.length > 0 && (u += ` (values: ${i.enumValues.join(", ")})`), i.range && (u += ` (range: ${i.range.min}-${i.range.max})`), u;
+          const l = a.nodeProperties.map((i) => {
+            let c = `${i.name}: ${i.type}`;
+            return i.enumValues && i.enumValues.length > 0 && (c += ` (values: ${i.enumValues.join(", ")})`), i.range && (c += ` (range: ${i.range.min}-${i.range.max})`), c;
           });
           return Promise.resolve({
             success: !0,
             message: `Node properties:
 ${l.map((i) => `- ${i}`).join(`
 `)}`,
-            data: { nodeProperties: r.nodeProperties }
+            data: { nodeProperties: a.nodeProperties }
           });
         }
         case "edgeProperties": {
-          const l = r.edgeProperties.map((i) => {
-            let u = `${i.name}: ${i.type}`;
-            return i.enumValues && i.enumValues.length > 0 && (u += ` (values: ${i.enumValues.join(", ")})`), i.range && (u += ` (range: ${i.range.min}-${i.range.max})`), u;
+          const l = a.edgeProperties.map((i) => {
+            let c = `${i.name}: ${i.type}`;
+            return i.enumValues && i.enumValues.length > 0 && (c += ` (values: ${i.enumValues.join(", ")})`), i.range && (c += ` (range: ${i.range.min}-${i.range.max})`), c;
           });
           return l.length === 0 ? Promise.resolve({
             success: !0,
@@ -962,23 +993,23 @@ ${l.map((i) => `- ${i}`).join(`
             message: `Edge properties:
 ${l.map((i) => `- ${i}`).join(`
 `)}`,
-            data: { edgeProperties: r.edgeProperties }
+            data: { edgeProperties: a.edgeProperties }
           });
         }
         case "all": {
-          let i = r.nodeProperties.find((g) => g.name === "type")?.enumValues ?? [];
+          let i = a.nodeProperties.find((g) => g.name === "type")?.enumValues ?? [];
           i.length === 0 && (i = n(o.nodes.values(), "type"));
-          let d = r.edgeProperties.find((g) => g.name === "type")?.enumValues ?? [];
-          d.length === 0 && (d = n(o.edges.values(), "type"));
-          const p = r.nodeProperties.map((g) => g.name), m = r.edgeProperties.map((g) => g.name);
+          let u = a.edgeProperties.find((g) => g.name === "type")?.enumValues ?? [];
+          u.length === 0 && (u = n(o.edges.values(), "type"));
+          const p = a.nodeProperties.map((g) => g.name), m = a.edgeProperties.map((g) => g.name);
           let h = `Graph Schema Summary:
-- ${r.nodeCount} nodes with ${r.nodeProperties.length} properties
-- ${r.edgeCount} edges with ${r.edgeProperties.length} properties`;
+- ${a.nodeCount} nodes with ${a.nodeProperties.length} properties
+- ${a.edgeCount} edges with ${a.edgeProperties.length} properties`;
           return i.length > 0 && (h += `
 
-Node types: ${i.join(", ")}`), d.length > 0 && (h += `
+Node types: ${i.join(", ")}`), u.length > 0 && (h += `
 
-Edge types: ${d.join(", ")}`), p.length > 0 && (h += `
+Edge types: ${u.join(", ")}`), p.length > 0 && (h += `
 
 Node properties: ${p.join(", ")}`), m.length > 0 && (h += `
 
@@ -986,12 +1017,12 @@ Edge properties: ${m.join(", ")}`), Promise.resolve({
             success: !0,
             message: h,
             data: {
-              nodeCount: r.nodeCount,
-              edgeCount: r.edgeCount,
+              nodeCount: a.nodeCount,
+              edgeCount: a.edgeCount,
               nodeTypes: i,
-              edgeTypes: d,
-              nodeProperties: r.nodeProperties,
-              edgeProperties: r.edgeProperties
+              edgeTypes: u,
+              nodeProperties: a.nodeProperties,
+              edgeProperties: a.edgeProperties
             }
           });
         }
@@ -1008,12 +1039,16 @@ Edge properties: ${m.join(", ")}`), Promise.resolve({
       });
     }
   }
-}, Ce = c.string().describe("Layout algorithm type (e.g., 'circular', 'ngraph', 'random', 'spiral', 'd3')"), $e = c.enum(["2d", "3d"]).describe("Dimension mode: '2d' or '3d'"), xe = {
+};
+function y(r, e) {
+  return e?.tx ?? r.getSession();
+}
+const Me = d.string().describe("Layout algorithm type (e.g., 'circular', 'ngraph', 'random', 'spiral', 'd3')"), Pe = d.enum(["2d", "3d"]).describe("Dimension mode: '2d' or '3d'"), Ee = {
   name: "setLayout",
   description: "Change the graph layout algorithm. Common layouts include 'circular' (nodes in a circle), 'ngraph' (force-directed physics), 'random', 'spiral', 'shell', 'd3' (D3 force simulation), 'spring', 'planar', 'spectral', and 'forceatlas2'.",
-  parameters: c.object({
-    type: Ce,
-    options: c.record(c.unknown()).optional().describe("Additional layout-specific options")
+  parameters: d.object({
+    type: Me,
+    options: d.record(d.unknown()).optional().describe("Additional layout-specific options")
   }),
   examples: [
     { input: "Use circular layout", params: { type: "circular" } },
@@ -1023,30 +1058,30 @@ Edge properties: ${m.join(", ")}`), Promise.resolve({
     { input: "Use D3 force layout", params: { type: "d3" } },
     { input: "Shell layout", params: { type: "shell" } }
   ],
-  async execute(a, e) {
-    const { type: t, options: s = {} } = e;
+  async execute(r, e, t) {
+    const { type: s, options: a = {} } = e;
     try {
-      return await a.setLayout(t, s), {
+      return await y(r, t).layout.set(re(s) ?? s, { engine: s, options: a }), {
         success: !0,
-        message: `Layout changed to "${t}". The graph is now being rearranged.`,
-        data: { layoutType: t }
+        message: `Layout changed to "${s}". The graph is now being rearranged.`,
+        data: { layoutType: s }
       };
-    } catch (r) {
-      const o = r.message;
-      return o.includes("not found") || o.includes("unknown") || o.includes("invalid") ? {
+    } catch (o) {
+      const n = o.message;
+      return _(o) && o.code === "E_UNKNOWN_LAYOUT" || n.includes("not found") || n.includes("unknown") || n.includes("invalid") ? {
         success: !1,
-        message: `Invalid layout type "${t}". Try 'circular', 'ngraph', 'random', 'spiral', 'shell', or 'd3'.`
+        message: `Invalid layout type "${s}". Try 'circular', 'ngraph', 'random', 'spiral', 'shell', or 'd3'.`
       } : {
         success: !1,
-        message: `Failed to set layout to "${t}": ${o}`
+        message: `Failed to set layout to "${s}": ${n}`
       };
     }
   }
-}, Me = {
+}, Ae = {
   name: "setDimension",
   description: "Switch between 2D and 3D graph visualization modes. In 2D mode, nodes are arranged on a flat plane. In 3D mode, nodes can be positioned in three-dimensional space.",
-  parameters: c.object({
-    dimension: $e
+  parameters: d.object({
+    dimension: Pe
   }),
   examples: [
     { input: "Switch to 2D view", params: { dimension: "2d" } },
@@ -1054,27 +1089,27 @@ Edge properties: ${m.join(", ")}`), Promise.resolve({
     { input: "Make it flat", params: { dimension: "2d" } },
     { input: "Enable 3D mode", params: { dimension: "3d" } }
   ],
-  async execute(a, e) {
-    const { dimension: t } = e;
+  async execute(r, e, t) {
+    const { dimension: s } = e;
     try {
-      const s = t === "2d", r = s ? "2D" : "3D";
-      return await a.setViewMode(s ? "2d" : "3d"), {
+      const a = s === "2d", o = a ? "2D" : "3D";
+      return await y(r, t).layout.setDimension(a ? "2d" : "3d"), {
         success: !0,
-        message: `Switched to ${r} mode. The graph will now be displayed ${s ? "on a flat plane" : "in three-dimensional space"}.`,
-        data: { dimension: r, is2D: s }
+        message: `Switched to ${o} mode. The graph will now be displayed ${a ? "on a flat plane" : "in three-dimensional space"}.`,
+        data: { dimension: o, is2D: a }
       };
-    } catch (s) {
+    } catch (a) {
       return {
         success: !1,
-        message: `Failed to change dimension: ${s.message}`
+        message: `Failed to change dimension: ${a.message}`
       };
     }
   }
-}, Pe = c.enum(["vr", "ar", "exit"]).describe("VR for virtual reality, AR for augmented reality, exit to return to normal view"), Ae = {
+}, Te = d.enum(["vr", "ar", "exit"]).describe("VR for virtual reality, AR for augmented reality, exit to return to normal view"), Ne = {
   name: "setImmersiveMode",
   description: "Enter or exit VR/AR immersive modes using WebXR. Use 'vr' for virtual reality (headset), 'ar' for augmented reality (pass-through or mobile AR), or 'exit' to return to normal desktop view.",
-  parameters: c.object({
-    mode: Pe
+  parameters: d.object({
+    mode: Te
   }),
   examples: [
     { input: "Enter VR mode", params: { mode: "vr" } },
@@ -1085,25 +1120,25 @@ Edge properties: ${m.join(", ")}`), Promise.resolve({
     { input: "Show augmented reality view", params: { mode: "ar" } },
     { input: "Go back to normal view", params: { mode: "exit" } }
   ],
-  async execute(a, e) {
+  async execute(r, e) {
     const { mode: t } = e;
     try {
       if (t === "exit") {
-        const n = a.exitImmersiveMode;
-        return n && await n.call(a), {
+        const n = r.exitImmersiveMode;
+        return n && await n.call(r), {
           success: !0,
           message: "Exited immersive mode, returned to normal view."
         };
       }
-      const { getXRHelper: s } = a, r = s?.call(a);
-      if (!r)
+      const { getXRHelper: s } = r, a = s?.call(r);
+      if (!a)
         return {
           success: !1,
           message: `WebXR is not available. ${t.toUpperCase()} mode requires a WebXR-capable browser and device.`
         };
       if (t === "vr") {
-        const { enterVR: n } = r;
-        return n ? (await n.call(r), {
+        const { enterVR: n } = a;
+        return n ? (await n.call(a), {
           success: !0,
           message: "Entering VR mode. Put on your headset to view the graph in virtual reality."
         }) : {
@@ -1111,8 +1146,8 @@ Edge properties: ${m.join(", ")}`), Promise.resolve({
           message: "VR mode is not supported on this device or browser."
         };
       }
-      const { enterAR: o } = r;
-      return o ? (await o.call(r), {
+      const { enterAR: o } = a;
+      return o ? (await o.call(a), {
         success: !0,
         message: "Entering AR mode. Point your device to see the graph in augmented reality."
       }) : {
@@ -1126,60 +1161,60 @@ Edge properties: ${m.join(", ")}`), Promise.resolve({
       };
     }
   }
-}, Ee = c.object({
-  color: c.string().optional().describe("Color for the node (e.g., '#ff0000', 'red')"),
-  size: c.number().positive().optional().describe("Size of the node (default is 1)"),
-  shape: c.string().optional().describe("Shape type (e.g., 'sphere', 'box', 'cylinder')"),
-  glowColor: c.string().optional().describe("Glow effect color"),
-  glowStrength: c.number().positive().optional().describe("Glow effect strength. One strength is drawn at a time for the whole scene"),
-  outlineColor: c.string().optional().describe("Outline color"),
-  outlineWidth: c.number().positive().optional().describe(
+}, ke = d.object({
+  color: d.string().optional().describe("Color for the node (e.g., '#ff0000', 'red')"),
+  size: d.number().positive().optional().describe("Size of the node (default is 1)"),
+  shape: d.string().optional().describe("Shape type (e.g., 'sphere', 'box', 'cylinder')"),
+  glowColor: d.string().optional().describe("Glow effect color"),
+  glowStrength: d.number().positive().optional().describe("Glow effect strength. One strength is drawn at a time for the whole scene"),
+  outlineColor: d.string().optional().describe("Outline color"),
+  outlineWidth: d.number().positive().optional().describe(
     "Outline width. Not drawn: every outline in the scene is stroked at one width, so asking for this is answered with the reason rather than applied"
   ),
-  enabled: c.boolean().optional().describe("Whether the node is visible")
-}).describe("Style properties for nodes"), Te = c.object({
-  color: c.string().optional().describe("Color for the edge line (e.g., '#00ff00', 'green')"),
-  width: c.number().positive().optional().describe("Width of the edge line"),
-  lineType: c.string().optional().describe("Line pattern (e.g., 'solid', 'dash', 'dot')"),
-  arrowColor: c.string().optional().describe("Color for the arrow head"),
-  arrowSize: c.number().positive().optional().describe("Size of the arrow head"),
-  arrowOpacity: c.number().min(0).max(1).optional().describe("Opacity of the arrow head, 0 to 1"),
-  enabled: c.boolean().optional().describe("Whether the edge is visible")
-}).describe("Style properties for edges"), Ne = { by: "plugin", name: "graphty-ai" };
-function ke(a) {
+  enabled: d.boolean().optional().describe("Whether the node is visible")
+}).describe("Style properties for nodes"), Ie = d.object({
+  color: d.string().optional().describe("Color for the edge line (e.g., '#00ff00', 'green')"),
+  width: d.number().positive().optional().describe("Width of the edge line"),
+  lineType: d.string().optional().describe("Line pattern (e.g., 'solid', 'dash', 'dot')"),
+  arrowColor: d.string().optional().describe("Color for the arrow head"),
+  arrowSize: d.number().positive().optional().describe("Size of the arrow head"),
+  arrowOpacity: d.number().min(0).max(1).optional().describe("Opacity of the arrow head, 0 to 1"),
+  enabled: d.boolean().optional().describe("Whether the edge is visible")
+}).describe("Style properties for edges"), Re = { by: "plugin", name: "graphty-ai" };
+function De(r) {
   const e = {}, t = [];
-  return a.color !== void 0 && (e["node.color"] = a.color), a.size !== void 0 && (e["node.size"] = a.size), a.shape !== void 0 && (e["node.shape"] = a.shape), a.glowColor !== void 0 && (e["node.glow"] = a.glowColor), a.glowStrength !== void 0 && (e["node.glowStrength"] = a.glowStrength), a.outlineColor !== void 0 && (e["node.outline"] = a.outlineColor), a.enabled === !1 && (e["node.opacity"] = 0), a.outlineWidth !== void 0 && t.push({ property: "outlineWidth", reason: ee }), { set: e, unsupported: t };
+  return r.color !== void 0 && (e["node.color"] = r.color), r.size !== void 0 && (e["node.size"] = r.size), r.shape !== void 0 && (e["node.shape"] = r.shape), r.glowColor !== void 0 && (e["node.glow"] = r.glowColor), r.glowStrength !== void 0 && (e["node.glowStrength"] = r.glowStrength), r.outlineColor !== void 0 && (e["node.outline"] = r.outlineColor), r.enabled === !1 && (e["node.opacity"] = 0), r.outlineWidth !== void 0 && t.push({ property: "outlineWidth", reason: ae }), { set: e, unsupported: t };
 }
-function Ie(a) {
+function Le(r) {
   const e = {};
-  return a.color !== void 0 && (e["edge.color"] = a.color), a.width !== void 0 && (e["edge.width"] = a.width), a.lineType !== void 0 && (e["edge.style"] = a.lineType), a.enabled === !1 && (e["edge.opacity"] = 0), a.arrowColor !== void 0 && (e["edge.arrowHeadColor"] = a.arrowColor), a.arrowSize !== void 0 && (e["edge.arrowHeadSize"] = a.arrowSize), a.arrowOpacity !== void 0 && (e["edge.arrowHeadOpacity"] = a.arrowOpacity), { set: e, unsupported: [] };
+  return r.color !== void 0 && (e["edge.color"] = r.color), r.width !== void 0 && (e["edge.width"] = r.width), r.lineType !== void 0 && (e["edge.style"] = r.lineType), r.enabled === !1 && (e["edge.opacity"] = 0), r.arrowColor !== void 0 && (e["edge.arrowHeadColor"] = r.arrowColor), r.arrowSize !== void 0 && (e["edge.arrowHeadSize"] = r.arrowSize), r.arrowOpacity !== void 0 && (e["edge.arrowHeadOpacity"] = r.arrowOpacity), { set: e, unsupported: [] };
 }
-const Re = /* @__PURE__ */ new Set(["", "*", "all", "*.*", "true"]);
-function De(a) {
-  return !a || Re.has(a.toLowerCase().trim());
+const je = /* @__PURE__ */ new Set(["", "*", "all", "*.*", "true"]);
+function ze(r) {
+  return !r || je.has(r.toLowerCase().trim());
 }
-function _(a, e, t, s) {
+function G(r, e, t, s) {
   return {
-    name: a,
+    name: r,
     target: e,
     kind: "custom",
-    source: Ne,
-    selector: De(t) ? { match: "everything" } : { match: "expression", where: t.replace(/"/g, "'") },
+    source: Re,
+    selector: ze(t) ? { match: "everything" } : { match: "expression", where: t.replace(/"/g, "'") },
     set: s
   };
 }
-function K(a) {
-  return oe(a) ? `${a.message} (${a.code})` : a instanceof Error ? a.message : String(a);
+function H(r) {
+  return _(r) ? `${r.message} (${r.code})` : r instanceof Error ? r.message : String(r);
 }
-async function W(a, e, t, s) {
-  const { styles: r } = a.getSession(), o = r.validate(e);
+async function B(r, e, t, s) {
+  const { styles: a } = r, o = a.validate(e);
   if (!o.ok)
     return {
       success: !1,
       message: `That ${s} style could not be applied: ${o.errors.map((n) => n.message).join(" ")}`
     };
   try {
-    const n = await r.add(e), l = t.map(({ property: u, reason: d }) => ` ${u} was not applied: ${d}`).join(""), i = o.unresolvedPaths.length === 0 ? "" : ` Nothing in this graph answers ${o.unresolvedPaths.join(", ")} yet, so the layer may paint nothing until it does.`;
+    const n = await a.add(e), l = t.map(({ property: c, reason: u }) => ` ${c} was not applied: ${u}`).join(""), i = o.unresolvedPaths.length === 0 ? "" : ` Nothing in this graph answers ${o.unresolvedPaths.join(", ")} yet, so the layer may paint nothing until it does.`;
     return {
       success: !0,
       message: `Added the ${s} style layer "${n.name}".${l}${i}`,
@@ -1188,19 +1223,19 @@ async function W(a, e, t, s) {
   } catch (n) {
     return {
       success: !1,
-      message: `That ${s} style could not be applied: ${K(n)}`
+      message: `That ${s} style could not be applied: ${H(n)}`
     };
   }
 }
-const Le = {
+const Ue = {
   name: "findAndStyleNodes",
   description: `Style the nodes matching a selector by adding a style layer. Use an empty selector to match every node. A node's own fields are published under 'data.', so write 'data.type == "server"'. Styles include color, size, shape, glow color and outline color.`,
-  parameters: c.object({
-    selector: c.string().describe(
+  parameters: d.object({
+    selector: d.string().describe(
       `Expression matching nodes (empty string matches all). A record's own fields live under 'data.', so write 'data.type == "server"'.`
     ),
-    style: Ee,
-    layerName: c.string().optional().describe("Name for this style layer (for later removal)")
+    style: ke,
+    layerName: d.string().optional().describe("Name for this style layer (for later removal)")
   }),
   examples: [
     {
@@ -1224,23 +1259,23 @@ const Le = {
       params: { selector: "", style: { shape: "box" }, layerName: "box-shapes" }
     }
   ],
-  async execute(a, e) {
+  async execute(r, e, t) {
     const {
-      selector: t,
-      style: s,
-      layerName: r = `ai-node-style-${Date.now()}`
-    } = e, { set: o, unsupported: n } = ke(s);
-    return W(a, _(r, "node", t, o), n, "node");
+      selector: s,
+      style: a,
+      layerName: o = `ai-node-style-${Date.now()}`
+    } = e, { set: n, unsupported: l } = De(a);
+    return B(y(r, t), G(o, "node", s, n), l, "node");
   }
-}, je = {
+}, qe = {
   name: "findAndStyleEdges",
   description: "Style the edges matching a selector by adding a style layer. Use an empty selector to match every edge. An edge's own fields are published under 'data.', so write 'data.weight > `0.5`'. Styles include color, width and line pattern.",
-  parameters: c.object({
-    selector: c.string().describe(
+  parameters: d.object({
+    selector: d.string().describe(
       "Expression matching edges (empty string matches all). A record's own fields live under 'data.', so write 'data.weight > `0.5`'."
     ),
-    style: Te,
-    layerName: c.string().optional().describe("Name for this style layer (for later removal)")
+    style: Ie,
+    layerName: d.string().optional().describe("Name for this style layer (for later removal)")
   }),
   examples: [
     {
@@ -1260,73 +1295,73 @@ const Le = {
       params: { selector: "", style: { lineType: "dash" }, layerName: "dashed" }
     }
   ],
-  async execute(a, e) {
+  async execute(r, e, t) {
     const {
-      selector: t,
-      style: s,
-      layerName: r = `ai-edge-style-${Date.now()}`
-    } = e, { set: o, unsupported: n } = Ie(s);
-    return W(a, _(r, "edge", t, o), n, "edge");
+      selector: s,
+      style: a,
+      layerName: o = `ai-edge-style-${Date.now()}`
+    } = e, { set: n, unsupported: l } = Le(a);
+    return B(y(r, t), G(o, "edge", s, n), l, "edge");
   }
-}, ze = {
+}, Ve = {
   name: "clearStyles",
   description: "Clear styles added by AI commands. Specify a layerName to clear a specific style, or leave empty to clear all AI-added styles.",
-  parameters: c.object({
-    layerName: c.string().optional().describe("Name of the style layer to clear (clears all if not specified)")
+  parameters: d.object({
+    layerName: d.string().optional().describe("Name of the style layer to clear (clears all if not specified)")
   }),
   examples: [
     { input: "Clear all styling", params: {} },
     { input: "Remove red node styling", params: { layerName: "red-nodes" } }
   ],
-  async execute(a, e) {
-    const { layerName: t } = e, { styles: s } = a.getSession();
+  async execute(r, e, t) {
+    const { layerName: s } = e, { styles: a } = y(r, t);
     try {
-      if (t === void 0) {
-        const o = await s.removeBySource(
-          (n) => n.by === "plugin" && n.name === "graphty-ai"
+      if (s === void 0) {
+        const n = await a.removeBySource(
+          (l) => l.by === "plugin" && l.name === "graphty-ai"
         );
         return {
           success: !0,
-          message: `Cleared ${String(o.length)} AI-added style layer(s).`,
-          data: { clearedCount: o.length }
+          message: `Cleared ${String(n.length)} AI-added style layer(s).`,
+          data: { clearedCount: n.length }
         };
       }
-      const r = s.list().filter(
-        (o) => o.name === t && o.source.by === "plugin" && o.source.name === "graphty-ai"
+      const o = a.list().filter(
+        (n) => n.name === s && n.source.by === "plugin" && n.source.name === "graphty-ai"
       );
-      if (r.length === 0)
+      if (o.length === 0)
         return {
           success: !0,
-          message: `Style layer "${t}" not found (may already be cleared).`
+          message: `Style layer "${s}" not found (may already be cleared).`
         };
-      for (const o of r)
-        await s.remove(o.id);
+      for (const n of o)
+        await a.remove(n.id);
       return {
         success: !0,
-        message: `Cleared style layer "${t}".`,
-        data: { clearedCount: r.length }
+        message: `Cleared style layer "${s}".`,
+        data: { clearedCount: o.length }
       };
-    } catch (r) {
+    } catch (o) {
       return {
         success: !1,
-        message: `Failed to clear styles: ${K(r)}`
+        message: `Failed to clear styles: ${H(o)}`
       };
     }
   }
 };
-function E() {
+function N() {
   return [
-    ...se.map((a) => a.id),
-    ...Q().map((a) => a.id)
+    ...ne.map((r) => r.id),
+    ...se().map((r) => r.id)
   ];
 }
-const qe = c.string().describe(
+const Fe = d.string().describe(
   "Named camera view. The element ships 'fitToGraph', 'topView', 'sideView', 'frontView' and 'isometric'; an application may have registered others."
-), T = c.object({
-  x: c.number(),
-  y: c.number(),
-  z: c.number()
-}).describe("3D position coordinates"), Ue = {
+), k = d.object({
+  x: d.number(),
+  y: d.number(),
+  z: d.number()
+}).describe("3D position coordinates"), Oe = {
   name: "setCameraPosition",
   /*
    * READ AT PROMPT TIME, NOT AT IMPORT TIME. The description is what the system prompt shows
@@ -1337,13 +1372,13 @@ const qe = c.string().describe(
    * registered.
    */
   get description() {
-    return `Set the camera position using a preset (${E().join(", ")}) or specific coordinates. Presets automatically calculate the best view for the current graph. Animation can be enabled for smooth transitions.`;
+    return `Set the camera position using a preset (${N().join(", ")}) or specific coordinates. Presets automatically calculate the best view for the current graph. Animation can be enabled for smooth transitions.`;
   },
-  parameters: c.object({
-    preset: qe.optional().describe("Named camera preset to apply"),
-    position: T.optional().describe("Custom camera position (3D only)"),
-    target: T.optional().describe("Point the camera should look at (3D only)"),
-    animate: c.boolean().optional().describe("Whether to animate the camera transition (default: true)")
+  parameters: d.object({
+    preset: Fe.optional().describe("Named camera preset to apply"),
+    position: k.optional().describe("Custom camera position (3D only)"),
+    target: k.optional().describe("Point the camera should look at (3D only)"),
+    animate: d.boolean().optional().describe("Whether to animate the camera transition (default: true)")
   }),
   examples: [
     { input: "Show from top", params: { preset: "topView", animate: !0 } },
@@ -1356,11 +1391,11 @@ const qe = c.string().describe(
       params: { position: { x: 10, y: 20, z: 30 }, target: { x: 0, y: 0, z: 0 } }
     }
   ],
-  async execute(a, e) {
+  async execute(r, e) {
     const {
       preset: t,
       position: s,
-      target: r,
+      target: a,
       animate: o = !0
     } = e;
     try {
@@ -1370,23 +1405,23 @@ const qe = c.string().describe(
           message: "Either 'preset' or 'position' must be provided."
         };
       if (t)
-        return te(t) ? (await a.setCameraState({ preset: t }, { animate: o, description: `Setting camera to ${t} view` }), {
+        return oe(t) ? (await r.setCameraState({ preset: t }, { animate: o, description: `Setting camera to ${t} view` }), {
           success: !0,
           message: `Camera moved to ${t} view${o ? " (animated)" : ""}.`,
           data: { preset: t, animated: o }
         }) : {
           success: !1,
-          message: `Unknown camera view "${t}". Available views: ${E().join(", ")}.`
+          message: `Unknown camera view "${t}". Available views: ${N().join(", ")}.`
         };
       if (s) {
         const n = { position: s };
-        return r && (n.target = r), await a.setCameraState(n, {
+        return a && (n.target = a), await r.setCameraState(n, {
           animate: o,
           description: "Moving camera to specified position"
         }), {
           success: !0,
           message: `Camera moved to position (${s.x}, ${s.y}, ${s.z})${o ? " (animated)" : ""}.`,
-          data: { position: s, target: r, animated: o }
+          data: { position: s, target: a, animated: o }
         };
       }
       return {
@@ -1401,78 +1436,78 @@ const qe = c.string().describe(
     }
   }
 };
-function Ve(a, e) {
-  const t = a.getDataManager(), { nodes: s } = t, r = [];
+function _e(r, e) {
+  const t = r.getDataManager(), { nodes: s } = t, a = [];
   if (!e || e.length === 0) {
     for (const [o] of s)
-      r.push(String(o));
-    return r;
+      a.push(String(o));
+    return a;
   }
   try {
     const n = `[?${e.replace(/"/g, "'")}]`;
     for (const [l, i] of s) {
-      const { data: u } = i, d = ae.search([u], n);
-      Array.isArray(d) && d.length > 0 && r.push(String(l));
+      const { data: c } = i, u = le.search([c], n);
+      Array.isArray(u) && u.length > 0 && a.push(String(l));
     }
   } catch {
     return [];
   }
-  return r;
+  return a;
 }
-const Fe = {
+const Ke = {
   name: "zoomToNodes",
   description: "Zoom the camera to fit specific nodes in view. Use a JMESPath selector to choose which nodes to focus on, or leave empty to fit all nodes. Optionally add padding around the nodes.",
-  parameters: c.object({
-    selector: c.string().optional().describe("JMESPath expression to match nodes (empty matches all)"),
-    animate: c.boolean().optional().describe("Whether to animate the zoom (default: true)"),
-    padding: c.number().optional().describe("Extra padding around nodes (default: 1.2 = 20% padding)")
+  parameters: d.object({
+    selector: d.string().optional().describe("JMESPath expression to match nodes (empty matches all)"),
+    animate: d.boolean().optional().describe("Whether to animate the zoom (default: true)"),
+    padding: d.number().optional().describe("Extra padding around nodes (default: 1.2 = 20% padding)")
   }),
   examples: [
     { input: "Zoom to fit all nodes", params: { selector: "" } },
     { input: "Zoom to server nodes", params: { selector: "type == 'server'" } },
     { input: "Fit graph with more padding", params: { selector: "", padding: 1.5 } }
   ],
-  async execute(a, e) {
+  async execute(r, e) {
     const { selector: t = "", animate: s = !0 } = e;
     try {
-      const r = Ve(a, t);
-      if (r.length === 0 && t && t.length > 0)
+      const a = _e(r, t);
+      if (a.length === 0 && t && t.length > 0)
         return {
           success: !0,
           message: `No nodes matched the selector "${t}".`,
           affectedNodes: []
         };
-      await a.applyCameraView("fitToGraph", {
-        ...t && t.length > 0 ? { scope: { nodes: r } } : {},
+      await r.applyCameraView("fitToGraph", {
+        ...t && t.length > 0 ? { scope: { nodes: a } } : {},
         animate: s,
         description: `Zooming to fit ${t ? "matching nodes" : "all nodes"}`
       });
-      const o = t ? r.length : a.getNodeCount();
+      const o = t ? a.length : r.getNodeCount();
       return {
         success: !0,
         message: `Zoomed to fit ${o} node(s)${t ? ` matching "${t}"` : ""}.`,
-        affectedNodes: r,
+        affectedNodes: a,
         data: { nodeCount: o, animated: s }
       };
-    } catch (r) {
+    } catch (a) {
       return {
         success: !1,
-        message: `Failed to zoom to nodes: ${r.message}`
+        message: `Failed to zoom to nodes: ${a.message}`
       };
     }
   }
-}, N = c.object({
-  namespace: c.string().describe("The namespace of the algorithm (e.g., 'graphty')"),
-  type: c.string().describe("The type of algorithm to run (e.g., 'degree', 'pagerank')"),
-  options: c.record(c.string(), c.unknown()).optional().describe(
+}, I = d.object({
+  namespace: d.string().describe("The namespace of the algorithm (e.g., 'graphty')"),
+  type: d.string().describe("The type of algorithm to run (e.g., 'degree', 'pagerank')"),
+  options: d.record(d.string(), d.unknown()).optional().describe(
     "The algorithm's options, by name (e.g., { source: 'a', target: 'b' } for dijkstra, { dampingFactor: 0.9 } for pagerank). An unknown name or an out-of-range value is refused."
   )
-}), k = 50, I = c.object({
-  namespace: c.string().optional().describe("Optional namespace to filter algorithms by")
-}), Oe = {
+}), R = 50, D = d.object({
+  namespace: d.string().optional().describe("Optional namespace to filter algorithms by")
+}), We = {
   name: "runAlgorithm",
   description: "Run a graph algorithm to analyze the graph structure, optionally with options such as a source and target. Returns a bounded summary: the top 10 elements and the value range for a metric, the group sizes for a partition, the route for a path, plus any graph-level values.",
-  parameters: N,
+  parameters: I,
   examples: [
     {
       input: "Calculate the degree of each node",
@@ -1491,63 +1526,72 @@ const Fe = {
       params: { namespace: "graphty", type: "dijkstra", options: { source: "A", target: "B" } }
     }
   ],
-  async execute(a, e) {
-    const t = N.safeParse(e);
-    if (!t.success)
+  async execute(r, e, t) {
+    const s = I.safeParse(e);
+    if (!s.success)
       return {
         success: !1,
-        message: `Invalid parameters: ${t.error.message}`
+        message: `Invalid parameters: ${s.error.message}`
       };
-    const { namespace: s, type: r, options: o } = t.data;
+    const { namespace: a, type: o, options: n } = s.data;
     try {
-      if (!x.get(a, s, r)) {
-        const m = x.getRegisteredAlgorithms(s), h = m.length > 0 ? `Available in namespace '${s}': ${m.map((g) => g.split(":")[1]).join(", ")}` : `No algorithms found in namespace '${s}'. Use listAlgorithms to see available options.`;
+      if (!M.get(r, a, o)) {
+        const h = M.getRegisteredAlgorithms(a), g = h.length > 0 ? `Available in namespace '${a}': ${h.map((v) => v.split(":")[1]).join(", ")}` : `No algorithms found in namespace '${a}'. Use listAlgorithms to see available options.`;
         return {
           success: !1,
-          message: `Algorithm not found: ${s}:${r}. ${h}`
+          message: `Algorithm not found: ${a}:${o}. ${g}`
         };
       }
-      const l = (s === "graphty" ? re(r) : void 0) ?? P(`${s}:${r}`) ?? P(r);
-      if (l === void 0)
-        return await a.runAlgorithm(s, r, { algorithmOptions: o }), {
+      const i = (a === "graphty" ? ie(o) : void 0) ?? E(`${a}:${o}`) ?? E(o);
+      if (i === void 0)
+        return await y(r, t).execute({
+          op: "algo.legacy",
+          namespace: a,
+          type: o,
+          ...n === void 0 ? {} : { options: n }
+        }), {
           success: !0,
-          message: `Successfully ran ${s}:${r} algorithm. Results are now available in node data.`,
-          data: { namespace: s, type: r, nodeCount: a.getNodeCount() }
+          message: `Successfully ran ${a}:${o} algorithm. Results are now available in node data.`,
+          data: { namespace: a, type: o, nodeCount: r.getNodeCount() }
         };
-      const i = "params" in l ? l.params : {}, u = await a.run(l.descriptor.key, { ...i, ...o }), d = {
-        namespace: s,
-        type: r,
-        algorithm: l.descriptor.key,
+      const c = "params" in i ? i.params : {}, u = await y(r, t).run({
+        op: "algo.run",
+        algorithm: i.descriptor.key,
+        params: { ...c, ...n }
+      }), p = {
+        namespace: a,
+        type: o,
+        algorithm: i.descriptor.key,
         shape: u.shape,
         summary: u.summary(),
         graph: u.graph
       };
-      let p;
+      let m;
       if (u.shape === "path") {
-        const m = u.ranking("order").map((h) => String(h.id)).reverse();
-        p = m.slice(0, k), d.path = {
-          nodeIds: p,
-          total: m.length,
-          truncated: m.length > k
+        const h = u.ranking("order").map((g) => String(g.id)).reverse();
+        m = h.slice(0, R), p.path = {
+          nodeIds: m,
+          total: h.length,
+          truncated: h.length > R
         };
       }
       return {
         success: !0,
-        message: `Successfully ran ${s}:${r} algorithm. ${u.reading()}`,
-        data: d,
-        ...p === void 0 ? {} : { affectedNodes: p }
+        message: `Successfully ran ${a}:${o} algorithm. ${u.reading()}`,
+        data: p,
+        ...m === void 0 ? {} : { affectedNodes: m }
       };
-    } catch (n) {
+    } catch (l) {
       return {
         success: !1,
-        message: `Failed to run algorithm ${s}:${r}: ${n instanceof Error ? n.message : String(n)}`
+        message: `Failed to run algorithm ${a}:${o}: ${l instanceof Error ? l.message : String(l)}`
       };
     }
   }
-}, _e = {
+}, Ge = {
   name: "listAlgorithms",
   description: "List all available graph algorithms that can be run on the graph. Optionally filter by namespace.",
-  parameters: I,
+  parameters: D,
   examples: [
     {
       input: "What algorithms are available?",
@@ -1563,8 +1607,8 @@ const Fe = {
     }
   ],
   // eslint-disable-next-line @typescript-eslint/require-await
-  async execute(a, e) {
-    const t = I.safeParse(e);
+  async execute(r, e) {
+    const t = D.safeParse(e);
     if (!t.success)
       return {
         success: !1,
@@ -1572,8 +1616,8 @@ const Fe = {
       };
     const { namespace: s } = t.data;
     try {
-      const r = x.getRegisteredAlgorithms(s);
-      return r.length === 0 ? {
+      const a = M.getRegisteredAlgorithms(s);
+      return a.length === 0 ? {
         success: !0,
         message: s ? `No algorithms found in namespace '${s}'.` : "No algorithms are currently registered.",
         data: {
@@ -1582,180 +1626,180 @@ const Fe = {
         }
       } : {
         success: !0,
-        message: s ? `Found ${r.length} algorithm(s) in namespace '${s}': ${r.join(", ")}` : `Found ${r.length} available algorithm(s): ${r.join(", ")}`,
+        message: s ? `Found ${a.length} algorithm(s) in namespace '${s}': ${a.join(", ")}` : `Found ${a.length} available algorithm(s): ${a.join(", ")}`,
         data: {
-          algorithms: r,
-          count: r.length
+          algorithms: a,
+          count: a.length
         }
       };
-    } catch (r) {
+    } catch (a) {
       return {
         success: !1,
-        message: `Failed to list algorithms: ${r instanceof Error ? r.message : String(r)}`
+        message: `Failed to list algorithms: ${a instanceof Error ? a.message : String(a)}`
       };
     }
   }
 };
-function Ke(a, e = 100) {
-  return a.length <= e ? a : `${a.slice(0, e)}...`;
+function He(r, e = 100) {
+  return r.length <= e ? r : `${r.slice(0, e)}...`;
 }
-function M(a, e) {
-  if (a == null)
+function P(r, e) {
+  if (r == null)
     return;
   const t = e.split(".");
-  let s = a;
-  for (const r of t) {
+  let s = r;
+  for (const a of t) {
     if (s == null || typeof s != "object")
       return;
-    s = s[r];
+    s = s[a];
   }
   return s;
 }
-function C(a, e = 100) {
-  if (a == null)
-    return a;
-  if (typeof a == "string")
-    return Ke(a, e);
-  if (Array.isArray(a))
-    return a.map((t) => C(t, e));
-  if (typeof a == "object") {
+function $(r, e = 100) {
+  if (r == null)
+    return r;
+  if (typeof r == "string")
+    return He(r, e);
+  if (Array.isArray(r))
+    return r.map((t) => $(t, e));
+  if (typeof r == "object") {
     const t = {};
-    for (const [s, r] of Object.entries(a))
-      t[s] = C(r, e);
+    for (const [s, a] of Object.entries(r))
+      t[s] = $(a, e);
     return t;
   }
-  return a;
+  return r;
 }
-function G(a) {
-  if (a.length === 0)
+function X(r) {
+  if (r.length === 0)
     return { min: 0, max: 0, avg: 0, median: 0, count: 0 };
-  const e = [...a].sort((i, u) => i - u), t = a.reduce((i, u) => i + u, 0), s = e[0], r = e[e.length - 1], o = t / a.length, n = Math.floor(e.length / 2), l = e.length % 2 === 0 ? (e[n - 1] + e[n]) / 2 : e[n];
-  return { min: s, max: r, avg: o, median: l, count: a.length };
+  const e = [...r].sort((i, c) => i - c), t = r.reduce((i, c) => i + c, 0), s = e[0], a = e[e.length - 1], o = t / r.length, n = Math.floor(e.length / 2), l = e.length % 2 === 0 ? (e[n - 1] + e[n]) / 2 : e[n];
+  return { min: s, max: a, avg: o, median: l, count: r.length };
 }
-function We(a, e = 5) {
-  if (a.length === 0)
+function Be(r, e = 5) {
+  if (r.length === 0)
     return [];
-  const t = Math.min(...a), s = Math.max(...a);
+  const t = Math.min(...r), s = Math.max(...r);
   if (t === s)
     return [
       {
-        range: R(t, s),
-        count: a.length,
+        range: L(t, s),
+        count: r.length,
         min: t,
         max: s
       }
     ];
-  const r = (s - t) / e, o = [];
+  const a = (s - t) / e, o = [];
   for (let n = 0; n < e; n++) {
-    const l = t + n * r, i = n === e - 1 ? s : t + (n + 1) * r;
+    const l = t + n * a, i = n === e - 1 ? s : t + (n + 1) * a;
     o.push({
-      range: R(l, i),
+      range: L(l, i),
       count: 0,
       min: l,
       max: i
     });
   }
-  for (const n of a) {
-    let l = Math.floor((n - t) / r);
+  for (const n of r) {
+    let l = Math.floor((n - t) / a);
     l >= e && (l = e - 1), o[l].count++;
   }
   return o;
 }
-function R(a, e) {
+function L(r, e) {
   const t = (s) => Number.isInteger(s) ? s.toString() : s.toFixed(2);
-  return `${t(a)} - ${t(e)}`;
+  return `${t(r)} - ${t(e)}`;
 }
-function Ge(a) {
-  if (a == null)
+function Xe(r) {
+  if (r == null)
     return "null";
-  if (Array.isArray(a))
+  if (Array.isArray(r))
     return "array";
-  const e = typeof a;
+  const e = typeof r;
   return e === "string" || e === "number" || e === "boolean" ? e : e === "object" ? "object" : "null";
 }
-function He(a, e) {
+function Ye(r, e) {
   const t = [];
   let s = 0;
-  for (const r of a) {
-    const o = M(r.data, e);
+  for (const a of r) {
+    const o = P(a.data, e);
     o == null ? s++ : t.push(o);
   }
   return { values: t, nullCount: s };
 }
-function H(a) {
-  if (a.length === 0)
+function Y(r) {
+  if (r.length === 0)
     return "null";
   const e = /* @__PURE__ */ new Map();
-  for (const t of a) {
-    const s = Ge(t);
+  for (const t of r) {
+    const s = Xe(t);
     e.set(s, (e.get(s) ?? 0) + 1);
   }
   return e.delete("null"), e.size === 0 ? "null" : e.size > 1 ? "mixed" : e.keys().next().value;
 }
-function Be(a, e = 3) {
+function Ze(r, e = 3) {
   const t = /* @__PURE__ */ new Set();
-  for (const s of a)
-    B(s.data, "", t, 0, e);
+  for (const s of r)
+    Z(s.data, "", t, 0, e);
   return Array.from(t).sort();
 }
-function B(a, e, t, s, r) {
-  if (!(s >= r || a === null || a === void 0 || typeof a != "object" || Array.isArray(a)))
-    for (const o of Object.keys(a)) {
+function Z(r, e, t, s, a) {
+  if (!(s >= a || r === null || r === void 0 || typeof r != "object" || Array.isArray(r)))
+    for (const o of Object.keys(r)) {
       const n = e ? `${e}.${o}` : o;
       t.add(n);
-      const l = a[o];
-      l !== null && typeof l == "object" && !Array.isArray(l) && B(l, n, t, s + 1, r);
+      const l = r[o];
+      l !== null && typeof l == "object" && !Array.isArray(l) && Z(l, n, t, s + 1, a);
     }
 }
-const Xe = c.enum(["nodes", "edges", "both"]).optional().describe("What to sample: 'nodes', 'edges', or 'both' (default)"), D = 3, L = 10, j = 100;
-function y(a, e) {
-  if (a.length <= e)
-    return [...a];
-  const t = [...a];
+const Je = d.enum(["nodes", "edges", "both"]).optional().describe("What to sample: 'nodes', 'edges', or 'both' (default)"), j = 3, z = 10, U = 100;
+function b(r, e) {
+  if (r.length <= e)
+    return [...r];
+  const t = [...r];
   for (let s = 0; s < e; s++) {
-    const r = s + Math.floor(Math.random() * (t.length - s));
-    [t[s], t[r]] = [t[r], t[s]];
+    const a = s + Math.floor(Math.random() * (t.length - s));
+    [t[s], t[a]] = [t[a], t[s]];
   }
   return t.slice(0, e);
 }
-function z(a, e, t) {
-  if (a.length <= e)
-    return [...a];
-  const s = /* @__PURE__ */ new Map(), r = [];
-  for (const i of a) {
-    const u = t(i);
-    if (u === void 0)
-      r.push(i);
+function q(r, e, t) {
+  if (r.length <= e)
+    return [...r];
+  const s = /* @__PURE__ */ new Map(), a = [];
+  for (const i of r) {
+    const c = t(i);
+    if (c === void 0)
+      a.push(i);
     else {
-      const d = s.get(u) ?? [];
-      d.push(i), s.set(u, d);
+      const u = s.get(c) ?? [];
+      u.push(i), s.set(c, u);
     }
   }
-  const o = s.size + (r.length > 0 ? 1 : 0);
+  const o = s.size + (a.length > 0 ? 1 : 0);
   if (o === 0)
-    return y(a, e);
+    return b(r, e);
   const n = Math.max(1, Math.floor(e / o)), l = [];
   for (const i of s.values()) {
-    const u = y(i, n);
-    l.push(...u);
+    const c = b(i, n);
+    l.push(...c);
   }
-  if (r.length > 0) {
-    const i = y(r, n);
+  if (a.length > 0) {
+    const i = b(a, n);
     l.push(...i);
   }
   if (l.length < e) {
-    const i = a.filter((d) => !l.includes(d)), u = y(i, e - l.length);
-    l.push(...u);
+    const i = r.filter((u) => !l.includes(u)), c = b(i, e - l.length);
+    l.push(...c);
   }
   return l.slice(0, e);
 }
-const Ze = {
+const Qe = {
   name: "sampleData",
   description: "Get sample nodes and/or edges from the graph to inspect actual data structures. Useful for understanding what properties exist and what values they contain before writing selectors.",
-  parameters: c.object({
-    target: Xe,
-    count: c.number().min(1).max(L).optional().describe(`Number of samples to return per type (1-${L}, default ${D})`),
-    stratifyBy: c.string().optional().describe("Property path to stratify sampling by (e.g., 'data.type' to sample from each type)")
+  parameters: d.object({
+    target: Je,
+    count: d.number().min(1).max(z).optional().describe(`Number of samples to return per type (1-${z}, default ${j})`),
+    stratifyBy: d.string().optional().describe("Property path to stratify sampling by (e.g., 'data.type' to sample from each type)")
   }),
   examples: [
     { input: "Show me some example nodes", params: { target: "nodes" } },
@@ -1766,36 +1810,36 @@ const Ze = {
       params: { target: "nodes", count: 6, stratifyBy: "data.type" }
     }
   ],
-  execute(a, e) {
+  execute(r, e) {
     const {
       target: t = "both",
-      count: s = D,
-      stratifyBy: r
+      count: s = j,
+      stratifyBy: a
     } = e;
     try {
-      const o = a.getDataManager(), n = {};
+      const o = r.getDataManager(), n = {};
       if (t === "nodes" || t === "both") {
         const i = Array.from(o.nodes.values());
-        let u;
-        r ? u = z(i, s, (d) => {
-          const p = M(d.data, r);
+        let c;
+        a ? c = q(i, s, (u) => {
+          const p = P(u.data, a);
           return typeof p == "string" ? p : void 0;
-        }) : u = y(i, s), n.nodes = u.map((d) => ({
-          id: String(d.id),
-          data: C(d.data, j)
+        }) : c = b(i, s), n.nodes = c.map((u) => ({
+          id: String(u.id),
+          data: $(u.data, U)
         }));
       }
       if (t === "edges" || t === "both") {
         const i = Array.from(o.edges.values());
-        let u;
-        r ? u = z(i, s, (d) => {
-          const p = M(d.data, r);
+        let c;
+        a ? c = q(i, s, (u) => {
+          const p = P(u.data, a);
           return typeof p == "string" ? p : void 0;
-        }) : u = y(i, s), n.edges = u.map((d) => ({
-          id: d.id,
-          source: String(d.srcId),
-          target: String(d.dstId),
-          data: C(d.data, j)
+        }) : c = b(i, s), n.edges = c.map((u) => ({
+          id: u.id,
+          source: String(u.srcId),
+          target: String(u.dstId),
+          data: $(u.data, U)
         }));
       }
       const l = [];
@@ -1811,35 +1855,35 @@ const Ze = {
       });
     }
   }
-}, q = 20, U = 50, Ye = 5;
-function Je(a, e, t, s, r) {
+}, V = 20, F = 50, et = 5;
+function tt(r, e, t, s, a) {
   const o = t.filter((p) => typeof p == "string"), n = /* @__PURE__ */ new Map();
   for (const p of o)
     n.set(p, (n.get(p) ?? 0) + 1);
-  const l = Array.from(n.entries()).sort((p, m) => m[1] - p[1]), i = l.length > r, u = l.slice(0, r), d = {};
-  for (const [p, m] of u)
-    d[p] = {
+  const l = Array.from(n.entries()).sort((p, m) => m[1] - p[1]), i = l.length > a, c = l.slice(0, a), u = {};
+  for (const [p, m] of c)
+    u[p] = {
       count: m,
       percentage: m / o.length * 100
     };
   return {
-    property: a,
+    property: r,
     target: e,
     type: "string",
     totalCount: o.length + s,
     nullCount: s,
     uniqueCount: n.size,
-    distribution: d,
+    distribution: u,
     truncated: i
   };
 }
-function Qe(a, e, t, s) {
-  const r = t.filter((l) => typeof l == "number"), o = G(r), n = We(r, Ye);
+function st(r, e, t, s) {
+  const a = t.filter((l) => typeof l == "number"), o = X(a), n = Be(a, et);
   return {
-    property: a,
+    property: r,
     target: e,
     type: "number",
-    totalCount: r.length + s,
+    totalCount: a.length + s,
     nullCount: s,
     statistics: {
       min: o.min,
@@ -1853,43 +1897,43 @@ function Qe(a, e, t, s) {
     }))
   };
 }
-function et(a, e, t, s) {
-  const r = t.filter((l) => typeof l == "boolean"), o = r.filter((l) => l).length, n = r.length - o;
+function rt(r, e, t, s) {
+  const a = t.filter((l) => typeof l == "boolean"), o = a.filter((l) => l).length, n = a.length - o;
   return {
-    property: a,
+    property: r,
     target: e,
     type: "boolean",
-    totalCount: r.length + s,
+    totalCount: a.length + s,
     nullCount: s,
     distribution: {
       true: {
         count: o,
-        percentage: r.length > 0 ? o / r.length * 100 : 0
+        percentage: a.length > 0 ? o / a.length * 100 : 0
       },
       false: {
         count: n,
-        percentage: r.length > 0 ? n / r.length * 100 : 0
+        percentage: a.length > 0 ? n / a.length * 100 : 0
       }
     }
   };
 }
-function tt(a, e, t, s, r) {
+function at(r, e, t, s, a) {
   const o = t.filter((h) => Array.isArray(h)), n = [], l = [];
   for (const h of o)
     l.push(h.length), n.push(...h);
-  const i = H(n), u = /* @__PURE__ */ new Set();
+  const i = Y(n), c = /* @__PURE__ */ new Set();
   for (const h of n)
-    typeof h == "string" ? u.add(h) : typeof h == "number" || typeof h == "boolean" ? u.add(String(h)) : h != null && u.add(JSON.stringify(h));
-  const d = Array.from(u), p = d.length > r, m = G(l);
+    typeof h == "string" ? c.add(h) : typeof h == "number" || typeof h == "boolean" ? c.add(String(h)) : h != null && c.add(JSON.stringify(h));
+  const u = Array.from(c), p = u.length > a, m = X(l);
   return {
-    property: a,
+    property: r,
     target: e,
     type: "array",
     totalCount: o.length + s,
     nullCount: s,
     itemType: i,
-    uniqueItems: d.slice(0, r),
-    uniqueItemCount: d.length,
+    uniqueItems: u.slice(0, a),
+    uniqueItemCount: u.length,
     lengthStatistics: {
       min: m.min,
       max: m.max,
@@ -1898,28 +1942,28 @@ function tt(a, e, t, s, r) {
     truncated: p
   };
 }
-function st(a, e, t, s) {
-  const r = {};
+function ot(r, e, t, s) {
+  const a = {};
   for (const o of t) {
     const n = typeof o;
-    Array.isArray(o) ? r.array = (r.array || 0) + 1 : n === "object" && o !== null ? r.object = (r.object || 0) + 1 : (n === "string" || n === "number" || n === "boolean") && (r[n] = (r[n] || 0) + 1);
+    Array.isArray(o) ? a.array = (a.array || 0) + 1 : n === "object" && o !== null ? a.object = (a.object || 0) + 1 : (n === "string" || n === "number" || n === "boolean") && (a[n] = (a[n] || 0) + 1);
   }
   return {
-    property: a,
+    property: r,
     target: e,
     type: "mixed",
     totalCount: t.length + s,
     nullCount: s,
-    typeCounts: r
+    typeCounts: a
   };
 }
-const rt = {
+const nt = {
   name: "describeProperty",
   description: "Get detailed information about a specific property in node or edge data. Returns value distributions for strings, statistics for numbers, counts for booleans, and unique items for arrays.",
-  parameters: c.object({
-    property: c.string().describe("Property path to analyze (e.g., 'type', 'data.category', 'weight')"),
-    target: c.enum(["nodes", "edges"]).optional().describe("Whether to analyze node or edge properties (default: 'nodes')"),
-    limit: c.number().min(1).max(U).optional().describe(`Maximum number of unique values to show (1-${U}, default ${q})`)
+  parameters: d.object({
+    property: d.string().describe("Property path to analyze (e.g., 'type', 'data.category', 'weight')"),
+    target: d.enum(["nodes", "edges"]).optional().describe("Whether to analyze node or edge properties (default: 'nodes')"),
+    limit: d.number().min(1).max(F).optional().describe(`Maximum number of unique values to show (1-${F}, default ${V})`)
   }),
   examples: [
     { input: "Describe the type property on nodes", params: { property: "type", target: "nodes" } },
@@ -1930,22 +1974,22 @@ const rt = {
     { input: "Show me the distribution of data.category", params: { property: "data.category" } },
     { input: "Analyze the tags property", params: { property: "tags", limit: 10 } }
   ],
-  execute(a, e) {
+  execute(r, e) {
     const {
       property: t,
       target: s = "nodes",
-      limit: r = q
+      limit: a = V
     } = e;
     try {
-      const o = a.getDataManager(), n = Array.from(s === "nodes" ? o.nodes.values() : o.edges.values());
+      const o = r.getDataManager(), n = Array.from(s === "nodes" ? o.nodes.values() : o.edges.values());
       if (n.length === 0)
         return Promise.resolve({
           success: !1,
           message: `No ${s} found in the graph.`
         });
-      const { values: l, nullCount: i } = He(n, t);
+      const { values: l, nullCount: i } = Ye(n, t);
       if (l.length === 0 && i === n.length) {
-        const m = Be(n);
+        const m = Ze(n);
         return Promise.resolve({
           success: !1,
           message: `Property "${t}" not found on ${s}. Available properties: ${m.slice(0, 10).join(", ")}${m.length > 10 ? "..." : ""}`,
@@ -1954,23 +1998,23 @@ const rt = {
           }
         });
       }
-      const u = H(l);
-      let d;
-      switch (u) {
+      const c = Y(l);
+      let u;
+      switch (c) {
         case "string":
-          d = Je(t, s, l, i, r);
+          u = tt(t, s, l, i, a);
           break;
         case "number":
-          d = Qe(t, s, l, i);
+          u = st(t, s, l, i);
           break;
         case "boolean":
-          d = et(t, s, l, i);
+          u = rt(t, s, l, i);
           break;
         case "array":
-          d = tt(t, s, l, i, r);
+          u = at(t, s, l, i, a);
           break;
         case "mixed":
-          d = st(t, s, l, i);
+          u = ot(t, s, l, i);
           break;
         default:
           return Promise.resolve({
@@ -1979,29 +2023,29 @@ const rt = {
           });
       }
       let p;
-      switch (u) {
+      switch (c) {
         case "string": {
-          const m = d;
+          const m = u;
           p = `Property "${t}" is a string with ${m.uniqueCount} unique value${m.uniqueCount !== 1 ? "s" : ""}.`;
           break;
         }
         case "number": {
-          const m = d;
+          const m = u;
           p = `Property "${t}" is a number (min: ${m.statistics.min.toFixed(2)}, max: ${m.statistics.max.toFixed(2)}, avg: ${m.statistics.avg.toFixed(2)}).`;
           break;
         }
         case "boolean": {
-          const m = d;
+          const m = u;
           p = `Property "${t}" is a boolean (true: ${m.distribution.true.percentage.toFixed(1)}%, false: ${m.distribution.false.percentage.toFixed(1)}%).`;
           break;
         }
         case "array": {
-          const m = d;
+          const m = u;
           p = `Property "${t}" is an array of ${m.itemType} values with ${m.uniqueItemCount} unique item${m.uniqueItemCount !== 1 ? "s" : ""}.`;
           break;
         }
         case "mixed": {
-          const h = Object.keys(d.typeCounts).join(", ");
+          const h = Object.keys(u.typeCounts).join(", ");
           p = `Property "${t}" has mixed types: ${h}.`;
           break;
         }
@@ -2011,7 +2055,7 @@ const rt = {
       return Promise.resolve({
         success: !0,
         message: p,
-        data: d
+        data: u
       });
     } catch (o) {
       return Promise.resolve({
@@ -2021,7 +2065,7 @@ const rt = {
     }
   }
 };
-class at {
+class it {
   constructor() {
     this.name = "mock", this.supportsStreaming = !0, this.supportsTools = !0, this.responses = /* @__PURE__ */ new Map(), this.defaultResponse = {
       text: "This is a mock response.",
@@ -2088,12 +2132,12 @@ class at {
    * @returns Matching response or default response
    */
   findResponse(e) {
-    const t = [...e].reverse().find((r) => r.role === "user");
+    const t = [...e].reverse().find((a) => a.role === "user");
     if (!t)
       return this.defaultResponse;
     const s = t.content.toLowerCase();
-    for (const [r, o] of this.responses)
-      if (s.includes(r))
+    for (const [a, o] of this.responses)
+      if (s.includes(a))
         return o;
     return this.defaultResponse;
   }
@@ -2115,7 +2159,7 @@ class at {
       throw new Error("Request was aborted");
     if (this.configuredError)
       throw this.configuredError;
-    if (this.delay > 0 && await new Promise((r) => setTimeout(r, this.delay)), s?.signal?.aborted)
+    if (this.delay > 0 && await new Promise((a) => setTimeout(a, this.delay)), s?.signal?.aborted)
       throw new Error("Request was aborted");
     return this.findResponse(e);
   }
@@ -2127,24 +2171,24 @@ class at {
    * @param callbacks - Streaming callbacks for text and tool calls
    * @param signal - Optional abort signal
    */
-  async generateStream(e, t, s, r) {
+  async generateStream(e, t, s, a) {
     if (this.callHistory.push({
       messages: e,
       tools: t,
       streaming: !0,
       timestamp: Date.now()
-    }), r?.aborted)
+    }), a?.aborted)
       throw new Error("Request was aborted");
     if (this.configuredError)
       throw s.onError(this.configuredError), this.configuredError;
     const o = this.findResponse(e), { text: n } = o;
     for (const l of n) {
-      if (r?.aborted)
+      if (a?.aborted)
         throw new Error("Request was aborted");
       s.onChunk(l), this.delay > 0 && await new Promise((i) => setTimeout(i, this.delay / n.length));
     }
     for (const l of o.toolCalls) {
-      if (r?.aborted)
+      if (a?.aborted)
         throw new Error("Request was aborted");
       s.onToolCall(l.name, l.arguments);
     }
@@ -2163,7 +2207,7 @@ class at {
     return Promise.resolve(!0);
   }
 }
-class ot {
+class lt {
   /**
    * Creates a new VercelAiProvider instance.
    * @param providerType - Type of provider (openai, anthropic, or google)
@@ -2187,9 +2231,9 @@ class ot {
       throw new Error(`API key not configured for ${this.name}`);
     switch (this.providerType) {
       case "openai":
-        return le({ apiKey: this.apiKey, baseURL: this.baseUrl })(this.model ?? "gpt-4o");
+        return de({ apiKey: this.apiKey, baseURL: this.baseUrl })(this.model ?? "gpt-4o");
       case "anthropic":
-        return ne({
+        return ce({
           apiKey: this.apiKey,
           baseURL: this.baseUrl,
           // Enable browser support - Anthropic requires this header for CORS
@@ -2198,7 +2242,7 @@ class ot {
           }
         })(this.model ?? "claude-3-haiku-20240307");
       default:
-        return ie({ apiKey: this.apiKey, baseURL: this.baseUrl })(this.model ?? "gemini-2.0-flash");
+        return ue({ apiKey: this.apiKey, baseURL: this.baseUrl })(this.model ?? "gemini-2.0-flash");
     }
   }
   /**
@@ -2210,8 +2254,8 @@ class ot {
    * @returns Promise resolving to LLM response
    */
   async generate(e, t, s) {
-    const r = this.getModel(), o = this.convertMessages(e), n = this.convertTools(t), l = await ce({
-      model: r,
+    const a = this.getModel(), o = this.convertMessages(e), n = this.convertTools(t), l = await me({
+      model: a,
       messages: o,
       tools: n,
       maxOutputTokens: this.maxTokens,
@@ -2231,22 +2275,22 @@ class ot {
    * @param callbacks - Streaming callbacks for text and tool calls
    * @param signal - Optional abort signal
    */
-  async generateStream(e, t, s, r) {
-    const o = this.getModel(), n = this.convertMessages(e), l = this.convertTools(t), i = ue({
+  async generateStream(e, t, s, a) {
+    const o = this.getModel(), n = this.convertMessages(e), l = this.convertTools(t), i = pe({
       model: o,
       messages: n,
       tools: l,
       maxOutputTokens: this.maxTokens,
       temperature: this.temperature,
-      abortSignal: r
+      abortSignal: a
     });
-    let u = "";
-    const d = [];
+    let c = "";
+    const u = [];
     try {
       for await (const m of i.fullStream)
         switch (m.type) {
           case "text-delta":
-            u += m.text, s.onChunk(m.text);
+            c += m.text, s.onChunk(m.text);
             break;
           case "tool-call": {
             let h = {};
@@ -2256,7 +2300,7 @@ class ot {
               name: m.toolName,
               arguments: h
             };
-            d.push(g), s.onToolCall(m.toolName, h);
+            u.push(g), s.onToolCall(m.toolName, h);
             break;
           }
           case "tool-result": {
@@ -2272,8 +2316,8 @@ class ot {
         }
       const p = await i.usage;
       s.onComplete({
-        text: u,
-        toolCalls: d,
+        text: c,
+        toolCalls: u,
         usage: p.inputTokens !== void 0 && p.outputTokens !== void 0 ? { promptTokens: p.inputTokens, completionTokens: p.outputTokens } : void 0
       });
     } catch (p) {
@@ -2366,75 +2410,75 @@ class ot {
     }
   }
 }
-async function nt() {
+async function ct() {
   return (await import("./WebLlmProvider-BEFvNcC5.js")).WebLlmProvider;
 }
-function it(a) {
-  if (a === "mock")
-    return new at();
-  if (a === "webllm")
+function ut(r) {
+  if (r === "mock")
+    return new it();
+  if (r === "webllm")
     throw new Error(
       "WebLlmProvider cannot be created synchronously. Use createWebLlmProvider() or getWebLlmProviderClass() instead."
     );
-  return new ot(a);
+  return new lt(r);
 }
-async function It() {
-  const a = await nt();
-  return new a();
+async function Lt() {
+  const r = await ct();
+  return new r();
 }
-const $ = 10, V = 50;
-function lt(a) {
+const x = 10, O = 50;
+function dt(r) {
   const e = [];
-  return e.push(ct(a)), a.nodeProperties.length > 0 ? e.push(ut(a.nodeProperties)) : a.nodeCount > 0 && e.push(`### Node Properties
-No custom properties on node data.`), a.edgeProperties.length > 0 ? e.push(dt(a.edgeProperties)) : a.edgeCount > 0 && e.push(`### Edge Properties
+  return e.push(mt(r)), r.nodeProperties.length > 0 ? e.push(pt(r.nodeProperties)) : r.nodeCount > 0 && e.push(`### Node Properties
+No custom properties on node data.`), r.edgeProperties.length > 0 ? e.push(ht(r.edgeProperties)) : r.edgeCount > 0 && e.push(`### Edge Properties
 No custom properties on edge data.`), e.join(`
 
 `);
 }
-function ct(a) {
+function mt(r) {
   return `## Data Schema
-- Nodes: ${a.nodeCount}
-- Edges: ${a.edgeCount}`;
+- Nodes: ${r.nodeCount}
+- Edges: ${r.edgeCount}`;
 }
-function ut(a) {
+function pt(r) {
   const e = ["### Node Properties"];
-  for (const t of a)
-    e.push(X(t));
+  for (const t of r)
+    e.push(J(t));
   return e.join(`
 `);
 }
-function dt(a) {
+function ht(r) {
   const e = ["### Edge Properties"];
-  for (const t of a)
-    e.push(X(t));
+  for (const t of r)
+    e.push(J(t));
   return e.join(`
 `);
 }
-function X(a) {
-  const e = gt(a.name), t = a.nullable ? "?" : "", s = mt(a), r = pt(a);
-  return `- \`${e}\`: ${s}${t}${r}`;
+function J(r) {
+  const e = vt(r.name), t = r.nullable ? "?" : "", s = gt(r), a = ft(r);
+  return `- \`${e}\`: ${s}${t}${a}`;
 }
-function mt(a) {
-  return a.type === "array" && a.itemType ? `${a.itemType}[]` : a.type;
+function gt(r) {
+  return r.type === "array" && r.itemType ? `${r.itemType}[]` : r.type;
 }
-function pt(a) {
+function ft(r) {
   const e = [];
-  if (a.format && e.push(`format: ${a.format}`), a.enumValues && a.enumValues.length > 0) {
-    const t = ht(a.enumValues);
+  if (r.format && e.push(`format: ${r.format}`), r.enumValues && r.enumValues.length > 0) {
+    const t = yt(r.enumValues);
     e.push(`values: [${t}]`);
   }
-  return a.range && e.push(`range: ${a.range.min}..${a.range.max}`), e.length === 0 ? "" : ` (${e.join(", ")})`;
+  return r.range && e.push(`range: ${r.range.min}..${r.range.max}`), e.length === 0 ? "" : ` (${e.join(", ")})`;
 }
-function ht(a) {
-  if (a.length <= $)
-    return a.map((s) => `"${s}"`).join(", ");
-  const e = a.slice(0, $), t = a.length - $;
+function yt(r) {
+  if (r.length <= x)
+    return r.map((s) => `"${s}"`).join(", ");
+  const e = r.slice(0, x), t = r.length - x;
   return `${e.map((s) => `"${s}"`).join(", ")}, ... +${t} more`;
 }
-function gt(a) {
-  return a.length <= V ? a : `${a.slice(0, V - 3)}...`;
+function vt(r) {
+  return r.length <= O ? r : `${r.slice(0, O - 3)}...`;
 }
-class ft {
+class bt {
   /**
    * Create a new SchemaManager.
    * @param graph - The graph to extract schema from
@@ -2451,7 +2495,7 @@ class ft {
    */
   extract() {
     if (this.cachedSchema === null) {
-      const e = new O(this.graph, this.options);
+      const e = new W(this.graph, this.options);
       this.cachedSchema = e.extract();
     }
     return this.cachedSchema;
@@ -2472,7 +2516,7 @@ class ft {
   getFormattedSchema() {
     if (this.cachedFormattedSchema === null) {
       const e = this.extract();
-      this.cachedFormattedSchema = lt(e);
+      this.cachedFormattedSchema = dt(e);
     }
     return this.cachedFormattedSchema;
   }
@@ -2486,13 +2530,13 @@ class ft {
     this.cachedSchema = null, this.cachedFormattedSchema = null;
   }
 }
-const yt = 300;
-class Z {
+const wt = 300;
+class Q {
   /**
    * Creates a new AiManager instance.
    */
   constructor() {
-    this.graph = null, this.controller = null, this.provider = null, this.schemaManager = null, this.dataAddedListenerId = null, this.debouncedSchemaUpdate = null, this.disposed = !1, this.initialized = !1, this.commandRegistry = new pe(), this.apiKeyManager = new de(), this.statusManager = new F();
+    this.graph = null, this.controller = null, this.provider = null, this.schemaManager = null, this.dataAddedListenerId = null, this.debouncedSchemaUpdate = null, this.disposed = !1, this.initialized = !1, this.commandRegistry = new fe(), this.apiKeyManager = new he(), this.statusManager = new K();
   }
   /**
    * Initialize the AI Manager with a graph and configuration.
@@ -2504,10 +2548,10 @@ class Z {
       encryptionKey: t.keyPersistence.encryptionKey,
       storage: t.keyPersistence.storage ?? "localStorage",
       prefix: t.keyPersistence.prefix
-    }), t.providerInstance ? this.provider = t.providerInstance : (this.provider = it(t.provider), t.apiKey && (this.apiKeyManager.setKey(t.provider, t.apiKey), this.provider.configure({
+    }), t.providerInstance ? this.provider = t.providerInstance : (this.provider = ut(t.provider), t.apiKey && (this.apiKeyManager.setKey(t.provider, t.apiKey), this.provider.configure({
       apiKey: t.apiKey,
       model: t.model
-    }))), t.registerBuiltinCommands !== !1 && this.registerBuiltinCommands(), this.initializeSchemaManager(), this.controller = new me({
+    }))), t.registerBuiltinCommands !== !1 && this.registerBuiltinCommands(), this.initializeSchemaManager(), this.controller = new ge({
       provider: this.provider,
       commandRegistry: this.commandRegistry,
       graph: this.graph,
@@ -2524,9 +2568,9 @@ class Z {
    */
   initializeSchemaManager() {
     if (this.graph) {
-      this.schemaManager = new ft(this.graph), this.schemaManager.extract(), this.debouncedSchemaUpdate = Y.debounce(() => {
+      this.schemaManager = new bt(this.graph), this.schemaManager.extract(), this.debouncedSchemaUpdate = ee.debounce(() => {
         this.schemaManager && this.schemaManager.invalidateCache();
-      }, yt);
+      }, wt);
       try {
         const { eventManager: e } = this.graph;
         this.dataAddedListenerId = e.addListener("data-added", () => {
@@ -2540,10 +2584,17 @@ class Z {
    * Register built-in commands for graph control.
    */
   registerBuiltinCommands() {
-    this.registerCommand(ye), this.registerCommand(be), this.registerCommand(Se), this.registerCommand(Ze), this.registerCommand(rt), this.registerCommand(_e), this.registerCommand(Oe), this.registerCommand(xe), this.registerCommand(Me), this.registerCommand(Ae), this.registerCommand(Le), this.registerCommand(je), this.registerCommand(ze), this.registerCommand(Ue), this.registerCommand(Fe);
+    this.registerCommand(we), this.registerCommand(Ce), this.registerCommand(xe), this.registerCommand(Qe), this.registerCommand(nt), this.registerCommand(Ge), this.registerCommand(We), this.registerCommand(Ee), this.registerCommand(Ae), this.registerCommand(Ne), this.registerCommand(Ue), this.registerCommand(qe), this.registerCommand(Ve), this.registerCommand(Oe), this.registerCommand(Ke);
   }
   /**
    * Register a custom command.
+   *
+   * Each assistant message is one undoable step. A command joins it by writing through
+   * `ctx.tx` (`ctx.tx.styles.add`, `ctx.tx.layout.set`, `ctx.tx.run`): those changes are undone
+   * with the rest of the message, and rolled back if a command throws. A change made through
+   * `ctx.graph` is a step of its own and is not rolled back. A command stops when
+   * `ctx.abortSignal` fires, which happens when the message is cancelled or undone while it is
+   * still going.
    * @param command - The command to register
    */
   registerCommand(e) {
@@ -2668,41 +2719,41 @@ class Z {
     }
   }
 }
-function vt() {
-  return new Z();
+function St() {
+  return new Q();
 }
-const Rt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const jt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  AiManager: Z,
-  createAiManager: vt
+  AiManager: Q,
+  createAiManager: St
 }, Symbol.toStringTag, { value: "Module" }));
 export {
-  me as A,
-  pe as C,
-  at as M,
-  O as S,
-  ot as V,
-  Z as a,
-  F as b,
-  ft as c,
-  ze as d,
-  vt as e,
-  lt as f,
-  it as g,
-  It as h,
-  rt as i,
-  je as j,
-  Le as k,
-  be as l,
-  nt as m,
-  _e as n,
-  Ue as o,
-  Me as p,
-  ye as q,
-  Oe as r,
-  Ze as s,
-  Ae as t,
-  xe as u,
-  Rt as v,
-  Fe as z
+  ge as A,
+  fe as C,
+  it as M,
+  W as S,
+  lt as V,
+  Q as a,
+  K as b,
+  bt as c,
+  Ve as d,
+  St as e,
+  dt as f,
+  ut as g,
+  Lt as h,
+  nt as i,
+  qe as j,
+  Ue as k,
+  Ce as l,
+  ct as m,
+  Ge as n,
+  Oe as o,
+  Ae as p,
+  we as q,
+  We as r,
+  Qe as s,
+  Ne as t,
+  Ee as u,
+  jt as v,
+  Ke as z
 };