@dpantani/tdmcp 0.1.0 → 0.2.0

package/dist/index.js

@@ -549,7 +549,7 @@ function registerAllResources(server, ctx) {
 }
 
 // src/tools/layer1/applyPostProcessing.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/feedback/errorChecker.ts
 async function checkErrors(client, path, recursive = true) {
@@ -624,11 +624,49 @@ async function connectNodesViaBridge(client, sourcePath, targetPath, sourceOutpu
   }
   const src = JSON.stringify(sourcePath);
   const dst = JSON.stringify(targetPath);
-  const python = `op(${dst}).inputConnectors[${targetInput}].connect(op(${src}).outputConnectors[${sourceOutput}])`;
+  const python = [
+    `__s = op(${src}); __d = op(${dst})`,
+    `if __s is None or __d is None: raise LookupError('connect: source or target not found (%s -> %s)' % (${src}, ${dst}))`,
+    `if __s.parent() is None or __d.parent() is None or __s.parent().path != __d.parent().path: raise ValueError('connect: cannot wire across containers (%s -> %s); use a Select/In OP to bring an operator across networks' % (${src}, ${dst}))`,
+    `__d.inputConnectors[${targetInput}].connect(__s.outputConnectors[${sourceOutput}])`
+  ].join("\n");
   await client.executePythonScript(python, false);
   return { method: "python" };
 }
 
+// src/tools/layer2/createControlPanel.ts
+import { z as z6 } from "zod";
+
+// src/tools/pythonReport.ts
+function buildPayloadScript(template, payload) {
+  const b64 = Buffer.from(JSON.stringify(payload), "utf8").toString("base64");
+  return template.replace("__PAYLOAD_B64__", b64);
+}
+function parsePythonReport(stdout) {
+  if (!stdout) throw new TdApiError("The TouchDesigner script returned no output.");
+  const lines = stdout.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i]?.trim();
+    if (!line) continue;
+    if (line.startsWith("{") && line.endsWith("}")) {
+      try {
+        return JSON.parse(line);
+      } catch {
+      }
+    }
+    break;
+  }
+  const start = stdout.indexOf("{");
+  const end = stdout.lastIndexOf("}");
+  if (start >= 0 && end > start) {
+    try {
+      return JSON.parse(stdout.slice(start, end + 1));
+    } catch {
+    }
+  }
+  throw new TdApiError(`Could not parse the TouchDesigner script result: ${stdout.slice(0, 200)}`);
+}
+
 // src/tools/result.ts
 function textResult(text) {
   return { content: [{ type: "text", text }] };
@@ -664,6 +702,254 @@ async function guardTd(fn, onOk) {
   }
 }
 
