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

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

@@ -0,0 +1,46 @@
+---
+name: sandbox-tokens
+description: Count, encode, and decode LLM tokens in a Code node or CodeAct action, with js-tiktoken running on the host
+---
+
+# Token counting in the sandbox
+
+Specifier: `@nodetool-ai/sandbox-tokens`. Import it at the top of the body.
+
+One encoding's BPE ranks are several megabytes, well past the 1 MB cap on a
+compiled guest module, so this pack is a **host module**: the import resolves to
+a generated facade over NodeTool's own implementation. The ranks load once per
+process per encoding.
+
+This is what the removed `nodetool.text.CountTokens` node did.
+
+## count — how many tokens a text costs
+
+```js
+import { count } from "@nodetool-ai/sandbox-tokens";
+
+const tokens = await count(inputs.text, "cl100k_base");
+return { tokens, fitsContext: tokens < 8000 };
+```
+
+Encodings: `cl100k_base` (default — GPT-4, GPT-3.5), `o200k_base` (GPT-4o),
+`p50k_base`, `r50k_base`. Empty text is 0 without loading anything.
+
+## encode / decode — the token ids themselves
+
+```js
+import { encode, decode } from "@nodetool-ai/sandbox-tokens";
+
+const ids = await encode(inputs.text);
+// Truncate on a token boundary rather than a character one.
+return { head: await decode(ids.slice(0, 500)) };
+```
+
+## Gotchas
+
+- **All three are async.**
+- **5 MB per call**, the shared host-module text cap.
+- **tiktoken is OpenAI's tokenizer.** Anthropic, Gemini, and local models count
+  differently — treat the number as an estimate for anything else.
+- **Round-tripping is not free.** `decode(encode(t))` allocates the ranks and
+  two passes; use `count` when you only need the number.

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

@@ -0,0 +1,40 @@
+{
+  "name": "@nodetool-ai/sandbox-tokens",
+  "version": "0.8.4",
+  "description": "LLM token counting inside the NodeTool sandbox, from js-tiktoken running on the host",
+  "license": "MIT",
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "host",
+        "host": "tokens"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-tokens"
+  },
+  "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",
+    "tokens",
+    "tiktoken",
+    "count"
+  ]
+}

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

@@ -0,0 +1,93 @@
+---
+name: sandbox-twilio
+description: Send SMS and WhatsApp messages and look up numbers from a Code node or CodeAct action, with NodeTool's Twilio request builder running on the host
+---
+
+# Twilio in the sandbox
+
+Specifier: `@nodetool-ai/sandbox-twilio`. Import it at the top of the body.
+
+Twilio is HTTP Basic auth over form-encoded bodies, on a URL that buries the
+account SID in the path. None of that is hard; all of it is easy to get wrong
+once, and the failure is a 401 that names nothing.
+
+**Nothing here sends a request.** `request` builds one; the guest's own `fetch`
+sends it, under the run's fetch cap and SSRF guard.
+
+## request
+
+```js
+import { request } from "@nodetool-ai/sandbox-twilio";
+
+const accountSid = await nodetool.secrets.get("TWILIO_ACCOUNT_SID");
+const authToken = await nodetool.secrets.get("TWILIO_AUTH_TOKEN");
+
+const req = await request({
+  accountSid, authToken,
+  path: "Messages.json",
+  method: "POST",
+  params: { To: inputs.to, From: inputs.from, Body: inputs.text }
+});
+const res = await fetch(req.url, req);
+if (!res.ok) throw new Error(`Twilio: ${res.json.message ?? res.status}`);
+return { sid: res.json.sid, status: res.json.status };
+```
+
+Options: `accountSid` and `authToken` (required), `path` (required), `method`
+(default `GET`), `params`, `host` (default `api.twilio.com`), `query`.
+
+`params` become the form body on a write and the query string on a read.
+
+A `path` **without** a leading slash is an Account resource and lands under
+`/2010-04-01/Accounts/<sid>/`. One **with** a leading slash is used as written,
+which is how the other products are reached.
+
+## WhatsApp
+
+Same endpoint; the numbers carry a `whatsapp:` prefix.
+
+```js
+const req = await request({
+  accountSid, authToken, path: "Messages.json", method: "POST",
+  params: {
+    To: `whatsapp:${inputs.to}`,
+    From: `whatsapp:${inputs.from}`,
+    Body: inputs.text
+  }
+});
+```
+
+## Reading messages
+
+```js
+const req = await request({
+  accountSid, authToken, path: "Messages.json",
+  params: { To: inputs.to, PageSize: 50 }
+});
+const { messages } = (await fetch(req.url, req)).json;
+```
+
+## Number lookup
+
+Lookup lives on its own host, so pass an absolute path:
+
+```js
+const req = await request({
+  accountSid, authToken,
+  host: "lookups.twilio.com",
+  path: `/v2/PhoneNumbers/${encodeURIComponent(inputs.phone)}`,
+  params: { Fields: "line_type_intelligence" }
+});
+```
+
+## Gotchas
+
+- **`request` is async.** A host call is a round trip.
+- **Parameter names are PascalCase.** `To`, `From`, `Body`, `MediaUrl` —
+  Twilio ignores what it does not recognize, so a lowercase `body` sends an
+  empty message rather than an error.
+- **Numbers are E.164.** `+15551234567`, country code and all.
+- **Only `*.twilio.com` hosts are accepted**, so a mistyped `host` fails here
+  rather than mailing credentials somewhere else.
+- **An error is a non-2xx with JSON.** Read `res.json.message` and
+  `res.json.code`; the code maps to Twilio's error reference.

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

