@nodetool-ai/node-sdk 0.8.4-a24.2 → 0.8.4

package/dist/_sandbox/sandbox-dsl/sandbox/core.js

@@ -0,0 +1,382 @@
+/**
+ * The guest half of the NodeTool workflow DSL.
+ *
+ * `@nodetool-ai/dsl`'s own `core.ts` carries two things: the wiring model
+ * (`createNode`, `workflow`) and a host runner (`run`) that imports the kernel,
+ * the runtime, and the Python bridge. Only the first half is computation, so
+ * only the first half is here — a guest module that imported `WorkflowRunner`
+ * would fail admission on the first Node builtin behind it.
+ *
+ * Two things differ from the host DSL, both on purpose:
+ *
+ *  - Node ids read like the node type (`text_to_image`, `text_to_image_2`)
+ *    rather than being UUIDs. A model writes and reads these ids, and an id it
+ *    can say out loud is worth more than one that is globally unique.
+ *  - `workflow()` returns the kernel graph shape — `{id, type, properties}`
+ *    nodes and `{id, source, sourceHandle, target, targetHandle}` edges — which
+ *    is what `validate_workflow` and `create_workflow` already take. The host
+ *    DSL's `{data, streaming}` node shape is for its own runner.
+ *
+ * The generated namespace modules import `createNode` from here and nothing
+ * else; every type in their signatures is erased at build time.
+ */
+
+/** Nodes registered since the last `workflow()` call, by id. */
+let registry = new Map();
+/** Per-stem counters behind the readable auto ids. */
+let counters = new Map();
+const dslNodes = new WeakMap();
+const handleDescriptors = new WeakMap();
+
+let nodeScope = "";
+let scopeCounters = new Map();
+let captureConnection;
+
+export function withBuildScope(build, capture) {
+  const previous = { registry, counters, nodeScope, scopeCounters, captureConnection };
+  registry = new Map(); counters = new Map(); nodeScope = ""; scopeCounters = new Map(); captureConnection = capture;
+  try { return build(); }
+  finally { ({ registry, counters, nodeScope, scopeCounters, captureConnection } = previous); }
+}
+
+export function withNodeScope(id, build) {
+  if (id !== undefined && (typeof id !== "string" || !id.length)) throw new Error("Workflow scope id must be a non-empty string");
+  const previous = nodeScope;
+  const stem = previous + (id ?? "call");
+  const count = (scopeCounters.get(stem) ?? 0) + 1;
+  if (id && count > 1) throw new Error(`Duplicate workflow scope "${stem}"`);
+  scopeCounters.set(stem, count);
+  nodeScope = stem + (id ? "/" : `_${count}/`);
+  try { return build(); } finally { nodeScope = previous; }
+}
+
+export function resolveConnection(value) {
+  if (isOutputHandle(value)) {
+    const descriptor = handleDescriptors.get(value);
+    return captureConnection && descriptor && registry.get(value.source) !== descriptor ? captureConnection(value) : value;
+  }
+  if (value !== null && typeof value === "object" && dslNodes.has(value)) {
+    if (!value.defaultOutputHandle) {
+      throw new Error("Node " + value.nodeType + " requires an explicit output slot");
+    }
+    return resolveConnection(value.defaultOutputHandle);
+  }
+  return undefined;
+}
+
+function autoId(nodeType) {
+  const last = String(nodeType).split(".").pop() || "node";
+  const stem = last
+    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+    .replace(/[^A-Za-z0-9_]/g, "_")
+    .toLowerCase();
+  let id = nodeScope + stem;
+  while (registry.has(id)) {
+    const next = (counters.get(stem) || 1) + 1;
+    counters.set(stem, next);
+    id = nodeScope + stem + "_" + next;
+  }
+  return id;
+}
+
+export function isOutputHandle(value) {
+  return (
+    value !== null && typeof value === "object" && value.__handle === true
+  );
+}
+
+/**
+ * Find a handle nested inside a prop value — in an array, or under an object
+ * key. Returns the path to the first one, or null.
+ *
+ * A connection is only made from a handle assigned directly to an input (or,
+ * for a list input, from an array of handles). One buried deeper is not wired:
+ * it used to be written verbatim into the node's properties, the node
+ * producing it was never reached, and the graph validated clean with the
+ * producer missing entirely. Reporting the path turns that silent hole into an
+ * error a caller can act on.
+ */
+function findNestedHandlePath(value, seen) {
+  if (value === null || typeof value !== "object") return null;
+  if (seen.indexOf(value) !== -1) return null;
+  seen.push(value);
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      const item = value[i];
+      if (resolveConnection(item)) return "[" + i + "]";
+      const deeper = findNestedHandlePath(item, seen);
+      if (deeper !== null) return "[" + i + "]" + deeper;
+    }
+    return null;
+  }
+  for (const key of Object.keys(value)) {
+    if (resolveConnection(value[key])) return "." + key;
+    const deeper = findNestedHandlePath(value[key], seen);
+    if (deeper !== null) return "." + key + deeper;
+  }
+  return null;
+}
+
+/**
+ * Classify one non-handle input value for wiring.
+ *
+ * An array whose every element is a handle is list fan-in — the same shape the
+ * editor produces when several sources feed one `list[...]` input — and wires
+ * one edge per element. Anything else holding a handle anywhere inside is
+ * refused with the path named.
+ */
+function classifyInput(name, value) {
+  if (Array.isArray(value)) {
+    let sawHandle = false;
+    let sawLiteral = false;
+    for (const item of value) {
+      if (isOutputHandle(item)) {
+        sawHandle = true;
+      } else {
+        sawLiteral = true;
+      }
+    }
+    if (!sawHandle) return { kind: "plain" };
+    if (sawLiteral) {
+      throw new Error(
+        'Input "' +
+          name +
+          '" mixes wired outputs and literal values in one array. Wire the ' +
+          "whole list — every element an output() handle — or pass plain " +
+          "values only."
+      );
+    }
+    return { kind: "fanin" };
+  }
+  const nested = findNestedHandlePath(value, []);
+  if (nested !== null) {
+    throw new Error(
+      'Input "' +
+        name +
+        '" holds a node output at "' +
+        name +
+        nested +
+        '". A connection is only made from a handle assigned directly to an ' +
+        "input — one buried in an object is not wired, and the node producing " +
+        "it would be left out of the graph. Give each source its own input."
+    );
+  }
+  return { kind: "plain" };
+}
+
+/** Original producer identity, including isolated build scopes. */
+export function connectionIdentity(handle) {
+  return handleDescriptors.get(handle) ?? handle;
+}
+
+export function connectionSlot(handle) { return handle.sourceHandle; }
+
+function createHandle(nodeId, slot, descriptor) {
+  const handle = {
+    __handle: true,
+    source: nodeId,
+    sourceHandle: slot,
+    ...(descriptor.outputTypes && descriptor.outputTypes[slot] ? { valueType: descriptor.outputTypes[slot] } : {})
+  };
+  // Interpolating a handle into a string silently yields "[object Object]":
+  // no edge is created and the node gets that literal text. Refuse the
+  // conversion so the mistake surfaces where it was made.
+  //
+  // The refusal names both ways out. Told only "pass it as the property
+  // value", a model that wants one prompt built from four upstream values has
+  // nowhere to go and rewrites the same template eight times; the node that
+  // does this is `nodetool.text.Template`, and the message has to say so.
+  handle[Symbol.toPrimitive] = function () {
+    throw new Error(
+      "Cannot use " +
+        nodeId +
+        "." +
+        slot +
+        " inside a string. A handle wires an edge; it is not text. Pass it " +
+        "as the property value itself — { prompt: " +
+        nodeId +
+        ".output() }. To build one string out of several handles plus fixed " +
+        'text, wire them into a template node: template({ string: "Hi ' +
+        '{{name}}, about {{topic}}", name: a.output(), topic: b.output() }) ' +
+        'from "@nodetool-ai/sandbox-dsl/nodetool.text" — each extra key is a ' +
+        "dynamic input, and its {{key}} placeholder is replaced at run time. " +
+        "An Agent node's fixed instructions belong in its `system` property, " +
+        "not in the interpolated prompt."
+    );
+  };
+  handleDescriptors.set(handle, descriptor);
+  return Object.freeze(handle);
+}
+
+/**
+ * Register one node and return its handle factory.
+ *
+ * Called only by the generated namespace modules, which pin `nodeType` and the
+ * output names from the node's own metadata. `opts.id` names the node when the
+ * program wants a stable id.
+ */
+export function createNode(nodeType, inputs, opts) {
+  if (typeof nodeType !== "string" || nodeType.length === 0) {
+    throw new Error("createNode(nodeType, inputs): nodeType must be a non-empty string");
+  }
+  if (inputs !== undefined && (inputs === null || typeof inputs !== "object" || Array.isArray(inputs))) {
+    throw new Error("createNode(nodeType, inputs): inputs must be an object");
+  }
+  if (opts && opts.id !== undefined && (typeof opts.id !== "string" || opts.id.length === 0)) {
+    throw new Error("Node id must be a non-empty string");
+  }
+  const explicit = opts && opts.id;
+
+  const nodeId = explicit !== undefined ? nodeScope + explicit : nodeScope + autoId(nodeType);
+  if (registry.has(nodeId)) throw new Error('Duplicate node id "' + nodeId + '"');
+  const outputNames = opts && opts.outputNames ? [...opts.outputNames] : [];
+  const defaultOutput =
+    (opts && opts.defaultOutput) ??
+    (outputNames.length === 1 && !(opts && opts.multiOutput) ? outputNames[0] : undefined);
+
+  const descriptor = {
+    nodeId,
+    nodeType,
+    inputs: Object.fromEntries(Object.entries(inputs ?? {}).map(([key, value]) => [
+      key,
+      resolveConnection(value) ?? (Array.isArray(value)
+        ? value.map((item) => resolveConnection(item) ?? item)
+        : value)
+    ])),
+    streaming: Boolean(opts && opts.streaming),
+    streamingInput: Boolean(opts && opts.streamingInput),
+    outputTypes: opts && opts.outputTypes,
+    dynamicOutputs: opts && opts.dynamicOutputs,
+    inputMode: opts && opts.inputMode,
+    outputCorrelation: opts && opts.outputCorrelation
+  };
+  registry.set(nodeId, descriptor);
+
+  const known = new Set(outputNames);
+  const output = (slot) => {
+    const resolved = slot ?? defaultOutput;
+    if (!resolved) {
+      throw new Error(
+        "Node " + nodeType + " has several outputs; name one: node.output(\"" +
+          (outputNames[0] ?? "output") + "\")"
+      );
+    }
+    if (known.size > 0 && !known.has(resolved)) {
+      throw new Error(
+        "Unknown output slot '" + resolved + "' for " + nodeType +
+          ". Available: " + outputNames.join(", ")
+      );
+    }
+    return createHandle(nodeId, resolved, descriptor);
+  };
+
+  const node = {
+    nodeId, nodeType, inputs: descriptor.inputs, output,
+    outputs: Object.freeze(Object.fromEntries(outputNames.map((name) => [name, output(name)]))),
+    defaultOutputHandle: outputNames.length === 1 && !(opts && opts.multiOutput) && defaultOutput ? output() : undefined,
+    [Symbol.toPrimitive]: () => {
+      throw new Error("Cannot coerce a DSL node to a primitive. Pass it directly to an input or select node.output(slot).");
+    }
+  };
+  const reserved = new Set([...Object.keys(node), "then", "constructor", "__proto__"]);
+  for (const name of outputNames) {
+    if (!reserved.has(name)) Object.defineProperty(node, name, { get: () => output(name) });
+  }
+  Object.freeze(node);
+  dslNodes.set(node, descriptor);
+  return node;
+}
+
+/**
+ * Collect the graph reachable from `terminals` and reset the registry.
+ *
+ * Only nodes an edge path reaches from a terminal are included: a node built
+ * and then never wired is dead, and a graph that carried it would fail
+ * validation for a property nobody meant to set.
+ */
+export function workflow(...terminals) {
+  if (terminals.length === 0) {
+    throw new Error("workflow() requires at least one terminal node");
+  }
+
+  const reached = new Map();
+  const edges = [];
+  const queue = [];
+  /** Inputs fully supplied by edges; their stored values are not shipped. */
+  const wiredInputs = new Set();
+
+  const admit = (node) => {
+    const id = node && node.nodeId;
+    const descriptor = typeof id === "string" ? registry.get(id) : undefined;
+    if (descriptor === undefined || (dslNodes.has(node) && dslNodes.get(node) !== descriptor)) {
+      throw new Error(
+        "workflow(): not a node from this program" +
+          (typeof id === "string" ? ' ("' + id + '")' : "") +
+          ". A handle from an earlier workflow() call is already spent."
+      );
+    }
+    if (!reached.has(id)) {
+      reached.set(id, descriptor);
+      queue.push(id);
+    }
+  };
+
+  for (const terminal of terminals) admit(terminal);
+
+  for (let queueIndex = 0; queueIndex < queue.length; queueIndex++) {
+    const currentId = queue[queueIndex];
+    const descriptor = reached.get(currentId);
+    for (const [name, value] of Object.entries(descriptor.inputs)) {
+      let sources;
+      if (isOutputHandle(value)) {
+        sources = [value];
+      } else {
+        const kind = classifyInput(name, value);
+        if (kind.kind !== "fanin") continue;
+        sources = value;
+      }
+      wiredInputs.add(currentId + "." + name);
+      for (const handle of sources) {
+        if (handleDescriptors.has(handle) && handleDescriptors.get(handle) !== registry.get(handle.source)) {
+          throw new Error("workflow(): a handle from an earlier workflow() call is already spent.");
+        }
+        edges.push({
+          id: "e" + (edges.length + 1) + "_" + handle.source + "_" + currentId,
+          source: handle.source,
+          sourceHandle: handle.sourceHandle,
+          target: currentId,
+          targetHandle: name
+        });
+        admit({ nodeId: handle.source });
+      }
+    }
+  }
+
+  const nodes = [...reached.values()].map((descriptor) => {
+    const properties = {};
+    for (const [name, value] of Object.entries(descriptor.inputs)) {
+      if (
+        !isOutputHandle(value) &&
+        !wiredInputs.has(descriptor.nodeId + "." + name)
+      ) {
+        properties[name] = value;
+      }
+    }
+    return {
+      id: descriptor.nodeId,
+      type: descriptor.nodeType,
+      properties,
+      ...(descriptor.streaming ? { is_streaming_output: true } : {}),
+      ...(descriptor.streamingInput ? { is_streaming_input: true } : {}),
+      ...(descriptor.dynamicOutputs ? { dynamic_outputs: descriptor.dynamicOutputs } : {}),
+      ...(descriptor.inputMode ? { input_mode: descriptor.inputMode } : {}),
+      ...(descriptor.outputCorrelation ? { output_correlation: descriptor.outputCorrelation } : {})
+    };
+  });
+
+  registry.clear();
+  scopeCounters.clear();
+  counters.clear();
+
+  return { nodes, edges };
+}