+// src/tools/layer2/createControlPanel.ts
+var controlSchema = z6.object({
+  name: z6.string().describe(
+    "Control label; also sanitized into a valid TD custom-parameter name (e.g. 'blur amount' \u2192 'Bluramount')."
+  ),
+  type: z6.enum(["float", "int", "toggle", "menu", "rgb", "pulse", "string"]).default("float").describe(
+    "Widget kind: float/int sliders, a toggle, a dropdown menu, an RGB swatch, a momentary pulse, or a text field."
+  ),
+  label: z6.string().optional().describe("Display label (defaults to `name`)."),
+  min: z6.coerce.number().optional().describe("Slider lower bound (float/int) \u2014 also hard-clamped."),
+  max: z6.coerce.number().optional().describe("Slider upper bound (float/int) \u2014 also hard-clamped."),
+  default: z6.union([z6.number(), z6.boolean(), z6.string()]).optional().describe("Initial value."),
+  menu_items: z6.array(z6.string()).optional().describe("Options for a 'menu' control."),
+  bind_to: z6.array(z6.string()).optional().describe(
+    "Parameters this control should drive, each written as 'nodePath.parName' (e.g. '/project1/sys/blur1.size'). Each target is switched to expression mode so moving the control moves the parameter live. Not supported for 'rgb'/'pulse'."
+  )
+});
+var createControlPanelSchema = z6.object({
+  comp_path: z6.string().default("/project1").describe(
+    "COMP that will receive the custom parameters \u2014 usually a generated system's container."
+  ),
+  page: z6.string().default("Controls").describe("Name of the custom-parameter page to add the controls to."),
+  controls: z6.array(controlSchema).min(1).describe("The controls (knobs/sliders/toggles/menus) to expose.")
+});
+var PANEL_SCRIPT = `
+import json, base64, traceback
+_payload = json.loads(base64.b64decode("__PAYLOAD_B64__").decode("utf-8"))
+_comp = op(_payload["comp"]); _page_name = _payload["page"]; _controls = _payload["controls"]
+report = {"comp": _payload["comp"], "page": _page_name, "created": [], "bound": [], "warnings": []}
+
+def _parname(s):
+    s = "".join(ch for ch in s if ch.isalnum())
+    if not s:
+        s = "Par"
+    if not s[0].isalpha():
+        s = "P" + s
+    # TD custom-parameter names must be a leading uppercase letter followed by lowercase
+    # letters/digits only, so lowercase the tail \u2014 otherwise camelCase input like "CamZoom"
+    # keeps its internal capital and TouchDesigner rejects the name.
+    return s[0].upper() + s[1:].lower()
+
+if _comp is None:
+    report["fatal"] = "COMP not found: " + _payload["comp"]
+elif not hasattr(_comp, "appendCustomPage"):
+    report["fatal"] = _payload["comp"] + " is not a COMP, so it cannot hold custom parameters."
+else:
+    _page = None
+    for _pg in _comp.customPages:
+        if _pg.name == _page_name:
+            _page = _pg
+            break
+    if _page is None:
+        _page = _comp.appendCustomPage(_page_name)
+    for _spec in _controls:
+        try:
+            _name = _parname(_spec["name"]); _typ = _spec.get("type", "float"); _label = _spec.get("label") or _spec["name"]
+            if _typ == "float":
+                _pg = _page.appendFloat(_name, label=_label)
+            elif _typ == "int":
+                _pg = _page.appendInt(_name, label=_label)
+            elif _typ == "toggle":
+                _pg = _page.appendToggle(_name, label=_label)
+            elif _typ == "menu":
+                _pg = _page.appendMenu(_name, label=_label)
+            elif _typ == "rgb":
+                _pg = _page.appendRGB(_name, label=_label)
+            elif _typ == "pulse":
+                _pg = _page.appendPulse(_name, label=_label)
+            elif _typ in ("string", "str"):
+                _pg = _page.appendStr(_name, label=_label)
+            else:
+                report["warnings"].append("Unknown control type '%s' for '%s'." % (_typ, _spec["name"]))
+                continue
+            _p0 = _pg[0]; _dflt = _spec.get("default", None)
+            if _typ in ("float", "int"):
+                _mn = _spec.get("min", None); _mx = _spec.get("max", None)
+                if _mn is not None:
+                    _p0.normMin = _mn; _p0.min = _mn; _p0.clampMin = True
+                if _mx is not None:
+                    _p0.normMax = _mx; _p0.max = _mx; _p0.clampMax = True
+                if _dflt is not None:
+                    _p0.default = _dflt; _p0.val = _dflt
+            elif _typ == "toggle":
+                if _dflt is not None:
+                    _p0.default = bool(_dflt); _p0.val = bool(_dflt)
+            elif _typ == "menu":
+                _items = _spec.get("menu_items") or []
+                if _items:
+                    _names = [str(x) for x in _items]
+                    _p0.menuNames = _names; _p0.menuLabels = _names
+                if _dflt is not None and str(_dflt) in [str(x) for x in _items]:
+                    _p0.default = str(_dflt); _p0.val = str(_dflt)
+            elif _typ in ("string", "str"):
+                if _dflt is not None:
+                    _p0.default = str(_dflt); _p0.val = str(_dflt)
+            report["created"].append({"control": _spec["name"], "name": _name, "type": _typ, "pars": [pp.name for pp in _pg], "value": _p0.eval()})
+            _binds = _spec.get("bind_to") or []
+            if _binds and _typ in ("rgb", "pulse"):
+                report["warnings"].append("bind_to ignored for '%s' (a %s control cannot drive a single parameter)." % (_spec["name"], _typ))
+                _binds = []
+            for _t in _binds:
+                try:
+                    _dot = _t.rfind(".")
+                    if _dot <= 0:
+                        report["warnings"].append("Invalid bind target '%s' (expected 'nodePath.parName')." % _t)
+                        continue
+                    _np = _t[:_dot]; _pn = _t[_dot + 1:]; _tn = op(_np)
+                    if _tn is None:
+                        report["warnings"].append("Bind target node not found: %s" % _np)
+                        continue
+                    _tp = getattr(_tn.par, _pn, None)
+                    if _tp is None:
+                        report["warnings"].append("Bind target parameter not found: %s.%s" % (_np, _pn))
+                        continue
+                    _PM = type(_tp.mode)
+                    _tp.expr = "op(%s).par.%s" % (repr(_payload["comp"]), _name)
+                    _tp.mode = _PM.EXPRESSION
+                    report["bound"].append({"control": _name, "target": _np + "." + _pn})
+                except Exception:
+                    report["warnings"].append("Failed to bind '%s' to '%s': %s" % (_name, _t, traceback.format_exc().splitlines()[-1]))
+        except Exception:
+            report["warnings"].append("Failed to create control '%s': %s" % (_spec.get("name", "?"), traceback.format_exc().splitlines()[-1]))
+print(json.dumps(report))
+`;
+function buildPanelScript(payload) {
+  return buildPayloadScript(PANEL_SCRIPT, payload);
+}
+function parseReport(stdout) {
+  return parsePythonReport(stdout);
+}
+async function createControlPanelImpl(ctx, args) {
+  return guardTd(
+    async () => {
+      const script = buildPanelScript({
+        comp: args.comp_path,
+        page: args.page,
+        controls: args.controls
+      });
+      const exec = await ctx.client.executePythonScript(script, true);
+      return parseReport(exec.stdout);
+    },
+    (report) => {
+      if (report.fatal) {
+        return jsonResult(`Could not build control panel: ${report.fatal}`, report);
+      }
+      const summary = `Added ${report.created.length} control(s) on page "${report.page}" of ${report.comp}, ${report.bound.length} bound to live parameter(s)${report.warnings.length ? `, ${report.warnings.length} warning(s)` : ""}.`;
+      return jsonResult(summary, report);
+    }
+  );
+}
+var registerCreateControlPanel = (server, ctx) => {
+  server.registerTool(
+    "create_control_panel",
+    {
+      title: "Create control panel",
+      description: "Expose live controls on a COMP: append custom parameters (sliders, toggles, menus, RGB, pulse) and bind them to node parameters so the artist can drive a generated system in real time. Point `comp_path` at a system container and list the controls; use each control's `bind_to` to wire it to one or more 'nodePath.parName' targets.",
+      inputSchema: createControlPanelSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => createControlPanelImpl(ctx, args)
+  );
+};
+
+// src/tools/layout.ts
+var X_STEP = 200;
+var Y_STEP = 140;
+var SIBLING_GAP = 80;
+function pushTo(map, key, value) {
+  const existing = map.get(key);
+  if (existing) existing.push(value);
+  else map.set(key, [value]);
+}
+function parentOf(path) {
+  const i = path.lastIndexOf("/");
+  return i <= 0 ? "/" : path.slice(0, i);
+}
+function layerByLongestPath(nodes, preds) {
+  const memo = /* @__PURE__ */ new Map();
+  const visiting = /* @__PURE__ */ new Set();
+  const depth = (node) => {
+    const cached2 = memo.get(node);
+    if (cached2 !== void 0) return cached2;
+    if (visiting.has(node)) return 0;
+    visiting.add(node);
+    let best = 0;
+    for (const pred of preds.get(node) ?? []) best = Math.max(best, depth(pred) + 1);
+    visiting.delete(node);
+    memo.set(node, best);
+    return best;
+  };
+  const layers = /* @__PURE__ */ new Map();
+  for (const node of nodes) layers.set(node, depth(node));
+  return layers;
+}
+function computeDataflowLayout(nodes, edges) {
+  const set = new Set(nodes);
+  const preds = /* @__PURE__ */ new Map();
+  for (const { from, to } of edges) {
+    if (from === to || !set.has(from) || !set.has(to)) continue;
+    pushTo(preds, to, from);
+  }
+  const layerOf = layerByLongestPath(nodes, preds);
+  const byLayer = /* @__PURE__ */ new Map();
+  for (const node of nodes) pushTo(byLayer, layerOf.get(node) ?? 0, node);
+  const positions = {};
+  for (const [layer, members] of byLayer) {
+    const center = (members.length - 1) / 2;
+    members.forEach((node, i) => {
+      positions[node] = [layer * X_STEP, (center - i) * Y_STEP];
+    });
+  }
+  return positions;
+}
+function computeLayoutByParent(nodes, edges) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const node of nodes) pushTo(groups, parentOf(node), node);
+  const merged = {};
+  for (const members of groups.values()) {
+    Object.assign(merged, computeDataflowLayout(members, edges));
+  }
+  return merged;
+}
+function layoutScript(positions) {
+  return [
+    `_pos = ${JSON.stringify(positions)}`,
+    "for _p, _xy in _pos.items():",
+    "    _n = op(_p)",
+    "    if _n is not None:",
+    "        _n.nodeX = _xy[0]",
+    "        _n.nodeY = _xy[1]"
+  ].join("\n");
+}
+function placeBelowSiblingsScript(parentPath, nodePath) {
+  const q11 = JSON.stringify;
+  return [
+    `_parent = op(${q11(parentPath)})`,
+    `_new = op(${q11(nodePath)})`,
+    "if _parent is not None and _new is not None:",
+    "    _sibs = [c for c in _parent.children if c is not _new]",
+    "    if _sibs:",
+    "        _new.nodeX = min(c.nodeX for c in _sibs)",
+    `        _new.nodeY = min(c.nodeY for c in _sibs) - _new.nodeHeight - ${SIBLING_GAP}`,
+    "    else:",
+    "        _new.nodeX = 0",
+    "        _new.nodeY = 0"
+  ].join("\n");
+}
+
 // src/tools/layer1/orchestration.ts
 var q = (value) => JSON.stringify(value);
 var UNIFORM_KINDS = {
@@ -707,6 +993,9 @@ var NetworkBuilder = class {
   warnings = [];
   nameToPath = /* @__PURE__ */ new Map();
   pathToType = /* @__PURE__ */ new Map();
+  // Intended data-flow wires, recorded even when the physical connect fails or is
+  // satisfied via a source parameter, so auto-layout still reflects the flow.
+  edges = [];
   async add(type, name, parameters, parentPath) {
     const ref = await this.ctx.client.createNode({
       parent_path: parentPath ?? this.containerPath,
@@ -729,6 +1018,7 @@ for _c in list(_g.children):
     return this.nameToPath.get(name);
   }
   async connect(fromPath, toPath, fromOutput = 0, toInput = 0) {
+    this.edges.push({ from: fromPath, to: toPath });
     const targetType = this.pathToType.get(toPath);
     const param = targetType ? converterSourceParam(targetType) : void 0;
     if (param) {
@@ -755,6 +1045,19 @@ for _c in list(_g.children):
       this.warnings.push(`Python step failed: ${friendlyTdError(err)}`);
     }
   }
+  /** Arranges every created node left→right along the recorded data flow. */
+  async layout() {
+    const positions = computeLayoutByParent(
+      this.created.map((c) => c.path),
+      this.edges
+    );
+    if (Object.keys(positions).length === 0) return;
+    try {
+      await this.ctx.client.executePythonScript(layoutScript(positions), false);
+    } catch (err) {
+      this.warnings.push(`Auto-layout skipped: ${friendlyTdError(err)}`);
+    }
+  }
 };
 async function createSystemContainer(ctx, parentPath, name) {
   const container = await ctx.client.createNode({
@@ -762,6 +1065,14 @@ async function createSystemContainer(ctx, parentPath, name) {
     type: "baseCOMP",
     name
   });
+  try {
+    await ctx.client.executePythonScript(
+      placeBelowSiblingsScript(parentPath, container.path),
+      false
+    );
+  } catch (err) {
+    ctx.logger.debug("container placement skipped", { err: String(err) });
+  }
   return new NetworkBuilder(ctx, container.path);
 }
 async function buildFromRecipe(ctx, recipe, parentPath) {
@@ -864,11 +1175,37 @@ _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 };
+  const controls = recipe.controls.map((control) => ({
+    ...control,
+    bind_to: control.bind_to?.map((target) => {
+      const dot = target.lastIndexOf(".");
+      if (dot <= 0) return target;
+      const path = builder.pathOf(target.slice(0, dot));
+      return path ? `${path}.${target.slice(dot + 1)}` : target;
+    })
+  }));
+  return { builder, outputPath, controls };
+}
+async function exposeControls(ctx, compPath, controls) {
+  try {
+    const script = buildPanelScript({ comp: compPath, page: "Controls", controls });
+    const exec = await ctx.client.executePythonScript(script, true);
+    return parsePythonReport(exec.stdout);
+  } catch (err) {
+    return { created: [], bound: [], warnings: [`Control panel skipped: ${friendlyTdError(err)}`] };
+  }
 }
 async function finalize(ctx, options) {
   const { builder } = options;
+  await builder.layout();
   const warnings = [...builder.warnings];
+  let controlsSummary;
+  if (options.controls?.length) {
+    const result = await exposeControls(ctx, builder.containerPath, options.controls);
+    warnings.push(...result.warnings);
+    if (result.fatal) warnings.push(`Control panel skipped: ${result.fatal}`);
+    else controlsSummary = { added: result.created.map((c) => c.name), bound: result.bound.length };
+  }
   let errors = [];
   try {
     const report = await checkErrors(ctx.client, builder.containerPath);
@@ -894,6 +1231,7 @@ async function finalize(ctx, options) {
     created: builder.created.map((c) => c.path),
     output: options.outputPath,
     recipe: options.recipeId,
+    controls: controlsSummary,
     errors,
     warnings,
     ...options.extra
@@ -917,7 +1255,13 @@ ${JSON.stringify(data, null, 2)}
 // src/tools/layer1/applyPostProcessing.ts
 var q2 = (value) => JSON.stringify(value);
 var DIRECT_EFFECTS = {
-  bloom: { type: "bloomTOP" },
+  // bloomTOP defaults bloom everything above 0.01 and adds it back, which blows bright
+  // sources out to solid white. Raise the threshold so only highlights bloom, and soften the
+  // intensity for a tasteful glow that preserves the underlying image.
+  bloom: {
+    type: "bloomTOP",
+    parameters: { bloomthreshold: 0.8, bloomintensity: 0.6, bloomfill: 0.5 }
+  },
   blur: { type: "blurTOP", parameters: { size: 4 } },
   edge_detect: { type: "edgeTOP" },
   sharpen: { type: "sharpenTOP" },
@@ -978,10 +1322,10 @@ var EFFECTS = [
   "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")
+var applyPostProcessingSchema = z7.object({
+  source_path: z7.string().describe("Path of the TOP to post-process."),
+  effects: z7.array(z7.enum(EFFECTS)).min(1).describe("Effects to apply in order."),
+  parent_path: z7.string().default("/project1")
 });
 async function addGlslEffect(builder, name, fragment) {
   const glsl = await builder.add("glslTOP", name);
@@ -1041,27 +1385,81 @@ var registerApplyPostProcessing = (server, ctx) => {
 };
 
 // src/tools/layer1/createAudioReactive.ts
-import { z as z7 } from "zod";
+import { z as z8 } 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;
+    // Audio Spectrum CHOP magnitudes are tiny (~0.01\u20130.1); scale into the [0,1] bar
+    // range so realistic input renders visible bars instead of a near-black frame.
+    float amp = texture(sTD2DInputs[0], vec2(uv.x, 0.5)).r * 20.0;
     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(
+var STYLE_SHADERS = {
+  // Radial spectrum bars emanating from the centre by angle.
+  geometric: `out vec4 fragColor;
+void main(){
+    vec2 pos = vUV.st - 0.5;
+    float ang = atan(pos.y, pos.x) * 0.159155 + 0.5;
+    float rad = length(pos) * 2.0;
+    float amp = texture(sTD2DInputs[0], vec2(ang, 0.5)).r * 20.0;
+    float bar = step(rad, clamp(amp, 0.0, 1.0));
+    vec3 col = mix(vec3(0.05, 0.0, 0.15), vec3(0.2, 0.9, 1.0), ang) * bar;
+    fragColor = TDOutputSwizzle(vec4(col, 1.0));
+}
+`,
+  // A grid of dots whose size tracks each column's spectrum bin.
+  particle: `out vec4 fragColor;
+void main(){
+    vec2 uv = vUV.st;
+    vec2 cell = fract(uv * 16.0) - 0.5;
+    float colx = floor(uv.x * 16.0) / 16.0;
+    float amp = texture(sTD2DInputs[0], vec2(colx, 0.5)).r * 20.0;
+    float dot = smoothstep(0.45 * clamp(amp, 0.05, 1.0), 0.0, length(cell));
+    vec3 col = dot * mix(vec3(0.1, 0.4, 1.0), vec3(1.0, 0.3, 0.6), uv.y);
+    fragColor = TDOutputSwizzle(vec4(col, 1.0));
+}
+`,
+  // Concentric rings warped by the spectrum — a tunnel/echo look.
+  feedback: `out vec4 fragColor;
+void main(){
+    vec2 pos = vUV.st - 0.5;
+    float rad = length(pos);
+    float ang = atan(pos.y, pos.x);
+    float amp = texture(sTD2DInputs[0], vec2(rad, 0.5)).r * 20.0;
+    float rings = 0.5 + 0.5 * sin(rad * 40.0 - amp * 12.0 + ang * 3.0);
+    vec3 col = rings * mix(vec3(0.6, 0.1, 0.8), vec3(0.1, 0.8, 0.9), rad * 2.0);
+    fragColor = TDOutputSwizzle(vec4(col, 1.0));
+}
+`,
+  // An LED matrix: columns light up to a height set by their spectrum bin.
+  instancing: `out vec4 fragColor;
+void main(){
+    vec2 uv = vUV.st;
+    vec2 cell = floor(uv * vec2(16.0, 8.0));
+    vec2 fr = fract(uv * vec2(16.0, 8.0));
+    float amp = texture(sTD2DInputs[0], vec2(cell.x / 16.0, 0.5)).r * 20.0;
+    float lit = step((cell.y + 0.5) / 8.0, clamp(amp, 0.0, 1.0));
+    float pad = step(0.1, fr.x) * step(fr.x, 0.9) * step(0.1, fr.y) * step(fr.y, 0.9);
+    vec3 col = lit * pad * mix(vec3(0.0, 1.0, 0.4), vec3(1.0, 0.8, 0.0), cell.y / 8.0);
+    fragColor = TDOutputSwizzle(vec4(col, 1.0));
+}
+`
+};
+var createAudioReactiveSchema = z8.object({
+  audio_source: z8.enum(["microphone", "file", "device_in", "existing_chop"]).default("microphone"),
+  audio_file_path: z8.string().optional().describe("Audio file path (audio_source='file')."),
+  existing_chop_path: z8.string().optional().describe("Existing CHOP path (audio_source='existing_chop')."),
+  visual_style: z8.enum(["geometric", "particle", "feedback", "glsl", "instancing"]),
+  frequency_bands: z8.coerce.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")
+  beat_detection: z8.boolean().default(true),
+  expose_controls: z8.boolean().default(true).describe("Expose a live 'Sensitivity' knob (how strongly the audio drives the visual)."),
+  parent_path: z8.string().default("/project1")
 });
 async function buildAudioSource(builder, args) {
   if (args.audio_source === "existing_chop" && args.existing_chop_path) {
@@ -1093,40 +1491,38 @@ async function createAudioReactiveImpl(ctx, args) {
     }
     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)}
+    const sensitivity = await builder.add("levelTOP", "sensitivity", { brightness1: 1 });
+    await builder.connect(audioTex, sensitivity);
+    const shader = args.visual_style === "glsl" ? AUDIO_SPECTRUM_SHADER : STYLE_SHADERS[args.visual_style] ?? AUDIO_SPECTRUM_SHADER;
+    const 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(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.`
-      );
-    }
+    );
+    await builder.connect(sensitivity, visual);
     const out = await builder.add("nullTOP", "out1");
     await builder.connect(visual, out);
+    const controls = args.expose_controls ? [
+      {
+        name: "Sensitivity",
+        type: "float",
+        min: 0,
+        max: 4,
+        default: 1,
+        bind_to: [`${sensitivity}.brightness1`]
+      }
+    ] : [];
     return finalize(ctx, {
       summary: `Created an audio-reactive system (source: ${args.audio_source}, style: ${args.visual_style}, ${args.frequency_bands} bands).`,
       builder,
       outputPath: out,
+      controls,
       extra: {
         audio_source: args.audio_source,
         visual_style: args.visual_style,
@@ -1140,7 +1536,7 @@ var registerCreateAudioReactive = (server, ctx) => {
     "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.",
+      description: "Build an audio analysis chain (spectrum + level + optional beat) and a spectrum visual driven by it. Each visual_style renders the spectrum its own way: glsl=horizontal bars, geometric=radial bars, particle=dot field, feedback=ring tunnel, instancing=LED grid.",
       inputSchema: createAudioReactiveSchema.shape,
       annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
     },
@@ -1149,7 +1545,7 @@ var registerCreateAudioReactive = (server, ctx) => {
 };
 
 // src/tools/layer1/createDataVisualization.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var q4 = (value) => JSON.stringify(value);
 var BARS_SHADER = `out vec4 fragColor;
 void main(){
@@ -1165,10 +1561,11 @@ var SOURCE_TYPE = {
   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")
+var createDataVisualizationSchema = z9.object({
+  data_source: z9.enum(["table", "file", "chop"]).default("table"),
+  chart_style: z9.enum(["bars", "graph", "points"]).default("bars"),
+  expose_controls: z9.boolean().default(true).describe("Expose a live 'Scale' knob that amplifies the data values feeding the chart."),
+  parent_path: z9.string().default("/project1")
 });
 async function createDataVisualizationImpl(ctx, args) {
   return runBuild(async () => {
@@ -1197,7 +1594,9 @@ for v in ${JSON.stringify(rows)}:
     }
     const tex = await builder.add("choptoTOP", "data_tex");
     await builder.connect(chop, tex);
-    let visual = tex;
+    const scale = await builder.add("levelTOP", "scale", { brightness1: 1 });
+    await builder.connect(tex, scale);
+    let visual = scale;
     if (args.chart_style === "bars") {
       const glsl = await builder.add("glslTOP", "chart", {
         outputresolution: "custom",
@@ -1210,7 +1609,7 @@ for v in ${JSON.stringify(rows)}:
         `op(${q4(frag)}).text = ${q4(BARS_SHADER)}
 op(${q4(glsl)}).par.pixeldat = op(${q4(frag)}).name`
       );
-      await builder.connect(tex, glsl);
+      await builder.connect(scale, glsl);
       visual = glsl;
     } else {
       builder.warnings.push(
@@ -1222,10 +1621,21 @@ op(${q4(glsl)}).par.pixeldat = op(${q4(frag)}).name`
     builder.warnings.push(
       "Wire your real data into the 'data' node \u2014 a placeholder source was created."
     );
+    const controls = args.expose_controls ? [
+      {
+        name: "Scale",
+        type: "float",
+        min: 0,
+        max: 4,
+        default: 1,
+        bind_to: [`${scale}.brightness1`]
+      }
+    ] : [];
     return finalize(ctx, {
       summary: `Created a data visualization (source: ${args.data_source}, style: ${args.chart_style}).`,
       builder,
       outputPath: out,
+      controls,
       extra: { data_source: args.data_source, chart_style: args.chart_style }
     });
   });
@@ -1244,7 +1654,7 @@ var registerCreateDataVisualization = (server, ctx) => {
 };
 
 // src/tools/layer1/createFeedbackNetwork.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var q5 = (value) => JSON.stringify(value);
 function colorizeShader(colors) {
   const toVec3 = (hex) => {
@@ -1265,6 +1675,14 @@ void main(){
 }
 `;
 }
+var SEED_GLSL = `out vec4 fragColor;
+void main(){
+    vec2 uv = vUV.st;
+    float v = sin(uv.x * 12.0) + sin(uv.y * 12.0) + sin((uv.x + uv.y) * 8.0);
+    vec3 col = 0.5 + 0.5 * cos(vec3(0.0, 2.0, 4.0) + v);
+    fragColor = TDOutputSwizzle(vec4(col, 1.0));
+}
+`;
 var SEED_TYPES = {
   noise: "noiseTOP",
   shape: "circleTOP",
@@ -1284,10 +1702,10 @@ var TRANSFORM_TYPES = {
   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([
+var createFeedbackNetworkSchema = z10.object({
+  seed_type: z10.enum(["noise", "shape", "image", "video", "webcam", "glsl"]).default("noise"),
+  transformations: z10.array(
+    z10.enum([
       "blur",
       "displace",
       "edge",
@@ -1299,9 +1717,10 @@ var createFeedbackNetworkSchema = z9.object({
       "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")
+  feedback_gain: z10.coerce.number().min(0).max(1).default(0.95),
+  colors: z10.array(z10.string()).max(2).optional().describe("Up to two hex colors to colorize the otherwise-grayscale output."),
+  expose_controls: z10.boolean().default(true).describe("Expose a live 'Feedback' knob on the system container, bound to the loop's decay."),
+  parent_path: z10.string().default("/project1")
 });
 async function createFeedbackNetworkImpl(ctx, args) {
   return runBuild(async () => {
@@ -1309,6 +1728,13 @@ async function createFeedbackNetworkImpl(ctx, args) {
     const seed = await builder.add(SEED_TYPES[args.seed_type], "seed", {
       ...args.seed_type === "noise" ? { monochrome: 1, period: 4 } : {}
     });
+    if (args.seed_type === "glsl") {
+      const seedFrag = await builder.add("textDAT", "seed_frag");
+      await builder.python(
+        `op(${q5(seedFrag)}).text = ${q5(SEED_GLSL)}
+op(${q5(seed)}).par.pixeldat = op(${q5(seedFrag)}).name`
+      );
+    }
     const feedback = await builder.add("feedbackTOP", "feedback1");
     const comp = await builder.add("compositeTOP", "comp1");
     await builder.setParams(comp, { operand: "maximum" });
@@ -1325,7 +1751,7 @@ async function createFeedbackNetworkImpl(ctx, args) {
       last = node;
     }
     const gain = await builder.add("levelTOP", "gain");
-    await builder.setParams(gain, { gain: args.feedback_gain });
+    await builder.setParams(gain, { brightness1: args.feedback_gain });
     await builder.connect(last, gain);
     let output = gain;
     if (args.colors && args.colors.length > 0) {
@@ -1341,10 +1767,21 @@ op(${q5(colorize)}).par.pixeldat = op(${q5(frag)}).name`
     const out = await builder.add("nullTOP", "out1");
     await builder.connect(output, out);
     await builder.python(`op(${q5(feedback)}).par.top = op(${q5(gain)}).name`);
+    const controls = args.expose_controls ? [
+      {
+        name: "Feedback",
+        type: "float",
+        min: 0,
+        max: 1,
+        default: args.feedback_gain,
+        bind_to: [`${gain}.brightness1`]
+      }
+    ] : [];
     return finalize(ctx, {
       summary: `Created a feedback network (seed: ${args.seed_type}, gain: ${args.feedback_gain}, ${args.transformations.length} transform(s)).`,
       builder,
       outputPath: out,
+      controls,
       extra: { seed_type: args.seed_type, transformations: args.transformations }
     });
   });
@@ -1363,7 +1800,7 @@ var registerCreateFeedbackNetwork = (server, ctx) => {
 };
 
 // src/tools/layer1/createGenerativeArt.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var q6 = (value) => JSON.stringify(value);
 var DEFAULT_PLASMA = `out vec4 fragColor;
 uniform float uTime;
@@ -1375,12 +1812,66 @@ void main(){
     fragColor = TDOutputSwizzle(vec4(col, 1.0));
 }
 `;
+var VORONOI_SHADER = `out vec4 fragColor;
+uniform float uTime;
+vec2 hash2(vec2 p){ return fract(sin(vec2(dot(p,vec2(127.1,311.7)),dot(p,vec2(269.5,183.3))))*43758.5453); }
+vec2 cellNoise(vec2 p){
+  vec2 ip=floor(p); vec2 fp=fract(p);
+  float d1=8.0; float d2=8.0;
+  for(int yy=-1; yy<=1; yy++){
+    for(int xx=-1; xx<=1; xx++){
+      vec2 nb=vec2(float(xx),float(yy));
+      vec2 pt=hash2(ip+nb);
+      pt=0.5+0.5*sin(uTime*0.5+6.2831*pt);
+      vec2 diff=nb+pt-fp; float dd=length(diff);
+      if(dd<d1){ d2=d1; d1=dd; } else if(dd<d2){ d2=dd; }
+    }
+  }
+  return vec2(d1,d2);
+}
+void main(){
+  vec2 uv=vUV.st*8.0;
+  vec2 fc=cellNoise(uv);
+  float edge=smoothstep(0.0,0.08,fc.y-fc.x);
+  float cell=fc.x;
+  vec3 col=mix(vec3(0.02),vec3(0.5+0.5*cell,0.7,0.9),edge);
+  fragColor=TDOutputSwizzle(vec4(col,1.0));
+}
+`;
+var FBM_SHADER = `out vec4 fragColor;
+uniform float uTime;
+float hashF(vec2 p){ return fract(sin(dot(p,vec2(127.1,311.7)))*43758.5453); }
+float vnoise(vec2 p){
+  vec2 ip=floor(p); vec2 fp=fract(p);
+  vec2 uu=fp*fp*(3.0-2.0*fp);
+  float na=hashF(ip+vec2(0.0,0.0));
+  float nb=hashF(ip+vec2(1.0,0.0));
+  float nc=hashF(ip+vec2(0.0,1.0));
+  float nd=hashF(ip+vec2(1.0,1.0));
+  return mix(mix(na,nb,uu.x),mix(nc,nd,uu.x),uu.y);
+}
+float fbm(vec2 p){
+  float acc=0.0; float amp=0.5;
+  for(int oc=0; oc<6; oc++){ acc+=amp*vnoise(p); p*=2.0; amp*=0.5; }
+  return acc;
+}
+void main(){
+  vec2 uv=vUV.st*3.0;
+  float val=fbm(uv+vec2(uTime*0.1, uTime*0.05));
+  vec3 col=mix(vec3(0.02,0.05,0.15), vec3(0.95,0.6,0.25), val);
+  fragColor=TDOutputSwizzle(vec4(col,1.0));
+}
+`;
+var TECHNIQUE_SHADERS = {
+  voronoi: VORONOI_SHADER,
+  fractal: FBM_SHADER
+};
 var RECIPE_FOR = /* @__PURE__ */ new Map([
   ["reaction_diffusion", "reaction_diffusion"],
   ["noise_landscape", "noise_landscape"]
 ]);
-var createGenerativeArtSchema = z10.object({
-  technique: z10.enum([
+var createGenerativeArtSchema = z11.object({
+  technique: z11.enum([
     "noise_landscape",
     "reaction_diffusion",
     "strange_attractor",
@@ -1391,18 +1882,25 @@ var createGenerativeArtSchema = z10.object({
     "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")
+  color_palette: z11.string().optional().describe("Free-text palette hint (best-effort)."),
+  evolution_speed: z11.coerce.number().positive().default(1),
+  custom_glsl_code: z11.string().optional().describe("Fragment shader (only for technique 'custom_glsl')."),
+  expose_controls: z11.boolean().default(true).describe("Expose a live 'Speed' knob (evolution speed) on the system container."),
+  parent_path: z11.string().default("/project1")
 });
-async function buildGlslGenerative(ctx, parentPath, name, fragment) {
+async function buildGlslGenerative(ctx, parentPath, name, fragment, speed = 1) {
   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`
+  );
+  await builder.python(
+    `_g = op(${q6(glsl)})
+_g.seq.vec.numBlocks = max(_g.seq.vec.numBlocks, 1)
+_g.par.vec0name = 'uTime'
+_g.par.vec0valuex.expr = ${q6(`absTime.seconds * (parent().par.Speed.eval() if hasattr(parent().par, 'Speed') else ${speed})`)}`
   );
   const out = await builder.add("nullTOP", "out1");
   await builder.connect(glsl, out);
@@ -1410,16 +1908,22 @@ op(${q6(glsl)}).par.pixeldat = op(${q6(frag)}).name`
 }
 async function createGenerativeArtImpl(ctx, args) {
   return runBuild(async () => {
+    const speedControls = args.expose_controls ? [{ name: "Speed", type: "float", min: 0, max: 4, default: args.evolution_speed }] : [];
     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);
+        const { builder: builder2, outputPath, controls } = await buildFromRecipe(
+          ctx,
+          recipe,
+          args.parent_path
+        );
         return finalize(ctx, {
           summary: `Created "${recipe.name}" generative system.`,
           builder: builder2,
           outputPath,
           recipeId,
+          controls,
           extra: { technique: args.technique, color_palette: args.color_palette }
         });
       }
@@ -1430,7 +1934,8 @@ async function createGenerativeArtImpl(ctx, args) {
         ctx,
         args.parent_path,
         "generative_custom_glsl",
-        fragment
+        fragment,
+        args.evolution_speed
       );
       if (!args.custom_glsl_code) {
         builder2.warnings.push("No custom_glsl_code provided; used a default plasma shader.");
@@ -1439,22 +1944,25 @@ async function createGenerativeArtImpl(ctx, args) {
         summary: "Created a custom GLSL generative system.",
         builder: builder2,
         outputPath,
+        controls: speedControls,
         extra: { technique: args.technique }
       });
     }
-    const pattern = ctx.knowledge.getGlslPattern(args.technique);
-    if (pattern?.code?.snippet) {
+    const inlineShader = TECHNIQUE_SHADERS[args.technique];
+    if (inlineShader) {
       const { builder: builder2, outputPath } = await buildGlslGenerative(
         ctx,
         args.parent_path,
         `generative_${args.technique}`,
-        pattern.code.snippet
+        inlineShader,
+        args.evolution_speed
       );
       return finalize(ctx, {
-        summary: `Created a "${args.technique}" system from the GLSL knowledge pattern "${pattern.name}".`,
+        summary: `Created a "${args.technique}" generative system (GLSL).`,
         builder: builder2,
         outputPath,
-        extra: { technique: args.technique, glsl_pattern: pattern.id }
+        controls: speedControls,
+        extra: { technique: args.technique, color_palette: args.color_palette }
       });
     }
     const builder = await createSystemContainer(
@@ -1469,7 +1977,7 @@ async function createGenerativeArtImpl(ctx, args) {
     await builder.connect(level, out);
     await builder.python(
       `p = op(${q6(noise)}).par.tz
-p.expr = ${q6(`absTime.seconds * ${args.evolution_speed}`)}`
+p.expr = ${q6(`absTime.seconds * (parent().par.Speed.eval() if hasattr(parent().par, 'Speed') else ${args.evolution_speed})`)}`
     );
     builder.warnings.push(
       `Technique "${args.technique}" is approximated with an animated-noise generator in this version.`
@@ -1478,6 +1986,7 @@ p.expr = ${q6(`absTime.seconds * ${args.evolution_speed}`)}`
       summary: `Created an approximate "${args.technique}" generative system.`,
       builder,
       outputPath: out,
+      controls: speedControls,
       extra: { technique: args.technique, evolution_speed: args.evolution_speed }
     });
   });
@@ -1496,7 +2005,7 @@ var registerCreateGenerativeArt = (server, ctx) => {
 };
 
 // src/tools/layer1/createParticleSystem.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var q7 = (value) => JSON.stringify(value);
 var EMITTER_SOP = {
   point: "addSOP",
@@ -1506,13 +2015,51 @@ var EMITTER_SOP = {
   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")
+var q22 = (n) => Number.isFinite(n) ? n.toString() : "0";
+function computeParticleDynamics(args) {
+  const f = new Set(args.forces);
+  const birth = Math.max(1, Math.round(args.particle_count / args.lifetime));
+  let drag = 2;
+  if (f.has("drag")) drag = 3.5;
+  if (f.has("repel")) drag = 1;
+  let turb = 0;
+  if (f.has("noise")) turb = 1;
+  if (f.has("turbulence")) turb = 1.8;
+  if (f.has("attract") || f.has("repel") || f.has("vortex")) turb = Math.max(turb, 1.2);
+  const gravity = f.has("gravity") ? -0.6 : 0;
+  const wind = f.has("vortex") ? 0.5 : 0;
+  const lifevar = Number((args.lifetime * 0.25).toFixed(3));
+  return { birth, drag, turb, gravity, wind, lifevar };
+}
+function particleDynamicsPython(particlePath, args, dyn) {
+  return [
+    `_p = op(${q7(particlePath)})`,
+    `_p.par.birth = ${dyn.birth}`,
+    `_p.par.lifevar = ${q22(dyn.lifevar)}`,
+    "_p.par.normals = True",
+    "_p.par.jitter = True",
+    `_p.par.timepreroll = ${q22(args.lifetime)}`,
+    "_p.par.dodrag = True",
+    `_p.par.drag = ${q22(dyn.drag)}`,
+    `_p.par.turbx = ${q22(dyn.turb)}`,
+    `_p.par.turby = ${q22(dyn.turb)}`,
+    `_p.par.turbz = ${q22(dyn.turb)}`,
+    "_p.par.period = 3.0",
+    `_p.par.externaly = ${q22(dyn.gravity)}`,
+    `_p.par.windx = ${q22(dyn.wind)}`,
+    "_p.par.reset.pulse()"
+  ].join("\n");
+}
+var createParticleSystemSchema = z12.object({
+  // Default to "sphere": its varied normals give particles a radial initial velocity, so the
+  // out-of-the-box system is a full cloud. ("point" has no normals and stays a thin stream.)
+  emitter_shape: z12.enum(["point", "line", "circle", "sphere", "mesh", "image"]).default("sphere"),
+  particle_count: z12.coerce.number().int().positive().default(1e4),
+  forces: z12.array(z12.enum(["gravity", "noise", "attract", "repel", "vortex", "turbulence", "drag"])).default(["noise", "gravity"]),
+  render_style: z12.enum(["points", "sprites", "lines", "trails", "instanced_geo"]).default("sprites"),
+  lifetime: z12.coerce.number().positive().default(3),
+  expose_controls: z12.boolean().default(true).describe("Expose live Drag / Turbulence / Gravity / Lifetime knobs on the system container."),
+  parent_path: z12.string().default("/project1")
 });
 async function createParticleSystemImpl(ctx, args) {
   return runBuild(async () => {
@@ -1533,14 +2080,28 @@ async function createParticleSystemImpl(ctx, args) {
       { name: "emitter", path: emitter.path, type: emitter.type },
       { name: "particle", path: particle.path, type: particle.type }
     );
+    if (args.emitter_shape === "point") {
+      await builder.python(
+        `_e = op(${q7(emitter.path)})
+_e.par.addpts = True
+_e.seq.point.numBlocks = max(_e.seq.point.numBlocks, 1)`
+      );
+    }
     await builder.connect(emitter.path, particle.path);
+    const dynamics = computeParticleDynamics(args);
+    await builder.python(particleDynamicsPython(particle.path, args, dynamics));
     const mat = await builder.add(
       args.render_style === "sprites" ? "pointspriteMAT" : "constantMAT",
       "mat"
     );
-    const cam = await builder.add("cameraCOMP", "cam", { tz: 5 });
+    const cam = await builder.add("cameraCOMP", "cam", { tz: 6 });
     const light = await builder.add("lightCOMP", "light", { tx: 3, ty: 4, tz: 4 });
-    const render = await builder.add("renderTOP", "render");
+    const render = await builder.add("renderTOP", "render", {
+      bgcolorr: 0.02,
+      bgcolorg: 0.02,
+      bgcolorb: 0.05,
+      bgcolora: 1
+    });
     const out = await builder.add("nullTOP", "out1");
     await builder.connect(render, out);
     await builder.python(
@@ -1556,13 +2117,58 @@ async function createParticleSystemImpl(ctx, args) {
         `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.`
+    const approximated = args.forces.filter(
+      (x) => x === "attract" || x === "repel" || x === "vortex"
     );
+    if (approximated.length > 0) {
+      builder.warnings.push(
+        `Forces ${approximated.join(", ")} have no native Particle SOP equivalent and are approximated with turbulence.`
+      );
+    }
+    if (args.render_style !== "points" && args.render_style !== "sprites") {
+      builder.warnings.push(
+        `Render style "${args.render_style}" falls back to point/sprite rendering in this version.`
+      );
+    }
+    const controls = args.expose_controls ? [
+      {
+        name: "Drag",
+        type: "float",
+        min: 0,
+        max: 8,
+        default: dynamics.drag,
+        bind_to: [`${particle.path}.drag`]
+      },
+      {
+        name: "Turbulence",
+        type: "float",
+        min: 0,
+        max: 4,
+        default: dynamics.turb,
+        bind_to: [`${particle.path}.turbx`, `${particle.path}.turby`, `${particle.path}.turbz`]
+      },
+      {
+        name: "Gravity",
+        type: "float",
+        min: -3,
+        max: 3,
+        default: dynamics.gravity,
+        bind_to: [`${particle.path}.externaly`]
+      },
+      {
+        name: "Lifetime",
+        type: "float",
+        min: 0.1,
+        max: 10,
+        default: args.lifetime,
+        bind_to: [`${particle.path}.life`]
+      }
+    ] : [];
     return finalize(ctx, {
       summary: `Created a particle system (emitter: ${args.emitter_shape}, ~${args.particle_count} particles, render: ${args.render_style}).`,
       builder,
       outputPath: out,
+      controls,
       extra: {
         emitter_shape: args.emitter_shape,
         forces: args.forces,
@@ -1585,7 +2191,7 @@ var registerCreateParticleSystem = (server, ctx) => {
 };
 
 // src/tools/layer1/createVisualSystem.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // src/tools/layer1/intent.ts
 var GENERIC_TERMS = /* @__PURE__ */ new Set([
@@ -1611,11 +2217,15 @@ function significantTerms(description) {
 }
 
 // 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)
+var createVisualSystemSchema = z13.object({
+  description: z13.string().min(1).describe("Natural-language description of the visual system."),
+  parent_path: z13.string().default("/project1"),
+  resolution: z13.enum(["720p", "1080p", "4K", "custom"]).default("1080p").describe(
+    "Advisory target resolution. Recorded in the build note; the sub-builders use their own internal sizes and do not enforce this per-node."
+  ),
+  target_fps: z13.coerce.number().positive().default(60).describe(
+    "Advisory target frame rate (informational only \u2014 TD's real cook rate is a project-level setting, not set here)."
+  )
 });
 function classify(description) {
   const d = description.toLowerCase();
@@ -1687,7 +2297,7 @@ function withNote(result, note) {
 }
 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).`;
+  const note = `Interpreted "${args.description}" as a ${label} system (advisory target ${args.resolution} @ ${args.target_fps}fps).`;
   ctx.logger.info("create_visual_system classified", { kind, description: args.description });
   switch (kind) {
     case "audio":
@@ -1697,6 +2307,7 @@ async function createVisualSystemImpl(ctx, args) {
           visual_style: pickAudioStyle(args.description),
           frequency_bands: 8,
           beat_detection: true,
+          expose_controls: true,
           parent_path: args.parent_path
         }),
         note
@@ -1709,6 +2320,7 @@ async function createVisualSystemImpl(ctx, args) {
           forces: ["noise", "gravity"],
           render_style: "sprites",
           lifetime: 3,
+          expose_controls: true,
           parent_path: args.parent_path
         }),
         note
@@ -1720,6 +2332,7 @@ async function createVisualSystemImpl(ctx, args) {
           transformations: ["blur", "displace", "level"],
           feedback_gain: 0.95,
           colors: parseColors(args.description),
+          expose_controls: true,
           parent_path: args.parent_path
         }),
         note
@@ -1730,6 +2343,7 @@ async function createVisualSystemImpl(ctx, args) {
         await createGenerativeArtImpl(ctx, {
           technique: kind,
           evolution_speed: 1,
+          expose_controls: true,
           parent_path: args.parent_path
         }),
         note
@@ -1738,13 +2352,18 @@ async function createVisualSystemImpl(ctx, args) {
       const recipe = ctx.recipes.findByTags(significantTerms(args.description));
       if (recipe) {
         return runBuild(async () => {
-          const { builder, outputPath } = await buildFromRecipe(ctx, recipe, args.parent_path);
+          const { builder, outputPath, controls } = 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
+              recipeId: recipe.id,
+              controls
             }),
             note
           );
@@ -1754,6 +2373,7 @@ async function createVisualSystemImpl(ctx, args) {
         await createGenerativeArtImpl(ctx, {
           technique: "custom_glsl",
           evolution_speed: 1,
+          expose_controls: true,
           parent_path: args.parent_path
         }),
         note
@@ -1775,9 +2395,9 @@ var registerCreateVisualSystem = (server, ctx) => {
 };
 
 // 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.")
+import { z as z14 } from "zod";
+var describeProjectSchema = z14.object({
+  description: z14.string().min(1).describe("Natural-language description of the visual you want.")
 });
 function describeProjectImpl(ctx, args) {
   const d = args.description.toLowerCase();
@@ -1803,7 +2423,7 @@ function describeProjectImpl(ctx, args) {
     tool = "create_feedback_network";
     summary = "feedback network";
   } else {
-    tool = "create_generative_art";
+    tool = "create_visual_system";
     summary = "generative visual";
     recipeId = ctx.recipes.findByTags(significantTerms(d))?.id;
   }
@@ -1839,11 +2459,11 @@ var registerDescribeProject = (server, ctx) => {
 };
 
 // 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)
+import { z as z15 } from "zod";
+var getPreviewSchema = z15.object({
+  node_path: z15.string().describe("Path of the TOP node to capture."),
+  width: z15.coerce.number().int().positive().default(640),
+  height: z15.coerce.number().int().positive().default(360)
 });
 async function getPreviewImpl(ctx, args) {
   return guardTd(
@@ -1869,7 +2489,7 @@ var registerGetPreview = (server, ctx) => {
 };
 
 // src/tools/layer1/setupOutput.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var q8 = (value) => JSON.stringify(value);
 var OUTPUT_MAP = {
   window: "windowCOMP",
@@ -1883,12 +2503,12 @@ var RESOLUTIONS = {
   "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")
+var setupOutputSchema = z16.object({
+  source_path: z16.string().describe("Path of the final TOP to output."),
+  output_type: z16.enum(["window", "ndi", "syphon_spout", "record", "touch_out"]).default("window"),
+  resolution: z16.enum(["720p", "1080p", "4K"]).default("1080p"),
+  record_format: z16.enum(["mp4", "mov", "image_sequence"]).optional(),
+  parent_path: z16.string().default("/project1")
 });
 async function setupOutputImpl(ctx, args) {
   return runBuild(async () => {
@@ -1913,7 +2533,13 @@ w.par.winh = ${height}`,
       }
     } else {
       try {
-        await connectNodesViaBridge(ctx.client, args.source_path, node.path);
+        const select = await ctx.client.createNode({
+          parent_path: args.parent_path,
+          type: "selectTOP",
+          name: `${args.output_type}_src`
+        });
+        await ctx.client.updateNodeParameters(select.path, { top: args.source_path });
+        await connectNodesViaBridge(ctx.client, select.path, node.path);
       } catch (err) {
         warnings.push(`Could not connect source to output: ${friendlyTdError(err)}`);
       }
@@ -1961,13 +2587,165 @@ var layer1Registrars = [
   registerCreateVisualSystem
 ];
 
+// src/tools/layer2/animateParameter.ts
+import { z as z17 } from "zod";
+var WAVE_MAP = {
+  sine: "sin",
+  triangle: "tri",
+  ramp: "ramp",
+  square: "square",
+  pulse: "pulse",
+  random: "normal"
+};
+var animateParameterSchema = z17.object({
+  targets: z17.array(z17.string()).min(1).describe(
+    "Parameters to animate, each written as 'nodePath.parName' (e.g. '/project1/sys/blur1.size'). Each is switched to expression mode so it tracks the oscillator live."
+  ),
+  waveform: z17.enum(["sine", "triangle", "ramp", "square", "pulse", "random"]).default("sine").describe("Oscillator shape. Every waveform sweeps the full min\u2013max range."),
+  min: z17.coerce.number().default(0).describe("Low end of the value sweep."),
+  max: z17.coerce.number().default(1).describe("High end of the value sweep."),
+  period_seconds: z17.coerce.number().positive().default(4).describe("Seconds for one full cycle (lower = faster)."),
+  container_path: z17.string().optional().describe("Where to create the LFO CHOP; defaults to the first target's parent network."),
+  name: z17.string().default("lfo_anim").describe("Name for the LFO CHOP.")
+});
+var ANIMATE_SCRIPT = `
+import json, base64, traceback
+_p = json.loads(base64.b64decode("__PAYLOAD_B64__").decode("utf-8"))
+report = {"targets_bound": [], "warnings": []}
+try:
+    _targets = _p["targets"]
+    _first = _targets[0]; _dot0 = _first.rfind(".")
+    if _dot0 <= 0:
+        report["fatal"] = "Invalid target '%s' (expected 'nodePath.parName')." % _first
+    else:
+        _np0 = _first[:_dot0]; _firstnode = op(_np0)
+        if _firstnode is None:
+            report["fatal"] = "Target node not found: %s" % _np0
+        else:
+            _cont = _p.get("container") or _firstnode.parent().path
+            _parent = op(_cont)
+            if _parent is None:
+                report["fatal"] = "Container not found: %s" % _cont
+            else:
+                _lfo = _parent.create(lfoCHOP, _p["name"])
+                _lfo.par.wavetype = _p["wavetype"]
+                _lfo.par.frequency = _p["frequency"]
+                _lfo.par.amp = _p["amp"]
+                _lfo.par.offset = _p["offset"]
+                _ch = _lfo.par.channelname.eval() or "chan1"
+                report["lfo"] = _lfo.path; report["container"] = _cont
+                report["channel"] = _ch; report["frequency"] = _p["frequency"]
+                for _t in _targets:
+                    try:
+                        _dot = _t.rfind(".")
+                        if _dot <= 0:
+                            report["warnings"].append("Invalid target '%s' (expected 'nodePath.parName')." % _t); continue
+                        _npth = _t[:_dot]; _pn = _t[_dot + 1:]; _tn = op(_npth)
+                        if _tn is None:
+                            report["warnings"].append("Target node not found: %s" % _npth); continue
+                        _tp = getattr(_tn.par, _pn, None)
+                        if _tp is None:
+                            report["warnings"].append("Target parameter not found: %s.%s" % (_npth, _pn)); continue
+                        _PM = type(_tp.mode)
+                        _tp.expr = "op(%s)[%s]" % (repr(_lfo.path), repr(_ch))
+                        _tp.mode = _PM.EXPRESSION
+                        report["targets_bound"].append(_npth + "." + _pn)
+                    except Exception:
+                        report["warnings"].append("Failed to bind '%s': %s" % (_t, traceback.format_exc().splitlines()[-1]))
+except Exception:
+    report["fatal"] = traceback.format_exc().splitlines()[-1]
+print(json.dumps(report))
+`;
+function buildAnimateScript(payload) {
+  return buildPayloadScript(ANIMATE_SCRIPT, payload);
+}
+var BIPOLAR_WAVEFORMS = /* @__PURE__ */ new Set(["sine", "triangle", "square"]);
+async function animateParameterImpl(ctx, args) {
+  const span = args.max - args.min;
+  const bipolar = BIPOLAR_WAVEFORMS.has(args.waveform);
+  const amp = bipolar ? span / 2 : span;
+  const offset = bipolar ? (args.max + args.min) / 2 : args.min;
+  const frequency = 1 / args.period_seconds;
+  return guardTd(
+    async () => {
+      const script = buildAnimateScript({
+        targets: args.targets,
+        name: args.name,
+        wavetype: WAVE_MAP[args.waveform],
+        frequency,
+        amp,
+        offset,
+        container: args.container_path ?? null
+      });
+      const exec = await ctx.client.executePythonScript(script, true);
+      return parsePythonReport(exec.stdout);
+    },
+    (report) => {
+      if (report.fatal) {
+        return jsonResult(`Could not set up animation: ${report.fatal}`, report);
+      }
+      const summary = `Animating ${report.targets_bound.length} parameter(s) with a ${args.waveform} LFO (period ${args.period_seconds}s, range ${args.min}\u2013${args.max}) at ${report.lfo}${report.warnings.length ? `, ${report.warnings.length} warning(s)` : ""}.`;
+      return jsonResult(summary, report);
+    }
+  );
+}
+var registerAnimateParameter = (server, ctx) => {
+  server.registerTool(
+    "animate_parameter",
+    {
+      title: "Animate parameter",
+      description: "Drive one or more node parameters over time with an LFO (sine/triangle/ramp/square/pulse/random). Creates an LFO CHOP and binds each target so it oscillates between min and max with the given period \u2014 movement without manual keyframing.",
+      inputSchema: animateParameterSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => animateParameterImpl(ctx, args)
+  );
+};
+
+// src/tools/layer2/arrangeNetwork.ts
+import { z as z18 } from "zod";
+var arrangeNetworkSchema = z18.object({
+  path: z18.string().describe("COMP whose children to arrange, e.g. '/project1' or a container path."),
+  recursive: z18.boolean().default(false).describe("Also arrange the nodes inside nested COMPs (each network is tidied on its own).")
+});
+async function arrangeNetworkImpl(ctx, args) {
+  return guardTd(
+    async () => {
+      const topology = await ctx.client.getNetworkTopology(args.path, args.recursive);
+      const nodes = topology.nodes.map((n) => n.path);
+      const edges = topology.connections.map((c) => ({ from: c.source_path, to: c.target_path }));
+      const positions = computeLayoutByParent(nodes, edges);
+      if (nodes.length > 0) {
+        await ctx.client.executePythonScript(layoutScript(positions), false);
+      }
+      return Object.keys(positions).length;
+    },
+    (arranged) => jsonResult(
+      arranged === 0 ? `No nodes to arrange under ${args.path}.` : `Arranged ${arranged} node(s) under ${args.path} into a left\u2192right data-flow layout.`,
+      { path: args.path, arranged, recursive: args.recursive }
+    )
+  );
+}
+var registerArrangeNetwork = (server, ctx) => {
+  server.registerTool(
+    "arrange_network",
+    {
+      title: "Arrange network layout",
+      description: "Tidy an existing network: reposition a COMP's children into a readable left\u2192right data-flow layout (sources on the left, output on the right). Use this to clean up nodes that are piled on top of each other. Set recursive to also arrange the contents of nested COMPs.",
+      inputSchema: arrangeNetworkSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => arrangeNetworkImpl(ctx, args)
+  );
+};
+
 // 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)
+import { z as z19 } from "zod";
+var connectNodesSchema = z19.object({
+  source_path: z19.string().describe("Path of the source node (output side)."),
+  target_path: z19.string().describe("Path of the target node (input side)."),
+  source_output: z19.number().int().nonnegative().default(0),
+  target_input: z19.number().int().nonnegative().default(0)
 });
 async function connectNodesImpl(ctx, args) {
   return guardTd(
@@ -2001,23 +2779,34 @@ var registerConnectNodes = (server, ctx) => {
 };
 
 // src/tools/layer2/createContainer.ts
-import { z as z17 } from "zod";
+import { z as z20 } 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).")
+var createContainerSchema = z20.object({
+  parent_path: z20.string().default("/project1").describe("Parent COMP to create the container in."),
+  name: z20.string().optional(),
+  comp_type: z20.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
-    }),
+    async () => {
+      const node = await ctx.client.createNode({
+        parent_path: args.parent_path,
+        type: COMP_MAP[args.comp_type],
+        name: args.name
+      });
+      try {
+        await ctx.client.executePythonScript(
+          placeBelowSiblingsScript(args.parent_path, node.path),
+          false
+        );
+      } catch (err) {
+        ctx.logger.debug("container placement skipped", { err: String(err) });
+      }
+      return node;
+    },
     (node) => jsonResult(`Created ${args.comp_type} COMP at ${node.path}.`, { node })
   );
 }
@@ -2034,20 +2823,161 @@ var registerCreateContainer = (server, ctx) => {
   );
 };
 
+// src/tools/layer2/createExternalIo.ts
+import { z as z21 } from "zod";
+var bindSchema = z21.object({
+  channel: z21.string().describe(
+    "Channel name produced by the input (e.g. an OSC address tail 'fader1', or a MIDI channel name)."
+  ),
+  target: z21.string().describe("Parameter to drive, written as 'nodePath.parName'.")
+});
+var createExternalIoSchema = z21.object({
+  kind: z21.enum(["osc_in", "midi_in", "dmx_out", "ndi_in", "syphon_spout_in"]).describe(
+    "What to bridge: OSC input, MIDI input, DMX/Art-Net output (lighting), or NDI / Syphon-Spout video input. (Video/NDI/Syphon *outputs* live in setup_output.)"
+  ),
+  parent_path: z21.string().default("/project1").describe("COMP to create the I/O operator in."),
+  name: z21.string().optional(),
+  port: z21.coerce.number().int().optional().describe("(osc_in) UDP port to listen on. Defaults to 7000."),
+  normalize: z21.enum(["off", "0to1", "-1to1", "onoff"]).default("0to1").describe("(midi_in) How to scale incoming MIDI values."),
+  bind_to: z21.array(bindSchema).optional().describe(
+    "(osc_in/midi_in) Map incoming channels to parameters. Each binding tolerates a channel that hasn't arrived yet (falls back to 0 instead of erroring)."
+  ),
+  source_path: z21.string().optional().describe("(dmx_out) CHOP whose channel values are sent out as DMX."),
+  interface: z21.enum(["artnet", "sacn", "enttecusbpro", "enttecusbpromk2", "serial", "kinet"]).default("artnet").describe("(dmx_out) DMX transport."),
+  universe: z21.coerce.number().int().default(1).describe("(dmx_out) DMX universe."),
+  net_address: z21.string().optional().describe("(dmx_out) Target IP address for Art-Net / sACN."),
+  source_name: z21.string().optional().describe("(ndi_in/syphon_spout_in) Name of the NDI source or Spout sender to receive.")
+});
+var IO_SCRIPT = `
+import json, base64, traceback
+_p = json.loads(base64.b64decode("__PAYLOAD_B64__").decode("utf-8"))
+report = {"kind": _p["kind"], "warnings": []}
+_TYPEMAP = {"osc_in": oscinCHOP, "midi_in": midiinCHOP, "dmx_out": dmxoutCHOP, "ndi_in": ndiinTOP, "syphon_spout_in": syphonspoutinTOP}
+try:
+    _kind = _p["kind"]; _parent = op(_p["parent"])
+    if _parent is None:
+        report["fatal"] = "Parent COMP not found: " + str(_p["parent"])
+    else:
+        _name = _p.get("name")
+        _node = _parent.create(_TYPEMAP[_kind], _name) if _name else _parent.create(_TYPEMAP[_kind])
+        report["node"] = _node.path; report["type"] = _node.type
+        def _setpar(parname, val):
+            if val is None:
+                return
+            pr = getattr(_node.par, parname, None)
+            if pr is None:
+                report["warnings"].append("No parameter '%s' on %s" % (parname, _node.type)); return
+            try:
+                pr.val = val
+            except Exception:
+                report["warnings"].append("Could not set parameter '%s'" % parname)
+        if _kind == "osc_in":
+            _setpar("port", _p.get("port"))
+        elif _kind == "midi_in":
+            _setpar("norm", _p.get("normalize"))
+        elif _kind == "dmx_out":
+            _setpar("interface", _p.get("interface")); _setpar("universe", _p.get("universe")); _setpar("netaddress", _p.get("net_address"))
+            _src = _p.get("source")
+            if _src:
+                _s = op(_src)
+                if _s is None:
+                    report["warnings"].append("Source CHOP not found: " + _src)
+                else:
+                    try:
+                        _node.inputConnectors[0].connect(_s); report["source"] = _s.path
+                    except Exception:
+                        report["warnings"].append("Could not connect source " + _src)
+        elif _kind == "ndi_in":
+            _setpar("name", _p.get("source_name"))
+        elif _kind == "syphon_spout_in":
+            _setpar("sendername", _p.get("source_name"))
+        _bound = []
+        if _kind in ("osc_in", "midi_in"):
+            for _b in (_p.get("bind_to") or []):
+                try:
+                    _ch = _b["channel"]; _t = _b["target"]; _dot = _t.rfind(".")
+                    if _dot <= 0:
+                        report["warnings"].append("Invalid bind target '%s' (expected 'nodePath.parName')." % _t); continue
+                    _np = _t[:_dot]; _pn = _t[_dot + 1:]; _tn = op(_np)
+                    if _tn is None:
+                        report["warnings"].append("Bind target node not found: " + _np); continue
+                    _tp = getattr(_tn.par, _pn, None)
+                    if _tp is None:
+                        report["warnings"].append("Bind target parameter not found: %s.%s" % (_np, _pn)); continue
+                    _expr = "op(%r)[%r] if %r in [c.name for c in op(%r).chans()] else 0" % (_node.path, _ch, _ch, _node.path)
+                    _PM = type(_tp.mode); _tp.expr = _expr; _tp.mode = _PM.EXPRESSION
+                    _bound.append({"channel": _ch, "target": _np + "." + _pn})
+                except Exception:
+                    report["warnings"].append("Bind failed: " + traceback.format_exc().splitlines()[-1])
+        report["bound"] = _bound
+        report["errors"] = [str(e) for e in _node.errors()][:3]
+except Exception:
+    report["fatal"] = traceback.format_exc().splitlines()[-1]
+print(json.dumps(report))
+`;
+function buildIoScript(payload) {
+  return buildPayloadScript(IO_SCRIPT, payload);
+}
+async function createExternalIoImpl(ctx, args) {
+  return guardTd(
+    async () => {
+      const script = buildIoScript({
+        kind: args.kind,
+        parent: args.parent_path,
+        name: args.name ?? null,
+        port: args.kind === "osc_in" ? args.port ?? 7e3 : null,
+        normalize: args.normalize,
+        bind_to: args.bind_to ?? null,
+        source: args.source_path ?? null,
+        interface: args.interface,
+        universe: args.universe,
+        net_address: args.net_address ?? null,
+        source_name: args.source_name ?? null
+      });
+      const exec = await ctx.client.executePythonScript(script, true);
+      return parsePythonReport(exec.stdout);
+    },
+    (report) => {
+      if (report.fatal) {
+        return jsonResult(`Could not create ${report.kind}: ${report.fatal}`, report);
+      }
+      const bound = report.bound?.length ? `, ${report.bound.length} binding(s)` : "";
+      const errs = report.errors?.length ? `, ${report.errors.length} node error(s)` : "";
+      const warns = report.warnings.length ? `, ${report.warnings.length} warning(s)` : "";
+      return jsonResult(
+        `Created ${report.kind} (${report.type}) at ${report.node}${bound}${errs}${warns}.`,
+        report
+      );
+    }
+  );
+}
+var registerCreateExternalIo = (server, ctx) => {
+  server.registerTool(
+    "create_external_io",
+    {
+      title: "Create external I/O",
+      description: "Bridge TouchDesigner to the outside world: OSC input or MIDI input (a control surface \u2014 bind incoming channels straight to parameters), DMX/Art-Net output for lighting, or NDI / Syphon-Spout video input. Validate live where possible, but real signal needs the hardware/sender present.",
+      inputSchema: createExternalIoSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => createExternalIoImpl(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()
+import { z as z22 } from "zod";
+var UniformSchema = z22.object({
+  name: z22.string(),
+  type: z22.enum(["float", "vec2", "vec3", "vec4", "int", "sampler2D"]),
+  default_value: z22.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 createGlslShaderSchema = z22.object({
+  parent_path: z22.string().describe("Parent COMP to create the GLSL TOP inside."),
+  name: z22.string().optional().describe("Name for the GLSL TOP (default 'glsl1')."),
+  fragment_shader: z22.string().min(1).describe("GLSL fragment (pixel) shader source."),
+  vertex_shader: z22.string().optional().describe("Optional GLSL vertex shader source."),
+  uniforms: z22.array(UniformSchema).optional().describe("Optional uniform declarations to best-effort bind on the GLSL TOP."),
+  resolution: z22.enum(["720p", "1080p", "4K", "input"]).default("input")
 });
 var RESOLUTIONS2 = {
   "720p": [1280, 720],
@@ -2090,25 +3020,35 @@ async function createGlslShaderImpl(ctx, args) {
       }
       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 {
+        const samplers = args.uniforms.filter((u) => u.type === "sampler2D");
+        if (samplers.length > 0) {
           warnings.push(
-            "Could not auto-bind uniforms; declare them in the shader and set them on the GLSL TOP manually."
+            `sampler2D uniform(s) ${samplers.map((u) => u.name).join(", ")} must be wired manually (GLSL TOP Samplers page / TOP inputs).`
           );
         }
+        const specs = args.uniforms.filter((u) => u.type !== "sampler2D").map((u) => ({
+          name: u.name,
+          comps: (u.default_value ?? "").split(",").map((s) => Number(s.trim())).filter((n) => Number.isFinite(n)).slice(0, 4)
+        })).filter((s) => s.comps.length > 0);
+        if (specs.length > 0) {
+          const bind = [
+            `g = op(${q9(glsl.path)})`,
+            `_specs = ${JSON.stringify(specs)}`,
+            "g.seq.vec.numBlocks = max(g.seq.vec.numBlocks, len(_specs))",
+            "for i, s in enumerate(_specs):",
+            "    setattr(g.par, 'vec%dname' % i, s['name'])",
+            "    for axis, val in zip('xyzw', s['comps']):",
+            "        try: setattr(g.par, 'vec%dvalue%s' % (i, axis), val)",
+            "        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's Vectors page manually."
+            );
+          }
+        }
       }
       if (args.resolution !== "input") {
         const [width, height] = RESOLUTIONS2[args.resolution];
@@ -2137,16 +3077,16 @@ var registerCreateGlslShader = (server, ctx) => {
 };
 
 // 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()
+import { z as z23 } from "zod";
+var ChainNodeSchema = z23.object({
+  type: z23.string().describe("Operator type, e.g. 'noiseTOP'."),
+  name: z23.string().optional(),
+  parameters: z23.record(z23.string(), z23.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.")
+var createNodeChainSchema = z23.object({
+  parent_path: z23.string().describe("Parent COMP to create the chain inside."),
+  nodes: z23.array(ChainNodeSchema).min(1).describe("Ordered list of nodes to create."),
+  connect_sequentially: z23.boolean().default(true).describe("Wire output[0] \u2192 input[0] for each consecutive pair.")
 });
 async function createNodeChainImpl(ctx, args) {
   const created = [];
@@ -2189,6 +3129,25 @@ async function createNodeChainImpl(ctx, args) {
       }
     }
   }
+  const edges = [];
+  if (args.connect_sequentially) {
+    for (let i = 0; i < created.length - 1; i++) {
+      const from = created[i];
+      const to = created[i + 1];
+      if (from && to) edges.push({ from: from.path, to: to.path });
+    }
+  }
+  const positions = computeDataflowLayout(
+    created.map((c) => c.path),
+    edges
+  );
+  if (Object.keys(positions).length > 0) {
+    try {
+      await ctx.client.executePythonScript(layoutScript(positions), false);
+    } catch (err) {
+      warnings.push(`Auto-layout skipped: ${friendlyTdError(err)}`);
+    }
+  }
   return jsonResult(
     `Created ${created.length} node(s) and ${connections.length} connection(s) under ${args.parent_path}.`,
     { created, connections, warnings }
@@ -2208,17 +3167,17 @@ var registerCreateNodeChain = (server, ctx) => {
 };
 
 // src/tools/layer2/createPythonScript.ts
-import { z as z20 } from "zod";
+import { z as z24 } 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).")
+var createPythonScriptSchema = z24.object({
+  parent_path: z24.string().describe("Parent COMP to create the DAT inside."),
+  name: z24.string().optional(),
+  code: z24.string().min(1).describe("Python source to place in the DAT."),
+  dat_type: z24.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(
@@ -2228,10 +3187,20 @@ async function createPythonScriptImpl(ctx, args) {
         type: TYPE_MAP[args.dat_type],
         name: args.name
       });
-      await ctx.client.executePythonScript(
-        `op(${JSON.stringify(dat.path)}).text = ${JSON.stringify(args.code)}`,
-        false
-      );
+      const path = JSON.stringify(dat.path);
+      const code = JSON.stringify(args.code);
+      const script = args.dat_type === "script" ? [
+        `_op = op(${path})`,
+        "_cb = None",
+        "try:",
+        "    _cb = _op.par.callbacks.eval()",
+        "except Exception:",
+        "    _cb = None",
+        "if _cb is None:",
+        "    _cb = _op.parent().op(_op.name + '_callbacks')",
+        `_cb.text = ${code}`
+      ].join("\n") : `op(${path}).text = ${code}`;
+      await ctx.client.executePythonScript(script, false);
       return dat;
     },
     (dat) => jsonResult(`Created ${args.dat_type} DAT at ${dat.path}.`, { node: dat })
@@ -2251,12 +3220,12 @@ var registerCreatePythonScript = (server, ctx) => {
 };
 
 // src/tools/layer2/duplicateNetwork.ts
-import { z as z21 } from "zod";
+import { z as z25 } 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).")
+var duplicateNetworkSchema = z25.object({
+  source_path: z25.string().describe("Path of the node/COMP to duplicate."),
+  name: z25.string().optional().describe("Name for the copy (auto-generated if omitted)."),
+  parent_path: z25.string().optional().describe("Where to place the copy (defaults to the source's parent).")
 });
 async function duplicateNetworkImpl(ctx, args) {
   const script = [
@@ -2288,14 +3257,236 @@ var registerDuplicateNetwork = (server, ctx) => {
   );
 };
 
+// src/tools/layer2/manageComponent.ts
+import { z as z26 } from "zod";
+var manageComponentSchema = z26.object({
+  action: z26.enum(["save", "load"]).describe("save a COMP to a .tox file, or load a .tox into the project."),
+  file_path: z26.string().describe("Absolute path to the .tox file (e.g. '/Users/me/components/widget.tox')."),
+  comp_path: z26.string().optional().describe("(save) The COMP to save as a reusable .tox component."),
+  parent_path: z26.string().default("/project1").describe("(load) COMP to place the loaded component inside."),
+  linked: z26.boolean().default(false).describe(
+    "(load) Create a live-linked instance (externaltox) that re-reads the file on change, instead of an independent copy."
+  ),
+  name: z26.string().optional().describe("(load, linked) Name for the linked COMP; defaults to the file name."),
+  create_folders: z26.boolean().default(false).describe("(save) Create the parent folders if they do not exist.")
+});
+var COMPONENT_SCRIPT = `
+import json, base64, traceback, os
+_p = json.loads(base64.b64decode("__PAYLOAD_B64__").decode("utf-8"))
+report = {"action": _p["action"], "file_path": _p["file_path"], "warnings": []}
+try:
+    _action = _p["action"]; _fp = _p["file_path"]
+    if _action == "save":
+        _c = op(_p.get("comp"))
+        if _c is None:
+            report["fatal"] = "COMP not found: " + str(_p.get("comp"))
+        elif not _c.isCOMP:
+            report["fatal"] = str(_p.get("comp")) + " is not a COMP, so it cannot be saved as a .tox."
+        else:
+            _saved = _c.save(_fp, createFolders=bool(_p.get("create_folders")))
+            report["saved"] = str(_saved)
+            report["size"] = os.path.getsize(_fp) if os.path.isfile(_fp) else None
+    elif _action == "load":
+        if not os.path.isfile(_fp):
+            report["fatal"] = "File not found: " + _fp
+        else:
+            _parent = op(_p["parent"])
+            if _parent is None:
+                report["fatal"] = "Parent COMP not found: " + str(_p["parent"])
+            elif _p.get("linked"):
+                _stem = os.path.splitext(os.path.basename(_fp))[0]
+                _new = _parent.create(baseCOMP, _p.get("name") or _stem)
+                _new.par.externaltox = _fp
+                try:
+                    _new.par.reinitnet.pulse()
+                except Exception:
+                    pass
+                report["loaded"] = _new.path; report["linked"] = True
+                report["type"] = _new.type; report["children"] = sorted([c.name for c in _new.children])
+            else:
+                _new = _parent.loadTox(_fp)
+                if _new is None:
+                    report["fatal"] = "loadTox produced no component from " + _fp
+                else:
+                    report["loaded"] = _new.path; report["linked"] = False
+                    report["type"] = _new.type; report["children"] = sorted([c.name for c in _new.children])
+    else:
+        report["fatal"] = "Unknown action: " + str(_action)
+except Exception:
+    report["fatal"] = traceback.format_exc().splitlines()[-1]
+print(json.dumps(report))
+`;
+function buildComponentScript(payload) {
+  return buildPayloadScript(COMPONENT_SCRIPT, payload);
+}
+async function manageComponentImpl(ctx, args) {
+  if (args.action === "save" && !args.comp_path) {
+    return errorResult("A `comp_path` is required to save a component.");
+  }
+  return guardTd(
+    async () => {
+      const script = buildComponentScript({
+        action: args.action,
+        file_path: args.file_path,
+        comp: args.comp_path ?? null,
+        parent: args.parent_path,
+        linked: args.linked,
+        name: args.name ?? null,
+        create_folders: args.create_folders
+      });
+      const exec = await ctx.client.executePythonScript(script, true);
+      return parsePythonReport(exec.stdout);
+    },
+    (report) => {
+      if (report.fatal) {
+        return jsonResult(`Component ${report.action} failed: ${report.fatal}`, report);
+      }
+      const summary = report.action === "save" ? `Saved ${args.comp_path} to ${report.saved}${report.size != null ? ` (${report.size} bytes)` : ""}.` : `Loaded ${report.loaded}${report.linked ? " (live-linked)" : ""} from ${report.file_path}${report.children?.length ? ` \u2014 ${report.children.length} child node(s)` : ""}.`;
+      return jsonResult(summary, report);
+    }
+  );
+}
+var registerManageComponent = (server, ctx) => {
+  server.registerTool(
+    "manage_component",
+    {
+      title: "Save / load component (.tox)",
+      description: "Build a reusable component library: save any COMP as a .tox file, or load a .tox back into the project (as an independent copy, or a live-linked instance via `linked`). Paths are on the machine running TouchDesigner.",
+      inputSchema: manageComponentSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => manageComponentImpl(ctx, args)
+  );
+};
+
+// src/tools/layer2/managePresets.ts
+import { z as z27 } from "zod";
+var managePresetsSchema = z27.object({
+  action: z27.enum(["store", "recall", "list", "delete"]).describe("store a snapshot, recall one, list all, or delete one."),
+  comp_path: z27.string().default("/project1").describe(
+    "COMP whose parameter values the preset captures \u2014 usually a control-panel container."
+  ),
+  name: z27.string().optional().describe("Preset name (required for store/recall/delete)."),
+  params: z27.array(z27.string()).optional().describe(
+    "Specific custom-parameter names to capture/restore. Defaults to every custom parameter on the COMP."
+  )
+});
+var PRESETS_SCRIPT = `
+import json, base64, traceback
+_p = json.loads(base64.b64decode("__PAYLOAD_B64__").decode("utf-8"))
+KEY = "tdmcp_presets"
+report = {"action": _p["action"], "comp": _p["comp"], "warnings": []}
+_c = op(_p["comp"])
+try:
+    if _c is None:
+        report["fatal"] = "COMP not found: " + _p["comp"]
+    elif not hasattr(_c, "customPars"):
+        report["fatal"] = _p["comp"] + " is not a COMP, so it has no custom parameters to snapshot."
+    else:
+        _store = dict(_c.fetch(KEY, {}))
+        _action = _p["action"]; _name = _p.get("name")
+        if _action == "list":
+            report["presets"] = sorted(_store.keys())
+        elif _action == "store":
+            _wanted = _p.get("params") or None
+            _pars = list(_c.customPars) if _wanted is None else [getattr(_c.par, n, None) for n in _wanted]
+            _vals = {}
+            for _pr in _pars:
+                if _pr is None:
+                    continue
+                _vals[_pr.name] = _pr.eval()
+            _store[_name] = _vals; _c.store(KEY, _store)
+            report["name"] = _name; report["captured"] = sorted(_vals.keys()); report["presets"] = sorted(_store.keys())
+        elif _action == "recall":
+            if _name not in _store:
+                report["fatal"] = "Preset not found: '%s' (available: %s)" % (_name, ", ".join(sorted(_store.keys())) or "none")
+            else:
+                _restored = []
+                for _nm, _v in _store[_name].items():
+                    _pr = getattr(_c.par, _nm, None)
+                    if _pr is None:
+                        report["warnings"].append("Parameter no longer exists: " + _nm); continue
+                    if _pr.readOnly:
+                        report["warnings"].append("Parameter is read-only: " + _nm); continue
+                    try:
+                        _pr.val = _v; _restored.append(_nm)
+                    except Exception:
+                        report["warnings"].append("Could not restore " + _nm)
+                report["name"] = _name; report["restored"] = sorted(_restored)
+        elif _action == "delete":
+            if _name in _store:
+                _store.pop(_name, None); _c.store(KEY, _store); report["deleted"] = _name
+            else:
+                report["warnings"].append("Preset not found: " + str(_name))
+            report["presets"] = sorted(_store.keys())
+        else:
+            report["fatal"] = "Unknown action: " + str(_action)
+except Exception:
+    report["fatal"] = traceback.format_exc().splitlines()[-1]
+print(json.dumps(report))
+`;
+function buildPresetsScript(payload) {
+  return buildPayloadScript(PRESETS_SCRIPT, payload);
+}
+async function managePresetsImpl(ctx, args) {
+  if (args.action !== "list" && !args.name) {
+    return errorResult(`A preset name is required for the '${args.action}' action.`);
+  }
+  return guardTd(
+    async () => {
+      const script = buildPresetsScript({
+        action: args.action,
+        comp: args.comp_path,
+        name: args.name,
+        params: args.params ?? null
+      });
+      const exec = await ctx.client.executePythonScript(script, true);
+      return parsePythonReport(exec.stdout);
+    },
+    (report) => {
+      if (report.fatal) {
+        return jsonResult(`Preset ${report.action} failed: ${report.fatal}`, report);
+      }
+      let summary;
+      switch (report.action) {
+        case "store":
+          summary = `Stored preset "${report.name}" (${report.captured?.length ?? 0} parameter(s)) on ${report.comp}.`;
+          break;
+        case "recall":
+          summary = `Recalled preset "${report.name}" (${report.restored?.length ?? 0} parameter(s) restored) on ${report.comp}.`;
+          break;
+        case "delete":
+          summary = report.deleted ? `Deleted preset "${report.deleted}" on ${report.comp}.` : `No preset to delete on ${report.comp}.`;
+          break;
+        default:
+          summary = `${report.presets?.length ?? 0} preset(s) on ${report.comp}: ${report.presets?.join(", ") || "none"}.`;
+      }
+      if (report.warnings.length) summary += ` ${report.warnings.length} warning(s).`;
+      return jsonResult(summary, report);
+    }
+  );
+}
+var registerManagePresets = (server, ctx) => {
+  server.registerTool(
+    "manage_presets",
+    {
+      title: "Manage presets",
+      description: "Store, recall, list, or delete named snapshots of a COMP's parameter values \u2014 the live-performance preset system. Pair with create_control_panel: snapshot the knob positions and jump between looks. Snapshots are saved in the COMP's storage so they persist with the project.",
+      inputSchema: managePresetsSchema.shape,
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+    },
+    (args) => managePresetsImpl(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())
+import { z as z28 } from "zod";
+var UpdateSchema = z28.object({
+  path: z28.string(),
+  parameters: z28.record(z28.string(), z28.unknown())
 });
-var setParametersBatchSchema = z22.object({
-  updates: z22.array(UpdateSchema).min(1).describe(
+var setParametersBatchSchema = z28.object({
+  updates: z28.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)."
   )
 });
@@ -2308,7 +3499,12 @@ async function setParametersBatchImpl(ctx, args) {
         parameters: update.parameters
       }))
     ),
-    (result) => jsonResult(`Applied ${args.updates.length} parameter update(s) in one batch.`, result)
+    (result) => {
+      const failed = result.results.filter((r) => !r.ok);
+      const okCount = result.results.length - failed.length;
+      const summary = failed.length ? `Applied ${okCount}/${result.results.length} parameter update(s); ${failed.length} failed (see results).` : `Applied ${okCount} parameter update(s) in one batch.`;
+      return jsonResult(summary, result);
+    }
   );
 }
 var registerSetParametersBatch = (server, ctx) => {
@@ -2332,26 +3528,32 @@ var layer2Registrars = [
   registerCreatePythonScript,
   registerSetParametersBatch,
   registerCreateContainer,
-  registerDuplicateNetwork
+  registerCreateControlPanel,
+  registerAnimateParameter,
+  registerManagePresets,
+  registerManageComponent,
+  registerCreateExternalIo,
+  registerDuplicateNetwork,
+  registerArrangeNetwork
 ];
 
 // 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.")
+import { z as z29 } from "zod";
+var compareTdNodesSchema = z29.object({
+  path_a: z29.string().describe("First node path."),
+  path_b: z29.string().describe("Second node path."),
+  only_diff: z29.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()
+var compareTdNodesOutputSchema = z29.object({
+  a: z29.string(),
+  b: z29.string(),
+  type_a: z29.string(),
+  type_b: z29.string(),
+  type_match: z29.boolean(),
+  differing_count: z29.number(),
+  same_count: z29.number(),
+  differing: z29.array(z29.object({ param: z29.string(), a: z29.unknown(), b: z29.unknown() })),
+  identical: z29.array(z29.string()).optional()
 });
 async function compareTdNodesImpl(ctx, args) {
   return guardTd(
@@ -2405,12 +3607,12 @@ var registerCompareTdNodes = (server, ctx) => {
 };
 
 // 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.")
+import { z as z30 } from "zod";
+var createTdNodeSchema = z30.object({
+  parent_path: z30.string().default("/project1").describe("Parent COMP path to create the node inside."),
+  type: z30.string().describe("Operator type string, e.g. 'noiseTOP', 'feedbackTOP', 'nullTOP', 'constantCHOP'."),
+  name: z30.string().optional().describe("Optional node name (auto-generated if omitted)."),
+  parameters: z30.record(z30.string(), z30.unknown()).optional().describe("Optional initial parameter overrides as key\u2192value pairs.")
 });
 async function createTdNodeImpl(ctx, args) {
   const warnings = [];
@@ -2427,7 +3629,18 @@ async function createTdNodeImpl(ctx, args) {
       name: args.name,
       parameters: args.parameters
     }),
-    (node) => jsonResult(`Created ${node.type || args.type} at ${node.path}.`, { node, warnings })
+    (node) => {
+      const allWarnings = [...warnings];
+      if (node.parameter_warnings?.length) {
+        allWarnings.push(
+          `These parameter(s) were not applied (unknown name or bad value): ${node.parameter_warnings.join(", ")}.`
+        );
+      }
+      return jsonResult(`Created ${node.type || args.type} at ${node.path}.`, {
+        node,
+        warnings: allWarnings
+      });
+    }
   );
 }
 var registerCreateTdNode = (server, ctx) => {
@@ -2444,9 +3657,9 @@ var registerCreateTdNode = (server, ctx) => {
 };
 
 // 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'.")
+import { z as z31 } from "zod";
+var deleteTdNodeSchema = z31.object({
+  path: z31.string().describe("Full path of the node to delete, e.g. '/project1/noise1'.")
 });
 async function deleteTdNodeImpl(ctx, args) {
   return guardTd(
@@ -2468,12 +3681,12 @@ var registerDeleteTdNode = (server, ctx) => {
 };
 
 // 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.")
+import { z as z32 } from "zod";
+var execNodeMethodSchema = z32.object({
+  path: z32.string().describe("Full path of the node to call the method on."),
+  method: z32.string().describe("Method name to call, e.g. 'cook', 'par', 'destroy', 'copy'."),
+  args: z32.array(z32.unknown()).default([]).describe("Positional arguments."),
+  kwargs: z32.record(z32.string(), z32.unknown()).default({}).describe("Keyword arguments.")
 });
 async function execNodeMethodImpl(ctx, args) {
   return guardTd(
@@ -2496,12 +3709,12 @@ var registerExecNodeMethod = (server, ctx) => {
 };
 
 // src/tools/layer3/executePythonScript.ts
-import { z as z27 } from "zod";
-var executePythonScriptSchema = z27.object({
-  script: z27.string().min(1).describe(
+import { z as z33 } from "zod";
+var executePythonScriptSchema = z33.object({
+  script: z33.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.")
+  return_output: z33.boolean().default(true).describe("Capture stdout / the value of the last expression and return it.")
 });
 async function executePythonScriptImpl(ctx, args) {
   return guardTd(
@@ -2524,110 +3737,112 @@ var registerExecutePythonScript = (server, ctx) => {
 };
 
 // src/tools/layer3/findTdNodes.ts
-import { z as z29 } from "zod";
+import { z as z35 } 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()
+import { z as z34 } from "zod";
+var ApiEnvelopeSchema = z34.object({
+  ok: z34.boolean(),
+  data: z34.unknown().optional(),
+  error: z34.object({ code: z34.string().optional(), message: z34.string() }).optional()
 });
-var NodeRefSchema = z28.object({
-  path: z28.string(),
-  type: z28.string().default(""),
-  name: z28.string().default("")
+var NodeRefSchema = z34.object({
+  path: z34.string(),
+  type: z34.string().default(""),
+  name: z34.string().default(""),
+  /** Parameters that could not be applied at create time (unknown name or bad value). */
+  parameter_warnings: z34.array(z34.string()).optional()
 });
 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()
+  parameters: z34.record(z34.string(), z34.unknown()).default({}),
+  inputs: z34.array(z34.string()).optional(),
+  outputs: z34.array(z34.string()).optional(),
+  family: z34.string().optional(),
+  errors: z34.array(z34.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 NodeListSchema = z34.object({ nodes: z34.array(NodeRefSchema).default([]) });
+var InfoSchema = z34.object({
+  td_version: z34.string().optional(),
+  python_version: z34.string().optional(),
+  build: z34.string().optional(),
+  bridge_version: z34.string().optional(),
+  project: z34.string().optional()
 });
-var NodeErrorSchema = z28.object({
-  path: z28.string(),
-  message: z28.string(),
-  type: z28.string().optional()
+var NodeErrorSchema = z34.object({
+  path: z34.string(),
+  message: z34.string(),
+  type: z34.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 NodeErrorsSchema = z34.object({ errors: z34.array(NodeErrorSchema).default([]) });
+var PreviewSchema = z34.object({
+  path: z34.string(),
+  width: z34.number().int().positive(),
+  height: z34.number().int().positive(),
+  format: z34.string().default("png"),
+  base64: z34.string()
 });
-var ExecResultSchema = z28.object({
-  result: z28.unknown().optional(),
-  stdout: z28.string().optional(),
-  printed: z28.array(z28.string()).optional()
+var ExecResultSchema = z34.object({
+  result: z34.unknown().optional(),
+  stdout: z34.string().optional(),
+  printed: z34.array(z34.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 MethodResultSchema = z34.object({ result: z34.unknown() });
+var DeleteResultSchema = z34.object({ deleted: z34.string() });
+var ConnectionSchema = z34.object({
+  source_path: z34.string(),
+  source_output: z34.number().int().default(0),
+  target_path: z34.string(),
+  target_input: z34.number().int().default(0)
 });
-var TopologySchema = z28.object({
-  nodes: z28.array(NodeRefSchema).default([]),
-  connections: z28.array(ConnectionSchema).default([])
+var TopologySchema = z34.object({
+  nodes: z34.array(NodeRefSchema).default([]),
+  connections: z34.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()
+var PerformanceSchema = z34.object({
+  nodes: z34.array(
+    z34.object({
+      path: z34.string(),
+      cook_time_ms: z34.number().default(0),
+      cook_count: z34.number().optional()
     })
   ).default([]),
-  total_cook_time_ms: z28.number().optional(),
-  gpu_memory_mb: z28.number().optional()
+  total_cook_time_ms: z34.number().optional(),
+  gpu_memory_mb: z34.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 BatchOpResultSchema = z34.object({
+  action: z34.string(),
+  ok: z34.boolean(),
+  path: z34.string().optional(),
+  data: z34.unknown().optional(),
+  error: z34.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 BatchResultSchema = z34.object({ results: z34.array(BatchOpResultSchema).default([]) });
+var CreateNodeInputSchema = z34.object({
+  parent_path: z34.string(),
+  type: z34.string(),
+  name: z34.string().optional(),
+  parameters: z34.record(z34.string(), z34.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()
+var BatchOperationSchema = z34.discriminatedUnion("action", [
+  z34.object({
+    action: z34.literal("create"),
+    parent_path: z34.string(),
+    type: z34.string(),
+    name: z34.string().optional(),
+    parameters: z34.record(z34.string(), z34.unknown()).optional()
   }),
-  z28.object({
-    action: z28.literal("update"),
-    path: z28.string(),
-    parameters: z28.record(z28.string(), z28.unknown())
+  z34.object({
+    action: z34.literal("update"),
+    path: z34.string(),
+    parameters: z34.record(z34.string(), z34.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)
+  z34.object({ action: z34.literal("delete"), path: z34.string() }),
+  z34.object({
+    action: z34.literal("connect"),
+    source_path: z34.string(),
+    target_path: z34.string(),
+    source_output: z34.number().int().default(0),
+    target_input: z34.number().int().default(0)
   })
 ]);
 
@@ -2636,27 +3851,27 @@ function globToRegExp(pattern) {
   const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
   return new RegExp(escaped, "i");
 }
-function parentOf(path) {
+function parentOf2(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 findTdNodesSchema = z35.object({
+  parent_path: z35.string().default("/project1").describe("Where to search from."),
+  pattern: z35.string().optional().describe("Case-insensitive name/path filter with '*' wildcards (e.g. 'text*', '*noise*')."),
+  type: z35.string().optional().describe("Case-insensitive operator-type substring (e.g. 'TOP', 'noise')."),
+  recursive: z35.boolean().default(true).describe("Search the whole sub-network (true) or only direct children (false)."),
+  path_only: z35.boolean().default(false).describe("Return only matching paths."),
+  limit: z35.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()
+var findTdNodesOutputSchema = z35.object({
+  parent_path: z35.string(),
+  recursive: z35.boolean(),
+  count: z35.number(),
+  truncated: z35.boolean(),
+  paths: z35.array(z35.string()).optional(),
+  matches: z35.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;
@@ -2693,9 +3908,9 @@ var registerFindTdNodes = (server, ctx) => {
 };
 
 // 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'.")
+import { z as z36 } from "zod";
+var getModuleHelpSchema = z36.object({
+  name: z36.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);
@@ -2736,9 +3951,9 @@ var registerGetModuleHelp = (server, ctx) => {
 };
 
 // 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'.")
+import { z as z37 } from "zod";
+var getTdClassDetailsSchema = z37.object({
+  class_name: z37.string().describe("Python class name, e.g. 'OP', 'TOP', 'App', 'CHOP'.")
 });
 function getTdClassDetailsImpl(ctx, args) {
   const cls = ctx.knowledge.getPythonClass(args.class_name);
@@ -2768,9 +3983,9 @@ var registerGetTdClassDetails = (server, ctx) => {
 };
 
 // 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.")
+import { z as z38 } from "zod";
+var getTdClassesSchema = z38.object({
+  filter: z38.string().optional().describe("Optional case-insensitive substring to filter class names by.")
 });
 function getTdClassesImpl(ctx, args) {
   let classes = ctx.knowledge.listPythonClasses();
@@ -2831,17 +4046,17 @@ var registerGetTdInfo = (server, 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.")
+import { z as z39 } from "zod";
+var getTdNodeErrorsSchema = z39.object({
+  path: z39.string().describe("Full path of the node (or network root) to check for errors."),
+  recursive: z39.boolean().default(false).describe("If true, check the whole network under `path`; otherwise just that node."),
+  summary: z39.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()
+var getTdNodeErrorsOutputSchema = z39.object({
+  path: z39.string(),
+  total: z39.number(),
+  errors: z39.array(NodeErrorSchema).optional(),
+  by_type: z39.record(z39.string(), z39.number()).optional()
 });
 async function getTdNodeErrorsImpl(ctx, args) {
   return guardTd(
@@ -2883,11 +4098,11 @@ var registerGetTdNodeErrors = (server, ctx) => {
 };
 
 // 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.")
+import { z as z40 } from "zod";
+var getTdNodeParametersSchema = z40.object({
+  path: z40.string().describe("Full path of the node to inspect."),
+  keys: z40.array(z40.string()).optional().describe("Only return these parameter names (case-sensitive). Omit to return all parameters."),
+  omit_io: z40.boolean().default(false).describe("Drop the inputs/outputs lists from the result to save context.")
 });
 async function getTdNodeParametersImpl(ctx, args) {
   return guardTd(
@@ -2930,29 +4145,29 @@ var registerGetTdNodeParameters = (server, ctx) => {
 };
 
 // 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(
+import { z as z41 } from "zod";
+var getTdNodesSchema = z41.object({
+  parent_path: z41.string().default("/project1").describe("Parent COMP whose direct children should be listed."),
+  pattern: z41.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(
+  path_only: z41.boolean().default(false).describe("Return only the list of node paths, dropping type/name."),
+  limit: z41.number().int().positive().optional().describe("Cap the number of nodes returned."),
+  detail_level: z41.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()
+var getTdNodesOutputSchema = z41.object({
+  parent_path: z41.string(),
+  count: z41.number(),
+  detail_level: z41.enum(["summary", "full"]),
+  truncated: z41.boolean(),
+  by_type: z41.record(z41.string(), z41.number()).optional(),
+  sample: z41.array(z41.string()).optional(),
+  paths: z41.array(z41.string()).optional(),
+  nodes: z41.array(NodeRefSchema).optional(),
+  hint: z41.string().optional()
 });
 async function getTdNodesImpl(ctx, args) {
   return guardTd(
@@ -3020,11 +4235,11 @@ var registerGetTdNodes = (server, ctx) => {
 };
 
 // src/tools/layer3/getTdPerformance.ts
-import { z as z36 } from "zod";
+import { z as z42 } from "zod";
 
 // src/feedback/performanceMonitor.ts
-async function checkPerformance(client, path, targetFps = 60) {
-  const perf = await client.getNetworkPerformance(path);
+async function checkPerformance(client, path, targetFps = 60, recursive = true) {
+  const perf = await client.getNetworkPerformance(path, recursive);
   const frameBudgetMs = 1e3 / targetFps;
   const warnings = [];
   for (const node of perf.nodes) {
@@ -3040,31 +4255,35 @@ async function checkPerformance(client, path, targetFps = 60) {
       `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 };
+  const nodes = [...perf.nodes].sort((a, b) => b.cook_time_ms - a.cook_time_ms);
+  return { path, targetFps, frameBudgetMs, totalCookMs, 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 getTdPerformanceSchema = z42.object({
+  root_path: z42.string().default("/project1").describe("Network root to measure cook times under."),
+  target_fps: z42.number().positive().default(60).describe("Frame-rate target used to flag slow nodes."),
+  recursive: z42.boolean().default(true).describe(
+    "Measure every descendant (true, default) so cook time inside generated containers is counted, not just the root's direct children."
+  )
 });
-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()
+var getTdPerformanceOutputSchema = z42.object({
+  path: z42.string(),
+  targetFps: z42.number(),
+  frameBudgetMs: z42.number(),
+  totalCookMs: z42.number(),
+  nodes: z42.array(
+    z42.object({
+      path: z42.string(),
+      cook_time_ms: z42.number(),
+      cook_count: z42.number().optional()
     })
   ),
-  warnings: z36.array(z36.string())
+  warnings: z42.array(z42.string())
 });
 async function getTdPerformanceImpl(ctx, args) {
   return guardTd(
-    () => checkPerformance(ctx.client, args.root_path, args.target_fps),
+    () => checkPerformance(ctx.client, args.root_path, args.target_fps, args.recursive),
     (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
@@ -3076,7 +4295,7 @@ var registerGetTdPerformance = (server, ctx) => {
     "get_td_performance",
     {
       title: "Get network performance",
-      description: "Report cook times under a network and warn about nodes that exceed the frame budget.",
+      description: "Report cook times under a network (recursively by default, slowest node first) and warn about nodes that exceed the frame budget.",
       inputSchema: getTdPerformanceSchema.shape,
       outputSchema: getTdPerformanceOutputSchema.shape,
       annotations: { readOnlyHint: true, openWorldHint: true }
@@ -3086,7 +4305,7 @@ var registerGetTdPerformance = (server, ctx) => {
 };
 
 // src/tools/layer3/getTdTopology.ts
-import { z as z37 } from "zod";
+import { z as z43 } from "zod";
 
 // src/feedback/networkVerifier.ts
 async function verifyNetwork(client, path) {
@@ -3107,14 +4326,14 @@ async function verifyNetwork(client, path) {
 }
 
 // src/tools/layer3/getTdTopology.ts
-var getTdTopologySchema = z37.object({
-  root_path: z37.string().default("/project1").describe("Network root to map.")
+var getTdTopologySchema = z43.object({
+  root_path: z43.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()),
+var getTdTopologyOutputSchema = z43.object({
+  path: z43.string(),
+  nodeCount: z43.number(),
+  connectionCount: z43.number(),
+  issues: z43.array(z43.string()),
   topology: TopologySchema
 });
 async function getTdTopologyImpl(ctx, args) {
@@ -3141,27 +4360,27 @@ var registerGetTdTopology = (server, ctx) => {
 };
 
 // src/tools/layer3/snapshotTdGraph.ts
-import { z as z38 } from "zod";
+import { z as z44 } 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 snapshotTdGraphSchema = z44.object({
+  path: z44.string().default("/project1").describe("Network root to snapshot."),
+  include_params: z44.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()
+var snapshotTdGraphOutputSchema = z44.object({
+  path: z44.string(),
+  nodeCount: z44.number(),
+  connectionCount: z44.number(),
+  issues: z44.array(z44.string()),
+  params_truncated: z44.boolean(),
+  nodes: z44.array(
+    z44.object({
+      path: z44.string(),
+      type: z44.string(),
+      name: z44.string(),
+      parameters: z44.record(z44.string(), z44.unknown()).optional()
     })
   ),
-  connections: z38.array(ConnectionSchema)
+  connections: z44.array(ConnectionSchema)
 });
 async function snapshotTdGraphImpl(ctx, args) {
   return guardTd(
@@ -3215,25 +4434,25 @@ var registerSnapshotTdGraph = (server, ctx) => {
 };
 
 // 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(
+import { z as z45 } from "zod";
+var summarizeTdErrorsSchema = z45.object({
+  path: z45.string().default("/project1").describe("Network root to collect errors under."),
+  group_by: z45.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() })
+var summarizeTdErrorsOutputSchema = z45.object({
+  path: z45.string(),
+  total: z45.number(),
+  group_by: z45.enum(["message", "type", "parent"]),
+  groups: z45.array(
+    z45.object({
+      key: z45.string(),
+      count: z45.number(),
+      sample: z45.object({ path: z45.string(), message: z45.string() })
     })
   ),
-  suggestions: z39.array(z39.string())
+  suggestions: z45.array(z45.string())
 });
 async function summarizeTdErrorsImpl(ctx, args) {
   return guardTd(
@@ -3250,7 +4469,7 @@ async function summarizeTdErrorsImpl(ctx, args) {
           suggestions: []
         });
       }
-      const keyOf = (e) => args.group_by === "message" ? e.message : args.group_by === "type" ? e.type || "error" : parentOf(e.path);
+      const keyOf = (e) => args.group_by === "message" ? e.message : args.group_by === "type" ? e.type || "error" : parentOf2(e.path);
       const grouped = /* @__PURE__ */ new Map();
       const byPath = /* @__PURE__ */ new Map();
       for (const e of errors) {
@@ -3293,10 +4512,10 @@ var registerSummarizeTdErrors = (server, ctx) => {
 };
 
 // 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 }.")
+import { z as z46 } from "zod";
+var updateTdNodeParametersSchema = z46.object({
+  path: z46.string().describe("Full path of the node whose parameters to update."),
+  parameters: z46.record(z46.string(), z46.unknown()).describe("Parameter overrides as key\u2192value pairs, e.g. { period: 4, amplitude: 0.5 }.")
 });
 async function updateTdNodeParametersImpl(ctx, args) {
   return guardTd(
@@ -3359,7 +4578,7 @@ function getVersion() {
     try {
       const raw = readFileSync(resolve2(dir, "package.json"), "utf8");
       const pkg = JSON.parse(raw);
-      if (pkg.name === "tdmcp" && pkg.version) {
+      if (pkg.version && (pkg.name === "@dpantani/tdmcp" || pkg.name === "tdmcp")) {
         cached = pkg.version;
         return cached;
       }
@@ -3730,61 +4949,68 @@ import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as
 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(
+import { z as z47 } from "zod";
+var RecipeNodeSchema = z47.object({
+  name: z47.string().describe("Unique node name within the recipe (used for wiring)."),
+  type: z47.string().describe("Operator type, e.g. 'noiseTOP'."),
+  parameters: z47.record(z47.string(), z47.unknown()).default({}),
+  parent: z47.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(
+  render: z47.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()
+  comment: z47.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 RecipeConnectionSchema = z47.object({
+  from: z47.string().describe("Source node name."),
+  to: z47.string().describe("Target node name."),
+  from_output: z47.number().int().nonnegative().default(0),
+  to_input: z47.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 RecipeParameterSchema = z47.object({
+  name: z47.string().describe("Friendly name of the exposed control."),
+  node: z47.string().describe("Recipe node name the parameter belongs to."),
+  param: z47.string().describe("TD parameter name on that node."),
+  value: z47.unknown().optional(),
+  label: z47.string().optional(),
+  min: z47.number().optional(),
+  max: z47.number().optional(),
+  description: z47.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(
+var RecipeGlslUniformSchema = z47.object({
+  node: z47.string().describe("Recipe node name of the GLSL TOP that declares the uniform."),
+  name: z47.string().describe("Uniform name as referenced in the shader, e.g. 'uFeed'."),
+  kind: z47.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()
+  value: z47.union([z47.number(), z47.array(z47.number())]).optional().describe("Initial value: a number for float, or an array of components for vec/color."),
+  label: z47.string().optional(),
+  min: z47.number().optional(),
+  max: z47.number().optional(),
+  description: z47.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("")
+var RecipeSchema = z47.object({
+  id: z47.string(),
+  name: z47.string(),
+  description: z47.string().default(""),
+  tags: z47.array(z47.string()).default([]),
+  difficulty: z47.enum(["beginner", "intermediate", "advanced"]).default("intermediate"),
+  td_version_min: z47.string().default("2023"),
+  nodes: z47.array(RecipeNodeSchema).min(1),
+  connections: z47.array(RecipeConnectionSchema).default([]),
+  parameters: z47.array(RecipeParameterSchema).default([]),
+  glsl_uniforms: z47.array(RecipeGlslUniformSchema).default([]),
+  glsl_code: z47.record(z47.string(), z47.string()).optional(),
+  python_code: z47.record(z47.string(), z47.string()).optional(),
+  /**
+   * Live controls to auto-expose on the system container: custom parameters (knobs/
+   * sliders/toggles) bound to node parameters so the built system is immediately
+   * playable. Each control's `bind_to` uses recipe node *names* ("nodeName.parName");
+   * buildFromRecipe rewrites them to the real created paths.
+   */
+  controls: z47.array(controlSchema).default([]),
+  preview_description: z47.string().default("")
 });
 
 // src/recipes/loader.ts
@@ -4007,40 +5233,46 @@ var TouchDesignerClient = class {
       recursive ? { recursive: true } : void 0
     );
   }
-  getNetworkPerformance(path) {
-    return this.request("GET", `/api/network/${segment(path)}/performance`, PerformanceSchema);
+  getNetworkPerformance(path, recursive = false) {
+    return this.request(
+      "GET",
+      `/api/network/${segment(path)}/performance`,
+      PerformanceSchema,
+      void 0,
+      recursive ? { recursive: true } : void 0
+    );
   }
 };
 
 // src/utils/config.ts
-import { z as z42 } from "zod";
-var ConfigSchema = z42.object({
+import { z as z48 } from "zod";
+var ConfigSchema = z48.object({
   /** TouchDesigner bridge host. */
-  tdHost: z42.string().min(1).default("127.0.0.1"),
+  tdHost: z48.string().min(1).default("127.0.0.1"),
   /** TouchDesigner bridge port (WebServer DAT). */
-  tdPort: z42.coerce.number().int().positive().max(65535).default(9980),
+  tdPort: z48.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"),
+  transport: z48.enum(["stdio", "http"]).default("stdio"),
   /** Log verbosity (written to stderr). */
-  logLevel: z42.enum(["debug", "info", "warn", "error", "silent"]).default("info"),
+  logLevel: z48.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),
+  requestTimeoutMs: z48.coerce.number().int().positive().default(1e4),
   /** HTTP transport port (only used when transport=http). */
-  httpPort: z42.coerce.number().int().positive().max(65535).default(3939),
+  httpPort: z48.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"),
+  events: z48.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"),
+  rawPython: z48.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()
+  bridgeToken: z48.string().min(1).optional()
 });
 function loadConfig(env = process.env) {
   return ConfigSchema.parse({