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

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

@@ -0,0 +1,136 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { createNode } from "../core.js";
+function textToVideo(inputs, options) {
+  return createNode("nodetool.video.TextToVideo", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function imageToVideo(inputs, options) {
+  return createNode("nodetool.video.ImageToVideo", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function referenceToVideo(inputs, options) {
+  return createNode("nodetool.video.ReferenceToVideo", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function loadVideoFile(inputs, options) {
+  return createNode("nodetool.video.LoadVideoFile", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function saveVideoFile(inputs, options) {
+  return createNode("nodetool.video.SaveVideoFile", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function loadVideoAssets(inputs, options) {
+  return createNode("nodetool.video.LoadVideoAssets", inputs, { id: options?.id, outputNames: ["video", "name", "videos", "names"], outputTypes: { "video": "video", "name": "str", "videos": "list", "names": "list" }, streaming: true, inputMode: "buffered", outputCorrelation: { "video": { "kind": "iteration", "source": "__execution__", "group": "items" }, "name": { "kind": "iteration", "source": "__execution__", "group": "items" }, "videos": { "kind": "single", "source": "__execution__" }, "names": { "kind": "single", "source": "__execution__" } } });
+}
+function saveVideo(inputs, options) {
+  return createNode("nodetool.video.SaveVideo", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function forEachFrame(inputs, options) {
+  return createNode("nodetool.video.ForEachFrame", inputs, { id: options?.id, outputNames: ["frame", "index", "fps"], outputTypes: { "frame": "image", "index": "int", "fps": "float" }, streaming: true, inputMode: "buffered", outputCorrelation: { "frame": { "kind": "iteration", "source": "video", "group": "items" }, "index": { "kind": "iteration", "source": "video", "group": "items" }, "fps": { "kind": "single", "source": "video" } } });
+}
+function fps(inputs, options) {
+  return createNode("nodetool.video.Fps", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "float" }, defaultOutput: "output" });
+}
+function frameToVideo(inputs, options) {
+  return createNode("nodetool.video.FrameToVideo", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output", streamingInput: true, inputMode: "stream", outputCorrelation: { "output": { "kind": "aggregate", "source": "frame", "collapse": "innermost" } } });
+}
+function concat(inputs, options) {
+  return createNode("nodetool.video.Concat", inputs ?? {}, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function trim(inputs, options) {
+  return createNode("nodetool.video.Trim", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function resize(inputs, options) {
+  return createNode("nodetool.video.Resize", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function rotate(inputs, options) {
+  return createNode("nodetool.video.Rotate", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function setSpeed(inputs, options) {
+  return createNode("nodetool.video.SetSpeed", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function easeCurve(inputs, options) {
+  return createNode("nodetool.video.EaseCurve", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function overlay(inputs, options) {
+  return createNode("nodetool.video.Overlay", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function colorBalance(inputs, options) {
+  return createNode("nodetool.video.ColorBalance", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function denoise(inputs, options) {
+  return createNode("nodetool.video.Denoise", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function stabilize(inputs, options) {
+  return createNode("nodetool.video.Stabilize", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function sharpness(inputs, options) {
+  return createNode("nodetool.video.Sharpness", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function blur(inputs, options) {
+  return createNode("nodetool.video.Blur", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function saturation(inputs, options) {
+  return createNode("nodetool.video.Saturation", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function addSubtitles(inputs, options) {
+  return createNode("nodetool.video.AddSubtitles", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function reverse(inputs, options) {
+  return createNode("nodetool.video.Reverse", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function transition(inputs, options) {
+  return createNode("nodetool.video.Transition", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function addAudio(inputs, options) {
+  return createNode("nodetool.video.AddAudio", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function chromaKey(inputs, options) {
+  return createNode("nodetool.video.ChromaKey", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function extractAudio(inputs, options) {
+  return createNode("nodetool.video.ExtractAudio", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "audio" }, defaultOutput: "output" });
+}
+function extractFrame(inputs, options) {
+  return createNode("nodetool.video.ExtractFrame", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "image" }, defaultOutput: "output" });
+}
+function getVideoInfo(inputs, options) {
+  return createNode("nodetool.video.GetVideoInfo", inputs, { id: options?.id, outputNames: ["duration", "width", "height", "fps", "frame_count", "codec", "has_audio"], outputTypes: { "duration": "float", "width": "int", "height": "int", "fps": "float", "frame_count": "int", "codec": "str", "has_audio": "bool" } });
+}
+function videoToVideo(inputs, options) {
+  return createNode("nodetool.video.VideoToVideo", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+function lipSync(inputs, options) {
+  return createNode("nodetool.video.LipSync", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "video" }, defaultOutput: "output" });
+}
+export {
+  addAudio,
+  addSubtitles,
+  blur,
+  chromaKey,
+  colorBalance,
+  concat,
+  denoise,
+  easeCurve,
+  extractAudio,
+  extractFrame,
+  forEachFrame,
+  fps,
+  frameToVideo,
+  getVideoInfo,
+  imageToVideo,
+  lipSync,
+  loadVideoAssets,
+  loadVideoFile,
+  overlay,
+  referenceToVideo,
+  resize,
+  reverse,
+  rotate,
+  saturation,
+  saveVideo,
+  saveVideoFile,
+  setSpeed,
+  sharpness,
+  stabilize,
+  textToVideo,
+  transition,
+  trim,
+  videoToVideo
+};

package/dist/_sandbox/sandbox-dsl/sandbox/generated/nodetool.workflows.app_node.js

@@ -0,0 +1,8 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { createNode } from "../core.js";
+function app(inputs, options) {
+  return createNode("nodetool.workflows.app_node.App", inputs, { id: options?.id, outputNames: [], outputTypes: {}, streaming: true, inputMode: "buffered" });
+}
+export {
+  app
+};

package/dist/_sandbox/sandbox-dsl/sandbox/generated/nodetool.workflows.base_node.js

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

package/dist/_sandbox/sandbox-dsl/sandbox/generated/nodetool.workflows.subgraph.js

@@ -0,0 +1,8 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { createNode } from "../core.js";
+function subgraph(inputs, options) {
+  return createNode("nodetool.workflows.subgraph.Subgraph", inputs, { id: options?.id, outputNames: [], outputTypes: {}, streaming: true, inputMode: "buffered", outputCorrelation: { "output": { "kind": "single", "source": "__execution__" } } });
+}
+export {
+  subgraph
+};

package/dist/_sandbox/sandbox-dsl/sandbox/generated/nodetool.workflows.workflow_node.js

@@ -0,0 +1,8 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { createNode } from "../core.js";
+function workflow(inputs, options) {
+  return createNode("nodetool.workflows.workflow_node.Workflow", inputs, { id: options?.id, outputNames: [], outputTypes: {}, streaming: true, inputMode: "buffered", outputCorrelation: { "output": { "kind": "single", "source": "__execution__" } } });
+}
+export {
+  workflow
+};

package/dist/_sandbox/sandbox-dsl/sandbox/generated/openai.agents.js

@@ -0,0 +1,16 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { createNode } from "../core.js";
+function realtimeAgent(inputs, options) {
+  return createNode("openai.agents.RealtimeAgent", inputs, { id: options?.id, outputNames: ["chunk", "audio", "text"], outputTypes: { "chunk": "chunk", "audio": "audio", "text": "str" }, streamingInput: true });
+}
+function realtimeTranscription(inputs, options) {
+  return createNode("openai.agents.RealtimeTranscription", inputs, { id: options?.id, outputNames: ["text", "chunk"], outputTypes: { "text": "str", "chunk": "chunk" }, streamingInput: true });
+}
+function liveAgent(inputs, options) {
+  return createNode("openai.agents.LiveAgent", inputs, { id: options?.id, outputNames: ["chunk", "audio", "text", "input_transcript"], outputTypes: { "chunk": "chunk", "audio": "audio", "text": "str", "input_transcript": "str" }, streamingInput: true });
+}
+export {
+  liveAgent,
+  realtimeAgent,
+  realtimeTranscription
+};

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

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

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

@@ -0,0 +1,16 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { createNode } from "../core.js";
+function createImage(inputs, options) {
+  return createNode("openai.image.CreateImage", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "image" }, defaultOutput: "output" });
+}
+function editImage(inputs, options) {
+  return createNode("openai.image.EditImage", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "image" }, defaultOutput: "output" });
+}
+function imageVariation(inputs, options) {
+  return createNode("openai.image.ImageVariation", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "image" }, defaultOutput: "output" });
+}
+export {
+  createImage,
+  editImage,
+  imageVariation
+};

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

@@ -0,0 +1,16 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { createNode } from "../core.js";
+function embedding(inputs, options) {
+  return createNode("openai.text.Embedding", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "list" }, defaultOutput: "output" });
+}
+function webSearch(inputs, options) {
+  return createNode("openai.text.WebSearch", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "str" }, defaultOutput: "output" });
+}
+function moderation(inputs, options) {
+  return createNode("openai.text.Moderation", inputs, { id: options?.id, outputNames: ["flagged", "categories", "category_scores"], outputTypes: { "flagged": "bool", "categories": "dict[str, bool]", "category_scores": "dict[str, float]" } });
+}
+export {
+  embedding,
+  moderation,
+  webSearch
+};

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

@@ -0,0 +1,56 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { createNode } from "../core.js";
+function collection(inputs, options) {
+  return createNode("vector.Collection", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "collection" }, defaultOutput: "output" });
+}
+function count(inputs, options) {
+  return createNode("vector.Count", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "int" }, defaultOutput: "output" });
+}
+function getDocuments(inputs, options) {
+  return createNode("vector.GetDocuments", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "list[str]" }, defaultOutput: "output" });
+}
+function peek(inputs, options) {
+  return createNode("vector.Peek", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "list[str]" }, defaultOutput: "output" });
+}
+function indexImage(inputs, options) {
+  return createNode("vector.IndexImage", inputs, { id: options?.id, outputNames: [], outputTypes: {} });
+}
+function indexEmbedding(inputs, options) {
+  return createNode("vector.IndexEmbedding", inputs, { id: options?.id, outputNames: [], outputTypes: {} });
+}
+function indexTextChunk(inputs, options) {
+  return createNode("vector.IndexTextChunk", inputs, { id: options?.id, outputNames: [], outputTypes: {} });
+}
+function indexAggregatedText(inputs, options) {
+  return createNode("vector.IndexAggregatedText", inputs, { id: options?.id, outputNames: [], outputTypes: {} });
+}
+function indexString(inputs, options) {
+  return createNode("vector.IndexString", inputs, { id: options?.id, outputNames: [], outputTypes: {} });
+}
+function queryImage(inputs, options) {
+  return createNode("vector.QueryImage", inputs, { id: options?.id, outputNames: ["ids", "documents", "metadatas", "distances"], outputTypes: { "ids": "list[str]", "documents": "list[str]", "metadatas": "list[dict]", "distances": "list[float]" } });
+}
+function queryText(inputs, options) {
+  return createNode("vector.QueryText", inputs, { id: options?.id, outputNames: ["ids", "documents", "metadatas", "distances"], outputTypes: { "ids": "list[str]", "documents": "list[str]", "metadatas": "list[dict]", "distances": "list[float]" } });
+}
+function removeOverlap(inputs, options) {
+  return createNode("vector.RemoveOverlap", inputs, { id: options?.id, outputNames: ["documents"], outputTypes: { "documents": "list[str]" }, defaultOutput: "documents" });
+}
+function hybridSearch(inputs, options) {
+  return createNode("vector.HybridSearch", inputs, { id: options?.id, outputNames: ["ids", "documents", "metadatas", "distances", "scores"], outputTypes: { "ids": "list[str]", "documents": "list[str]", "metadatas": "list[dict]", "distances": "list[float]", "scores": "list[float]" } });
+}
+export {
+  collection,
+  count,
+  getDocuments,
+  hybridSearch,
+  indexAggregatedText,
+  indexEmbedding,
+  indexImage,
+  indexString,
+  indexTextChunk,
+  peek,
+  queryImage,
+  queryText,
+  removeOverlap
+};

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

@@ -0,0 +1,8 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { createNode } from "../core.js";
+function liveTranscription(inputs, options) {
+  return createNode("whisper_cpp.LiveTranscription", inputs, { id: options?.id, outputNames: ["chunk", "text"], outputTypes: { "chunk": "chunk", "text": "str" }, streaming: true, streamingInput: true, outputCorrelation: { "chunk": { "kind": "iteration", "source": "__execution__", "group": "stream" }, "text": { "kind": "single", "source": "__execution__" } } });
+}
+export {
+  liveTranscription
+};

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

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

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

@@ -0,0 +1,12 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { createNode } from "../core.js";
+function chatComplete(inputs, options) {
+  return createNode("xai.text.ChatComplete", inputs, { id: options?.id, outputNames: ["output"], outputTypes: { "output": "str" }, defaultOutput: "output" });
+}
+function webSearch(inputs, options) {
+  return createNode("xai.text.WebSearch", inputs, { id: options?.id, outputNames: ["output", "citations"], outputTypes: { "output": "str", "citations": "list[str]" } });
+}
+export {
+  chatComplete,
+  webSearch
+};

package/dist/_sandbox/sandbox-dsl/sandbox/generated/xai.vision.js

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

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

@@ -0,0 +1,13 @@
+/**
+ * The pack's root module: the graph builder, plus every namespace under one
+ * name.
+ *
+ * `workflow()` lives only here. A program that imports a namespace subpath for
+ * its node wrappers still declares the root, because the root is what turns the
+ * nodes it built into a graph.
+ */
+
+export { createNode, isOutputHandle, resolveConnection } from "./core.js";
+export * from "./generated/index.js";
+
+export { workflow, t, choose, map, template } from "./authoring.js";

package/dist/_sandbox/sandbox-dsl/scripts/build.mjs

@@ -0,0 +1,116 @@
+/**
+ * Build the pack's guest modules from `packages/dsl/src/generated`.
+ *
+ * The DSL's namespace files are TypeScript whose only runtime import is
+ * `../core.js`; every type in a signature is erased. So the build is a
+ * per-file transform, not a bundle: one guest module per namespace, all of
+ * them sharing the one `core.js` this pack ships by hand. Bundling instead
+ * would inline that core into all 71 entries.
+ *
+ * The manifest's `sandboxModules` list is written from the same pass, so the
+ * pack cannot declare a module it did not build.
+ *
+ *   node packages/sandbox-packs/sandbox-dsl/scripts/build.mjs
+ *   node packages/sandbox-packs/sandbox-dsl/scripts/build.mjs --check
+ *
+ * `--check` writes nothing and exits non-zero when the built output differs
+ * from what is committed. The pack carries its own copy of the DSL, so it can
+ * rot against `packages/dsl` exactly the way that directory rotted against the
+ * node registry — and this copy is what agents author against.
+ */
+
+import { createRequire } from "node:module";
+import { readdirSync, readFileSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const require = createRequire(import.meta.url);
+/** @type {import("esbuild")} */
+const esbuild = require("esbuild");
+
+const here = dirname(fileURLToPath(import.meta.url));
+const packDir = join(here, "..");
+const generatedSource = join(packDir, "..", "..", "dsl", "src", "generated");
+const generatedOut = join(packDir, "sandbox", "generated");
+
+const banner = "// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit\n";
+
+const check = process.argv.includes("--check");
+
+/** Built files, path → contents. Written at the end, or compared under --check. */
+const outputs = new Map();
+/** Paths that differ from what is on disk. */
+const stale = [];
+
+function emit(path, contents) {
+  outputs.set(path, contents);
+  if (!check) return;
+  let current = null;
+  try {
+    current = readFileSync(path, "utf8");
+  } catch {
+    // Missing counts as stale, reported by the null comparison below.
+  }
+  if (current !== contents) stale.push(path);
+}
+
+if (!check) {
+  rmSync(generatedOut, { recursive: true, force: true });
+  mkdirSync(generatedOut, { recursive: true });
+}
+
+const sources = readdirSync(generatedSource)
+  .filter((file) => file.endsWith(".ts"))
+  .sort();
+
+const modules = [];
+let bytes = 0;
+for (const file of sources) {
+  const stem = file.replace(/\.ts$/, "");
+  const built = await esbuild.transform(readFileSync(join(generatedSource, file), "utf8"), {
+    loader: "ts",
+    format: "esm",
+    target: "es2022",
+    sourcefile: file
+  });
+  const code = `${banner}${built.code}`;
+  emit(join(generatedOut, `${stem}.js`), code);
+  bytes += Buffer.byteLength(code, "utf8");
+  if (stem === "index") continue;
+  modules.push({ name: stem, kind: "js", file: `sandbox/generated/${stem}.js` });
+}
+
+modules.sort((left, right) => (left.name < right.name ? -1 : 1));
+// The root is hand-written: it exports `workflow` from the core alongside the
+// generated namespaces, which the generated barrel alone cannot do.
+modules.unshift({ name: ".", kind: "js", file: "sandbox/index.js" });
+
+const authoringSource = join(packDir, "..", "..", "dsl", "src", "authoring.ts");
+const authoring = await esbuild.transform(readFileSync(authoringSource, "utf8"), { loader: "ts", format: "esm", target: "es2022" });
+emit(join(packDir, "sandbox", "authoring.js"), banner + authoring.code);
+
+const manifestPath = join(packDir, "package.json");
+const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+manifest.nodetool.sandboxModules = modules;
+manifest.nodetool.internal = ["sandbox/core.js", "sandbox/authoring.js", "sandbox/generated/index.js"];
+emit(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+
+if (check) {
+  if (stale.length > 0) {
+    console.error(
+      `sandbox-dsl is stale — ${stale.length === 1 ? "1 file differs" : `${stale.length} files differ`} from @nodetool-ai/dsl:`
+    );
+    for (const path of stale.slice(0, 10)) console.error(`  ${path}`);
+    if (stale.length > 10) console.error(`  … and ${stale.length - 10} more`);
+    console.error("Run `npm run build:sandbox-dsl` and commit the result.");
+    process.exit(1);
+  }
+  console.log(`sandbox-dsl is up to date (${modules.length} modules).`);
+} else {
+  for (const [path, contents] of outputs) writeFileSync(path, contents);
+}
+
+const core = Buffer.byteLength(readFileSync(join(packDir, "sandbox", "core.js"), "utf8"), "utf8");
+console.log(
+  `${modules.length} modules, ${bytes} bytes of generated JavaScript, ${core} bytes of core`
+);

package/dist/_sandbox/sandbox-epub/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: sandbox-epub
+description: Read an EPUB's metadata, table of contents, and chapters in a Code node or CodeAct action, with epub2 running on the host
+---
+
+# EPUB e-books in the sandbox
+
+Specifier: `@nodetool-ai/sandbox-epub`. Import it at the top of the body.
+
+epub2 reads from a file path, not a buffer, so this pack is a **host module**:
+the host stages your bytes in a temp file for the call and removes it
+afterward. The import resolves to a generated facade over NodeTool's own
+implementation.
+
+## metadata — title, author, language, and the rest
+
+```js
+import { metadata } from "@nodetool-ai/sandbox-epub";
+
+const bytes = await workspace.readBytes("book.epub");
+const meta = await metadata(bytes);   // { title, creator, language, publisher, ... }
+```
+
+## tableOfContents — chapter titles in reading order
+
+```js
+import { tableOfContents } from "@nodetool-ai/sandbox-epub";
+
+const toc = await tableOfContents(bytes);
+// [{ id, title, href, order }, ...]
+```
+
+## extractText — every chapter, concatenated
+
+```js
+import { extractText } from "@nodetool-ai/sandbox-epub";
+
+const text = await extractText(bytes);
+const withCustomBreaks = await extractText(bytes, { chapterSeparator: "\n\n---\n\n" });
+```
+
+`chapterSeparator` defaults to `"\n\n"`.
+
+## extractChapters — each chapter as its own item
+
+```js
+import { extractChapters } from "@nodetool-ai/sandbox-epub";
+
+const chapters = await extractChapters(bytes);
+// [{ id, title, href, text }, ...]
+```
+
+Get the bytes from `workspace.readBytes`, or from a fetched body with
+`await response.bytes()`.
+
+## Gotchas
+
+- **Every export is async.**
+- **10 MB per book.** Larger input is refused by name.
+- **HTML is stripped, not rendered.** `extractText`/`extractChapters` return
+  plain text — no headings, links, or images survive the conversion.

package/dist/_sandbox/sandbox-epub/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@nodetool-ai/sandbox-epub",
+  "version": "0.8.4",
+  "description": "Read EPUB e-books inside the NodeTool sandbox, from epub2 running on the host",
+  "license": "MIT",
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "host",
+        "host": "epub"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-epub"
+  },
+  "homepage": "https://nodetool.ai",
+  "bugs": {
+    "url": "https://github.com/nodetool-ai/nodetool/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "SKILL.md"
+  ],
+  "keywords": [
+    "nodetool",
+    "nodetool-sandbox-pack",
+    "sandbox",
+    "epub",
+    "ebook",
+    "book"
+  ]
+}

package/dist/_sandbox/sandbox-exif/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: sandbox-exif
+description: Read EXIF from image bytes in a Code node or CodeAct action, with exifr running on the host
+---
+
+# Photo metadata in the sandbox
+
+Specifier: `@nodetool-ai/sandbox-exif`. Import it at the top of the body.
+
+exifr does not compile into QuickJS, so this pack is a **host module**.
+
+## parse — bytes to tags
+
+```js
+import { parse } from "@nodetool-ai/sandbox-exif";
+
+const tags = await parse(inputs.bytes);
+return {
+  make: tags?.Make ?? null,
+  model: tags?.Model ?? null,
+  takenAt: tags?.DateTimeOriginal ?? null
+};
+```
+
+`inputs.bytes` is a `Uint8Array` from `workspace.readBytes` or `image.bytes`.
+
+## Gotchas
+
+- **Named export `parse`.** Not the library's default export.
+- **Missing tags return `null`.** A stripped JPEG has no EXIF.

package/dist/_sandbox/sandbox-exif/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@nodetool-ai/sandbox-exif",
+  "version": "0.8.4",
+  "description": "Read EXIF and other photo metadata inside the NodeTool sandbox, from exifr",
+  "license": "MIT",
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "host",
+        "host": "exif"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-exif"
+  },
+  "homepage": "https://nodetool.ai",
+  "bugs": {
+    "url": "https://github.com/nodetool-ai/nodetool/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "SKILL.md"
+  ],
+  "keywords": [
+    "nodetool",
+    "nodetool-sandbox-pack",
+    "sandbox",
+    "exif",
+    "photo",
+    "metadata"
+  ]
+}