package/dist/_sandbox/sandbox-dsl/sandbox/generated/gemini.audio.js

@@ -0,0 +1,12 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { createNode } from "../core.js";
+function textToSpeech(inputs, options) {
+  return createNode("gemini.audio.TextToSpeech", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "audio" }, defaultOutput: "output" });
+}
+function transcribe(inputs, options) {
+  return createNode("gemini.audio.Transcribe", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "str" }, defaultOutput: "output" });
+}
+export {
+  textToSpeech,
+  transcribe
+};

package/dist/_sandbox/sandbox-dsl/sandbox/generated/gemini.image.js

@@ -0,0 +1,8 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { createNode } from "../core.js";
+function imageGeneration(inputs, options) {
+  return createNode("gemini.image.ImageGeneration", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "image" }, defaultOutput: "output" });
+}
+export {
+  imageGeneration
+};

package/dist/_sandbox/sandbox-dsl/sandbox/generated/gemini.text.js

@@ -0,0 +1,12 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { createNode } from "../core.js";
+function groundedSearch(inputs, options) {
+  return createNode("gemini.text.GroundedSearch", inputs, { id: options?.id, outputNames: ["results", "sources", "text"], outputTypes: { "results": "list[str]", "sources": "list[source]", "text": "str" } });
+}
+function embedding(inputs, options) {
+  return createNode("gemini.text.Embedding", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "list" }, defaultOutput: "output" });
+}
+export {
+  embedding,
+  groundedSearch
+};