@@ -0,0 +1,39 @@
+{
+  "name": "@nodetool-ai/sandbox-twilio",
+  "version": "0.8.4",
+  "description": "Build authenticated Twilio API requests inside the NodeTool sandbox, from NodeTool's helper running on the host",
+  "license": "MIT",
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "host",
+        "host": "twilio"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-twilio"
+  },
+  "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",
+    "twilio",
+    "sms"
+  ]
+}

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

@@ -0,0 +1,74 @@
+---
+name: sandbox-xlsx
+description: Read and write Excel workbooks in a Code node or CodeAct action, with exceljs running on the host
+---
+
+# Excel workbooks in the sandbox
+
+Specifier: `@nodetool-ai/sandbox-xlsx`. Import it at the top of the body.
+
+exceljs is built on Node streams and ships its own zip layer; it will never be a
+guest module. This pack is a **host module**: the import resolves to a generated
+facade over NodeTool's own implementation.
+
+## parse — workbook bytes to records
+
+```js
+import { parse } from "@nodetool-ai/sandbox-xlsx";
+
+const bytes = await workspace.readBytes("report.xlsx");
+const sheets = await parse(bytes);            // { "Sheet1": [...], "Costs": [...] }
+const rows = await parse(bytes, { sheet: "Costs" });   // one sheet's rows
+return { sheetNames: Object.keys(sheets), rows };
+```
+
+Options: `sheet` (name — returns that sheet's rows directly) and `header`
+(default `true`; `false` gives raw cell arrays). Formula cells yield their
+computed result, dates come back as ISO strings, and rich text is flattened.
+
+Get the bytes from `workspace.readBytes`, or from a fetched body with
+`await response.bytes()`.
+
+## write — records to workbook bytes
+
+```js
+import { write } from "@nodetool-ai/sandbox-xlsx";
+
+const bytes = await write({ Costs: inputs.rows, Notes: [{ note: "draft" }] });
+await workspace.writeBytes("report.xlsx", bytes);
+```
+
+`{sheetName: rows}` is the short form. The long form is an array, one entry per
+sheet, which is where per-sheet options live:
+
+```js
+const bytes = await write([
+  {
+    name: "Costs",
+    rows: inputs.rows,
+    columns: ["item", "usd"],                 // pin the column order
+    styles: [
+      { range: "A1:B1", bold: true, background: "FFE9A8" },
+      { range: "B2:B999", numberFormat: "$#,##0.00" }
+    ]
+  }
+]);
+```
+
+Rows are records by default, and the header is the union of their keys in
+first-seen order unless `columns` pins it. `header: false` takes arrays of
+cells instead and writes no header row. Column widths are fitted to the
+content; pass `{ autoFitColumns: false }` to leave them alone. A style's
+`range` is `A1` or `A1:C20`, and it takes `bold`, `italic`, `size`, `color`,
+`background` (hex, with or without `#`) and `numberFormat`.
+
+## Gotchas
+
+- **Both exports are async.**
+- **10 MB per workbook read.** Larger input is refused by name.
+- **A missing sheet name throws**, and the error lists the sheets that exist.
+- **`write` caps a workbook at 64 sheets and 250 000 cells.**
+- **Values that are not a number, string, boolean or date are stored as JSON
+  text.** A cell cannot hold bytes.
+- **Nothing is saved for you.** `write` returns bytes; `workspace.writeBytes`
+  (or `sandboxToAsset`) is what puts them somewhere.

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

@@ -0,0 +1,40 @@
+{
+  "name": "@nodetool-ai/sandbox-xlsx",
+  "version": "0.8.4",
+  "description": "Read Excel workbooks inside the NodeTool sandbox, from exceljs running on the host",
+  "license": "MIT",
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "host",
+        "host": "xlsx"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-xlsx"
+  },
+  "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",
+    "xlsx",
+    "excel",
+    "spreadsheet"
+  ]
+}

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

