@dpantani/tdmcp 0.1.0

package/dist/index.js

@@ -0,0 +1,4375 @@
+#!/usr/bin/env node
+
+// src/cli/installBridge.ts
+import { cpSync, existsSync as existsSync2 } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/utils/paths.ts
+import { existsSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+var moduleDir = dirname(fileURLToPath(import.meta.url));
+function firstExisting(candidates, fallback) {
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return fallback;
+}
+function knowledgeDataDir() {
+  return firstExisting(
+    [resolve(moduleDir, "../knowledge/data"), resolve(moduleDir, "knowledge/data")],
+    resolve(moduleDir, "../knowledge/data")
+  );
+}
+function recipesDir() {
+  return firstExisting(
+    [resolve(moduleDir, "../../recipes"), resolve(moduleDir, "recipes")],
+    resolve(moduleDir, "../../recipes")
+  );
+}
+function bridgeModulesDir() {
+  return firstExisting(
+    [resolve(moduleDir, "../td/modules"), resolve(moduleDir, "../../td/modules")],
+    resolve(moduleDir, "../td/modules")
+  );
+}
+function bottobotPackageDir() {
+  const candidates = [
+    resolve(moduleDir, "../../node_modules/@bottobot/td-mcp"),
+    resolve(moduleDir, "../node_modules/@bottobot/td-mcp"),
+    resolve(process.cwd(), "node_modules/@bottobot/td-mcp")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(resolve(candidate, "wiki/data/processed"))) return candidate;
+  }
+  return void 0;
+}
+
+// src/cli/installBridge.ts
+function runInstallBridge(args) {
+  const dirFlag = args.indexOf("--dir");
+  const explicitDir = dirFlag !== -1 ? args[dirFlag + 1] : void 0;
+  const targetRoot = explicitDir ?? join(homedir(), "tdmcp-bridge");
+  const dest = join(targetRoot, "modules");
+  const src = bridgeModulesDir();
+  if (!existsSync2(src)) {
+    console.error(
+      `[tdmcp] Could not find the bridge modules to copy (looked in ${src}).
+If you're running from source, build first with \`npm run build\`.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  cpSync(src, dest, { recursive: true });
+  const oneLiner = "from mcp import install; install.run()";
+  const noPrefs = `import sys; sys.path.insert(0, ${JSON.stringify(dest)})
+${oneLiner.replace("install.run()", `install.run(modules_dir=${JSON.stringify(dest)})`)}`;
+  console.log(
+    [
+      "",
+      "  tdmcp bridge installed.",
+      `  Modules copied to:  ${dest}`,
+      "",
+      "  Now switch the bridge on inside TouchDesigner:",
+      "",
+      "  1. Open Preferences (Edit > Preferences, or the TouchDesigner menu on macOS).",
+      '     In "Python 64-bit Module Path", add this folder:',
+      "",
+      `       ${dest}`,
+      "",
+      "  2. Open the Textport (Dialogs > Textport and DATs) and run:",
+      "",
+      `       ${oneLiner}`,
+      "",
+      "  You should see: [tdmcp] bridge running on port 9980 (/project1/tdmcp_bridge)",
+      "",
+      "  \u26A0 Security: the bridge runs arbitrary Python inside TouchDesigner and the",
+      "    Web Server DAT listens on all network interfaces with no auth. Only run it",
+      "    on a trusted network, or firewall port 9980 to localhost.",
+      "",
+      "  Prefer not to touch Preferences? Paste this in the Textport instead:",
+      "",
+      ...noPrefs.split("\n").map((line) => `       ${line}`),
+      ""
+    ].join("\n")
+  );
+}
+
+// src/server/tdmcpServer.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/prompts/debugNetwork.ts
+import { z } from "zod";
+
+// src/prompts/types.ts
+function userPrompt(text) {
+  return { messages: [{ role: "user", content: { type: "text", text } }] };
+}
+
+// src/prompts/debugNetwork.ts
+var registerDebugNetwork = (server) => {
+  server.registerPrompt(
+    "debug_network",
+    {
+      title: "Debug network",
+      description: "Systematically debug a TD network: check errors, verify connections, inspect cook times, and suggest fixes.",
+      argsSchema: { root_path: z.string().describe("Root path to debug from, e.g. /project1.") }
+    },
+    ({ root_path }) => userPrompt(
+      [
+        `Debug the TouchDesigner network under ${root_path}. Work step by step:`,
+        `1. Call get_td_node_errors with path "${root_path}" and recursive=true. List every error/warning.`,
+        `2. Call get_td_nodes for "${root_path}" to map the children, and get_td_node_parameters on any node that errored.`,
+        "3. For each error, explain the likely cause (missing input, bad parameter, unsupported operator, resolution mismatch) and the concrete fix.",
+        "4. Apply fixes with update_td_node_parameters or connect_nodes, then re-run get_td_node_errors to confirm.",
+        "5. Finish with get_preview on the output TOP to confirm it renders."
+      ].join("\n")
+    )
+  );
+};
+
+// src/prompts/explainNetwork.ts
+import { z as z2 } from "zod";
+var registerExplainNetwork = (server) => {
+  server.registerPrompt(
+    "explain_network",
+    {
+      title: "Explain network",
+      description: "Generate a human-readable explanation of what a TD network does: data flow, key parameters, and artistic intent.",
+      argsSchema: { root_path: z2.string().describe("Root path to explain, e.g. /project1.") }
+    },
+    ({ root_path }) => userPrompt(
+      [
+        `Explain the TouchDesigner network under ${root_path} for someone learning TouchDesigner.`,
+        `1. Call get_td_nodes for "${root_path}" and follow the connections to understand the data flow.`,
+        "2. Describe the signal path from input to output in plain language (what each stage does and why).",
+        "3. Call out the key parameters an artist would tweak and what visual effect they have.",
+        "4. Summarize the artistic intent \u2014 what the piece looks like and the technique it uses.",
+        "Keep it concise and friendly; avoid dumping raw parameter lists."
+      ].join("\n")
+    )
+  );
+};
+
+// src/prompts/optimizePerformance.ts
+import { z as z3 } from "zod";
+var registerOptimizePerformance = (server) => {
+  server.registerPrompt(
+    "optimize_performance",
+    {
+      title: "Optimize performance",
+      description: "Analyze a TD network for performance: identify bottlenecks, suggest resolution changes, and recommend cooking optimizations.",
+      argsSchema: { root_path: z3.string().describe("Root path to optimize, e.g. /project1.") }
+    },
+    ({ root_path }) => userPrompt(
+      [
+        `Optimize the TouchDesigner network under ${root_path} for real-time performance.`,
+        `1. Inspect cook times: read tdmcp://operators for any heavy operators and use get_td_node_parameters under "${root_path}".`,
+        "2. Identify the most expensive nodes and explain why (resolution too high, cooking every frame, large blurs/feedback, CPU SOPs).",
+        "3. Recommend concrete fixes: lower TOP resolution, use Null/Select for caching, reduce blur sizes, move CPU work to GPU, limit cook rate, bypass unused branches.",
+        "4. Apply the safe changes with update_td_node_parameters and report the expected FPS impact. Do not delete nodes unless asked."
+      ].join("\n")
+    )
+  );
+};
+
+// src/prompts/remixVisual.ts
+import { z as z4 } from "zod";
+var registerRemixVisual = (server) => {
+  server.registerPrompt(
+    "remix_visual",
+    {
+      title: "Remix visual",
+      description: "Take an existing visual system and create variations \u2014 change colors, swap techniques, add effects, alter timing.",
+      argsSchema: {
+        source_path: z4.string().describe("Path of the visual system to remix."),
+        remix_direction: z4.string().describe("What to change, e.g. 'make it darker', 'add glitch', 'slow it down'.")
+      }
+    },
+    ({ source_path, remix_direction }) => userPrompt(
+      [
+        `Remix the visual system at ${source_path}. Direction: "${remix_direction}".`,
+        `1. Inspect it first: get_td_nodes and get_td_node_parameters under "${source_path}" to understand the current setup.`,
+        "2. Plan changes that match the direction (palette via level/hsv_adjust, motion via transform/feedback gain, texture via added effects).",
+        "3. Prefer non-destructive edits: update parameters, or use apply_post_processing to add effects after the output. Do not delete the original unless asked.",
+        "4. After editing, run get_td_node_errors and get_preview to show the remixed result, and describe what changed."
+      ].join("\n")
+    )
+  );
+};
+
+// src/prompts/visualArtistMode.ts
+import { z as z5 } from "zod";
+var registerVisualArtistMode = (server, ctx) => {
+  server.registerPrompt(
+    "visual_artist_mode",
+    {
+      title: "Visual artist mode",
+      description: "Think in terms of visual composition, color, motion and aesthetics rather than code while building in TouchDesigner.",
+      argsSchema: {
+        style: z5.string().optional().describe("Artistic style: abstract, geometric, organic, glitch, minimal, maximal.")
+      }
+    },
+    ({ style }) => {
+      const recipes = ctx.recipes.list().map((r) => r.id).join(", ");
+      return userPrompt(
+        [
+          "You are in Visual Artist Mode for TouchDesigner via the tdmcp server.",
+          "Think like a VJ / installation artist \u2014 composition, color, motion, rhythm, negative space \u2014 not code.",
+          "",
+          "Working method:",
+          "1. Prefer high-level tools: create_visual_system (from a description) or create_feedback_network / create_generative_art / create_audio_reactive / create_particle_system.",
+          "2. Before creating nodes, consult the knowledge resources: tdmcp://operators/{category|name} and tdmcp://recipes/{name}. Never invent operator types.",
+          "3. Build inside a new container; keep the project tidy.",
+          "4. After building, run get_td_node_errors, then get_preview so we can SEE the result, and iterate on the aesthetics.",
+          `Available recipes: ${recipes || "(none yet)"}.`,
+          style ? `
+Lean into a "${style}" aesthetic in your choices.` : ""
+        ].join("\n")
+      );
+    }
+  );
+};
+
+// src/prompts/index.ts
+function registerAllPrompts(server, ctx) {
+  registerVisualArtistMode(server, ctx);
+  registerDebugNetwork(server, ctx);
+  registerOptimizePerformance(server, ctx);
+  registerExplainNetwork(server, ctx);
+  registerRemixVisual(server, ctx);
+}
+
+// src/resources/glslPatternResource.ts
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/resources/shared.ts
+function firstVar(value) {
+  if (Array.isArray(value)) return value[0] ?? "";
+  return value ?? "";
+}
+function jsonContents(uri, data) {
+  return {
+    contents: [
+      { uri: uri.href, mimeType: "application/json", text: JSON.stringify(data, null, 2) }
+    ]
+  };
+}
+
+// src/resources/glslPatternResource.ts
+var registerGlslPatternResource = (server, ctx) => {
+  const template = new ResourceTemplate("tdmcp://glsl/{pattern_name}", {
+    list: async () => ({
+      resources: ctx.knowledge.listGlslPatterns().map((pattern) => ({
+        uri: `tdmcp://glsl/${pattern.id}`,
+        name: pattern.name,
+        description: `${pattern.difficulty} \u2014 ${pattern.description}`,
+        mimeType: "application/json"
+      }))
+    })
+  });
+  server.registerResource(
+    "td-glsl",
+    template,
+    {
+      title: "GLSL shader patterns",
+      description: "Named GLSL shader techniques with ready-to-use fragment shader snippets.",
+      mimeType: "application/json"
+    },
+    async (uri, variables) => {
+      const name = firstVar(variables.pattern_name);
+      const pattern = ctx.knowledge.getGlslPattern(name);
+      if (!pattern) return jsonContents(uri, { error: `GLSL pattern "${name}" not found.` });
+      return jsonContents(uri, pattern);
+    }
+  );
+};
+
+// src/resources/operatorResource.ts
+import { ResourceTemplate as ResourceTemplate2 } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/knowledge/normalize.ts
+function slugify(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function compactKey(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function toOperatorSummary(slug, doc) {
+  return {
+    slug,
+    name: doc.name,
+    displayName: doc.displayName ?? doc.name,
+    category: doc.category ?? "Unknown",
+    subcategory: doc.subcategory ?? "",
+    summary: doc.summary ?? doc.description ?? "",
+    keywords: doc.keywords ?? []
+  };
+}
+function toPythonSummary(cls) {
+  return {
+    className: cls.className,
+    displayName: cls.displayName ?? cls.className,
+    category: cls.category ?? "Unknown",
+    methodCount: cls.methods?.length ?? 0,
+    memberCount: cls.members?.length ?? 0
+  };
+}
+function toTutorialSummary(tut) {
+  return {
+    id: tut.id,
+    name: tut.name,
+    category: tut.category ?? "Unknown",
+    summary: tut.summary ?? tut.description ?? ""
+  };
+}
+function normalizePatterns(raw) {
+  let list = [];
+  if (Array.isArray(raw)) {
+    list = raw;
+  } else if (raw && typeof raw === "object") {
+    const obj = raw;
+    if (Array.isArray(obj.patterns)) {
+      list = obj.patterns;
+    } else {
+      list = Object.values(obj).filter((v) => !!v && typeof v === "object");
+    }
+  }
+  return list.filter((p) => typeof p.name === "string").map((p) => ({
+    id: slugify(p.name),
+    name: p.name,
+    description: p.description,
+    category: p.category,
+    workflow: Array.isArray(p.workflow) ? p.workflow : void 0,
+    use_case: p.use_case
+  }));
+}
+function normalizeGlsl(raw) {
+  const file = raw ?? {};
+  const techniques = Array.isArray(file.techniques) ? file.techniques : [];
+  return techniques.filter((t) => !!t && typeof t === "object").map((t) => {
+    const name = typeof t.name === "string" ? t.name : "Untitled";
+    const id = typeof t.id === "string" && t.id.length > 0 ? t.id : slugify(name);
+    return {
+      id,
+      name,
+      subcategory: typeof t.subcategory === "string" ? t.subcategory : void 0,
+      description: typeof t.description === "string" ? t.description : void 0,
+      difficulty: typeof t.difficulty === "string" ? t.difficulty : void 0,
+      operators: Array.isArray(t.operators) ? t.operators : void 0,
+      tags: Array.isArray(t.tags) ? t.tags : void 0,
+      notes: typeof t.notes === "string" ? t.notes : void 0,
+      code: t.code ?? void 0,
+      setup: typeof t.setup === "string" ? t.setup : void 0
+    };
+  });
+}
+
+// src/resources/operatorResource.ts
+var registerOperatorResource = (server, ctx) => {
+  const template = new ResourceTemplate2("tdmcp://operators/{name}", {
+    list: async () => ({
+      resources: ctx.knowledge.listOperatorCategories().map((category) => ({
+        uri: `tdmcp://operators/${category}`,
+        name: `Operators: ${category}`,
+        description: `All ${category} operators`,
+        mimeType: "application/json"
+      }))
+    }),
+    complete: {
+      name: async (value) => {
+        const categories = ctx.knowledge.listOperatorCategories();
+        const operators = ctx.knowledge.searchOperators(value, 20).map((o) => o.slug);
+        return [...categories, ...operators].slice(0, 50);
+      }
+    }
+  });
+  server.registerResource(
+    "td-operators",
+    template,
+    {
+      title: "TouchDesigner operators",
+      description: "Operator catalog. Read a category (TOP, CHOP, SOP, DAT, COMP, MAT, POP) to list its operators, or an operator name/slug for full documentation.",
+      mimeType: "application/json"
+    },
+    async (uri, variables) => {
+      const name = firstVar(variables.name);
+      const isCategory = ctx.knowledge.listOperatorCategories().some((category) => compactKey(category) === compactKey(name));
+      if (isCategory) {
+        const operators = ctx.knowledge.listOperators(name);
+        return jsonContents(uri, { category: name, count: operators.length, operators });
+      }
+      const doc = ctx.knowledge.getOperator(name);
+      if (!doc) {
+        const suggestions = ctx.knowledge.searchOperators(name, 5).map((o) => o.name);
+        return jsonContents(uri, { error: `Operator "${name}" not found.`, suggestions });
+      }
+      return jsonContents(uri, doc);
+    }
+  );
+};
+
+// src/resources/patternResource.ts
+import { ResourceTemplate as ResourceTemplate3 } from "@modelcontextprotocol/sdk/server/mcp.js";
+var registerPatternResource = (server, ctx) => {
+  const template = new ResourceTemplate3("tdmcp://patterns/{pattern_name}", {
+    list: async () => ({
+      resources: ctx.knowledge.listPatterns().map((pattern) => ({
+        uri: `tdmcp://patterns/${pattern.id}`,
+        name: pattern.name,
+        description: pattern.description,
+        mimeType: "application/json"
+      }))
+    })
+  });
+  server.registerResource(
+    "td-patterns",
+    template,
+    {
+      title: "TouchDesigner workflow patterns",
+      description: "Named operator-chain workflow patterns (recommended wiring for common tasks).",
+      mimeType: "application/json"
+    },
+    async (uri, variables) => {
+      const name = firstVar(variables.pattern_name);
+      const pattern = ctx.knowledge.getPattern(name);
+      if (!pattern) return jsonContents(uri, { error: `Pattern "${name}" not found.` });
+      return jsonContents(uri, pattern);
+    }
+  );
+};
+
+// src/resources/pythonApiResource.ts
+import { ResourceTemplate as ResourceTemplate4 } from "@modelcontextprotocol/sdk/server/mcp.js";
+var registerPythonApiResource = (server, ctx) => {
+  const template = new ResourceTemplate4("tdmcp://python-api/{class_name}", {
+    list: async () => ({
+      resources: ctx.knowledge.listPythonClasses().map((cls) => ({
+        uri: `tdmcp://python-api/${cls.className}`,
+        name: `Python: ${cls.className}`,
+        description: `${cls.methodCount} methods, ${cls.memberCount} members`,
+        mimeType: "application/json"
+      }))
+    }),
+    complete: {
+      class_name: async (value) => ctx.knowledge.listPythonClasses().map((c) => c.className).filter((n) => n.toLowerCase().includes(value.toLowerCase())).slice(0, 50)
+    }
+  });
+  server.registerResource(
+    "td-python-api",
+    template,
+    {
+      title: "TouchDesigner Python API",
+      description: "Python class reference (members + methods) for the TouchDesigner API.",
+      mimeType: "application/json"
+    },
+    async (uri, variables) => {
+      const className = firstVar(variables.class_name);
+      const cls = ctx.knowledge.getPythonClass(className);
+      if (!cls) return jsonContents(uri, { error: `Python class "${className}" not found.` });
+      return jsonContents(uri, cls);
+    }
+  );
+};
+
+// src/resources/recipeResource.ts
+import { ResourceTemplate as ResourceTemplate5 } from "@modelcontextprotocol/sdk/server/mcp.js";
+var registerRecipeResource = (server, ctx) => {
+  const template = new ResourceTemplate5("tdmcp://recipes/{recipe_name}", {
+    list: async () => ({
+      resources: ctx.recipes.list().map((recipe) => ({
+        uri: `tdmcp://recipes/${recipe.id}`,
+        name: recipe.name,
+        description: `${recipe.difficulty} \u2014 ${recipe.description}`,
+        mimeType: "application/json"
+      }))
+    })
+  });
+  server.registerResource(
+    "td-recipes",
+    template,
+    {
+      title: "Composite network recipes",
+      description: "Pre-validated composite network templates (nodes + connections + parameters).",
+      mimeType: "application/json"
+    },
+    async (uri, variables) => {
+      const name = firstVar(variables.recipe_name);
+      const recipe = ctx.recipes.get(name);
+      if (!recipe) {
+        return jsonContents(uri, {
+          error: `Recipe "${name}" not found.`,
+          available: ctx.recipes.list().map((r) => r.id)
+        });
+      }
+      return jsonContents(uri, recipe);
+    }
+  );
+};
+
+// src/resources/tutorialResource.ts
+import { ResourceTemplate as ResourceTemplate6 } from "@modelcontextprotocol/sdk/server/mcp.js";
+var registerTutorialResource = (server, ctx) => {
+  const template = new ResourceTemplate6("tdmcp://tutorials/{tutorial_name}", {
+    list: async () => ({
+      resources: ctx.knowledge.listTutorials().map((tutorial) => ({
+        uri: `tdmcp://tutorials/${tutorial.id}`,
+        name: tutorial.name,
+        description: tutorial.summary,
+        mimeType: "application/json"
+      }))
+    })
+  });
+  server.registerResource(
+    "td-tutorials",
+    template,
+    {
+      title: "TouchDesigner tutorials",
+      description: "Long-form tutorial content covering TD fundamentals and workflows.",
+      mimeType: "application/json"
+    },
+    async (uri, variables) => {
+      const name = firstVar(variables.tutorial_name);
+      const tutorial = ctx.knowledge.getTutorial(name);
+      if (!tutorial) return jsonContents(uri, { error: `Tutorial "${name}" not found.` });
+      return jsonContents(uri, tutorial);
+    }
+  );
+};
+
+// src/resources/index.ts
+function registerAllResources(server, ctx) {
+  registerOperatorResource(server, ctx);
+  registerPythonApiResource(server, ctx);
+  registerPatternResource(server, ctx);
+  registerGlslPatternResource(server, ctx);
+  registerRecipeResource(server, ctx);
+  registerTutorialResource(server, ctx);
+}
+
+// src/tools/layer1/applyPostProcessing.ts
+import { z as z6 } from "zod";
+
+// src/feedback/errorChecker.ts
+async function checkErrors(client, path, recursive = true) {
+  const result = recursive ? await client.getNetworkErrors(path) : await client.getNodeErrors(path);
+  return { path, hasErrors: result.errors.length > 0, errors: result.errors };
+}
+
+// src/feedback/previewCapture.ts
+async function capturePreview(client, path, width = 640, height = 360) {
+  const preview = await client.getPreview(path, width, height);
+  return {
+    path: preview.path,
+    width: preview.width,
+    height: preview.height,
+    base64: preview.base64,
+    mimeType: `image/${preview.format || "png"}`
+  };
+}
+
+// src/td-client/types.ts
+var TdError = class extends Error {
+  code;
+  constructor(message, code, options) {
+    super(message, options);
+    this.name = "TdError";
+    this.code = code;
+  }
+};
+var TdConnectionError = class extends TdError {
+  constructor(message, options) {
+    super(message, "TD_CONNECTION", options);
+    this.name = "TdConnectionError";
+  }
+};
+var TdTimeoutError = class extends TdError {
+  constructor(message, options) {
+    super(message, "TD_TIMEOUT", options);
+    this.name = "TdTimeoutError";
+  }
+};
+var TdApiError = class extends TdError {
+  status;
+  apiCode;
+  constructor(message, options) {
+    super(message, "TD_API", options);
+    this.name = "TdApiError";
+    this.status = options?.status;
+    this.apiCode = options?.apiCode;
+  }
+};
+function friendlyTdError(err) {
+  if (err instanceof TdError) return err.message;
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+
+// src/tools/layer2/connectHelper.ts
+async function connectNodesViaBridge(client, sourcePath, targetPath, sourceOutput = 0, targetInput = 0) {
+  try {
+    const result = await client.batch([
+      {
+        action: "connect",
+        source_path: sourcePath,
+        target_path: targetPath,
+        source_output: sourceOutput,
+        target_input: targetInput
+      }
+    ]);
+    if (result.results[0]?.ok) return { method: "batch" };
+  } catch (err) {
+    if (!(err instanceof TdApiError)) throw err;
+  }
+  const src = JSON.stringify(sourcePath);
+  const dst = JSON.stringify(targetPath);
+  const python = `op(${dst}).inputConnectors[${targetInput}].connect(op(${src}).outputConnectors[${sourceOutput}])`;
+  await client.executePythonScript(python, false);
+  return { method: "python" };
+}
+
+// src/tools/result.ts
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+function errorResult(message) {
+  return { isError: true, content: [{ type: "text", text: message }] };
+}
+function jsonResult(summary, data) {
+  const text = `${summary}
+
+\`\`\`json
+${JSON.stringify(data, null, 2)}
+\`\`\``;
+  return { content: [{ type: "text", text }] };
+}
+function structuredResult(summary, data) {
+  return {
+    content: [{ type: "text", text: summary }],
+    structuredContent: data
+  };
+}
+function imageResult(base64, mimeType = "image/png", caption) {
+  const content = [];
+  if (caption) content.push({ type: "text", text: caption });
+  content.push({ type: "image", data: base64, mimeType });
+  return { content };
+}
+async function guardTd(fn, onOk) {
+  try {
+    return onOk(await fn());
+  } catch (err) {
+    return errorResult(friendlyTdError(err));
+  }
+}
+
+// src/tools/layer1/orchestration.ts
+var q = (value) => JSON.stringify(value);
+var UNIFORM_KINDS = {
+  float: { seq: "vec", fields: ["valuex"] },
+  vec: { seq: "vec", fields: ["valuex", "valuey", "valuez", "valuew"] },
+  color: { seq: "color", fields: ["rgbr", "rgbg", "rgbb", "alpha"] }
+};
+function groupUniforms(uniforms) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const uniform of uniforms) {
+    const { seq } = UNIFORM_KINDS[uniform.kind];
+    const key = `${uniform.node} ${seq}`;
+    let group = groups.get(key);
+    if (!group) {
+      group = { node: uniform.node, seq, items: [] };
+      groups.set(key, group);
+    }
+    group.items.push(uniform);
+  }
+  return [...groups.values()];
+}
+function converterSourceParam(type) {
+  const match = /^(chop|dat|top|sop)to/i.exec(type);
+  return match?.[1]?.toLowerCase();
+}
+async function runBuild(fn) {
+  try {
+    return await fn();
+  } catch (err) {
+    return errorResult(friendlyTdError(err));
+  }
+}
+var NetworkBuilder = class {
+  constructor(ctx, containerPath) {
+    this.ctx = ctx;
+    this.containerPath = containerPath;
+  }
+  ctx;
+  containerPath;
+  created = [];
+  warnings = [];
+  nameToPath = /* @__PURE__ */ new Map();
+  pathToType = /* @__PURE__ */ new Map();
+  async add(type, name, parameters, parentPath) {
+    const ref = await this.ctx.client.createNode({
+      parent_path: parentPath ?? this.containerPath,
+      type,
+      name,
+      parameters
+    });
+    if (name) this.nameToPath.set(name, ref.path);
+    if (ref.name) this.nameToPath.set(ref.name, ref.path);
+    this.pathToType.set(ref.path, ref.type || type);
+    this.created.push({ name: ref.name || name || "", path: ref.path, type: ref.type || type });
+    if (/geometrycomp/i.test(type)) {
+      await this.python(`_g = op(${q(ref.path)})
+for _c in list(_g.children):
+    _c.destroy()`);
+    }
+    return ref.path;
+  }
+  pathOf(name) {
+    return this.nameToPath.get(name);
+  }
+  async connect(fromPath, toPath, fromOutput = 0, toInput = 0) {
+    const targetType = this.pathToType.get(toPath);
+    const param = targetType ? converterSourceParam(targetType) : void 0;
+    if (param) {
+      await this.setParams(toPath, { [param]: fromPath });
+      return;
+    }
+    try {
+      await connectNodesViaBridge(this.ctx.client, fromPath, toPath, fromOutput, toInput);
+    } catch (err) {
+      this.warnings.push(`Failed to connect ${fromPath} \u2192 ${toPath}: ${friendlyTdError(err)}`);
+    }
+  }
+  async setParams(path, parameters) {
+    try {
+      await this.ctx.client.updateNodeParameters(path, parameters);
+    } catch (err) {
+      this.warnings.push(`Failed to set parameters on ${path}: ${friendlyTdError(err)}`);
+    }
+  }
+  async python(code) {
+    try {
+      await this.ctx.client.executePythonScript(code, false);
+    } catch (err) {
+      this.warnings.push(`Python step failed: ${friendlyTdError(err)}`);
+    }
+  }
+};
+async function createSystemContainer(ctx, parentPath, name) {
+  const container = await ctx.client.createNode({
+    parent_path: parentPath,
+    type: "baseCOMP",
+    name
+  });
+  return new NetworkBuilder(ctx, container.path);
+}
+async function buildFromRecipe(ctx, recipe, parentPath) {
+  const builder = await createSystemContainer(ctx, parentPath, recipe.id);
+  for (const node of recipe.nodes) {
+    let parentPath2;
+    if (node.parent) {
+      parentPath2 = builder.pathOf(node.parent);
+      if (!parentPath2) {
+        builder.warnings.push(
+          `Node "${node.name}" references unknown parent "${node.parent}" (it must appear earlier in nodes).`
+        );
+      }
+    }
+    await builder.add(node.type, node.name, node.parameters, parentPath2);
+  }
+  if (recipe.glsl_code) {
+    for (const [nodeName, code] of Object.entries(recipe.glsl_code)) {
+      const target = builder.pathOf(nodeName);
+      if (!target) {
+        builder.warnings.push(`glsl_code references unknown node "${nodeName}".`);
+        continue;
+      }
+      const fragPath = await builder.add("textDAT", `${nodeName}_frag`);
+      await builder.python(
+        `op(${q(fragPath)}).text = ${q(code)}
+op(${q(target)}).par.pixeldat = op(${q(fragPath)}).name`
+      );
+    }
+  }
+  for (const group of groupUniforms(recipe.glsl_uniforms)) {
+    const target = builder.pathOf(group.node);
+    if (!target) {
+      builder.warnings.push(`glsl_uniforms references unknown node "${group.node}".`);
+      continue;
+    }
+    await builder.python(
+      `_seq = op(${q(target)}).seq.${group.seq}
+_seq.numBlocks = max(_seq.numBlocks, ${group.items.length})`
+    );
+    for (const [i, uniform] of group.items.entries()) {
+      const { fields } = UNIFORM_KINDS[uniform.kind];
+      const params = { [`${group.seq}${i}name`]: uniform.name };
+      const values = Array.isArray(uniform.value) ? uniform.value : uniform.value === void 0 ? [] : [uniform.value];
+      for (const [j, field] of fields.entries()) {
+        const value = values[j];
+        if (value !== void 0) params[`${group.seq}${i}${field}`] = value;
+      }
+      await builder.setParams(target, params);
+    }
+  }
+  if (recipe.python_code) {
+    for (const [nodeName, code] of Object.entries(recipe.python_code)) {
+      const target = builder.pathOf(nodeName);
+      if (!target) {
+        builder.warnings.push(`python_code references unknown node "${nodeName}".`);
+        continue;
+      }
+      await builder.python(`op(${q(target)}).text = ${q(code)}`);
+    }
+  }
+  for (const param of recipe.parameters) {
+    const target = builder.pathOf(param.node);
+    if (!target) {
+      builder.warnings.push(`Parameter "${param.name}" references unknown node "${param.node}".`);
+      continue;
+    }
+    if (param.value === void 0) continue;
+    let value = param.value;
+    if (typeof value === "string") {
+      const referenced = builder.pathOf(value);
+      if (referenced) value = referenced;
+    }
+    await builder.setParams(target, { [param.param]: value });
+  }
+  for (const connection of recipe.connections) {
+    const from = builder.pathOf(connection.from);
+    const to = builder.pathOf(connection.to);
+    if (!from || !to) {
+      builder.warnings.push(
+        `Connection ${connection.from} \u2192 ${connection.to} references an unknown node.`
+      );
+      continue;
+    }
+    await builder.connect(from, to, connection.from_output, connection.to_input);
+  }
+  for (const node of recipe.nodes) {
+    if (!node.render) continue;
+    const target = builder.pathOf(node.name);
+    if (!target) continue;
+    await builder.python(
+      `_n = op(${q(target)})
+_p = _n.parent()
+for _c in _p.children:
+    _c.render = False
+    _c.display = False
+_n.render = True
+_n.display = True`
+    );
+  }
+  const outNode = recipe.nodes.find((n) => /^out/i.test(n.name)) ?? recipe.nodes[recipe.nodes.length - 1];
+  const outputPath = outNode ? builder.pathOf(outNode.name) : void 0;
+  return { builder, outputPath };
+}
+async function finalize(ctx, options) {
+  const { builder } = options;
+  const warnings = [...builder.warnings];
+  let errors = [];
+  try {
+    const report = await checkErrors(ctx.client, builder.containerPath);
+    errors = report.errors;
+    if (report.hasErrors)
+      warnings.push(`${report.errors.length} node error(s) detected after build.`);
+  } catch (err) {
+    warnings.push(`Error check unavailable: ${friendlyTdError(err)}`);
+  }
+  let previewBase64;
+  let previewMime;
+  if (options.capturePreviewImage !== false && options.outputPath) {
+    try {
+      const preview = await capturePreview(ctx.client, options.outputPath);
+      previewBase64 = preview.base64;
+      previewMime = preview.mimeType;
+    } catch (err) {
+      warnings.push(`Preview unavailable: ${friendlyTdError(err)}`);
+    }
+  }
+  const data = {
+    container: builder.containerPath,
+    created: builder.created.map((c) => c.path),
+    output: options.outputPath,
+    recipe: options.recipeId,
+    errors,
+    warnings,
+    ...options.extra
+  };
+  const content = [
+    {
+      type: "text",
+      text: `${options.summary}
+
+\`\`\`json
+${JSON.stringify(data, null, 2)}
+\`\`\``
+    }
+  ];
+  if (previewBase64) {
+    content.push({ type: "image", data: previewBase64, mimeType: previewMime ?? "image/png" });
+  }
+  return { content };
+}
+
+// src/tools/layer1/applyPostProcessing.ts
+var q2 = (value) => JSON.stringify(value);
+var DIRECT_EFFECTS = {
+  bloom: { type: "bloomTOP" },
+  blur: { type: "blurTOP", parameters: { size: 4 } },
+  edge_detect: { type: "edgeTOP" },
+  sharpen: { type: "sharpenTOP" },
+  threshold: { type: "thresholdTOP", parameters: { threshold: 0.5 } },
+  invert: { type: "levelTOP", parameters: { invert: 1 } },
+  color_grade: { type: "levelTOP", parameters: { gamma1: 1.1, blacklevel: 0.02 } }
+};
+var GLSL_EFFECTS = {
+  rgb_split: `out vec4 fragColor;
+void main(){ vec2 uv=vUV.st; vec2 o=vec2(0.004,0.0);
+  float r=texture(sTD2DInputs[0],uv+o).r; float g=texture(sTD2DInputs[0],uv).g; float b=texture(sTD2DInputs[0],uv-o).b;
+  fragColor=TDOutputSwizzle(vec4(r,g,b,1.0)); }
+`,
+  chromatic_aberration: `out vec4 fragColor;
+void main(){ vec2 uv=vUV.st; vec2 o=(uv-0.5)*0.02;
+  float r=texture(sTD2DInputs[0],uv+o).r; float g=texture(sTD2DInputs[0],uv).g; float b=texture(sTD2DInputs[0],uv-o).b;
+  fragColor=TDOutputSwizzle(vec4(r,g,b,1.0)); }
+`,
+  scanlines: `out vec4 fragColor;
+void main(){ vec2 uv=vUV.st; vec4 c=texture(sTD2DInputs[0],uv);
+  float s=0.85+0.15*step(0.5,fract(uv.y*uTD2DInfos[0].res.w*0.5));
+  fragColor=TDOutputSwizzle(vec4(c.rgb*s,c.a)); }
+`,
+  vignette: `out vec4 fragColor;
+void main(){ vec2 uv=vUV.st; vec4 c=texture(sTD2DInputs[0],uv);
+  float v=smoothstep(0.8,0.35,distance(uv,vec2(0.5)));
+  fragColor=TDOutputSwizzle(vec4(c.rgb*v,c.a)); }
+`,
+  posterize: `out vec4 fragColor;
+void main(){ vec2 uv=vUV.st; vec4 c=texture(sTD2DInputs[0],uv);
+  vec3 p=floor(c.rgb*6.0)/6.0; fragColor=TDOutputSwizzle(vec4(p,c.a)); }
+`,
+  film_grain: `out vec4 fragColor;
+float hash(vec2 p){return fract(sin(dot(p,vec2(12.9898,78.233)))*43758.5453);}
+void main(){ vec2 uv=vUV.st; vec4 c=texture(sTD2DInputs[0],uv);
+  float g=hash(uv*uTD2DInfos[0].res.zw)*0.12-0.06; fragColor=TDOutputSwizzle(vec4(c.rgb+g,c.a)); }
+`,
+  glitch: `out vec4 fragColor;
+float hash(float x){return fract(sin(x*127.1)*43758.5453);}
+void main(){ vec2 uv=vUV.st; float band=floor(uv.y*24.0);
+  float off=(hash(band)-0.5)*0.06*step(0.7,hash(band*1.7));
+  fragColor=TDOutputSwizzle(texture(sTD2DInputs[0],uv+vec2(off,0.0))); }
+`
+};
+var EFFECTS = [
+  "bloom",
+  "chromatic_aberration",
+  "film_grain",
+  "vignette",
+  "color_grade",
+  "sharpen",
+  "blur",
+  "edge_detect",
+  "invert",
+  "threshold",
+  "posterize",
+  "glitch",
+  "rgb_split",
+  "scanlines"
+];
+var applyPostProcessingSchema = z6.object({
+  source_path: z6.string().describe("Path of the TOP to post-process."),
+  effects: z6.array(z6.enum(EFFECTS)).min(1).describe("Effects to apply in order."),
+  parent_path: z6.string().default("/project1")
+});
+async function addGlslEffect(builder, name, fragment) {
+  const glsl = await builder.add("glslTOP", name);
+  const frag = await builder.add("textDAT", `${name}_frag`);
+  await builder.python(
+    `op(${q2(frag)}).text = ${q2(fragment)}
+op(${q2(glsl)}).par.pixeldat = op(${q2(frag)}).name`
+  );
+  return glsl;
+}
+async function applyPostProcessingImpl(ctx, args) {
+  return runBuild(async () => {
+    const builder = await createSystemContainer(ctx, args.parent_path, "post_fx");
+    const source = await builder.add("selectTOP", "source");
+    await builder.setParams(source, { top: args.source_path });
+    let previous = source;
+    let applied = 0;
+    for (let i = 0; i < args.effects.length; i++) {
+      const effect = args.effects[i];
+      if (!effect) continue;
+      let nodePath;
+      const direct = DIRECT_EFFECTS[effect];
+      if (direct) {
+        nodePath = await builder.add(direct.type, `${effect}${i}`, direct.parameters);
+      } else if (GLSL_EFFECTS[effect]) {
+        nodePath = await addGlslEffect(builder, `${effect}${i}`, GLSL_EFFECTS[effect]);
+      }
+      if (!nodePath) {
+        builder.warnings.push(`Effect "${effect}" is not supported and was skipped.`);
+        continue;
+      }
+      await builder.connect(previous, nodePath);
+      previous = nodePath;
+      applied++;
+    }
+    const out = await builder.add("nullTOP", "out1");
+    await builder.connect(previous, out);
+    return finalize(ctx, {
+      summary: `Applied ${applied}/${args.effects.length} post-processing effect(s) to ${args.source_path}.`,
+      builder,
+      outputPath: out,
+      extra: { source_path: args.source_path, effects: args.effects }
+    });
+  });
+}
+var registerApplyPostProcessing = (server, ctx) => {
+  server.registerTool(
+    "apply_post_processing",
+    {
+      title: "Apply post-processing",
+      description: "Chain post-processing effects (bloom, glitch, rgb_split, vignette, etc.) onto an existing TOP. Returns the processed output.",
+      inputSchema: applyPostProcessingSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => applyPostProcessingImpl(ctx, args)
+  );
+};
+
+// src/tools/layer1/createAudioReactive.ts
+import { z as z7 } from "zod";
+var q3 = (value) => JSON.stringify(value);
+var AUDIO_SPECTRUM_SHADER = `out vec4 fragColor;
+void main(){
+    vec2 uv = vUV.st;
+    float amp = texture(sTD2DInputs[0], vec2(uv.x, 0.5)).r;
+    float bar = step(uv.y, clamp(amp, 0.0, 1.0));
+    vec3 col = mix(vec3(0.02, 0.0, 0.08), vec3(0.1, 0.8, 1.0), uv.x) * bar;
+    fragColor = TDOutputSwizzle(vec4(col, 1.0));
+}
+`;
+var createAudioReactiveSchema = z7.object({
+  audio_source: z7.enum(["microphone", "file", "device_in", "existing_chop"]).default("microphone"),
+  audio_file_path: z7.string().optional().describe("Audio file path (audio_source='file')."),
+  existing_chop_path: z7.string().optional().describe("Existing CHOP path (audio_source='existing_chop')."),
+  visual_style: z7.enum(["geometric", "particle", "feedback", "glsl", "instancing"]),
+  frequency_bands: z7.number().int().positive().default(8).describe(
+    "Spectrum resolution: sets the Audio Spectrum CHOP output length (TouchDesigner clamps it to 128\u20134096 bins). Higher = finer spectrum."
+  ),
+  beat_detection: z7.boolean().default(true),
+  parent_path: z7.string().default("/project1")
+});
+async function buildAudioSource(builder, args) {
+  if (args.audio_source === "existing_chop" && args.existing_chop_path) {
+    return args.existing_chop_path;
+  }
+  if (args.audio_source === "file") {
+    return builder.add("audiofileinCHOP", "audioin", {
+      ...args.audio_file_path ? { file: args.audio_file_path } : {},
+      play: 1
+    });
+  }
+  return builder.add("audiodeviceinCHOP", "audioin");
+}
+async function createAudioReactiveImpl(ctx, args) {
+  return runBuild(async () => {
+    const builder = await createSystemContainer(ctx, args.parent_path, "audio_reactive");
+    const audioSource = await buildAudioSource(builder, args);
+    const outLength = Math.min(Math.max(args.frequency_bands, 128), 4096);
+    const spectrum = await builder.add("audiospectrumCHOP", "spectrum", {
+      outputmenu: "setmanually",
+      outlength: outLength
+    });
+    await builder.connect(audioSource, spectrum);
+    const analyze = await builder.add("analyzeCHOP", "level", { function: 6 });
+    await builder.connect(audioSource, analyze);
+    if (args.beat_detection) {
+      const beat = await builder.add("beatCHOP", "beat");
+      await builder.connect(audioSource, beat);
+    }
+    const audioTex = await builder.add("choptoTOP", "audio_tex");
+    await builder.connect(spectrum, audioTex);
+    let visual;
+    if (args.visual_style === "glsl") {
+      visual = await builder.add("glslTOP", "visual", {
+        outputresolution: "custom",
+        resolutionw: 1280,
+        resolutionh: 720,
+        format: "rgba8fixed"
+      });
+      const frag = await builder.add("textDAT", "visual_frag");
+      await builder.python(
+        `op(${q3(frag)}).text = ${q3(AUDIO_SPECTRUM_SHADER)}
+op(${q3(visual)}).par.pixeldat = op(${q3(frag)}).name`
+      );
+      await builder.connect(audioTex, visual);
+    } else {
+      visual = await builder.add("circleTOP", "visual", { radius: 0.3 });
+      await builder.python(
+        `c = op(${q3(visual)})
+for p in ('radiusx', 'radiusy'):
+    try:
+        par = getattr(c.par, p)
+        par.expr = "0.2 + op('level')['chan1'] * 0.6"
+    except Exception: pass`
+      );
+      builder.warnings.push(
+        `Visual style "${args.visual_style}" is approximated: a circle driven by the audio level. Refine the mapping for production.`
+      );
+    }
+    const out = await builder.add("nullTOP", "out1");
+    await builder.connect(visual, out);
+    return finalize(ctx, {
+      summary: `Created an audio-reactive system (source: ${args.audio_source}, style: ${args.visual_style}, ${args.frequency_bands} bands).`,
+      builder,
+      outputPath: out,
+      extra: {
+        audio_source: args.audio_source,
+        visual_style: args.visual_style,
+        beat_detection: args.beat_detection
+      }
+    });
+  });
+}
+var registerCreateAudioReactive = (server, ctx) => {
+  server.registerTool(
+    "create_audio_reactive",
+    {
+      title: "Create audio-reactive visual",
+      description: "Build an audio analysis chain (spectrum + level + optional beat) and a visual driven by it. The 'glsl' style renders a spectrum visualization; other styles are approximated.",
+      inputSchema: createAudioReactiveSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => createAudioReactiveImpl(ctx, args)
+  );
+};
+
+// src/tools/layer1/createDataVisualization.ts
+import { z as z8 } from "zod";
+var q4 = (value) => JSON.stringify(value);
+var BARS_SHADER = `out vec4 fragColor;
+void main(){
+    vec2 uv = vUV.st;
+    float v = texture(sTD2DInputs[0], vec2(uv.x, 0.5)).r;
+    float bar = step(uv.y, clamp(v, 0.0, 1.0));
+    vec3 col = mix(vec3(0.03, 0.05, 0.1), vec3(0.2, 0.9, 0.6), uv.x) * bar;
+    fragColor = TDOutputSwizzle(vec4(col, 1.0));
+}
+`;
+var SOURCE_TYPE = {
+  table: "tableDAT",
+  file: "fileinDAT",
+  chop: "constantCHOP"
+};
+var createDataVisualizationSchema = z8.object({
+  data_source: z8.enum(["table", "file", "chop"]).default("table"),
+  chart_style: z8.enum(["bars", "graph", "points"]).default("bars"),
+  parent_path: z8.string().default("/project1")
+});
+async function createDataVisualizationImpl(ctx, args) {
+  return runBuild(async () => {
+    const builder = await createSystemContainer(ctx, args.parent_path, "data_viz");
+    const source = await builder.add(SOURCE_TYPE[args.data_source], "data");
+    if (args.data_source === "table") {
+      const rows = Array.from(
+        { length: 16 },
+        (_, i) => (0.5 + 0.45 * Math.sin(i * 0.6)).toFixed(3)
+      );
+      await builder.python(
+        `d = op(${q4(source)})
+d.clear()
+for v in ${JSON.stringify(rows)}:
+    d.appendRow([v])`
+      );
+    }
+    let chop = source;
+    if (args.data_source !== "chop") {
+      chop = await builder.add("dattoCHOP", "datto", {
+        firstrow: "values",
+        firstcolumn: "values",
+        output: "chanpercol"
+      });
+      await builder.connect(source, chop);
+    }
+    const tex = await builder.add("choptoTOP", "data_tex");
+    await builder.connect(chop, tex);
+    let visual = tex;
+    if (args.chart_style === "bars") {
+      const glsl = await builder.add("glslTOP", "chart", {
+        outputresolution: "custom",
+        resolutionw: 1280,
+        resolutionh: 720,
+        format: "rgba8fixed"
+      });
+      const frag = await builder.add("textDAT", "chart_frag");
+      await builder.python(
+        `op(${q4(frag)}).text = ${q4(BARS_SHADER)}
+op(${q4(glsl)}).par.pixeldat = op(${q4(frag)}).name`
+      );
+      await builder.connect(tex, glsl);
+      visual = glsl;
+    } else {
+      builder.warnings.push(
+        `Chart style "${args.chart_style}" renders the data as a texture strip; richer plotting needs customization.`
+      );
+    }
+    const out = await builder.add("nullTOP", "out1");
+    await builder.connect(visual, out);
+    builder.warnings.push(
+      "Wire your real data into the 'data' node \u2014 a placeholder source was created."
+    );
+    return finalize(ctx, {
+      summary: `Created a data visualization (source: ${args.data_source}, style: ${args.chart_style}).`,
+      builder,
+      outputPath: out,
+      extra: { data_source: args.data_source, chart_style: args.chart_style }
+    });
+  });
+}
+var registerCreateDataVisualization = (server, ctx) => {
+  server.registerTool(
+    "create_data_visualization",
+    {
+      title: "Create data visualization",
+      description: "Build a data-driven visualization: a data source feeds a CHOP that drives a chart TOP. Wire your real data into the created 'data' node.",
+      inputSchema: createDataVisualizationSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => createDataVisualizationImpl(ctx, args)
+  );
+};
+
+// src/tools/layer1/createFeedbackNetwork.ts
+import { z as z9 } from "zod";
+var q5 = (value) => JSON.stringify(value);
+function colorizeShader(colors) {
+  const toVec3 = (hex) => {
+    const m = hex ? /^#?([0-9a-fA-F]{6})$/.exec(hex.trim()) : null;
+    if (!m?.[1]) return "vec3(1.0)";
+    const n = Number.parseInt(m[1], 16);
+    const r = (n >> 16 & 255) / 255;
+    const g = (n >> 8 & 255) / 255;
+    const b = (n & 255) / 255;
+    return `vec3(${r.toFixed(4)}, ${g.toFixed(4)}, ${b.toFixed(4)})`;
+  };
+  const lo = colors.length >= 2 ? toVec3(colors[0]) : "vec3(0.0)";
+  const hi = toVec3(colors[colors.length - 1]);
+  return `out vec4 fragColor;
+void main(){
+    float l = texture(sTD2DInputs[0], vUV.st).r;
+    fragColor = TDOutputSwizzle(vec4(mix(${lo}, ${hi}, l), 1.0));
+}
+`;
+}
+var SEED_TYPES = {
+  noise: "noiseTOP",
+  shape: "circleTOP",
+  image: "moviefileinTOP",
+  video: "moviefileinTOP",
+  webcam: "videodeviceinTOP",
+  glsl: "glslTOP"
+};
+var TRANSFORM_TYPES = {
+  blur: "blurTOP",
+  displace: "displaceTOP",
+  edge: "edgeTOP",
+  level: "levelTOP",
+  hsv_adjust: "hsvadjustTOP",
+  transform: "transformTOP",
+  mirror: "mirrorTOP",
+  tile: "tileTOP",
+  luma_blur: "lumablurTOP"
+};
+var createFeedbackNetworkSchema = z9.object({
+  seed_type: z9.enum(["noise", "shape", "image", "video", "webcam", "glsl"]).default("noise"),
+  transformations: z9.array(
+    z9.enum([
+      "blur",
+      "displace",
+      "edge",
+      "level",
+      "hsv_adjust",
+      "transform",
+      "mirror",
+      "tile",
+      "luma_blur"
+    ])
+  ).default(["blur", "displace", "level"]),
+  feedback_gain: z9.number().min(0).max(1).default(0.95),
+  colors: z9.array(z9.string()).max(2).optional().describe("Up to two hex colors to colorize the otherwise-grayscale output."),
+  parent_path: z9.string().default("/project1")
+});
+async function createFeedbackNetworkImpl(ctx, args) {
+  return runBuild(async () => {
+    const builder = await createSystemContainer(ctx, args.parent_path, "feedback_system");
+    const seed = await builder.add(SEED_TYPES[args.seed_type], "seed", {
+      ...args.seed_type === "noise" ? { monochrome: 1, period: 4 } : {}
+    });
+    const feedback = await builder.add("feedbackTOP", "feedback1");
+    const comp = await builder.add("compositeTOP", "comp1");
+    await builder.setParams(comp, { operand: "maximum" });
+    await builder.connect(seed, comp, 0, 0);
+    await builder.connect(feedback, comp, 0, 1);
+    await builder.connect(seed, feedback);
+    let last = comp;
+    for (const transformation of args.transformations) {
+      const node = await builder.add(TRANSFORM_TYPES[transformation], transformation);
+      await builder.connect(last, node);
+      if (transformation === "displace" || transformation === "luma_blur") {
+        await builder.connect(seed, node, 0, 1);
+      }
+      last = node;
+    }
+    const gain = await builder.add("levelTOP", "gain");
+    await builder.setParams(gain, { gain: args.feedback_gain });
+    await builder.connect(last, gain);
+    let output = gain;
+    if (args.colors && args.colors.length > 0) {
+      const colorize = await builder.add("glslTOP", "colorize");
+      const frag = await builder.add("textDAT", "colorize_frag");
+      await builder.python(
+        `op(${q5(frag)}).text = ${q5(colorizeShader(args.colors))}
+op(${q5(colorize)}).par.pixeldat = op(${q5(frag)}).name`
+      );
+      await builder.connect(gain, colorize);
+      output = colorize;
+    }
+    const out = await builder.add("nullTOP", "out1");
+    await builder.connect(output, out);
+    await builder.python(`op(${q5(feedback)}).par.top = op(${q5(gain)}).name`);
+    return finalize(ctx, {
+      summary: `Created a feedback network (seed: ${args.seed_type}, gain: ${args.feedback_gain}, ${args.transformations.length} transform(s)).`,
+      builder,
+      outputPath: out,
+      extra: { seed_type: args.seed_type, transformations: args.transformations }
+    });
+  });
+}
+var registerCreateFeedbackNetwork = (server, ctx) => {
+  server.registerTool(
+    "create_feedback_network",
+    {
+      title: "Create feedback network",
+      description: "Build a feedback-based visual system: a seed feeds a loop that is transformed (blur/displace/etc.) and fed back each frame. Great for evolving, hypnotic visuals.",
+      inputSchema: createFeedbackNetworkSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => createFeedbackNetworkImpl(ctx, args)
+  );
+};
+
+// src/tools/layer1/createGenerativeArt.ts
+import { z as z10 } from "zod";
+var q6 = (value) => JSON.stringify(value);
+var DEFAULT_PLASMA = `out vec4 fragColor;
+uniform float uTime;
+void main(){
+    vec2 uv = vUV.st;
+    float v = sin(uv.x * 10.0 + uTime) + sin(uv.y * 10.0 + uTime * 0.7);
+    v += sin((uv.x + uv.y) * 8.0 + uTime * 1.3);
+    vec3 col = 0.5 + 0.5 * cos(vec3(0.0, 2.0, 4.0) + v);
+    fragColor = TDOutputSwizzle(vec4(col, 1.0));
+}
+`;
+var RECIPE_FOR = /* @__PURE__ */ new Map([
+  ["reaction_diffusion", "reaction_diffusion"],
+  ["noise_landscape", "noise_landscape"]
+]);
+var createGenerativeArtSchema = z10.object({
+  technique: z10.enum([
+    "noise_landscape",
+    "reaction_diffusion",
+    "strange_attractor",
+    "l_system",
+    "cellular_automata",
+    "flow_field",
+    "voronoi",
+    "fractal",
+    "custom_glsl"
+  ]),
+  color_palette: z10.string().optional().describe("Free-text palette hint (best-effort)."),
+  evolution_speed: z10.number().positive().default(1),
+  custom_glsl_code: z10.string().optional().describe("Fragment shader (only for technique 'custom_glsl')."),
+  parent_path: z10.string().default("/project1")
+});
+async function buildGlslGenerative(ctx, parentPath, name, fragment) {
+  const builder = await createSystemContainer(ctx, parentPath, name);
+  const glsl = await builder.add("glslTOP", "glsl1");
+  const frag = await builder.add("textDAT", "glsl1_frag");
+  await builder.python(
+    `op(${q6(frag)}).text = ${q6(fragment)}
+op(${q6(glsl)}).par.pixeldat = op(${q6(frag)}).name`
+  );
+  const out = await builder.add("nullTOP", "out1");
+  await builder.connect(glsl, out);
+  return { builder, outputPath: out };
+}
+async function createGenerativeArtImpl(ctx, args) {
+  return runBuild(async () => {
+    const recipeId = RECIPE_FOR.get(args.technique);
+    if (recipeId) {
+      const recipe = ctx.recipes.get(recipeId);
+      if (recipe) {
+        const { builder: builder2, outputPath } = await buildFromRecipe(ctx, recipe, args.parent_path);
+        return finalize(ctx, {
+          summary: `Created "${recipe.name}" generative system.`,
+          builder: builder2,
+          outputPath,
+          recipeId,
+          extra: { technique: args.technique, color_palette: args.color_palette }
+        });
+      }
+    }
+    if (args.technique === "custom_glsl") {
+      const fragment = args.custom_glsl_code ?? DEFAULT_PLASMA;
+      const { builder: builder2, outputPath } = await buildGlslGenerative(
+        ctx,
+        args.parent_path,
+        "generative_custom_glsl",
+        fragment
+      );
+      if (!args.custom_glsl_code) {
+        builder2.warnings.push("No custom_glsl_code provided; used a default plasma shader.");
+      }
+      return finalize(ctx, {
+        summary: "Created a custom GLSL generative system.",
+        builder: builder2,
+        outputPath,
+        extra: { technique: args.technique }
+      });
+    }
+    const pattern = ctx.knowledge.getGlslPattern(args.technique);
+    if (pattern?.code?.snippet) {
+      const { builder: builder2, outputPath } = await buildGlslGenerative(
+        ctx,
+        args.parent_path,
+        `generative_${args.technique}`,
+        pattern.code.snippet
+      );
+      return finalize(ctx, {
+        summary: `Created a "${args.technique}" system from the GLSL knowledge pattern "${pattern.name}".`,
+        builder: builder2,
+        outputPath,
+        extra: { technique: args.technique, glsl_pattern: pattern.id }
+      });
+    }
+    const builder = await createSystemContainer(
+      ctx,
+      args.parent_path,
+      `generative_${args.technique}`
+    );
+    const noise = await builder.add("noiseTOP", "noise1", { monochrome: 0, period: 6 });
+    const level = await builder.add("levelTOP", "level1");
+    const out = await builder.add("nullTOP", "out1");
+    await builder.connect(noise, level);
+    await builder.connect(level, out);
+    await builder.python(
+      `p = op(${q6(noise)}).par.tz
+p.expr = ${q6(`absTime.seconds * ${args.evolution_speed}`)}`
+    );
+    builder.warnings.push(
+      `Technique "${args.technique}" is approximated with an animated-noise generator in this version.`
+    );
+    return finalize(ctx, {
+      summary: `Created an approximate "${args.technique}" generative system.`,
+      builder,
+      outputPath: out,
+      extra: { technique: args.technique, evolution_speed: args.evolution_speed }
+    });
+  });
+}
+var registerCreateGenerativeArt = (server, ctx) => {
+  server.registerTool(
+    "create_generative_art",
+    {
+      title: "Create generative art",
+      description: "Create an evolving generative visual. Known techniques (reaction_diffusion, noise_landscape) use validated recipes; custom_glsl uses your shader; others fall back to a knowledge GLSL pattern or animated noise.",
+      inputSchema: createGenerativeArtSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => createGenerativeArtImpl(ctx, args)
+  );
+};
+
+// src/tools/layer1/createParticleSystem.ts
+import { z as z11 } from "zod";
+var q7 = (value) => JSON.stringify(value);
+var EMITTER_SOP = {
+  point: "addSOP",
+  line: "lineSOP",
+  circle: "circleSOP",
+  sphere: "sphereSOP",
+  mesh: "boxSOP",
+  image: "gridSOP"
+};
+var createParticleSystemSchema = z11.object({
+  emitter_shape: z11.enum(["point", "line", "circle", "sphere", "mesh", "image"]).default("point"),
+  particle_count: z11.number().int().positive().default(1e4),
+  forces: z11.array(z11.enum(["gravity", "noise", "attract", "repel", "vortex", "turbulence", "drag"])).default(["noise", "gravity"]),
+  render_style: z11.enum(["points", "sprites", "lines", "trails", "instanced_geo"]).default("sprites"),
+  lifetime: z11.number().positive().default(3),
+  parent_path: z11.string().default("/project1")
+});
+async function createParticleSystemImpl(ctx, args) {
+  return runBuild(async () => {
+    const builder = await createSystemContainer(ctx, args.parent_path, "particle_system");
+    const geo = await builder.add("geometryCOMP", "geo");
+    const emitter = await ctx.client.createNode({
+      parent_path: geo,
+      type: EMITTER_SOP[args.emitter_shape],
+      name: "emitter"
+    });
+    const particle = await ctx.client.createNode({
+      parent_path: geo,
+      type: "particleSOP",
+      name: "particle",
+      parameters: { life: args.lifetime }
+    });
+    builder.created.push(
+      { name: "emitter", path: emitter.path, type: emitter.type },
+      { name: "particle", path: particle.path, type: particle.type }
+    );
+    await builder.connect(emitter.path, particle.path);
+    const mat = await builder.add(
+      args.render_style === "sprites" ? "pointspriteMAT" : "constantMAT",
+      "mat"
+    );
+    const cam = await builder.add("cameraCOMP", "cam", { tz: 5 });
+    const light = await builder.add("lightCOMP", "light", { tx: 3, ty: 4, tz: 4 });
+    const render = await builder.add("renderTOP", "render");
+    const out = await builder.add("nullTOP", "out1");
+    await builder.connect(render, out);
+    await builder.python(
+      [
+        `g = op(${q7(geo)})`,
+        "p = op(g.path + '/particle')",
+        "p.render = True",
+        "p.display = True",
+        `g.par.material = ${q7(mat)}`,
+        `r = op(${q7(render)})`,
+        `r.par.geometry = ${q7(geo)}`,
+        `r.par.camera = ${q7(cam)}`,
+        `r.par.lights = ${q7(light)}`
+      ].join("\n")
+    );
+    builder.warnings.push(
+      `Particle forces (${args.forces.join(", ")}), exact count (${args.particle_count}) and the "${args.render_style}" render style are scaffolded; tune the particleSOP and material for production.`
+    );
+    return finalize(ctx, {
+      summary: `Created a particle system (emitter: ${args.emitter_shape}, ~${args.particle_count} particles, render: ${args.render_style}).`,
+      builder,
+      outputPath: out,
+      extra: {
+        emitter_shape: args.emitter_shape,
+        forces: args.forces,
+        render_style: args.render_style
+      }
+    });
+  });
+}
+var registerCreateParticleSystem = (server, ctx) => {
+  server.registerTool(
+    "create_particle_system",
+    {
+      title: "Create particle system",
+      description: "Build a particle system: an emitter feeds a particle SOP inside a Geometry COMP, rendered with a camera + light. Forces and render style are scaffolded for further tuning.",
+      inputSchema: createParticleSystemSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => createParticleSystemImpl(ctx, args)
+  );
+};
+
+// src/tools/layer1/createVisualSystem.ts
+import { z as z12 } from "zod";
+
+// src/tools/layer1/intent.ts
+var GENERIC_TERMS = /* @__PURE__ */ new Set([
+  "generative",
+  "visual",
+  "visuals",
+  "glow",
+  "glowing",
+  "abstract",
+  "field",
+  "system",
+  "animated",
+  "evolving",
+  "dynamic",
+  "background",
+  "colorful",
+  "colourful",
+  "bright",
+  "beautiful"
+]);
+function significantTerms(description) {
+  return description.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 3 && !GENERIC_TERMS.has(t));
+}
+
+// src/tools/layer1/createVisualSystem.ts
+var createVisualSystemSchema = z12.object({
+  description: z12.string().min(1).describe("Natural-language description of the visual system."),
+  parent_path: z12.string().default("/project1"),
+  resolution: z12.enum(["720p", "1080p", "4K", "custom"]).default("1080p"),
+  target_fps: z12.number().positive().default(60)
+});
+function classify(description) {
+  const d = description.toLowerCase();
+  const has = (...words) => words.some((w) => d.includes(w));
+  if (has("audio", "sound", "music", "beat", "frequenc", "spectrum", "reactive")) {
+    return { kind: "audio", label: "audio-reactive" };
+  }
+  if (has("particle", "swarm", "galaxy", "sparkle", "emitter")) {
+    return { kind: "particle", label: "particle" };
+  }
+  if (has("reaction", "diffusion", "gray-scott", "gray scott")) {
+    return { kind: "reaction_diffusion", label: "reaction-diffusion" };
+  }
+  if (has("landscape", "terrain", "mountain", "heightfield")) {
+    return { kind: "noise_landscape", label: "noise landscape" };
+  }
+  if (has("feedback", "tunnel", "echo", "trail", "infinite", "kaleido")) {
+    return { kind: "feedback", label: "feedback" };
+  }
+  return { kind: "default", label: "generative" };
+}
+function pickAudioStyle(description) {
+  const d = description.toLowerCase();
+  if (d.includes("particle")) return "particle";
+  if (d.includes("feedback") || d.includes("tunnel")) return "feedback";
+  if (d.includes("geometr") || d.includes("shape")) return "geometric";
+  if (d.includes("instanc")) return "instancing";
+  return "glsl";
+}
+function pickEmitter(description) {
+  const d = description.toLowerCase();
+  if (d.includes("galaxy") || d.includes("sphere") || d.includes("orbit")) return "sphere";
+  if (d.includes("ring") || d.includes("circle")) return "circle";
+  if (d.includes("line")) return "line";
+  return "point";
+}
+var COLOR_WORDS = {
+  red: "#e03030",
+  crimson: "#c01040",
+  orange: "#ff7a18",
+  amber: "#ffb000",
+  yellow: "#f5e050",
+  gold: "#e8c020",
+  green: "#30c050",
+  lime: "#9be025",
+  teal: "#10b0a0",
+  cyan: "#20d0e0",
+  blue: "#1840d0",
+  navy: "#0a1a66",
+  indigo: "#3010a0",
+  purple: "#7a20c0",
+  violet: "#8a40e0",
+  magenta: "#d020a0",
+  pink: "#ff60b0",
+  white: "#f0f0f0",
+  black: "#101015"
+};
+function parseColors(description) {
+  const d = description.toLowerCase();
+  const found = [];
+  for (const [word, hex] of Object.entries(COLOR_WORDS)) {
+    if (new RegExp(`\\b${word}`).test(d) && !found.includes(hex)) found.push(hex);
+    if (found.length >= 2) break;
+  }
+  return found;
+}
+function withNote(result, note) {
+  return { ...result, content: [{ type: "text", text: note }, ...result.content] };
+}
+async function createVisualSystemImpl(ctx, args) {
+  const { kind, label } = classify(args.description);
+  const note = `Interpreted "${args.description}" as a ${label} system (target ${args.resolution} @ ${args.target_fps}fps).`;
+  ctx.logger.info("create_visual_system classified", { kind, description: args.description });
+  switch (kind) {
+    case "audio":
+      return withNote(
+        await createAudioReactiveImpl(ctx, {
+          audio_source: "microphone",
+          visual_style: pickAudioStyle(args.description),
+          frequency_bands: 8,
+          beat_detection: true,
+          parent_path: args.parent_path
+        }),
+        note
+      );
+    case "particle":
+      return withNote(
+        await createParticleSystemImpl(ctx, {
+          emitter_shape: pickEmitter(args.description),
+          particle_count: 1e4,
+          forces: ["noise", "gravity"],
+          render_style: "sprites",
+          lifetime: 3,
+          parent_path: args.parent_path
+        }),
+        note
+      );
+    case "feedback":
+      return withNote(
+        await createFeedbackNetworkImpl(ctx, {
+          seed_type: "noise",
+          transformations: ["blur", "displace", "level"],
+          feedback_gain: 0.95,
+          colors: parseColors(args.description),
+          parent_path: args.parent_path
+        }),
+        note
+      );
+    case "reaction_diffusion":
+    case "noise_landscape":
+      return withNote(
+        await createGenerativeArtImpl(ctx, {
+          technique: kind,
+          evolution_speed: 1,
+          parent_path: args.parent_path
+        }),
+        note
+      );
+    default: {
+      const recipe = ctx.recipes.findByTags(significantTerms(args.description));
+      if (recipe) {
+        return runBuild(async () => {
+          const { builder, outputPath } = await buildFromRecipe(ctx, recipe, args.parent_path);
+          return withNote(
+            await finalize(ctx, {
+              summary: `Built "${recipe.name}" from a matching recipe.`,
+              builder,
+              outputPath,
+              recipeId: recipe.id
+            }),
+            note
+          );
+        });
+      }
+      return withNote(
+        await createGenerativeArtImpl(ctx, {
+          technique: "custom_glsl",
+          evolution_speed: 1,
+          parent_path: args.parent_path
+        }),
+        note
+      );
+    }
+  }
+}
+var registerCreateVisualSystem = (server, ctx) => {
+  server.registerTool(
+    "create_visual_system",
+    {
+      title: "Create visual system",
+      description: "Create a complete visual system from a natural-language description. Classifies intent (audio-reactive, particle, feedback, reaction-diffusion, landscape, generative) and builds it in a self-contained COMP, then verifies and previews it.",
+      inputSchema: createVisualSystemSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => createVisualSystemImpl(ctx, args)
+  );
+};
+
+// src/tools/layer1/describeProject.ts
+import { z as z13 } from "zod";
+var describeProjectSchema = z13.object({
+  description: z13.string().min(1).describe("Natural-language description of the visual you want.")
+});
+function describeProjectImpl(ctx, args) {
+  const d = args.description.toLowerCase();
+  const has = (...words) => words.some((w) => d.includes(w));
+  let tool;
+  let summary;
+  let recipeId;
+  if (has("audio", "sound", "music", "beat", "frequenc", "spectrum", "reactive")) {
+    tool = "create_audio_reactive";
+    summary = "audio-reactive visual";
+  } else if (has("particle", "swarm", "galaxy", "sparkle", "emitter")) {
+    tool = "create_particle_system";
+    summary = "particle system";
+  } else if (has("reaction", "diffusion", "gray-scott", "gray scott")) {
+    tool = "create_generative_art";
+    summary = "reaction-diffusion simulation";
+    recipeId = "reaction_diffusion";
+  } else if (has("landscape", "terrain", "mountain", "heightfield")) {
+    tool = "create_generative_art";
+    summary = "3D noise landscape";
+    recipeId = "noise_landscape";
+  } else if (has("feedback", "tunnel", "echo", "trail", "kaleido")) {
+    tool = "create_feedback_network";
+    summary = "feedback network";
+  } else {
+    tool = "create_generative_art";
+    summary = "generative visual";
+    recipeId = ctx.recipes.findByTags(significantTerms(d))?.id;
+  }
+  const lines = [
+    `Plan for: "${args.description}"`,
+    "",
+    `Interpreted as: ${summary}.`,
+    `Recommended tool: ${tool}${recipeId ? ` (recipe: ${recipeId})` : ""}.`
+  ];
+  if (recipeId) {
+    const recipe = ctx.recipes.get(recipeId);
+    if (recipe) {
+      lines.push("", `Recipe "${recipe.name}" would create:`);
+      for (const node of recipe.nodes) {
+        lines.push(`  - ${node.name} (${node.type})${node.comment ? ` \u2014 ${node.comment}` : ""}`);
+      }
+    }
+  }
+  lines.push("", "Next: call the recommended tool, then check get_td_node_errors and get_preview.");
+  return textResult(lines.join("\n"));
+}
+var registerDescribeProject = (server, ctx) => {
+  server.registerTool(
+    "plan_visual",
+    {
+      title: "Plan a visual from a description",
+      description: "Turn a natural-language description of a visual you WANT into a build plan (which tool/recipe and nodes) \u2014 a dry run that creates nothing. Note: this does NOT inspect the current TouchDesigner project; to read existing nodes use get_td_nodes / get_td_topology / find_td_nodes.",
+      inputSchema: describeProjectSchema.shape,
+      annotations: { readOnlyHint: true, openWorldHint: false }
+    },
+    (args) => describeProjectImpl(ctx, args)
+  );
+};
+
+// src/tools/layer1/getPreview.ts
+import { z as z14 } from "zod";
+var getPreviewSchema = z14.object({
+  node_path: z14.string().describe("Path of the TOP node to capture."),
+  width: z14.number().int().positive().default(640),
+  height: z14.number().int().positive().default(360)
+});
+async function getPreviewImpl(ctx, args) {
+  return guardTd(
+    () => capturePreview(ctx.client, args.node_path, args.width, args.height),
+    (preview) => imageResult(
+      preview.base64,
+      preview.mimeType,
+      `Preview of ${args.node_path} (${preview.width}\xD7${preview.height}).`
+    )
+  );
+}
+var registerGetPreview = (server, ctx) => {
+  server.registerTool(
+    "get_preview",
+    {
+      title: "Preview a TOP",
+      description: "Capture a TOP node as an inline image so you can see what was created.",
+      inputSchema: getPreviewSchema.shape,
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    (args) => getPreviewImpl(ctx, args)
+  );
+};
+
+// src/tools/layer1/setupOutput.ts
+import { z as z15 } from "zod";
+var q8 = (value) => JSON.stringify(value);
+var OUTPUT_MAP = {
+  window: "windowCOMP",
+  ndi: "ndioutTOP",
+  syphon_spout: "syphonspoutoutTOP",
+  record: "moviefileoutTOP",
+  touch_out: "touchoutTOP"
+};
+var RESOLUTIONS = {
+  "720p": [1280, 720],
+  "1080p": [1920, 1080],
+  "4K": [3840, 2160]
+};
+var setupOutputSchema = z15.object({
+  source_path: z15.string().describe("Path of the final TOP to output."),
+  output_type: z15.enum(["window", "ndi", "syphon_spout", "record", "touch_out"]).default("window"),
+  resolution: z15.enum(["720p", "1080p", "4K"]).default("1080p"),
+  record_format: z15.enum(["mp4", "mov", "image_sequence"]).optional(),
+  parent_path: z15.string().default("/project1")
+});
+async function setupOutputImpl(ctx, args) {
+  return runBuild(async () => {
+    const warnings = [];
+    const node = await ctx.client.createNode({
+      parent_path: args.parent_path,
+      type: OUTPUT_MAP[args.output_type],
+      name: `${args.output_type}_out`
+    });
+    if (args.output_type === "window") {
+      const [width, height] = RESOLUTIONS[args.resolution];
+      try {
+        await ctx.client.executePythonScript(
+          `w = op(${q8(node.path)})
+w.par.winop = ${q8(args.source_path)}
+w.par.winw = ${width}
+w.par.winh = ${height}`,
+          false
+        );
+      } catch (err) {
+        warnings.push(`Could not configure window: ${friendlyTdError(err)}`);
+      }
+    } else {
+      try {
+        await connectNodesViaBridge(ctx.client, args.source_path, node.path);
+      } catch (err) {
+        warnings.push(`Could not connect source to output: ${friendlyTdError(err)}`);
+      }
+    }
+    if (args.output_type === "record" && args.record_format) {
+      try {
+        await ctx.client.updateNodeParameters(node.path, { type: args.record_format });
+      } catch (err) {
+        warnings.push(`Could not set record format: ${friendlyTdError(err)}`);
+      }
+    }
+    return jsonResult(`Configured ${args.output_type} output for ${args.source_path}.`, {
+      output: node.path,
+      output_type: args.output_type,
+      source_path: args.source_path,
+      resolution: args.resolution,
+      warnings
+    });
+  });
+}
+var registerSetupOutput = (server, ctx) => {
+  server.registerTool(
+    "setup_output",
+    {
+      title: "Set up output",
+      description: "Route a TOP to an output: a display window, NDI stream, Syphon/Spout, a recording, or Touch Out.",
+      inputSchema: setupOutputSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => setupOutputImpl(ctx, args)
+  );
+};
+
+// src/tools/layer1/index.ts
+var layer1Registrars = [
+  registerCreateFeedbackNetwork,
+  registerCreateGenerativeArt,
+  registerCreateAudioReactive,
+  registerCreateParticleSystem,
+  registerCreateDataVisualization,
+  registerApplyPostProcessing,
+  registerSetupOutput,
+  registerGetPreview,
+  registerDescribeProject,
+  registerCreateVisualSystem
+];
+
+// src/tools/layer2/connectNodes.ts
+import { z as z16 } from "zod";
+var connectNodesSchema = z16.object({
+  source_path: z16.string().describe("Path of the source node (output side)."),
+  target_path: z16.string().describe("Path of the target node (input side)."),
+  source_output: z16.number().int().nonnegative().default(0),
+  target_input: z16.number().int().nonnegative().default(0)
+});
+async function connectNodesImpl(ctx, args) {
+  return guardTd(
+    () => connectNodesViaBridge(
+      ctx.client,
+      args.source_path,
+      args.target_path,
+      args.source_output,
+      args.target_input
+    ),
+    (result) => jsonResult(`Connected ${args.source_path} \u2192 ${args.target_path} (via ${result.method}).`, {
+      source: args.source_path,
+      target: args.target_path,
+      source_output: args.source_output,
+      target_input: args.target_input,
+      method: result.method
+    })
+  );
+}
+var registerConnectNodes = (server, ctx) => {
+  server.registerTool(
+    "connect_nodes",
+    {
+      title: "Connect two nodes",
+      description: "Wire one node's output into another node's input. Uses the batch endpoint when available, with a Python fallback.",
+      inputSchema: connectNodesSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => connectNodesImpl(ctx, args)
+  );
+};
+
+// src/tools/layer2/createContainer.ts
+import { z as z17 } from "zod";
+var COMP_MAP = {
+  container: "containerCOMP",
+  base: "baseCOMP"
+};
+var createContainerSchema = z17.object({
+  parent_path: z17.string().default("/project1").describe("Parent COMP to create the container in."),
+  name: z17.string().optional(),
+  comp_type: z17.enum(["container", "base"]).default("container").describe("'container' (2D panel COMP) or 'base' (generic COMP).")
+});
+async function createContainerImpl(ctx, args) {
+  return guardTd(
+    () => ctx.client.createNode({
+      parent_path: args.parent_path,
+      type: COMP_MAP[args.comp_type],
+      name: args.name
+    }),
+    (node) => jsonResult(`Created ${args.comp_type} COMP at ${node.path}.`, { node })
+  );
+}
+var registerCreateContainer = (server, ctx) => {
+  server.registerTool(
+    "create_container",
+    {
+      title: "Create container COMP",
+      description: "Create a self-contained COMP to hold a visual system.",
+      inputSchema: createContainerSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => createContainerImpl(ctx, args)
+  );
+};
+
+// src/tools/layer2/createGlslShader.ts
+import { z as z18 } from "zod";
+var UniformSchema = z18.object({
+  name: z18.string(),
+  type: z18.enum(["float", "vec2", "vec3", "vec4", "int", "sampler2D"]),
+  default_value: z18.string().optional()
+});
+var createGlslShaderSchema = z18.object({
+  parent_path: z18.string().describe("Parent COMP to create the GLSL TOP inside."),
+  name: z18.string().optional().describe("Name for the GLSL TOP (default 'glsl1')."),
+  fragment_shader: z18.string().min(1).describe("GLSL fragment (pixel) shader source."),
+  vertex_shader: z18.string().optional().describe("Optional GLSL vertex shader source."),
+  uniforms: z18.array(UniformSchema).optional().describe("Optional uniform declarations to best-effort bind on the GLSL TOP."),
+  resolution: z18.enum(["720p", "1080p", "4K", "input"]).default("input")
+});
+var RESOLUTIONS2 = {
+  "720p": [1280, 720],
+  "1080p": [1920, 1080],
+  "4K": [3840, 2160]
+};
+var q9 = (value) => JSON.stringify(value);
+async function createGlslShaderImpl(ctx, args) {
+  const desiredName = args.name ?? "glsl1";
+  return guardTd(
+    async () => {
+      const warnings = [];
+      const glsl = await ctx.client.createNode({
+        parent_path: args.parent_path,
+        type: "glslTOP",
+        name: desiredName
+      });
+      const glslName = glsl.name || desiredName;
+      const fragName = `${glslName}_frag`;
+      const frag = await ctx.client.createNode({
+        parent_path: args.parent_path,
+        type: "textDAT",
+        name: fragName
+      });
+      const wiring = [
+        `op(${q9(frag.path)}).text = ${q9(args.fragment_shader)}`,
+        `op(${q9(glsl.path)}).par.pixeldat = ${q9(frag.name || fragName)}`
+      ];
+      let vertexPath;
+      if (args.vertex_shader) {
+        const vertName = `${glslName}_vert`;
+        const vert = await ctx.client.createNode({
+          parent_path: args.parent_path,
+          type: "textDAT",
+          name: vertName
+        });
+        vertexPath = vert.path;
+        wiring.push(`op(${q9(vert.path)}).text = ${q9(args.vertex_shader)}`);
+        wiring.push(`op(${q9(glsl.path)}).par.vertexdat = ${q9(vert.name || vertName)}`);
+      }
+      await ctx.client.executePythonScript(wiring.join("\n"), false);
+      if (args.uniforms && args.uniforms.length > 0) {
+        const names = JSON.stringify(args.uniforms.map((u) => u.name));
+        const values = JSON.stringify(args.uniforms.map((u) => u.default_value ?? ""));
+        const bind = [
+          `g = op(${q9(glsl.path)})`,
+          `for i, nm in enumerate(${names}):`,
+          "    try: setattr(g.par, 'uniname' + str(i), nm)",
+          "    except Exception: pass",
+          `for i, v in enumerate(${values}):`,
+          "    try:",
+          "        if v != '': setattr(g.par, 'value' + str(i) + 'x', v)",
+          "    except Exception: pass"
+        ].join("\n");
+        try {
+          await ctx.client.executePythonScript(bind, false);
+        } catch {
+          warnings.push(
+            "Could not auto-bind uniforms; declare them in the shader and set them on the GLSL TOP manually."
+          );
+        }
+      }
+      if (args.resolution !== "input") {
+        const [width, height] = RESOLUTIONS2[args.resolution];
+        await ctx.client.updateNodeParameters(glsl.path, {
+          outputresolution: "custom",
+          resolutionw: width,
+          resolutionh: height
+        });
+      }
+      return { glsl, fragmentDat: frag.path, vertexDat: vertexPath, warnings };
+    },
+    (result) => jsonResult(`Created GLSL TOP at ${result.glsl.path}.`, result)
+  );
+}
+var registerCreateGlslShader = (server, ctx) => {
+  server.registerTool(
+    "create_glsl_shader",
+    {
+      title: "Create GLSL shader",
+      description: "Create a GLSL TOP with a fragment shader (and optional vertex shader) supplied via Text DATs, with optional uniform binding and output resolution.",
+      inputSchema: createGlslShaderSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => createGlslShaderImpl(ctx, args)
+  );
+};
+
+// src/tools/layer2/createNodeChain.ts
+import { z as z19 } from "zod";
+var ChainNodeSchema = z19.object({
+  type: z19.string().describe("Operator type, e.g. 'noiseTOP'."),
+  name: z19.string().optional(),
+  parameters: z19.record(z19.string(), z19.unknown()).optional()
+});
+var createNodeChainSchema = z19.object({
+  parent_path: z19.string().describe("Parent COMP to create the chain inside."),
+  nodes: z19.array(ChainNodeSchema).min(1).describe("Ordered list of nodes to create."),
+  connect_sequentially: z19.boolean().default(true).describe("Wire output[0] \u2192 input[0] for each consecutive pair.")
+});
+async function createNodeChainImpl(ctx, args) {
+  const created = [];
+  const warnings = [];
+  for (const node of args.nodes) {
+    if (!ctx.knowledge.operatorExists(node.type)) {
+      warnings.push(`Operator type "${node.type}" was not found in the knowledge base.`);
+    }
+  }
+  for (const node of args.nodes) {
+    try {
+      const ref = await ctx.client.createNode({
+        parent_path: args.parent_path,
+        type: node.type,
+        name: node.name,
+        parameters: node.parameters
+      });
+      created.push({
+        path: ref.path,
+        type: ref.type || node.type,
+        name: ref.name || node.name || ""
+      });
+    } catch (err) {
+      return errorResult(
+        `Stopped after creating ${created.length}/${args.nodes.length} node(s). Failed to create "${node.type}": ${friendlyTdError(err)}. Created so far: ${created.map((c) => c.path).join(", ") || "(none)"}. No nodes were deleted.`
+      );
+    }
+  }
+  const connections = [];
+  if (args.connect_sequentially && created.length > 1) {
+    for (let i = 0; i < created.length - 1; i++) {
+      const from = created[i];
+      const to = created[i + 1];
+      if (!from || !to) continue;
+      try {
+        const result = await connectNodesViaBridge(ctx.client, from.path, to.path);
+        connections.push({ from: from.path, to: to.path, method: result.method });
+      } catch (err) {
+        warnings.push(`Failed to connect ${from.path} \u2192 ${to.path}: ${friendlyTdError(err)}`);
+      }
+    }
+  }
+  return jsonResult(
+    `Created ${created.length} node(s) and ${connections.length} connection(s) under ${args.parent_path}.`,
+    { created, connections, warnings }
+  );
+}
+var registerCreateNodeChain = (server, ctx) => {
+  server.registerTool(
+    "create_node_chain",
+    {
+      title: "Create node chain",
+      description: "Create multiple nodes and (optionally) connect them in sequence. Returns all created paths; on failure it stops and reports partial progress without deleting anything.",
+      inputSchema: createNodeChainSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => createNodeChainImpl(ctx, args)
+  );
+};
+
+// src/tools/layer2/createPythonScript.ts
+import { z as z20 } from "zod";
+var TYPE_MAP = {
+  text: "textDAT",
+  execute: "executeDAT",
+  script: "scriptDAT"
+};
+var createPythonScriptSchema = z20.object({
+  parent_path: z20.string().describe("Parent COMP to create the DAT inside."),
+  name: z20.string().optional(),
+  code: z20.string().min(1).describe("Python source to place in the DAT."),
+  dat_type: z20.enum(["text", "execute", "script"]).default("text").describe("Kind of DAT: 'text' (plain), 'execute' (event hooks), or 'script' (table builder).")
+});
+async function createPythonScriptImpl(ctx, args) {
+  return guardTd(
+    async () => {
+      const dat = await ctx.client.createNode({
+        parent_path: args.parent_path,
+        type: TYPE_MAP[args.dat_type],
+        name: args.name
+      });
+      await ctx.client.executePythonScript(
+        `op(${JSON.stringify(dat.path)}).text = ${JSON.stringify(args.code)}`,
+        false
+      );
+      return dat;
+    },
+    (dat) => jsonResult(`Created ${args.dat_type} DAT at ${dat.path}.`, { node: dat })
+  );
+}
+var registerCreatePythonScript = (server, ctx) => {
+  server.registerTool(
+    "create_python_script",
+    {
+      title: "Create Python DAT",
+      description: "Create a DAT (text/execute/script) preloaded with Python code.",
+      inputSchema: createPythonScriptSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => createPythonScriptImpl(ctx, args)
+  );
+};
+
+// src/tools/layer2/duplicateNetwork.ts
+import { z as z21 } from "zod";
+var q10 = (value) => JSON.stringify(value);
+var duplicateNetworkSchema = z21.object({
+  source_path: z21.string().describe("Path of the node/COMP to duplicate."),
+  name: z21.string().optional().describe("Name for the copy (auto-generated if omitted)."),
+  parent_path: z21.string().optional().describe("Where to place the copy (defaults to the source's parent).")
+});
+async function duplicateNetworkImpl(ctx, args) {
+  const script = [
+    `src = op(${q10(args.source_path)})`,
+    `if src is None: raise Exception('source not found: ' + ${q10(args.source_path)})`,
+    args.parent_path ? `parent = op(${q10(args.parent_path)})` : "parent = src.parent()",
+    "if parent is None: raise Exception('parent not found')",
+    args.name ? `new = parent.copy(src, name=${q10(args.name)})` : "new = parent.copy(src)",
+    "result = new.path"
+  ].join("\n");
+  return guardTd(
+    () => ctx.client.executePythonScript(script, true),
+    (res) => jsonResult(`Duplicated ${args.source_path} \u2192 ${res.result ?? "(see stdout)"}.`, {
+      source: args.source_path,
+      copy: res.result
+    })
+  );
+}
+var registerDuplicateNetwork = (server, ctx) => {
+  server.registerTool(
+    "duplicate_network",
+    {
+      title: "Duplicate a network",
+      description: "Copy a node or whole COMP (and its contents) to a new node, optionally into another parent.",
+      inputSchema: duplicateNetworkSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => duplicateNetworkImpl(ctx, args)
+  );
+};
+
+// src/tools/layer2/setParametersBatch.ts
+import { z as z22 } from "zod";
+var UpdateSchema = z22.object({
+  path: z22.string(),
+  parameters: z22.record(z22.string(), z22.unknown())
+});
+var setParametersBatchSchema = z22.object({
+  updates: z22.array(UpdateSchema).min(1).describe(
+    "List of { path, parameters } updates sent in one batch request (per-update results; not transactional \u2014 a failed update does not roll back the others)."
+  )
+});
+async function setParametersBatchImpl(ctx, args) {
+  return guardTd(
+    () => ctx.client.batch(
+      args.updates.map((update) => ({
+        action: "update",
+        path: update.path,
+        parameters: update.parameters
+      }))
+    ),
+    (result) => jsonResult(`Applied ${args.updates.length} parameter update(s) in one batch.`, result)
+  );
+}
+var registerSetParametersBatch = (server, ctx) => {
+  server.registerTool(
+    "set_parameters_batch",
+    {
+      title: "Set parameters (batch)",
+      description: "Update parameters on multiple nodes in a single batch request. Each update reports its own success; a failure does not roll back the others.",
+      inputSchema: setParametersBatchSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => setParametersBatchImpl(ctx, args)
+  );
+};
+
+// src/tools/layer2/index.ts
+var layer2Registrars = [
+  registerCreateNodeChain,
+  registerConnectNodes,
+  registerCreateGlslShader,
+  registerCreatePythonScript,
+  registerSetParametersBatch,
+  registerCreateContainer,
+  registerDuplicateNetwork
+];
+
+// src/tools/layer3/compareTdNodes.ts
+import { z as z23 } from "zod";
+var compareTdNodesSchema = z23.object({
+  path_a: z23.string().describe("First node path."),
+  path_b: z23.string().describe("Second node path."),
+  only_diff: z23.boolean().default(true).describe("Return only the parameters that differ (true) or also list the identical ones.")
+});
+var compareTdNodesOutputSchema = z23.object({
+  a: z23.string(),
+  b: z23.string(),
+  type_a: z23.string(),
+  type_b: z23.string(),
+  type_match: z23.boolean(),
+  differing_count: z23.number(),
+  same_count: z23.number(),
+  differing: z23.array(z23.object({ param: z23.string(), a: z23.unknown(), b: z23.unknown() })),
+  identical: z23.array(z23.string()).optional()
+});
+async function compareTdNodesImpl(ctx, args) {
+  return guardTd(
+    async () => {
+      const [a, b] = await Promise.all([
+        ctx.client.getNode(args.path_a),
+        ctx.client.getNode(args.path_b)
+      ]);
+      return { a, b };
+    },
+    ({ a, b }) => {
+      const keys = /* @__PURE__ */ new Set([...Object.keys(a.parameters), ...Object.keys(b.parameters)]);
+      const differing = [];
+      const identical = [];
+      for (const key of [...keys].sort()) {
+        const va = a.parameters[key];
+        const vb = b.parameters[key];
+        if (JSON.stringify(va) === JSON.stringify(vb)) identical.push(key);
+        else differing.push({ param: key, a: va, b: vb });
+      }
+      const data = {
+        a: a.path,
+        b: b.path,
+        type_a: a.type,
+        type_b: b.type,
+        type_match: a.type === b.type,
+        differing_count: differing.length,
+        same_count: identical.length,
+        differing
+      };
+      if (!args.only_diff) data.identical = identical;
+      return structuredResult(
+        `${differing.length} differing parameter(s) between ${a.path} and ${b.path}${a.type === b.type ? "" : ` (types differ: ${a.type} vs ${b.type})`}.`,
+        data
+      );
+    }
+  );
+}
+var registerCompareTdNodes = (server, ctx) => {
+  server.registerTool(
+    "compare_td_nodes",
+    {
+      title: "Compare two nodes",
+      description: "Diff the parameters of two nodes, returning only the values that differ (by default). Useful for aligning settings across similar operators.",
+      inputSchema: compareTdNodesSchema.shape,
+      outputSchema: compareTdNodesOutputSchema.shape,
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    (args) => compareTdNodesImpl(ctx, args)
+  );
+};
+
+// src/tools/layer3/createTdNode.ts
+import { z as z24 } from "zod";
+var createTdNodeSchema = z24.object({
+  parent_path: z24.string().default("/project1").describe("Parent COMP path to create the node inside."),
+  type: z24.string().describe("Operator type string, e.g. 'noiseTOP', 'feedbackTOP', 'nullTOP', 'constantCHOP'."),
+  name: z24.string().optional().describe("Optional node name (auto-generated if omitted)."),
+  parameters: z24.record(z24.string(), z24.unknown()).optional().describe("Optional initial parameter overrides as key\u2192value pairs.")
+});
+async function createTdNodeImpl(ctx, args) {
+  const warnings = [];
+  if (!ctx.knowledge.operatorExists(args.type)) {
+    const suggestions = ctx.knowledge.searchOperators(args.type, 3).map((s) => s.name);
+    warnings.push(
+      `Operator type "${args.type}" was not found in the knowledge base.${suggestions.length ? ` Did you mean: ${suggestions.join(", ")}?` : ""}`
+    );
+  }
+  return guardTd(
+    () => ctx.client.createNode({
+      parent_path: args.parent_path,
+      type: args.type,
+      name: args.name,
+      parameters: args.parameters
+    }),
+    (node) => jsonResult(`Created ${node.type || args.type} at ${node.path}.`, { node, warnings })
+  );
+}
+var registerCreateTdNode = (server, ctx) => {
+  server.registerTool(
+    "create_td_node",
+    {
+      title: "Create TouchDesigner node",
+      description: "Create a single operator (node) inside a parent COMP. Validates the operator type against the knowledge base and warns (without blocking) on unknown types.",
+      inputSchema: createTdNodeSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => createTdNodeImpl(ctx, args)
+  );
+};
+
+// src/tools/layer3/deleteTdNode.ts
+import { z as z25 } from "zod";
+var deleteTdNodeSchema = z25.object({
+  path: z25.string().describe("Full path of the node to delete, e.g. '/project1/noise1'.")
+});
+async function deleteTdNodeImpl(ctx, args) {
+  return guardTd(
+    () => ctx.client.deleteNode(args.path),
+    (result) => jsonResult(`Deleted ${result.deleted}.`, result)
+  );
+}
+var registerDeleteTdNode = (server, ctx) => {
+  server.registerTool(
+    "delete_td_node",
+    {
+      title: "Delete TouchDesigner node",
+      description: "Delete a single node by path. Destructive \u2014 only call this when the user explicitly asks to remove a node.",
+      inputSchema: deleteTdNodeSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true }
+    },
+    (args) => deleteTdNodeImpl(ctx, args)
+  );
+};
+
+// src/tools/layer3/execNodeMethod.ts
+import { z as z26 } from "zod";
+var execNodeMethodSchema = z26.object({
+  path: z26.string().describe("Full path of the node to call the method on."),
+  method: z26.string().describe("Method name to call, e.g. 'cook', 'par', 'destroy', 'copy'."),
+  args: z26.array(z26.unknown()).default([]).describe("Positional arguments."),
+  kwargs: z26.record(z26.string(), z26.unknown()).default({}).describe("Keyword arguments.")
+});
+async function execNodeMethodImpl(ctx, args) {
+  return guardTd(
+    () => ctx.client.execNodeMethod(args.path, args.method, args.args, args.kwargs),
+    (result) => jsonResult(`Called ${args.path}.${args.method}().`, result)
+  );
+}
+var registerExecNodeMethod = (server, ctx) => {
+  if (ctx.allowRawPython === false) return;
+  server.registerTool(
+    "exec_node_method",
+    {
+      title: "Call node method",
+      description: "Escape hatch \u2014 invoke an arbitrary Python method on a node (operator). Prefer structured tools where one exists; use this for operations they don't cover (e.g. .cook(), .copy(), .destroy()).",
+      inputSchema: execNodeMethodSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true }
+    },
+    (args) => execNodeMethodImpl(ctx, args)
+  );
+};
+
+// src/tools/layer3/executePythonScript.ts
+import { z as z27 } from "zod";
+var executePythonScriptSchema = z27.object({
+  script: z27.string().min(1).describe(
+    "Python source to execute inside TouchDesigner (runs in the TD process, not locally)."
+  ),
+  return_output: z27.boolean().default(true).describe("Capture stdout / the value of the last expression and return it.")
+});
+async function executePythonScriptImpl(ctx, args) {
+  return guardTd(
+    () => ctx.client.executePythonScript(args.script, args.return_output),
+    (result) => jsonResult("Python executed in TouchDesigner.", result)
+  );
+}
+var registerExecutePythonScript = (server, ctx) => {
+  if (ctx.allowRawPython === false) return;
+  server.registerTool(
+    "execute_python_script",
+    {
+      title: "Execute Python in TouchDesigner",
+      description: "Escape hatch \u2014 run an arbitrary Python script inside the TouchDesigner process. Prefer the structured tools (find_td_nodes, get_td_node_parameters, update_td_node_parameters, summarize_td_errors, snapshot_td_graph, \u2026); reach for this only when no structured tool can express the operation. Code runs in TD only, never on the local machine.",
+      inputSchema: executePythonScriptSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true }
+    },
+    (args) => executePythonScriptImpl(ctx, args)
+  );
+};
+
+// src/tools/layer3/findTdNodes.ts
+import { z as z29 } from "zod";
+
+// src/td-client/validators.ts
+import { z as z28 } from "zod";
+var ApiEnvelopeSchema = z28.object({
+  ok: z28.boolean(),
+  data: z28.unknown().optional(),
+  error: z28.object({ code: z28.string().optional(), message: z28.string() }).optional()
+});
+var NodeRefSchema = z28.object({
+  path: z28.string(),
+  type: z28.string().default(""),
+  name: z28.string().default("")
+});
+var NodeDetailSchema = NodeRefSchema.extend({
+  parameters: z28.record(z28.string(), z28.unknown()).default({}),
+  inputs: z28.array(z28.string()).optional(),
+  outputs: z28.array(z28.string()).optional(),
+  family: z28.string().optional(),
+  errors: z28.array(z28.string()).optional()
+});
+var NodeListSchema = z28.object({ nodes: z28.array(NodeRefSchema).default([]) });
+var InfoSchema = z28.object({
+  td_version: z28.string().optional(),
+  python_version: z28.string().optional(),
+  build: z28.string().optional(),
+  bridge_version: z28.string().optional(),
+  project: z28.string().optional()
+});
+var NodeErrorSchema = z28.object({
+  path: z28.string(),
+  message: z28.string(),
+  type: z28.string().optional()
+});
+var NodeErrorsSchema = z28.object({ errors: z28.array(NodeErrorSchema).default([]) });
+var PreviewSchema = z28.object({
+  path: z28.string(),
+  width: z28.number().int().positive(),
+  height: z28.number().int().positive(),
+  format: z28.string().default("png"),
+  base64: z28.string()
+});
+var ExecResultSchema = z28.object({
+  result: z28.unknown().optional(),
+  stdout: z28.string().optional(),
+  printed: z28.array(z28.string()).optional()
+});
+var MethodResultSchema = z28.object({ result: z28.unknown() });
+var DeleteResultSchema = z28.object({ deleted: z28.string() });
+var ConnectionSchema = z28.object({
+  source_path: z28.string(),
+  source_output: z28.number().int().default(0),
+  target_path: z28.string(),
+  target_input: z28.number().int().default(0)
+});
+var TopologySchema = z28.object({
+  nodes: z28.array(NodeRefSchema).default([]),
+  connections: z28.array(ConnectionSchema).default([])
+});
+var PerformanceSchema = z28.object({
+  nodes: z28.array(
+    z28.object({
+      path: z28.string(),
+      cook_time_ms: z28.number().default(0),
+      cook_count: z28.number().optional()
+    })
+  ).default([]),
+  total_cook_time_ms: z28.number().optional(),
+  gpu_memory_mb: z28.number().optional()
+});
+var BatchOpResultSchema = z28.object({
+  action: z28.string(),
+  ok: z28.boolean(),
+  path: z28.string().optional(),
+  data: z28.unknown().optional(),
+  error: z28.string().optional()
+});
+var BatchResultSchema = z28.object({ results: z28.array(BatchOpResultSchema).default([]) });
+var CreateNodeInputSchema = z28.object({
+  parent_path: z28.string(),
+  type: z28.string(),
+  name: z28.string().optional(),
+  parameters: z28.record(z28.string(), z28.unknown()).optional()
+});
+var BatchOperationSchema = z28.discriminatedUnion("action", [
+  z28.object({
+    action: z28.literal("create"),
+    parent_path: z28.string(),
+    type: z28.string(),
+    name: z28.string().optional(),
+    parameters: z28.record(z28.string(), z28.unknown()).optional()
+  }),
+  z28.object({
+    action: z28.literal("update"),
+    path: z28.string(),
+    parameters: z28.record(z28.string(), z28.unknown())
+  }),
+  z28.object({ action: z28.literal("delete"), path: z28.string() }),
+  z28.object({
+    action: z28.literal("connect"),
+    source_path: z28.string(),
+    target_path: z28.string(),
+    source_output: z28.number().int().default(0),
+    target_input: z28.number().int().default(0)
+  })
+]);
+
+// src/tools/layer3/nodeMatch.ts
+function globToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(escaped, "i");
+}
+function parentOf(path) {
+  const idx = path.lastIndexOf("/");
+  return idx <= 0 ? "/" : path.slice(0, idx);
+}
+
+// src/tools/layer3/findTdNodes.ts
+var findTdNodesSchema = z29.object({
+  parent_path: z29.string().default("/project1").describe("Where to search from."),
+  pattern: z29.string().optional().describe("Case-insensitive name/path filter with '*' wildcards (e.g. 'text*', '*noise*')."),
+  type: z29.string().optional().describe("Case-insensitive operator-type substring (e.g. 'TOP', 'noise')."),
+  recursive: z29.boolean().default(true).describe("Search the whole sub-network (true) or only direct children (false)."),
+  path_only: z29.boolean().default(false).describe("Return only matching paths."),
+  limit: z29.number().int().positive().default(50).describe("Max matches to return.")
+});
+var findTdNodesOutputSchema = z29.object({
+  parent_path: z29.string(),
+  recursive: z29.boolean(),
+  count: z29.number(),
+  truncated: z29.boolean(),
+  paths: z29.array(z29.string()).optional(),
+  matches: z29.array(NodeRefSchema).optional()
+});
+async function findTdNodesImpl(ctx, args) {
+  const fetch2 = args.recursive ? async () => (await ctx.client.getNetworkTopology(args.parent_path, true)).nodes : async () => (await ctx.client.getNodes(args.parent_path)).nodes;
+  return guardTd(fetch2, (allNodes) => {
+    let nodes = allNodes;
+    if (args.pattern) {
+      const re = globToRegExp(args.pattern);
+      nodes = nodes.filter((n) => re.test(n.name) || re.test(n.path));
+    }
+    if (args.type) {
+      const t = args.type.toLowerCase();
+      nodes = nodes.filter((n) => n.type.toLowerCase().includes(t));
+    }
+    const count = nodes.length;
+    const truncated = count > args.limit;
+    nodes = nodes.slice(0, args.limit);
+    const summary = `${count} match(es) under ${args.parent_path}${truncated ? ` (showing ${args.limit})` : ""}.`;
+    const base = { parent_path: args.parent_path, recursive: args.recursive, count, truncated };
+    return args.path_only ? structuredResult(summary, { ...base, paths: nodes.map((n) => n.path) }) : structuredResult(summary, { ...base, matches: nodes });
+  });
+}
+var registerFindTdNodes = (server, ctx) => {
+  server.registerTool(
+    "find_td_nodes",
+    {
+      title: "Find TouchDesigner nodes",
+      description: "Search a network for nodes by name pattern and/or operator type. Recursive by default; pass path_only:true for a compact path list. Prefer this over get_td_nodes when you are looking for specific nodes.",
+      inputSchema: findTdNodesSchema.shape,
+      outputSchema: findTdNodesOutputSchema.shape,
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    (args) => findTdNodesImpl(ctx, args)
+  );
+};
+
+// src/tools/layer3/getModuleHelp.ts
+import { z as z30 } from "zod";
+var getModuleHelpSchema = z30.object({
+  name: z30.string().describe("Class or module name to get help for, e.g. 'OP', 'App', 'Project'.")
+});
+function getModuleHelpImpl(ctx, args) {
+  const cls = ctx.knowledge.getPythonClass(args.name);
+  if (!cls) {
+    const suggestions = ctx.knowledge.listPythonClasses().filter((c) => c.className.toLowerCase().includes(args.name.toLowerCase())).slice(0, 5).map((c) => c.className);
+    return jsonResult(`No help found for "${args.name}".`, { found: false, suggestions });
+  }
+  const lines = [`# ${cls.displayName || cls.className}`, ""];
+  if (cls.description) lines.push(cls.description, "");
+  if (cls.members && cls.members.length > 0) {
+    lines.push("## Members");
+    for (const m of cls.members) {
+      const ro = m.readOnly ? " (read-only)" : "";
+      lines.push(`- ${m.name}${m.returnType ? `: ${m.returnType}` : ""}${ro}`);
+    }
+    lines.push("");
+  }
+  if (cls.methods && cls.methods.length > 0) {
+    lines.push("## Methods");
+    for (const method of cls.methods) {
+      const sig = method.signature || method.name || "";
+      lines.push(`- ${sig}${method.returns ? ` -> ${method.returns}` : ""}`);
+    }
+  }
+  return textResult(lines.join("\n"));
+}
+var registerGetModuleHelp = (server, ctx) => {
+  server.registerTool(
+    "get_module_help",
+    {
+      title: "Get module/class help",
+      description: "Human-readable help (description, members, method signatures) for a TouchDesigner Python class or module, from the knowledge base.",
+      inputSchema: getModuleHelpSchema.shape,
+      annotations: { readOnlyHint: true, openWorldHint: false }
+    },
+    (args) => getModuleHelpImpl(ctx, args)
+  );
+};
+
+// src/tools/layer3/getTdClassDetails.ts
+import { z as z31 } from "zod";
+var getTdClassDetailsSchema = z31.object({
+  class_name: z31.string().describe("Python class name, e.g. 'OP', 'TOP', 'App', 'CHOP'.")
+});
+function getTdClassDetailsImpl(ctx, args) {
+  const cls = ctx.knowledge.getPythonClass(args.class_name);
+  if (!cls) {
+    const suggestions = ctx.knowledge.listPythonClasses().filter((c) => c.className.toLowerCase().includes(args.class_name.toLowerCase())).slice(0, 5).map((c) => c.className);
+    return structuredResult(`Python class "${args.class_name}" not found.`, {
+      found: false,
+      suggestions
+    });
+  }
+  return structuredResult(
+    `${cls.className} \u2014 ${cls.methods?.length ?? 0} methods, ${cls.members?.length ?? 0} members.`,
+    cls
+  );
+}
+var registerGetTdClassDetails = (server, ctx) => {
+  server.registerTool(
+    "get_td_class_details",
+    {
+      title: "Get TD Python class details",
+      description: "Full documentation for one TouchDesigner Python class (members + methods) from the knowledge base.",
+      inputSchema: getTdClassDetailsSchema.shape,
+      annotations: { readOnlyHint: true, openWorldHint: false }
+    },
+    (args) => getTdClassDetailsImpl(ctx, args)
+  );
+};
+
+// src/tools/layer3/getTdClasses.ts
+import { z as z32 } from "zod";
+var getTdClassesSchema = z32.object({
+  filter: z32.string().optional().describe("Optional case-insensitive substring to filter class names by.")
+});
+function getTdClassesImpl(ctx, args) {
+  let classes = ctx.knowledge.listPythonClasses();
+  if (args.filter) {
+    const needle = args.filter.toLowerCase();
+    classes = classes.filter(
+      (c) => c.className.toLowerCase().includes(needle) || c.displayName.toLowerCase().includes(needle)
+    );
+  }
+  return structuredResult(`Found ${classes.length} TouchDesigner Python API class(es).`, {
+    classes
+  });
+}
+var registerGetTdClasses = (server, ctx) => {
+  server.registerTool(
+    "get_td_classes",
+    {
+      title: "List TD Python classes",
+      description: "List TouchDesigner Python API classes from the embedded knowledge base (works offline). Optionally filter by name.",
+      inputSchema: getTdClassesSchema.shape,
+      annotations: { readOnlyHint: true, openWorldHint: false }
+    },
+    (args) => getTdClassesImpl(ctx, args)
+  );
+};
+
+// src/tools/layer3/getTdInfo.ts
+var DESCRIPTION = "Health check + TouchDesigner server info. Returns TD/Python version and bridge status when connected, plus the embedded knowledge-base stats. Use this first to confirm the bridge is reachable.";
+async function getTdInfoImpl(ctx) {
+  const knowledge = ctx.knowledge.stats();
+  try {
+    const info = await ctx.client.getInfo();
+    return jsonResult("TouchDesigner is connected.", {
+      connected: true,
+      endpoint: ctx.client.endpoint,
+      touchdesigner: info,
+      knowledge
+    });
+  } catch (err) {
+    return jsonResult("TouchDesigner is not reachable (the server is still running).", {
+      connected: false,
+      endpoint: ctx.client.endpoint,
+      reason: friendlyTdError(err),
+      knowledge
+    });
+  }
+}
+var registerGetTdInfo = (server, ctx) => {
+  server.registerTool(
+    "get_td_info",
+    {
+      title: "Get TouchDesigner info",
+      description: DESCRIPTION,
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    () => getTdInfoImpl(ctx)
+  );
+};
+
+// src/tools/layer3/getTdNodeErrors.ts
+import { z as z33 } from "zod";
+var getTdNodeErrorsSchema = z33.object({
+  path: z33.string().describe("Full path of the node (or network root) to check for errors."),
+  recursive: z33.boolean().default(false).describe("If true, check the whole network under `path`; otherwise just that node."),
+  summary: z33.boolean().default(false).describe("Return only counts grouped by error type instead of the full error list.")
+});
+var getTdNodeErrorsOutputSchema = z33.object({
+  path: z33.string(),
+  total: z33.number(),
+  errors: z33.array(NodeErrorSchema).optional(),
+  by_type: z33.record(z33.string(), z33.number()).optional()
+});
+async function getTdNodeErrorsImpl(ctx, args) {
+  return guardTd(
+    () => args.recursive ? ctx.client.getNetworkErrors(args.path) : ctx.client.getNodeErrors(args.path),
+    (result) => {
+      const errors = result.errors;
+      const total = errors.length;
+      const none = total === 0;
+      if (args.summary) {
+        const byType = {};
+        for (const e of errors) {
+          const key = e.type || "error";
+          byType[key] = (byType[key] ?? 0) + 1;
+        }
+        return structuredResult(
+          none ? `No errors found at ${args.path}.` : `${total} error(s) at ${args.path}.`,
+          { path: args.path, total, by_type: byType }
+        );
+      }
+      return structuredResult(
+        none ? `No errors found at ${args.path}.` : `Found ${total} error(s) at ${args.path}.`,
+        { path: args.path, total, errors }
+      );
+    }
+  );
+}
+var registerGetTdNodeErrors = (server, ctx) => {
+  server.registerTool(
+    "get_td_node_errors",
+    {
+      title: "Get node errors",
+      description: "Check a node (or its whole sub-network) for cook/compile errors and warnings. Pass `summary:true` for grouped counts instead of the full list.",
+      inputSchema: getTdNodeErrorsSchema.shape,
+      outputSchema: getTdNodeErrorsOutputSchema.shape,
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    (args) => getTdNodeErrorsImpl(ctx, args)
+  );
+};
+
+// src/tools/layer3/getTdNodeParameters.ts
+import { z as z34 } from "zod";
+var getTdNodeParametersSchema = z34.object({
+  path: z34.string().describe("Full path of the node to inspect."),
+  keys: z34.array(z34.string()).optional().describe("Only return these parameter names (case-sensitive). Omit to return all parameters."),
+  omit_io: z34.boolean().default(false).describe("Drop the inputs/outputs lists from the result to save context.")
+});
+async function getTdNodeParametersImpl(ctx, args) {
+  return guardTd(
+    () => ctx.client.getNode(args.path),
+    (node) => {
+      let parameters = node.parameters;
+      if (args.keys && args.keys.length > 0) {
+        const wanted = new Set(args.keys);
+        parameters = Object.fromEntries(
+          Object.entries(node.parameters).filter(([k]) => wanted.has(k))
+        );
+      }
+      const data = {
+        path: node.path,
+        type: node.type,
+        name: node.name,
+        parameters
+      };
+      if (!args.omit_io) {
+        data.inputs = node.inputs;
+        data.outputs = node.outputs;
+      }
+      const count = Object.keys(parameters).length;
+      return structuredResult(`${count} parameter(s) for ${node.path} (${node.type}).`, data);
+    }
+  );
+}
+var registerGetTdNodeParameters = (server, ctx) => {
+  server.registerTool(
+    "get_td_node_parameters",
+    {
+      title: "Get node parameters",
+      description: "Read the current parameters (and I/O) of a node. Pass `keys` to project specific parameters or `omit_io:true` to drop the inputs/outputs lists.",
+      inputSchema: getTdNodeParametersSchema.shape,
+      outputSchema: NodeDetailSchema.shape,
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    (args) => getTdNodeParametersImpl(ctx, args)
+  );
+};
+
+// src/tools/layer3/getTdNodes.ts
+import { z as z35 } from "zod";
+var getTdNodesSchema = z35.object({
+  parent_path: z35.string().default("/project1").describe("Parent COMP whose direct children should be listed."),
+  pattern: z35.string().optional().describe(
+    "Case-insensitive filter on node name/path. Supports '*' wildcards (e.g. 'text*', '*noise*')."
+  ),
+  path_only: z35.boolean().default(false).describe("Return only the list of node paths, dropping type/name."),
+  limit: z35.number().int().positive().optional().describe("Cap the number of nodes returned."),
+  detail_level: z35.enum(["summary", "full"]).default("summary").describe(
+    "'summary' (default) returns a count, a type breakdown and the first few paths; 'full' returns every node. Use 'full' (or path_only) when you need the complete list."
+  )
+});
+var SAMPLE_SIZE = 10;
+var getTdNodesOutputSchema = z35.object({
+  parent_path: z35.string(),
+  count: z35.number(),
+  detail_level: z35.enum(["summary", "full"]),
+  truncated: z35.boolean(),
+  by_type: z35.record(z35.string(), z35.number()).optional(),
+  sample: z35.array(z35.string()).optional(),
+  paths: z35.array(z35.string()).optional(),
+  nodes: z35.array(NodeRefSchema).optional(),
+  hint: z35.string().optional()
+});
+async function getTdNodesImpl(ctx, args) {
+  return guardTd(
+    () => ctx.client.getNodes(args.parent_path),
+    (list) => {
+      let nodes = list.nodes;
+      if (args.pattern) {
+        const re = globToRegExp(args.pattern);
+        nodes = nodes.filter((n) => re.test(n.name) || re.test(n.path));
+      }
+      const matched = nodes.length;
+      const truncated = args.limit !== void 0 && matched > args.limit;
+      if (args.limit !== void 0) nodes = nodes.slice(0, args.limit);
+      const where = args.pattern ? ` matching "${args.pattern}"` : "";
+      const base = {
+        parent_path: args.parent_path,
+        count: matched,
+        detail_level: args.detail_level,
+        truncated
+      };
+      if (args.path_only) {
+        return structuredResult(`${matched} node(s) under ${args.parent_path}${where}.`, {
+          ...base,
+          paths: nodes.map((n) => n.path)
+        });
+      }
+      if (args.detail_level === "summary") {
+        const byType = {};
+        for (const n of nodes) {
+          const key = n.type || "unknown";
+          byType[key] = (byType[key] ?? 0) + 1;
+        }
+        const sample = nodes.slice(0, SAMPLE_SIZE).map((n) => n.path);
+        return structuredResult(
+          `${matched} node(s) under ${args.parent_path}${where}. Summary only \u2014 pass detail_level:"full" or path_only:true for the full list.`,
+          {
+            ...base,
+            by_type: byType,
+            sample,
+            ...matched > sample.length ? {
+              hint: `Showing first ${sample.length} of ${matched}. Use detail_level:"full" for all.`
+            } : {}
+          }
+        );
+      }
+      return structuredResult(`${matched} node(s) under ${args.parent_path}${where}.`, {
+        ...base,
+        nodes
+      });
+    }
+  );
+}
+var registerGetTdNodes = (server, ctx) => {
+  server.registerTool(
+    "get_td_nodes",
+    {
+      title: "List TouchDesigner nodes",
+      description: 'List the direct child nodes of a COMP. Defaults to a compact summary (count + type breakdown + sample paths); pass detail_level:"full" or path_only:true for the complete list, and `pattern` to filter by name.',
+      inputSchema: getTdNodesSchema.shape,
+      outputSchema: getTdNodesOutputSchema.shape,
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    (args) => getTdNodesImpl(ctx, args)
+  );
+};
+
+// src/tools/layer3/getTdPerformance.ts
+import { z as z36 } from "zod";
+
+// src/feedback/performanceMonitor.ts
+async function checkPerformance(client, path, targetFps = 60) {
+  const perf = await client.getNetworkPerformance(path);
+  const frameBudgetMs = 1e3 / targetFps;
+  const warnings = [];
+  for (const node of perf.nodes) {
+    if (node.cook_time_ms > frameBudgetMs) {
+      warnings.push(
+        `${node.path} cooks in ${node.cook_time_ms.toFixed(2)}ms, exceeding the ${frameBudgetMs.toFixed(2)}ms budget at ${targetFps}fps.`
+      );
+    }
+  }
+  const totalCookMs = perf.total_cook_time_ms ?? perf.nodes.reduce((sum, node) => sum + node.cook_time_ms, 0);
+  if (totalCookMs > frameBudgetMs) {
+    warnings.push(
+      `Total cook time ${totalCookMs.toFixed(2)}ms exceeds the ${frameBudgetMs.toFixed(2)}ms budget at ${targetFps}fps.`
+    );
+  }
+  return { path, targetFps, frameBudgetMs, totalCookMs, nodes: perf.nodes, warnings };
+}
+
+// src/tools/layer3/getTdPerformance.ts
+var getTdPerformanceSchema = z36.object({
+  root_path: z36.string().default("/project1").describe("Network root to measure cook times under."),
+  target_fps: z36.number().positive().default(60).describe("Frame-rate target used to flag slow nodes.")
+});
+var getTdPerformanceOutputSchema = z36.object({
+  path: z36.string(),
+  targetFps: z36.number(),
+  frameBudgetMs: z36.number(),
+  totalCookMs: z36.number(),
+  nodes: z36.array(
+    z36.object({
+      path: z36.string(),
+      cook_time_ms: z36.number(),
+      cook_count: z36.number().optional()
+    })
+  ),
+  warnings: z36.array(z36.string())
+});
+async function getTdPerformanceImpl(ctx, args) {
+  return guardTd(
+    () => checkPerformance(ctx.client, args.root_path, args.target_fps),
+    (report) => structuredResult(
+      report.warnings.length === 0 ? `Within budget: ${report.totalCookMs.toFixed(2)}ms total under ${args.root_path} (${args.target_fps}fps).` : `${report.warnings.length} performance warning(s) under ${args.root_path}.`,
+      report
+    )
+  );
+}
+var registerGetTdPerformance = (server, ctx) => {
+  server.registerTool(
+    "get_td_performance",
+    {
+      title: "Get network performance",
+      description: "Report cook times under a network and warn about nodes that exceed the frame budget.",
+      inputSchema: getTdPerformanceSchema.shape,
+      outputSchema: getTdPerformanceOutputSchema.shape,
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    (args) => getTdPerformanceImpl(ctx, args)
+  );
+};
+
+// src/tools/layer3/getTdTopology.ts
+import { z as z37 } from "zod";
+
+// src/feedback/networkVerifier.ts
+async function verifyNetwork(client, path) {
+  const topology = await client.getNetworkTopology(path);
+  const issues = [];
+  if (topology.nodes.length === 0) {
+    issues.push(`No nodes were found under ${path}.`);
+  } else if (topology.nodes.length > 1 && topology.connections.length === 0) {
+    issues.push("Multiple nodes exist but none are connected.");
+  }
+  return {
+    path,
+    nodeCount: topology.nodes.length,
+    connectionCount: topology.connections.length,
+    issues,
+    topology
+  };
+}
+
+// src/tools/layer3/getTdTopology.ts
+var getTdTopologySchema = z37.object({
+  root_path: z37.string().default("/project1").describe("Network root to map.")
+});
+var getTdTopologyOutputSchema = z37.object({
+  path: z37.string(),
+  nodeCount: z37.number(),
+  connectionCount: z37.number(),
+  issues: z37.array(z37.string()),
+  topology: TopologySchema
+});
+async function getTdTopologyImpl(ctx, args) {
+  return guardTd(
+    () => verifyNetwork(ctx.client, args.root_path),
+    (report) => structuredResult(
+      `${report.nodeCount} node(s), ${report.connectionCount} connection(s) under ${args.root_path}.`,
+      report
+    )
+  );
+}
+var registerGetTdTopology = (server, ctx) => {
+  server.registerTool(
+    "get_td_topology",
+    {
+      title: "Get network topology",
+      description: "Return the nodes and connections under a network root, flagging obvious structural issues.",
+      inputSchema: getTdTopologySchema.shape,
+      outputSchema: getTdTopologyOutputSchema.shape,
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    (args) => getTdTopologyImpl(ctx, args)
+  );
+};
+
+// src/tools/layer3/snapshotTdGraph.ts
+import { z as z38 } from "zod";
+var MAX_PARAM_NODES = 60;
+var snapshotTdGraphSchema = z38.object({
+  path: z38.string().default("/project1").describe("Network root to snapshot."),
+  include_params: z38.boolean().default(false).describe("Also fetch each node's parameters (one request per node; capped for large graphs).")
+});
+var snapshotTdGraphOutputSchema = z38.object({
+  path: z38.string(),
+  nodeCount: z38.number(),
+  connectionCount: z38.number(),
+  issues: z38.array(z38.string()),
+  params_truncated: z38.boolean(),
+  nodes: z38.array(
+    z38.object({
+      path: z38.string(),
+      type: z38.string(),
+      name: z38.string(),
+      parameters: z38.record(z38.string(), z38.unknown()).optional()
+    })
+  ),
+  connections: z38.array(ConnectionSchema)
+});
+async function snapshotTdGraphImpl(ctx, args) {
+  return guardTd(
+    async () => {
+      const report = await verifyNetwork(ctx.client, args.path);
+      const refs = report.topology.nodes;
+      let paramsTruncated = false;
+      const params = /* @__PURE__ */ new Map();
+      if (args.include_params) {
+        const targets = refs.slice(0, MAX_PARAM_NODES);
+        paramsTruncated = refs.length > MAX_PARAM_NODES;
+        const details = await Promise.allSettled(targets.map((n) => ctx.client.getNode(n.path)));
+        for (const detail of details) {
+          if (detail.status === "fulfilled") params.set(detail.value.path, detail.value.parameters);
+        }
+      }
+      const nodes = refs.map((n) => ({
+        path: n.path,
+        type: n.type,
+        name: n.name,
+        ...args.include_params ? { parameters: params.get(n.path) ?? {} } : {}
+      }));
+      return { report, nodes, paramsTruncated };
+    },
+    ({ report, nodes, paramsTruncated }) => structuredResult(
+      `Snapshot of ${args.path}: ${report.nodeCount} node(s), ${report.connectionCount} connection(s)${report.issues.length ? `, ${report.issues.length} issue(s)` : ""}.`,
+      {
+        path: report.path,
+        nodeCount: report.nodeCount,
+        connectionCount: report.connectionCount,
+        issues: report.issues,
+        params_truncated: paramsTruncated,
+        nodes,
+        connections: report.topology.connections
+      }
+    )
+  );
+}
+var registerSnapshotTdGraph = (server, ctx) => {
+  server.registerTool(
+    "snapshot_td_graph",
+    {
+      title: "Snapshot network graph",
+      description: "Capture a compact, serializable snapshot of a network \u2014 nodes, connections, structural issues, and optionally each node's parameters \u2014 for review, diffing, or documentation.",
+      inputSchema: snapshotTdGraphSchema.shape,
+      outputSchema: snapshotTdGraphOutputSchema.shape,
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    (args) => snapshotTdGraphImpl(ctx, args)
+  );
+};
+
+// src/tools/layer3/summarizeTdErrors.ts
+import { z as z39 } from "zod";
+var summarizeTdErrorsSchema = z39.object({
+  path: z39.string().default("/project1").describe("Network root to collect errors under."),
+  group_by: z39.enum(["message", "type", "parent"]).default("message").describe(
+    "How to cluster errors: by exact message, by error type, or by parent container (to find a common upstream cause)."
+  )
+});
+var summarizeTdErrorsOutputSchema = z39.object({
+  path: z39.string(),
+  total: z39.number(),
+  group_by: z39.enum(["message", "type", "parent"]),
+  groups: z39.array(
+    z39.object({
+      key: z39.string(),
+      count: z39.number(),
+      sample: z39.object({ path: z39.string(), message: z39.string() })
+    })
+  ),
+  suggestions: z39.array(z39.string())
+});
+async function summarizeTdErrorsImpl(ctx, args) {
+  return guardTd(
+    () => ctx.client.getNetworkErrors(args.path),
+    (result) => {
+      const errors = result.errors;
+      const total = errors.length;
+      if (total === 0) {
+        return structuredResult(`No errors found under ${args.path}.`, {
+          path: args.path,
+          total: 0,
+          group_by: args.group_by,
+          groups: [],
+          suggestions: []
+        });
+      }
+      const keyOf = (e) => args.group_by === "message" ? e.message : args.group_by === "type" ? e.type || "error" : parentOf(e.path);
+      const grouped = /* @__PURE__ */ new Map();
+      const byPath = /* @__PURE__ */ new Map();
+      for (const e of errors) {
+        const key = keyOf(e);
+        const g = grouped.get(key);
+        if (g) g.count += 1;
+        else grouped.set(key, { count: 1, sample: { path: e.path, message: e.message } });
+        byPath.set(e.path, (byPath.get(e.path) ?? 0) + 1);
+      }
+      const groups = [...grouped.entries()].map(([key, g]) => ({ key, count: g.count, sample: g.sample })).sort((a, b) => b.count - a.count);
+      const worstNodes = [...byPath.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([p, c]) => `${p} (${c} error${c === 1 ? "" : "s"})`);
+      const suggestions = [];
+      if (groups[0] && groups[0].count > 1) {
+        suggestions.push(
+          `${groups[0].count} errors share ${args.group_by} "${groups[0].key}" \u2014 fixing the common cause clears them at once.`
+        );
+      }
+      if (worstNodes.length > 0) {
+        suggestions.push(`Check first: ${worstNodes.join(", ")}.`);
+      }
+      return structuredResult(
+        `${total} error(s) under ${args.path} in ${groups.length} ${args.group_by} group(s).`,
+        { path: args.path, total, group_by: args.group_by, groups, suggestions }
+      );
+    }
+  );
+}
+var registerSummarizeTdErrors = (server, ctx) => {
+  server.registerTool(
+    "summarize_td_errors",
+    {
+      title: "Summarize network errors",
+      description: "Collect errors across a network and cluster them by message, type, or parent container, with the worst-offending nodes and a suggested order to investigate. Use this instead of reading every node's errors one by one.",
+      inputSchema: summarizeTdErrorsSchema.shape,
+      outputSchema: summarizeTdErrorsOutputSchema.shape,
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    (args) => summarizeTdErrorsImpl(ctx, args)
+  );
+};
+
+// src/tools/layer3/updateTdNodeParameters.ts
+import { z as z40 } from "zod";
+var updateTdNodeParametersSchema = z40.object({
+  path: z40.string().describe("Full path of the node whose parameters to update."),
+  parameters: z40.record(z40.string(), z40.unknown()).describe("Parameter overrides as key\u2192value pairs, e.g. { period: 4, amplitude: 0.5 }.")
+});
+async function updateTdNodeParametersImpl(ctx, args) {
+  return guardTd(
+    () => ctx.client.updateNodeParameters(args.path, args.parameters),
+    (node) => jsonResult(`Updated ${Object.keys(args.parameters).length} parameter(s) on ${node.path}.`, {
+      node
+    })
+  );
+}
+var registerUpdateTdNodeParameters = (server, ctx) => {
+  server.registerTool(
+    "update_td_node_parameters",
+    {
+      title: "Update node parameters",
+      description: "Set one or more parameters on an existing node.",
+      inputSchema: updateTdNodeParametersSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => updateTdNodeParametersImpl(ctx, args)
+  );
+};
+
+// src/tools/layer3/index.ts
+var layer3Registrars = [
+  registerGetTdInfo,
+  registerCreateTdNode,
+  registerDeleteTdNode,
+  registerUpdateTdNodeParameters,
+  registerGetTdNodes,
+  registerGetTdNodeParameters,
+  registerGetTdNodeErrors,
+  registerExecutePythonScript,
+  registerExecNodeMethod,
+  registerGetTdClasses,
+  registerGetTdClassDetails,
+  registerGetModuleHelp,
+  registerGetTdPerformance,
+  registerGetTdTopology,
+  registerFindTdNodes,
+  registerSummarizeTdErrors,
+  registerCompareTdNodes,
+  registerSnapshotTdGraph
+];
+
+// src/tools/index.ts
+function registerAllTools(server, ctx) {
+  const registrars = [...layer3Registrars, ...layer2Registrars, ...layer1Registrars];
+  for (const register of registrars) register(server, ctx);
+}
+
+// src/utils/version.ts
+import { readFileSync } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var cached;
+function getVersion() {
+  if (cached) return cached;
+  let dir = dirname2(fileURLToPath2(import.meta.url));
+  for (let i = 0; i < 6; i++) {
+    try {
+      const raw = readFileSync(resolve2(dir, "package.json"), "utf8");
+      const pkg = JSON.parse(raw);
+      if (pkg.name === "tdmcp" && pkg.version) {
+        cached = pkg.version;
+        return cached;
+      }
+    } catch {
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  cached = "0.0.0";
+  return cached;
+}
+
+// src/knowledge/index.ts
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/utils/logger.ts
+var LEVELS = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40,
+  silent: 99
+};
+function createLogger(level = "info") {
+  const threshold = LEVELS[level];
+  const emit = (lvl, message, meta) => {
+    if (LEVELS[lvl] < threshold) return;
+    const stamp = (/* @__PURE__ */ new Date()).toISOString();
+    const suffix = meta && Object.keys(meta).length > 0 ? ` ${JSON.stringify(meta)}` : "";
+    process.stderr.write(`[tdmcp] ${stamp} ${lvl.toUpperCase()} ${message}${suffix}
+`);
+  };
+  return {
+    debug: (message, meta) => emit("debug", message, meta),
+    info: (message, meta) => emit("info", message, meta),
+    warn: (message, meta) => emit("warn", message, meta),
+    error: (message, meta) => emit("error", message, meta)
+  };
+}
+var silentLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+
+// src/knowledge/index.ts
+var EMPTY_SOURCE = {
+  kind: "empty",
+  operatorsDir: "",
+  pythonDir: "",
+  tutorialsDir: "",
+  patternsFile: "",
+  glslFile: ""
+};
+var KnowledgeBase = class _KnowledgeBase {
+  logger;
+  source;
+  opIndexCache;
+  opLookupCache;
+  opDocCache = /* @__PURE__ */ new Map();
+  pyIndexCache;
+  pyLookupCache;
+  pyDocCache = /* @__PURE__ */ new Map();
+  tutIndexCache;
+  tutLookupCache;
+  tutDocCache = /* @__PURE__ */ new Map();
+  patternsCache;
+  glslCache;
+  constructor(options = {}) {
+    this.logger = options.logger ?? silentLogger;
+    this.source = _KnowledgeBase.resolveSource(options.dataDir ?? knowledgeDataDir());
+    this.logger.debug("knowledge source resolved", { kind: this.source.kind });
+  }
+  static resolveSource(localDir) {
+    if (existsSync3(join2(localDir, "operators"))) {
+      return {
+        kind: "local",
+        operatorsDir: join2(localDir, "operators"),
+        operatorsIndex: join2(localDir, "operators", "index.json"),
+        pythonDir: join2(localDir, "python-api"),
+        tutorialsDir: join2(localDir, "tutorials"),
+        patternsFile: join2(localDir, "patterns.json"),
+        glslFile: join2(localDir, "glsl.json")
+      };
+    }
+    const bb = bottobotPackageDir();
+    if (bb) {
+      return {
+        kind: "bottobot",
+        operatorsDir: join2(bb, "wiki/data/processed"),
+        pythonDir: join2(bb, "wiki/data/python-api"),
+        tutorialsDir: join2(bb, "wiki/data/tutorials"),
+        patternsFile: join2(bb, "data/patterns.json"),
+        glslFile: join2(bb, "wiki/data/experimental/glsl.json")
+      };
+    }
+    return EMPTY_SOURCE;
+  }
+  readJson(path) {
+    try {
+      return JSON.parse(readFileSync2(path, "utf8"));
+    } catch (err) {
+      this.logger.debug("knowledge readJson failed", { path, error: String(err) });
+      return void 0;
+    }
+  }
+  listJsonFiles(dir) {
+    if (!dir || !existsSync3(dir)) return [];
+    try {
+      return readdirSync(dir).filter((f) => f.endsWith(".json") && f !== "index.json");
+    } catch {
+      return [];
+    }
+  }
+  // ---- Operators -----------------------------------------------------------
+  operatorIndex() {
+    if (this.opIndexCache) return this.opIndexCache;
+    if (this.source.kind === "empty") {
+      this.opIndexCache = [];
+      return this.opIndexCache;
+    }
+    if (this.source.operatorsIndex && existsSync3(this.source.operatorsIndex)) {
+      const data = this.readJson(this.source.operatorsIndex);
+      if (Array.isArray(data)) {
+        this.opIndexCache = data;
+        return this.opIndexCache;
+      }
+    }
+    const summaries = [];
+    for (const file of this.listJsonFiles(this.source.operatorsDir)) {
+      const doc = this.readJson(join2(this.source.operatorsDir, file));
+      if (doc?.name) summaries.push(toOperatorSummary(file.replace(/\.json$/, ""), doc));
+    }
+    this.opIndexCache = summaries;
+    return this.opIndexCache;
+  }
+  operatorLookup() {
+    if (this.opLookupCache) return this.opLookupCache;
+    const map = /* @__PURE__ */ new Map();
+    for (const summary of this.operatorIndex()) {
+      map.set(compactKey(summary.slug), summary.slug);
+      map.set(compactKey(summary.name), summary.slug);
+      map.set(compactKey(summary.displayName), summary.slug);
+    }
+    this.opLookupCache = map;
+    return map;
+  }
+  listOperatorCategories() {
+    const set = /* @__PURE__ */ new Set();
+    for (const summary of this.operatorIndex()) set.add(summary.category);
+    return [...set].sort();
+  }
+  listOperators(category) {
+    const all = this.operatorIndex();
+    if (!category) return all;
+    const wanted = compactKey(category);
+    return all.filter((s) => compactKey(s.category) === wanted);
+  }
+  getOperator(nameOrSlug) {
+    if (this.source.kind === "empty") return void 0;
+    const slug = this.operatorLookup().get(compactKey(nameOrSlug)) ?? slugify(nameOrSlug);
+    const cached2 = this.opDocCache.get(slug);
+    if (cached2 !== void 0) return cached2 ?? void 0;
+    const file = join2(this.source.operatorsDir, `${slug}.json`);
+    const doc = existsSync3(file) ? this.readJson(file) : void 0;
+    this.opDocCache.set(slug, doc ?? null);
+    return doc;
+  }
+  /** Soft existence check (by operator type, display name, or slug). */
+  operatorExists(typeOrName) {
+    return this.operatorLookup().has(compactKey(typeOrName));
+  }
+  searchOperators(query, limit = 25) {
+    const q11 = query.trim().toLowerCase();
+    if (!q11) return [];
+    const terms = q11.split(/\s+/);
+    const scored = [];
+    for (const summary of this.operatorIndex()) {
+      const haystack = `${summary.name} ${summary.displayName} ${summary.summary} ${summary.keywords.join(" ")}`.toLowerCase();
+      let score = 0;
+      for (const term of terms) {
+        if (haystack.includes(term)) score += 1;
+        if (summary.name.toLowerCase().includes(term)) score += 1;
+      }
+      if (score > 0) scored.push({ summary, score });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, limit).map((s) => s.summary);
+  }
+  // ---- Python API ----------------------------------------------------------
+  pythonIndex() {
+    if (this.pyIndexCache) return this.pyIndexCache;
+    if (this.source.kind === "empty") {
+      this.pyIndexCache = [];
+      return this.pyIndexCache;
+    }
+    const indexPath = join2(this.source.pythonDir, "index.json");
+    if (existsSync3(indexPath)) {
+      const data = this.readJson(indexPath);
+      if (Array.isArray(data)) {
+        this.pyIndexCache = data;
+        return this.pyIndexCache;
+      }
+    }
+    const summaries = [];
+    for (const file of this.listJsonFiles(this.source.pythonDir)) {
+      const cls = this.readJson(join2(this.source.pythonDir, file));
+      if (cls?.className) summaries.push(toPythonSummary(cls));
+    }
+    this.pyIndexCache = summaries;
+    return this.pyIndexCache;
+  }
+  pythonLookup() {
+    if (this.pyLookupCache) return this.pyLookupCache;
+    const map = /* @__PURE__ */ new Map();
+    for (const summary of this.pythonIndex()) {
+      map.set(compactKey(summary.className), summary.className);
+      map.set(compactKey(summary.displayName), summary.className);
+    }
+    this.pyLookupCache = map;
+    return map;
+  }
+  listPythonClasses() {
+    return this.pythonIndex();
+  }
+  getPythonClass(name) {
+    if (this.source.kind === "empty") return void 0;
+    const className = this.pythonLookup().get(compactKey(name)) ?? name;
+    const cached2 = this.pyDocCache.get(className);
+    if (cached2 !== void 0) return cached2 ?? void 0;
+    const file = join2(this.source.pythonDir, `${className}.json`);
+    const cls = existsSync3(file) ? this.readJson(file) : void 0;
+    this.pyDocCache.set(className, cls ?? null);
+    return cls;
+  }
+  // ---- Patterns ------------------------------------------------------------
+  patterns() {
+    if (this.patternsCache) return this.patternsCache;
+    if (this.source.kind === "empty") {
+      this.patternsCache = [];
+      return this.patternsCache;
+    }
+    const data = this.readJson(this.source.patternsFile);
+    if (Array.isArray(data) && data.length > 0 && typeof data[0].id === "string") {
+      this.patternsCache = data;
+    } else {
+      this.patternsCache = normalizePatterns(data);
+    }
+    return this.patternsCache;
+  }
+  listPatterns() {
+    return this.patterns().map((p) => ({
+      id: p.id,
+      name: p.name,
+      category: p.category ?? "Unknown",
+      description: p.description ?? ""
+    }));
+  }
+  getPattern(name) {
+    const key = compactKey(name);
+    return this.patterns().find((p) => compactKey(p.id) === key || compactKey(p.name) === key);
+  }
+  // ---- GLSL ----------------------------------------------------------------
+  glsl() {
+    if (this.glslCache) return this.glslCache;
+    if (this.source.kind === "empty") {
+      this.glslCache = [];
+      return this.glslCache;
+    }
+    const data = this.readJson(this.source.glslFile);
+    this.glslCache = Array.isArray(data) ? data : normalizeGlsl(data);
+    return this.glslCache;
+  }
+  listGlslPatterns() {
+    return this.glsl().map((g) => ({
+      id: g.id,
+      name: g.name,
+      description: g.description ?? "",
+      difficulty: g.difficulty ?? "unknown"
+    }));
+  }
+  getGlslPattern(name) {
+    const key = compactKey(name);
+    return this.glsl().find((g) => compactKey(g.id) === key || compactKey(g.name) === key);
+  }
+  // ---- Tutorials -----------------------------------------------------------
+  tutorialIndex() {
+    if (this.tutIndexCache) return this.tutIndexCache;
+    if (this.source.kind === "empty") {
+      this.tutIndexCache = [];
+      return this.tutIndexCache;
+    }
+    const indexPath = join2(this.source.tutorialsDir, "index.json");
+    if (existsSync3(indexPath)) {
+      const data = this.readJson(indexPath);
+      if (Array.isArray(data)) {
+        this.tutIndexCache = data;
+        return this.tutIndexCache;
+      }
+    }
+    const summaries = [];
+    for (const file of this.listJsonFiles(this.source.tutorialsDir)) {
+      const tut = this.readJson(join2(this.source.tutorialsDir, file));
+      if (tut?.id || tut?.name) {
+        const normalized = {
+          ...tut,
+          id: tut.id ?? file.replace(/\.json$/, ""),
+          name: tut.name ?? file
+        };
+        summaries.push(toTutorialSummary(normalized));
+      }
+    }
+    this.tutIndexCache = summaries;
+    return this.tutIndexCache;
+  }
+  tutorialLookup() {
+    if (this.tutLookupCache) return this.tutLookupCache;
+    const map = /* @__PURE__ */ new Map();
+    for (const file of this.listJsonFiles(this.source.tutorialsDir)) {
+      const slug = file.replace(/\.json$/, "");
+      map.set(compactKey(slug), slug);
+    }
+    for (const summary of this.tutorialIndex()) {
+      map.set(compactKey(summary.id), summary.id);
+      map.set(compactKey(summary.name), summary.id);
+    }
+    this.tutLookupCache = map;
+    return map;
+  }
+  listTutorials() {
+    return this.tutorialIndex();
+  }
+  getTutorial(name) {
+    if (this.source.kind === "empty") return void 0;
+    const slug = this.tutorialLookup().get(compactKey(name)) ?? slugify(name);
+    const cached2 = this.tutDocCache.get(slug);
+    if (cached2 !== void 0) return cached2 ?? void 0;
+    const file = join2(this.source.tutorialsDir, `${slug}.json`);
+    const tut = existsSync3(file) ? this.readJson(file) : void 0;
+    this.tutDocCache.set(slug, tut ?? null);
+    return tut;
+  }
+  // ---- Meta ----------------------------------------------------------------
+  get sourceKind() {
+    return this.source.kind;
+  }
+  stats() {
+    return {
+      source: this.source.kind,
+      operators: this.operatorIndex().length,
+      pythonClasses: this.pythonIndex().length,
+      patterns: this.patterns().length,
+      glsl: this.glsl().length,
+      tutorials: this.tutorialIndex().length
+    };
+  }
+};
+
+// src/recipes/loader.ts
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+
+// src/recipes/schema.ts
+import { z as z41 } from "zod";
+var RecipeNodeSchema = z41.object({
+  name: z41.string().describe("Unique node name within the recipe (used for wiring)."),
+  type: z41.string().describe("Operator type, e.g. 'noiseTOP'."),
+  parameters: z41.record(z41.string(), z41.unknown()).default({}),
+  parent: z41.string().optional().describe(
+    "Name of another recipe node (a COMP, e.g. a geometryCOMP) to nest this node inside of. The parent must appear earlier in `nodes`. Used to place SOPs inside a Geometry COMP."
+  ),
+  render: z41.boolean().optional().describe(
+    "For a SOP nested in a geometryCOMP: make this the rendered geometry. Sets the render/display flags on it and clears its siblings, so the COMP renders this instead of its default torus."
+  ),
+  comment: z41.string().optional()
+});
+var RecipeConnectionSchema = z41.object({
+  from: z41.string().describe("Source node name."),
+  to: z41.string().describe("Target node name."),
+  from_output: z41.number().int().nonnegative().default(0),
+  to_input: z41.number().int().nonnegative().default(0)
+});
+var RecipeParameterSchema = z41.object({
+  name: z41.string().describe("Friendly name of the exposed control."),
+  node: z41.string().describe("Recipe node name the parameter belongs to."),
+  param: z41.string().describe("TD parameter name on that node."),
+  value: z41.unknown().optional(),
+  label: z41.string().optional(),
+  min: z41.number().optional(),
+  max: z41.number().optional(),
+  description: z41.string().optional()
+});
+var RecipeGlslUniformSchema = z41.object({
+  node: z41.string().describe("Recipe node name of the GLSL TOP that declares the uniform."),
+  name: z41.string().describe("Uniform name as referenced in the shader, e.g. 'uFeed'."),
+  kind: z41.enum(["float", "vec", "color"]).default("float").describe(
+    "Uniform kind: float (uniform float), vec (uniform vec2/3/4), color (rgba). float/vec use the Vectors page; color uses the Colors page."
+  ),
+  value: z41.union([z41.number(), z41.array(z41.number())]).optional().describe("Initial value: a number for float, or an array of components for vec/color."),
+  label: z41.string().optional(),
+  min: z41.number().optional(),
+  max: z41.number().optional(),
+  description: z41.string().optional()
+});
+var RecipeSchema = z41.object({
+  id: z41.string(),
+  name: z41.string(),
+  description: z41.string().default(""),
+  tags: z41.array(z41.string()).default([]),
+  difficulty: z41.enum(["beginner", "intermediate", "advanced"]).default("intermediate"),
+  td_version_min: z41.string().default("2023"),
+  nodes: z41.array(RecipeNodeSchema).min(1),
+  connections: z41.array(RecipeConnectionSchema).default([]),
+  parameters: z41.array(RecipeParameterSchema).default([]),
+  glsl_uniforms: z41.array(RecipeGlslUniformSchema).default([]),
+  glsl_code: z41.record(z41.string(), z41.string()).optional(),
+  python_code: z41.record(z41.string(), z41.string()).optional(),
+  preview_description: z41.string().default("")
+});
+
+// src/recipes/loader.ts
+var RecipeLibrary = class {
+  dir;
+  logger;
+  cache;
+  constructor(options = {}) {
+    this.dir = options.dir ?? recipesDir();
+    this.logger = options.logger ?? silentLogger;
+  }
+  load() {
+    if (this.cache) return this.cache;
+    const recipes = [];
+    if (existsSync4(this.dir)) {
+      for (const file of readdirSync2(this.dir)) {
+        if (!file.endsWith(".json")) continue;
+        try {
+          const raw = JSON.parse(readFileSync3(join3(this.dir, file), "utf8"));
+          const parsed = RecipeSchema.safeParse(raw);
+          if (parsed.success) {
+            recipes.push(parsed.data);
+          } else {
+            this.logger.warn(`Invalid recipe ${file}`, { issues: parsed.error.issues.length });
+          }
+        } catch (err) {
+          this.logger.warn(`Failed to read recipe ${file}`, { error: String(err) });
+        }
+      }
+    }
+    this.cache = recipes;
+    return recipes;
+  }
+  all() {
+    return this.load();
+  }
+  list() {
+    return this.load().map((r) => ({
+      id: r.id,
+      name: r.name,
+      description: r.description,
+      tags: r.tags,
+      difficulty: r.difficulty
+    }));
+  }
+  get(id) {
+    const key = compactKey(id);
+    return this.load().find((r) => compactKey(r.id) === key || compactKey(r.name) === key);
+  }
+  /** Finds the best recipe whose tags/name/description match any of the given terms. */
+  findByTags(terms) {
+    const wanted = terms.map((t) => t.toLowerCase()).filter(Boolean);
+    if (wanted.length === 0) return void 0;
+    let best;
+    for (const recipe of this.load()) {
+      const haystack = `${recipe.name} ${recipe.description} ${recipe.tags.join(" ")}`.toLowerCase();
+      let score = 0;
+      for (const term of wanted) {
+        if (recipe.tags.some((tag) => tag.toLowerCase() === term)) score += 2;
+        else if (haystack.includes(term)) score += 1;
+      }
+      if (score > 0 && (!best || score > best.score)) best = { recipe, score };
+    }
+    return best?.recipe;
+  }
+};
+
+// src/td-client/touchDesignerClient.ts
+function extractErrorMessage(json) {
+  if (json && typeof json === "object") {
+    const obj = json;
+    const error = obj.error;
+    if (error && typeof error === "object" && typeof error.message === "string") {
+      return error.message;
+    }
+    if (typeof obj.message === "string") return obj.message;
+  }
+  return void 0;
+}
+function segment(path) {
+  return encodeURIComponent(path);
+}
+var TouchDesignerClient = class {
+  baseUrl;
+  timeoutMs;
+  logger;
+  token;
+  fetchImpl;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.timeoutMs = options.timeoutMs ?? 1e4;
+    this.logger = options.logger ?? silentLogger;
+    this.token = options.token;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  get endpoint() {
+    return this.baseUrl;
+  }
+  async request(method, path, schema, body, query) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0) url.searchParams.set(key, String(value));
+      }
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    let response;
+    try {
+      this.logger.debug(`TD ${method} ${path}`);
+      const headers = {};
+      if (body !== void 0) headers["content-type"] = "application/json";
+      if (this.token) headers.authorization = `Bearer ${this.token}`;
+      response = await this.fetchImpl(url, {
+        method,
+        signal: controller.signal,
+        headers: Object.keys(headers).length > 0 ? headers : void 0,
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      });
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new TdTimeoutError(
+          `TouchDesigner request timed out after ${this.timeoutMs}ms (${method} ${path}).`,
+          { cause: err }
+        );
+      }
+      throw new TdConnectionError(
+        `Cannot reach TouchDesigner at ${this.baseUrl}. Make sure TD is running with the tdmcp bridge (WebServer DAT) installed and listening on that port.`,
+        { cause: err }
+      );
+    } finally {
+      clearTimeout(timer);
+    }
+    const text = await response.text();
+    let json;
+    if (text) {
+      try {
+        json = JSON.parse(text);
+      } catch {
+        json = void 0;
+      }
+    }
+    if (!response.ok) {
+      const message = extractErrorMessage(json) ?? `TouchDesigner bridge returned HTTP ${response.status} for ${method} ${path}.`;
+      throw new TdApiError(message, { status: response.status });
+    }
+    const envelope = ApiEnvelopeSchema.safeParse(json);
+    if (!envelope.success) {
+      throw new TdApiError(`Malformed response from TouchDesigner bridge for ${method} ${path}.`, {
+        status: response.status
+      });
+    }
+    if (!envelope.data.ok) {
+      throw new TdApiError(
+        envelope.data.error?.message ?? `TouchDesigner reported an error for ${method} ${path}.`,
+        { status: response.status, apiCode: envelope.data.error?.code }
+      );
+    }
+    const parsed = schema.safeParse(envelope.data.data);
+    if (!parsed.success) {
+      throw new TdApiError(
+        `Unexpected data shape from TouchDesigner bridge for ${method} ${path}: ${parsed.error.message}`,
+        { status: response.status }
+      );
+    }
+    return parsed.data;
+  }
+  getInfo() {
+    return this.request("GET", "/api/info", InfoSchema);
+  }
+  createNode(input) {
+    return this.request("POST", "/api/nodes", NodeRefSchema, CreateNodeInputSchema.parse(input));
+  }
+  deleteNode(path) {
+    return this.request("DELETE", `/api/nodes/${segment(path)}`, DeleteResultSchema);
+  }
+  getNodes(parentPath) {
+    return this.request("GET", "/api/nodes", NodeListSchema, void 0, { parent: parentPath });
+  }
+  getNode(path) {
+    return this.request("GET", `/api/nodes/${segment(path)}`, NodeDetailSchema);
+  }
+  updateNodeParameters(path, parameters) {
+    return this.request("PATCH", `/api/nodes/${segment(path)}`, NodeDetailSchema, { parameters });
+  }
+  executePythonScript(script, returnOutput = true) {
+    return this.request("POST", "/api/exec", ExecResultSchema, {
+      script,
+      return_output: returnOutput
+    });
+  }
+  execNodeMethod(path, method, args = [], kwargs = {}) {
+    return this.request("POST", `/api/nodes/${segment(path)}/method`, MethodResultSchema, {
+      method,
+      args,
+      kwargs
+    });
+  }
+  getNodeErrors(path) {
+    return this.request("GET", `/api/nodes/${segment(path)}/errors`, NodeErrorsSchema);
+  }
+  getPreview(path, width = 640, height = 360) {
+    return this.request("GET", `/api/preview/${segment(path)}`, PreviewSchema, void 0, {
+      width,
+      height
+    });
+  }
+  batch(operations) {
+    return this.request("POST", "/api/batch", BatchResultSchema, { operations });
+  }
+  getNetworkErrors(path) {
+    return this.request("GET", `/api/network/${segment(path)}/errors`, NodeErrorsSchema);
+  }
+  getNetworkTopology(path, recursive = false) {
+    return this.request(
+      "GET",
+      `/api/network/${segment(path)}/topology`,
+      TopologySchema,
+      void 0,
+      recursive ? { recursive: true } : void 0
+    );
+  }
+  getNetworkPerformance(path) {
+    return this.request("GET", `/api/network/${segment(path)}/performance`, PerformanceSchema);
+  }
+};
+
+// src/utils/config.ts
+import { z as z42 } from "zod";
+var ConfigSchema = z42.object({
+  /** TouchDesigner bridge host. */
+  tdHost: z42.string().min(1).default("127.0.0.1"),
+  /** TouchDesigner bridge port (WebServer DAT). */
+  tdPort: z42.coerce.number().int().positive().max(65535).default(9980),
+  /** MCP transport: `stdio` (default, for local clients) or `http` (Streamable HTTP, loopback-only). */
+  transport: z42.enum(["stdio", "http"]).default("stdio"),
+  /** Log verbosity (written to stderr). */
+  logLevel: z42.enum(["debug", "info", "warn", "error", "silent"]).default("info"),
+  /** Per-request timeout against the TD bridge, in milliseconds. */
+  requestTimeoutMs: z42.coerce.number().int().positive().default(1e4),
+  /** HTTP transport port (only used when transport=http). */
+  httpPort: z42.coerce.number().int().positive().max(65535).default(3939),
+  /** Subscribe to TD WebSocket events and forward them as MCP logging notifications. */
+  events: z42.enum(["on", "off"]).default("on"),
+  /**
+   * Raw Python escape-hatch tools (`execute_python_script`, `exec_node_method`).
+   * Set to "off" to lock them out for restricted setups; on by default.
+   */
+  rawPython: z42.enum(["on", "off"]).default("on"),
+  /**
+   * Optional shared bearer token for the TD bridge. When set, the server sends it
+   * as `Authorization: Bearer <token>` and the bridge requires a match. Leave unset
+   * (default) for the zero-config local flow. Set the SAME value in TouchDesigner's
+   * environment (`TDMCP_BRIDGE_TOKEN`) to turn enforcement on.
+   */
+  bridgeToken: z42.string().min(1).optional()
+});
+function loadConfig(env = process.env) {
+  return ConfigSchema.parse({
+    tdHost: env.TDMCP_TD_HOST,
+    tdPort: env.TDMCP_TD_PORT,
+    transport: env.TDMCP_TRANSPORT,
+    logLevel: env.TDMCP_LOG_LEVEL,
+    requestTimeoutMs: env.TDMCP_REQUEST_TIMEOUT_MS,
+    httpPort: env.TDMCP_HTTP_PORT,
+    events: env.TDMCP_EVENTS,
+    rawPython: env.TDMCP_RAW_PYTHON,
+    bridgeToken: env.TDMCP_BRIDGE_TOKEN || void 0
+  });
+}
+function tdBaseUrl(config) {
+  return `http://${config.tdHost}:${config.tdPort}`;
+}
+
+// src/server/connectionManager.ts
+var ConnectionManager = class {
+  client;
+  constructor(config, logger) {
+    this.client = new TouchDesignerClient({
+      baseUrl: tdBaseUrl(config),
+      timeoutMs: config.requestTimeoutMs,
+      token: config.bridgeToken,
+      logger
+    });
+  }
+  async isReachable() {
+    try {
+      await this.client.getInfo();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/server/context.ts
+function buildToolContext(config, overrides = {}) {
+  const logger = overrides.logger ?? createLogger(config.logLevel);
+  const connection = overrides.connection ?? new ConnectionManager(config, logger);
+  const knowledge = overrides.knowledge ?? new KnowledgeBase({ logger });
+  const recipes = overrides.recipes ?? new RecipeLibrary({ logger });
+  return {
+    client: connection.client,
+    knowledge,
+    recipes,
+    logger,
+    allowRawPython: config.rawPython !== "off"
+  };
+}
+
+// src/server/tdmcpServer.ts
+var INSTRUCTIONS = `tdmcp lets you build visual systems in TouchDesigner.
+
+Workflow:
+1. Call get_td_info first to confirm the bridge is reachable.
+2. Consult the knowledge base resources (tdmcp://operators/..., tdmcp://recipes/...) before creating nodes \u2014 never invent operator types.
+3. Build with the highest-level tool that fits, dropping to Layer 2/3 for fine control.
+4. After building, check get_td_node_errors and capture get_preview so the artist can see the result.
+5. Prefer structured inspection/edit tools (find_td_nodes, get_td_node_parameters, summarize_td_errors, compare_td_nodes, snapshot_td_graph, update_td_node_parameters) and process their structuredContent with code. Treat execute_python_script and exec_node_method as a last resort, only when no structured tool fits.
+
+The server stays usable even when TouchDesigner is offline; tools return a friendly error in that case.`;
+function createTdmcpServer(config, overrides = {}) {
+  const ctx = buildToolContext(config, overrides);
+  const { knowledge, recipes, logger } = ctx;
+  const server = new McpServer(
+    { name: "tdmcp", version: getVersion() },
+    { instructions: INSTRUCTIONS }
+  );
+  registerAllTools(server, ctx);
+  registerAllResources(server, { knowledge, recipes, logger });
+  registerAllPrompts(server, { knowledge, recipes, logger });
+  logger.info("tdmcp server initialized", {
+    version: getVersion(),
+    knowledge: knowledge.stats(),
+    recipes: recipes.list().length
+  });
+  return server;
+}
+
+// src/server/transportFactory.ts
+import { randomUUID } from "crypto";
+import { createServer } from "http";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+
+// src/td-client/eventStream.ts
+var HIGH_FREQUENCY = /* @__PURE__ */ new Set(["timeline.frame", "node.cook"]);
+function parseEventMessage(raw, includeHighFrequency = false) {
+  if (typeof raw !== "string") return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  if (!parsed || typeof parsed !== "object") return void 0;
+  const event = parsed.event;
+  if (typeof event !== "string") return void 0;
+  if (!includeHighFrequency && HIGH_FREQUENCY.has(event)) return void 0;
+  return { event, data: parsed.data };
+}
+var TdEventStream = class {
+  socket;
+  closed = false;
+  backoffMs = 1e3;
+  url;
+  onEvent;
+  logger;
+  includeHighFrequency;
+  constructor(options) {
+    this.url = options.url;
+    this.onEvent = options.onEvent;
+    this.logger = options.logger ?? silentLogger;
+    this.includeHighFrequency = options.includeHighFrequency ?? false;
+  }
+  start() {
+    this.connect();
+  }
+  connect() {
+    if (this.closed) return;
+    let socket;
+    try {
+      socket = new WebSocket(this.url);
+    } catch {
+      this.scheduleReconnect();
+      return;
+    }
+    this.socket = socket;
+    socket.addEventListener("open", () => {
+      this.backoffMs = 1e3;
+      this.logger.debug("event stream connected", { url: this.url });
+    });
+    socket.addEventListener("message", (ev) => {
+      const event = parseEventMessage(ev.data, this.includeHighFrequency);
+      if (!event) return;
+      try {
+        this.onEvent(event);
+      } catch (err) {
+        this.logger.debug("event handler failed", { error: String(err) });
+      }
+    });
+    socket.addEventListener("close", () => this.scheduleReconnect());
+    socket.addEventListener("error", () => {
+    });
+  }
+  scheduleReconnect() {
+    if (this.closed) return;
+    const delay = this.backoffMs;
+    this.backoffMs = Math.min(this.backoffMs * 2, 3e4);
+    const timer = setTimeout(() => this.connect(), delay);
+    timer.unref?.();
+  }
+  close() {
+    this.closed = true;
+    try {
+      this.socket?.close();
+    } catch {
+    }
+  }
+};
+
+// src/server/transportFactory.ts
+var MCP_PATH = "/mcp";
+function forwardEvent(server, event) {
+  const level = event.event === "node.error" ? "error" : "info";
+  void server.sendLoggingMessage({ level, logger: "touchdesigner", data: event }).catch(() => {
+  });
+}
+function createEventStream(config, logger, onEvent) {
+  if (config.events !== "on") return void 0;
+  const url = `${tdBaseUrl(config).replace(/^http/, "ws")}/`;
+  const stream = new TdEventStream({ url, logger, onEvent });
+  stream.start();
+  return stream;
+}
+function readBody(req) {
+  return new Promise((resolve3, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString("utf8");
+      if (!raw) return resolve3(void 0);
+      try {
+        resolve3(JSON.parse(raw));
+      } catch (err) {
+        reject(err);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function sendJson(res, status, payload) {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(payload));
+}
+function startStdio(createMcpServer, config, logger) {
+  const server = createMcpServer();
+  const transport = new StdioServerTransport();
+  void server.connect(transport);
+  logger.info("tdmcp connected over stdio");
+  const events = createEventStream(config, logger, (event) => forwardEvent(server, event));
+  return {
+    close: async () => {
+      events?.close();
+      await server.close();
+    }
+  };
+}
+function startHttp(createMcpServer, config, logger) {
+  const transports = /* @__PURE__ */ new Map();
+  const servers = /* @__PURE__ */ new Map();
+  const events = createEventStream(config, logger, (event) => {
+    for (const sessionServer of servers.values()) forwardEvent(sessionServer, event);
+  });
+  const httpServer = createServer((req, res) => {
+    void handle(req, res).catch((err) => {
+      logger.error("HTTP request failed", { error: String(err) });
+      if (!res.headersSent) {
+        sendJson(res, 500, {
+          jsonrpc: "2.0",
+          error: { code: -32603, message: "Internal server error" },
+          id: null
+        });
+      }
+    });
+  });
+  async function handle(req, res) {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    if (url.pathname !== MCP_PATH) {
+      sendJson(res, 404, { error: "Not found. MCP endpoint is at /mcp." });
+      return;
+    }
+    const sessionId = req.headers["mcp-session-id"];
+    const existing = typeof sessionId === "string" ? transports.get(sessionId) : void 0;
+    if (req.method === "POST") {
+      const body = await readBody(req);
+      if (!existing) {
+        if (!isInitializeRequest(body)) {
+          sendJson(res, 400, {
+            jsonrpc: "2.0",
+            error: { code: -32e3, message: "No valid session; send an initialize request first." },
+            id: null
+          });
+          return;
+        }
+        const sessionServer = createMcpServer();
+        const created = new StreamableHTTPServerTransport({
+          sessionIdGenerator: () => randomUUID(),
+          onsessioninitialized: (id) => {
+            transports.set(id, created);
+            servers.set(id, sessionServer);
+          },
+          // Reject Host headers other than loopback to block DNS-rebinding attacks.
+          enableDnsRebindingProtection: true,
+          allowedHosts: [`127.0.0.1:${config.httpPort}`, `localhost:${config.httpPort}`]
+        });
+        created.onclose = () => {
+          if (created.sessionId) {
+            transports.delete(created.sessionId);
+            servers.delete(created.sessionId);
+          }
+        };
+        await sessionServer.connect(created);
+        await created.handleRequest(req, res, body);
+        return;
+      }
+      await existing.handleRequest(req, res, body);
+      return;
+    }
+    if (req.method === "GET" || req.method === "DELETE") {
+      if (!existing) {
+        sendJson(res, 400, { error: "Unknown or missing mcp-session-id." });
+        return;
+      }
+      await existing.handleRequest(req, res);
+      return;
+    }
+    sendJson(res, 405, { error: "Method not allowed." });
+  }
+  httpServer.listen(config.httpPort, "127.0.0.1", () => {
+    logger.info("tdmcp listening over Streamable HTTP", { port: config.httpPort, path: MCP_PATH });
+  });
+  return {
+    close: async () => {
+      events?.close();
+      for (const transport of transports.values()) await transport.close();
+      transports.clear();
+      servers.clear();
+      await new Promise((resolve3) => httpServer.close(() => resolve3()));
+    }
+  };
+}
+async function startTransport(createMcpServer, config, logger) {
+  if (config.transport === "http") {
+    return startHttp(createMcpServer, config, logger);
+  }
+  return startStdio(createMcpServer, config, logger);
+}
+
+// src/index.ts
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv[0] === "install-bridge") {
+    runInstallBridge(argv.slice(1));
+    return;
+  }
+  const config = loadConfig();
+  const logger = createLogger(config.logLevel);
+  try {
+    const handle = await startTransport(
+      () => createTdmcpServer(config, { logger }),
+      config,
+      logger
+    );
+    const shutdown = () => {
+      logger.info("tdmcp shutting down");
+      void handle.close().finally(() => process.exit(0));
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  } catch (err) {
+    logger.error("Failed to start tdmcp server", { error: String(err) });
+    process.exitCode = 1;
+  }
+}
+void main();
+//# sourceMappingURL=index.js.map