package/dist/_sandbox/sandbox-dsl/sandbox/generated/gemini.video.js

@@ -0,0 +1,12 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { createNode } from "../core.js";
+function textToVideo(inputs, options) {
+  return createNode("gemini.video.TextToVideo", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function imageToVideo(inputs, options) {
+  return createNode("gemini.video.ImageToVideo", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+export {
+  imageToVideo,
+  textToVideo
+};

package/dist/_sandbox/sandbox-dsl/sandbox/generated/index.js

@@ -0,0 +1,149 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import * as geminiAudio from "./gemini.audio.js";
+import * as geminiImage from "./gemini.image.js";
+import * as geminiText from "./gemini.text.js";
+import * as geminiVideo from "./gemini.video.js";
+import * as kieDynamic_schema from "./kie.dynamic_schema.js";
+import * as libAudio from "./lib.audio.js";
+import * as libBrowser from "./lib.browser.js";
+import * as libCharts from "./lib.charts.js";
+import * as libComfy from "./lib.comfy.js";
+import * as libGrid from "./lib.grid.js";
+import * as libImage from "./lib.image.js";
+import * as libImageChannel from "./lib.image.channel.js";
+import * as libImageColor from "./lib.image.color.js";
+import * as libImageColor_grading from "./lib.image.color_grading.js";
+import * as libImageDraw from "./lib.image.draw.js";
+import * as libImageEffects from "./lib.image.effects.js";
+import * as libImageEnhance from "./lib.image.enhance.js";
+import * as libImageFilter from "./lib.image.filter.js";
+import * as libImageKeyer from "./lib.image.keyer.js";
+import * as libImageMask from "./lib.image.mask.js";
+import * as libImageWarp from "./lib.image.warp.js";
+import * as libPdf from "./lib.pdf.js";
+import * as libSqlite from "./lib.sqlite.js";
+import * as libStable_diffusion_cpp from "./lib.stable_diffusion_cpp.js";
+import * as libSvg from "./lib.svg.js";
+import * as libVideoDownload from "./lib.video.download.js";
+import * as messagingDiscord from "./messaging.discord.js";
+import * as messagingTelegram from "./messaging.telegram.js";
+import * as mistralEmbeddings from "./mistral.embeddings.js";
+import * as mistralText from "./mistral.text.js";
+import * as mistralVision from "./mistral.vision.js";
+import * as agents from "./nodetool.agents.js";
+import * as audio from "./nodetool.audio.js";
+import * as audioRealtime from "./nodetool.audio.realtime.js";
+import * as audioSynth from "./nodetool.audio.synth.js";
+import * as blender from "./nodetool.blender.js";
+import * as code from "./nodetool.code.js";
+import * as compare from "./nodetool.compare.js";
+import * as constant from "./nodetool.constant.js";
+import * as control from "./nodetool.control.js";
+import * as creative from "./nodetool.creative.js";
+import * as data from "./nodetool.data.js";
+import * as document from "./nodetool.document.js";
+import * as entity from "./nodetool.entity.js";
+import * as fake from "./nodetool.fake.js";
+import * as game from "./nodetool.game.js";
+import * as generators from "./nodetool.generators.js";
+import * as image from "./nodetool.image.js";
+import * as input from "./nodetool.input.js";
+import * as manimgx from "./nodetool.manimgx.js";
+import * as model3d from "./nodetool.model3d.js";
+import * as output from "./nodetool.output.js";
+import * as script from "./nodetool.script.js";
+import * as sketch from "./nodetool.sketch.js";
+import * as storyboard from "./nodetool.storyboard.js";
+import * as text from "./nodetool.text.js";
+import * as timeline from "./nodetool.timeline.js";
+import * as triggers from "./nodetool.triggers.js";
+import * as variable from "./nodetool.variable.js";
+import * as video from "./nodetool.video.js";
+import * as workflowsApp_node from "./nodetool.workflows.app_node.js";
+import * as workflowsBase_node from "./nodetool.workflows.base_node.js";
+import * as workflowsSubgraph from "./nodetool.workflows.subgraph.js";
+import * as workflowsWorkflow_node from "./nodetool.workflows.workflow_node.js";
+import * as openaiAgents from "./openai.agents.js";
+import * as openaiAudio from "./openai.audio.js";
+import * as openaiImage from "./openai.image.js";
+import * as openaiText from "./openai.text.js";
+import * as vector from "./vector.js";
+import * as whisper_cpp from "./whisper_cpp.js";
+import * as xaiImage from "./xai.image.js";
+import * as xaiText from "./xai.text.js";
+import * as xaiVision from "./xai.vision.js";
+export {
+  agents,
+  audio,
+  audioRealtime,
+  audioSynth,
+  blender,
+  code,
+  compare,
+  constant,
+  control,
+  creative,
+  data,
+  document,
+  entity,
+  fake,
+  game,
+  geminiAudio,
+  geminiImage,
+  geminiText,
+  geminiVideo,
+  generators,
+  image,
+  input,
+  kieDynamic_schema,
+  libAudio,
+  libBrowser,
+  libCharts,
+  libComfy,
+  libGrid,
+  libImage,
+  libImageChannel,
+  libImageColor,
+  libImageColor_grading,
+  libImageDraw,
+  libImageEffects,
+  libImageEnhance,
+  libImageFilter,
+  libImageKeyer,
+  libImageMask,
+  libImageWarp,
+  libPdf,
+  libSqlite,
+  libStable_diffusion_cpp,
+  libSvg,
+  libVideoDownload,
+  manimgx,
+  messagingDiscord,
+  messagingTelegram,
+  mistralEmbeddings,
+  mistralText,
+  mistralVision,
+  model3d,
+  openaiAgents,
+  openaiAudio,
+  openaiImage,
+  openaiText,
+  output,
+  script,
+  sketch,
+  storyboard,
+  text,
+  timeline,
+  triggers,
+  variable,
+  vector,
+  video,
+  whisper_cpp,
+  workflowsApp_node,
+  workflowsBase_node,
+  workflowsSubgraph,
+  workflowsWorkflow_node,
+  xaiImage,
+  xaiText,
+  xaiVision
+};

package/dist/_sandbox/sandbox-dsl/sandbox/generated/kie.dynamic_schema.js

@@ -0,0 +1,8 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { createNode } from "../core.js";
+function kieAI(inputs, options) {
+  return createNode("kie.dynamic_schema.KieAI", inputs, { id: options?.id, outputNames: [], outputTypes: {} });
+}
+export {
+  kieAI
+};

package/dist/_sandbox/sandbox-dsl/sandbox/generated/lib.audio.js

@@ -0,0 +1,68 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { createNode } from "../core.js";
+function gain(inputs, options) {
+  return createNode("lib.audio.Gain", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "audio" }, defaultOutput: "output" });
+}
+function delay(inputs, options) {
+  return createNode("lib.audio.Delay", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "audio" }, defaultOutput: "output" });
+}
+function highPassFilter(inputs, options) {
+  return createNode("lib.audio.HighPassFilter", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "audio" }, defaultOutput: "output" });
+}
+function lowPassFilter(inputs, options) {
+  return createNode("lib.audio.LowPassFilter", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "audio" }, defaultOutput: "output" });
+}
+function highShelfFilter(inputs, options) {
+  return createNode("lib.audio.HighShelfFilter", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "audio" }, defaultOutput: "output" });
+}
+function lowShelfFilter(inputs, options) {
+  return createNode("lib.audio.LowShelfFilter", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "audio" }, defaultOutput: "output" });
+}
+function peakFilter(inputs, options) {
+  return createNode("lib.audio.PeakFilter", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "audio" }, defaultOutput: "output" });
+}
+function bitcrush(inputs, options) {
+  return createNode("lib.audio.Bitcrush", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "audio" }, defaultOutput: "output" });
+}
+function compress(inputs, options) {
+  return createNode("lib.audio.Compress", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "audio" }, defaultOutput: "output" });
+}
+function distortion(inputs, options) {
+  return createNode("lib.audio.Distortion", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "audio" }, defaultOutput: "output" });
+}
+function limiter(inputs, options) {
+  return createNode("lib.audio.Limiter", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "audio" }, defaultOutput: "output" });
+}
+function reverb(inputs, options) {
+  return createNode("lib.audio.Reverb", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "audio" }, defaultOutput: "output" });
+}
+function noiseGate(inputs, options) {
+  return createNode("lib.audio.NoiseGate", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "audio" }, defaultOutput: "output" });
+}
+function phaser(inputs, options) {
+  return createNode("lib.audio.Phaser", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "audio" }, defaultOutput: "output" });
+}
+function pitchShift(inputs, options) {
+  return createNode("lib.audio.PitchShift", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "audio" }, defaultOutput: "output" });
+}
+function timeStretch(inputs, options) {
+  return createNode("lib.audio.TimeStretch", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "audio" }, defaultOutput: "output" });
+}
+export {
+  bitcrush,
+  compress,
+  delay,
+  distortion,
+  gain,
+  highPassFilter,
+  highShelfFilter,
+  limiter,
+  lowPassFilter,
+  lowShelfFilter,
+  noiseGate,
+  peakFilter,
+  phaser,
+  pitchShift,
+  reverb,
+  timeStretch
+};

package/dist/_sandbox/sandbox-dsl/sandbox/generated/lib.browser.js

@@ -0,0 +1,8 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { createNode } from "../core.js";
+function screenshot(inputs, options) {
+  return createNode("lib.browser.Screenshot", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "image" }, defaultOutput: "output" });
+}
+export {
+  screenshot
+};

package/dist/_sandbox/sandbox-dsl/sandbox/generated/lib.charts.js

@@ -0,0 +1,8 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { createNode } from "../core.js";
+function chartRenderer(inputs, options) {
+  return createNode("lib.charts.ChartRenderer", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "image" }, defaultOutput: "output" });
+}
+export {
+  chartRenderer
+};