@@ -0,0 +1,36 @@
+---
+name: sandbox-xml
+description: Parse XML feeds and sitemaps in a Code node or CodeAct action, with fast-xml-parser running on the host
+---
+
+# XML in the sandbox
+
+Specifier: `@nodetool-ai/sandbox-xml`. Import it at the top of the body.
+
+fast-xml-parser reads a bare `window`, which the guest does not have, so it
+cannot be compiled in. This pack is a **host module**: the import resolves to a
+generated facade over NodeTool's own implementation.
+
+## parse — XML to a plain object
+
+```js
+import { parse } from "@nodetool-ai/sandbox-xml";
+
+const feed = await parse(inputs.xml);
+const items = feed?.rss?.channel?.item ?? [];
+return { titles: items.map((i) => i.title) };
+```
+
+Attributes ride along prefixed `@_` so they never collide with child-element
+keys; pass `{ attributes: false }` to drop them. Text values stay text — a
+numeric-looking id must not change shape between runs.
+
+Invalid XML throws with the parser's own reason rather than returning a partial
+tree.
+
+## Gotchas
+
+- **`parse` is async.**
+- **5 MB of text per call.**
+- **A single child is not an array.** `channel.item` is one object when the feed
+  has one item; normalize with `[].concat(x ?? [])`.

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

@@ -0,0 +1,40 @@
+{
+  "name": "@nodetool-ai/sandbox-xml",
+  "version": "0.8.4",
+  "description": "Parse XML feeds and sitemaps inside the NodeTool sandbox, from fast-xml-parser running on the host",
+  "license": "MIT",
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "host",
+        "host": "xml"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-xml"
+  },
+  "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",
+    "xml",
+    "rss",
+    "sitemap"
+  ]
+}

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

@@ -0,0 +1,48 @@
+---
+name: sandbox-yaml
+description: Read and write YAML inside a Code node or CodeAct action, with js-yaml running in the guest
+---
+
+# YAML in the sandbox
+
+Specifier: `@nodetool-ai/sandbox-yaml`. One module, the js-yaml root export.
+Import it at the top of the body.
+
+## load — YAML text to a value
+
+```js
+import yaml from "@nodetool-ai/sandbox-yaml";
+
+const config = yaml.load(inputs.text);
+return { name: config.name, replicas: config.replicas };
+```
+
+`load` reads one document and throws a `YAMLException` with a line and column
+on malformed input. Multi-document files go through `loadAll`, which returns an
+array.
+
+## dump — a value to YAML text
+
+```js
+import yaml from "@nodetool-ai/sandbox-yaml";
+
+return { text: yaml.dump({ name: inputs.name, tags: inputs.tags }, { indent: 2 }) };
+```
+
+`dump` throws on a cyclic structure unless you pass `{ noRefs: false }`, and on
+a value it cannot represent (a function, a symbol).
+
+## Gotchas
+
+- **Everything runs in the guest.** The 64 MB guest heap holds your input text,
+  the parse tree, and the returned value at once. A file of a few megabytes is
+  fine; a hundred megabytes is not.
+- **No timers, no I/O.** The guest has no `setTimeout`, no filesystem, and no
+  Node builtins. js-yaml needs none of them — that is why it is admitted — but
+  code you write around it must not reach for them either.
+- **The safe schema is not the default.** `yaml.load` uses `DEFAULT_SCHEMA`,
+  which resolves tags such as `!!timestamp`. For input from a stranger, pass
+  `{ schema: yaml.FAILSAFE_SCHEMA }` and get strings, arrays, and objects only.
+- **This pack is the only route to YAML.** There is no `data.parseYaml` global
+  any more; every library the sandbox offers is an importable module, and this
+  is the one for YAML. A node that needs it declares it.

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

@@ -0,0 +1,41 @@
+{
+  "name": "@nodetool-ai/sandbox-yaml",
+  "version": "0.8.4",
+  "description": "YAML parsing and dumping inside the NodeTool sandbox, from js-yaml",
+  "license": "MIT",
+  "dependencies": {
+    "js-yaml": "^4.3.0"
+  },
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "js",
+        "npm": "js-yaml"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-yaml"
+  },
+  "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",
+    "yaml"
+  ]
+}

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

@@ -0,0 +1,54 @@
+---
+name: sandbox-zip
+description: Read and write zip archives in a Code node or CodeAct action, with fflate running on the host under a 50 MB inflation cap
+---
+
+# Zip archives in the sandbox
+
+Specifier: `@nodetool-ai/sandbox-zip`. Import it at the top of the body.
+
+## Why this one runs on the host
+
+fflate is pure JavaScript and the sandbox compiler admits it, so this pack
+*could* have shipped as a guest module — and an earlier version did. It does
+not, because of the cap: a zip bomb is a policy question, and a policy enforced
+inside the guest is enforced by code the guest can simply not call. The guest's
+64 MB heap does not replicate it either — fflate inflates into host memory
+first. So the library stays on the host, with `unzip` refusing anything that
+inflates past **50 MB**, and there is no second route around that number.
+
+## unzip — extract an archive
+
+```js
+import { unzip } from "@nodetool-ai/sandbox-zip";
+
+const files = await unzip(inputs.archive);          // { "a/b.txt": Uint8Array }
+const readme = new TextDecoder().decode(files["README.md"]);
+return { names: Object.keys(files), readme };
+```
+
+Entry values arrive as real `Uint8Array`s. Decode text with `TextDecoder`.
+
+## zip — build one
+
+```js
+import { zip } from "@nodetool-ai/sandbox-zip";
+
+const archive = await zip({
+  "report.md": inputs.markdown,                     // strings are UTF-8 encoded
+  "data.json": JSON.stringify(inputs.rows)
+});
+await workspace.writeBytes("out.zip", archive);
+return { bytes: archive.length };
+```
+
+Entry values are `Uint8Array` or `string`.
+
+## Gotchas
+
+- **Both exports are async.**
+- **10 MB in, 50 MB out.** The archive itself is capped at 10 MB; the sum of the
+  entries `unzip` produces — and the sum of what `zip` is handed — is capped at
+  50 MB, checked as the entries are walked so a bomb stops part way.
+- **No streaming.** The whole archive is materialized. For a payload near the
+  cap, write entries to the workspace as you go instead.

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

@@ -0,0 +1,40 @@
+{
+  "name": "@nodetool-ai/sandbox-zip",
+  "version": "0.8.4",
+  "description": "Read and write zip archives inside the NodeTool sandbox, from fflate running on the host with a 50 MB inflation cap",
+  "license": "MIT",
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "host",
+        "host": "zip"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-zip"
+  },
+  "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",
+    "zip",
+    "archive",
+    "compression"
+  ]
+}

package/dist/code-node-validation.d.ts

@@ -46,6 +46,8 @@ export interface CodeNodeValidationInput {
     connectedInputs?: readonly string[];
     /** Output handles the node declares (`dynamic_outputs` keys). */
     declaredOutputs: readonly string[];
+    /** Scripts always send outputs through emit/output, including non-streaming bodies. */
+    outputContract?: "emit";
     /** Output handles other nodes are wired to. A superset check on `keys`. */
     connectedOutputs?: readonly string[];
     /**

package/dist/code-node-validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"code-node-validation.d.ts","sourceRoot":"","sources":["../src/code-node-validation.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAwBjE,qEAAqE;AACrE,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC,MAAM,CAEjD,CAAC;AAEH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,MAAM,CAuC9C,CAAC;AAkBH,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B;;;;;;;;;OASG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,uBAAuB;IACtC,kCAAkC;IAClC,IAAI,EAAE,OAAO,CAAC;IACd;;;OAGG;IACH,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC;;;;;OAKG;IACH,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,iEAAiE;IACjE,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,2EAA2E;IAC3E,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAAC;CACpD;AAiCD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,uBAAuB,GAC7B,aAAa,EAAE,CAsXjB"}
+{"version":3,"file":"code-node-validation.d.ts","sourceRoot":"","sources":["../src/code-node-validation.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAwBjE,qEAAqE;AACrE,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC,MAAM,CAEjD,CAAC;AAEH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,MAAM,CAuC9C,CAAC;AAkBH,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B;;;;;;;;;OASG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,uBAAuB;IACtC,kCAAkC;IAClC,IAAI,EAAE,OAAO,CAAC;IACd;;;OAGG;IACH,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC;;;;;OAKG;IACH,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,iEAAiE;IACjE,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,uFAAuF;IACvF,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,2EAA2E;IAC3E,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAAC;CACpD;AAiCD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,uBAAuB,GAC7B,aAAa,EAAE,CAsXjB"}

package/dist/code-node-validation.js

@@ -359,7 +359,7 @@ export function validateCodeNodeBody(input) {
     // A body that calls `emit`/`output` names its handles, so the return-path
     // analysis below does not apply to it at all — its returns are control flow
     // and carry nothing.
-    if (usesEmitOutputContract(code)) {
+    if (input.outputContract === "emit" || usesEmitOutputContract(code)) {
         issues.push(...emitContractIssues(parsed.statements, declared, connected));
         return withUnusedInputs(issues, declaredInputsUnused);
     }