@n8n/expression-runtime 0.15.0 → 0.17.0

package/dist/cjs/bridge/bridge-messages.d.ts

@@ -77,6 +77,287 @@ export declare const getNodeAllMessage: z.ZodObject<{
     branchIndex?: number | undefined;
     runIndex?: number | undefined;
 }>;
+/**
+ * `$input.first()` — fetch the first item of the current node's input.
+ * Host enforces zero arguments; the schema has no fields besides `type`.
+ */
+export declare const getInputFirstMessage: z.ZodObject<{
+    type: z.ZodLiteral<"getInputFirst">;
+}, "strict", z.ZodTypeAny, {
+    type: "getInputFirst";
+}, {
+    type: "getInputFirst";
+}>;
+/**
+ * `$input.last()` — fetch the last item of the current node's input.
+ */
+export declare const getInputLastMessage: z.ZodObject<{
+    type: z.ZodLiteral<"getInputLast">;
+}, "strict", z.ZodTypeAny, {
+    type: "getInputLast";
+}, {
+    type: "getInputLast";
+}>;
+/**
+ * `$input.all()` — fetch every item of the current node's input.
+ */
+export declare const getInputAllMessage: z.ZodObject<{
+    type: z.ZodLiteral<"getInputAll">;
+}, "strict", z.ZodTypeAny, {
+    type: "getInputAll";
+}, {
+    type: "getInputAll";
+}>;
+/**
+ * `$items(nodeName?, outputIndex?, runIndex?)` — fetch the execution data of
+ * a node by name (or the current node's input if `nodeName` is omitted).
+ *
+ * `runIndex` accepts negative values: the host uses `-1` as a sentinel for
+ * "latest run" (see `WorkflowDataProxy.$items` —
+ * `runIndex === undefined ? -1 : runIndex`). The schema uses
+ * `z.number().int()` without `.nonnegative()` so expressions can pass `-1`
+ * explicitly if they need to.
+ */
+export declare const getItemsMessage: z.ZodObject<{
+    type: z.ZodLiteral<"getItems">;
+    nodeName: z.ZodOptional<z.ZodString>;
+    outputIndex: z.ZodOptional<z.ZodNumber>;
+    runIndex: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    type: "getItems";
+    nodeName?: string | undefined;
+    runIndex?: number | undefined;
+    outputIndex?: number | undefined;
+}, {
+    type: "getItems";
+    nodeName?: string | undefined;
+    runIndex?: number | undefined;
+    outputIndex?: number | undefined;
+}>;
+/**
+ * `$fromAI(name, description?, type?, defaultValue?)` — the AI-builder
+ * placeholder accessor (aliases: `$fromAi`, `$fromai`).
+ *
+ * Two deliberate looseness points in this schema, both to preserve host
+ * contract / parity:
+ *
+ * 1. `name` is `z.string().optional()` (not required) so a call missing
+ *    the argument or passing an empty string reaches the host, which
+ *    throws the user-friendly `ExpressionError("Add a key, e.g. $fromAI('placeholder_name')")`.
+ *    Requiring it here would replace that error with a generic zod
+ *    message. The host also validates the regex `[a-zA-Z0-9_-]{0,64}`;
+ *    we don't pre-empt that either.
+ * 2. `defaultValue` is `z.unknown()` because the host accepts any value
+ *    as the fallback return (`handleFromAi` returns it directly via
+ *    `??`). Structured-clone at the bridge boundary still prevents
+ *    functions and other non-cloneable values from crossing.
+ *
+ * `description` and `type` are forwarded even though the host currently
+ * ignores them (`_description`, `_type`), so the protocol matches the
+ * documented call signature.
+ */
+export declare const fromAiMessage: z.ZodObject<{
+    type: z.ZodLiteral<"fromAi">;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    valueType: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodUnknown;
+}, "strict", z.ZodTypeAny, {
+    type: "fromAi";
+    name?: string | undefined;
+    description?: string | undefined;
+    valueType?: string | undefined;
+    defaultValue?: unknown;
+}, {
+    type: "fromAi";
+    name?: string | undefined;
+    description?: string | undefined;
+    valueType?: string | undefined;
+    defaultValue?: unknown;
+}>;
+/**
+ * `$('NodeName').pairedItem(itemIndex?)` / `.itemMatching(itemIndex)` /
+ * `.item` — resolve the paired item for a referenced node.
+ *
+ * All three host-side surface forms share one internal resolver
+ * (`pairedItemMethod` in `WorkflowDataProxy`), but the resolver closes
+ * over the literal property name the bridge accessed on the host proxy
+ * — so the error message and getter-vs-method form depend on *which*
+ * property the bridge reads. Three separate discriminators, each
+ * mapping a handler to a fixed literal property name, are the only way
+ * to preserve the host's friendly errors (e.g. "Missing item index for
+ * .itemMatching()") and the `.item` getter semantics without
+ * duplicating logic in-isolate.
+ *
+ * `itemIndex` is optional on all three at the schema level; the host
+ * throws the appropriate `ExpressionError` when it's missing for
+ * `.itemMatching()`, and applies the current-itemIndex default for
+ * `.pairedItem` and `.item`.
+ */
+export declare const getNodePairedItemMessage: z.ZodObject<{
+    type: z.ZodLiteral<"getNodePairedItem">;
+    nodeName: z.ZodString;
+    itemIndex: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    type: "getNodePairedItem";
+    nodeName: string;
+    itemIndex?: number | undefined;
+}, {
+    type: "getNodePairedItem";
+    nodeName: string;
+    itemIndex?: number | undefined;
+}>;
+/**
+ * `itemIndex` is `.optional()` even though `.itemMatching()` requires it
+ * at the host. The host's `pairedItemMethod` closure throws the friendly
+ * `"Missing item index for .itemMatching()"` error when the field is
+ * absent — keeping the schema permissive lets that host error surface
+ * verbatim instead of being replaced by a generic zod parse failure.
+ */
+export declare const getNodeItemMatchingMessage: z.ZodObject<{
+    type: z.ZodLiteral<"getNodeItemMatching">;
+    nodeName: z.ZodString;
+    itemIndex: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    type: "getNodeItemMatching";
+    nodeName: string;
+    itemIndex?: number | undefined;
+}, {
+    type: "getNodeItemMatching";
+    nodeName: string;
+    itemIndex?: number | undefined;
+}>;
+export declare const getNodeItemMessage: z.ZodObject<{
+    type: z.ZodLiteral<"getNodeItem">;
+    nodeName: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    type: "getNodeItem";
+    nodeName: string;
+}, {
+    type: "getNodeItem";
+    nodeName: string;
+}>;
+/**
+ * `$evaluateExpression(expression, itemIndex?)` — evaluate a nested
+ * expression string at runtime against the same execution context.
+ *
+ * The host recursively invokes the expression engine on the `expression`
+ * string — under the VM engine this re-enters the bridge with a fresh
+ * evaluation. `itemIndex` is optional and defaults to the current item;
+ * the schema mirrors the existing "nonnegative int" constraint used by
+ * the node-data RPCs.
+ */
+export declare const evaluateExpressionMessage: z.ZodObject<{
+    type: z.ZodLiteral<"evaluateExpression">;
+    expression: z.ZodString;
+    itemIndex: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    type: "evaluateExpression";
+    expression: string;
+    itemIndex?: number | undefined;
+}, {
+    type: "evaluateExpression";
+    expression: string;
+    itemIndex?: number | undefined;
+}>;
+/**
+ * `$getPairedItem(destinationNodeName, incomingSourceData, initialPairedItem)` —
+ * traverse the paired-item ancestry chain back to the named upstream node
+ * and return the matching execution item.
+ *
+ * Two host-side fields are deliberately omitted from the schema:
+ * - `usedMethodName` defaults to `$getPairedItem` on the host; the isolate
+ *   has no reason to spoof a different method name in the error path.
+ * - `nodeBeforeLast` is an internal recursion argument; only the host
+ *   itself sets it during the recursive walk.
+ *
+ * `incomingSourceData` is nullable because the host's signature accepts
+ * `ISourceData | null` (and throws a paired-item-not-found error when null).
+ */
+export declare const getPairedItemMessage: z.ZodObject<{
+    type: z.ZodLiteral<"getPairedItem">;
+    destinationNodeName: z.ZodString;
+    incomingSourceData: z.ZodNullable<z.ZodObject<{
+        previousNode: z.ZodString;
+        previousNodeOutput: z.ZodOptional<z.ZodNumber>;
+        previousNodeRun: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        previousNode: string;
+        previousNodeOutput?: number | undefined;
+        previousNodeRun?: number | undefined;
+    }, {
+        previousNode: string;
+        previousNodeOutput?: number | undefined;
+        previousNodeRun?: number | undefined;
+    }>>;
+    initialPairedItem: z.ZodObject<{
+        item: z.ZodNumber;
+        input: z.ZodOptional<z.ZodNumber>;
+        sourceOverwrite: z.ZodOptional<z.ZodObject<{
+            previousNode: z.ZodString;
+            previousNodeOutput: z.ZodOptional<z.ZodNumber>;
+            previousNodeRun: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            previousNode: string;
+            previousNodeOutput?: number | undefined;
+            previousNodeRun?: number | undefined;
+        }, {
+            previousNode: string;
+            previousNodeOutput?: number | undefined;
+            previousNodeRun?: number | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        item: number;
+        input?: number | undefined;
+        sourceOverwrite?: {
+            previousNode: string;
+            previousNodeOutput?: number | undefined;
+            previousNodeRun?: number | undefined;
+        } | undefined;
+    }, {
+        item: number;
+        input?: number | undefined;
+        sourceOverwrite?: {
+            previousNode: string;
+            previousNodeOutput?: number | undefined;
+            previousNodeRun?: number | undefined;
+        } | undefined;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    type: "getPairedItem";
+    destinationNodeName: string;
+    incomingSourceData: {
+        previousNode: string;
+        previousNodeOutput?: number | undefined;
+        previousNodeRun?: number | undefined;
+    } | null;
+    initialPairedItem: {
+        item: number;
+        input?: number | undefined;
+        sourceOverwrite?: {
+            previousNode: string;
+            previousNodeOutput?: number | undefined;
+            previousNodeRun?: number | undefined;
+        } | undefined;
+    };
+}, {
+    type: "getPairedItem";
+    destinationNodeName: string;
+    incomingSourceData: {
+        previousNode: string;
+        previousNodeOutput?: number | undefined;
+        previousNodeRun?: number | undefined;
+    } | null;
+    initialPairedItem: {
+        item: number;
+        input?: number | undefined;
+        sourceOverwrite?: {
+            previousNode: string;
+            previousNodeOutput?: number | undefined;
+            previousNodeRun?: number | undefined;
+        } | undefined;
+    };
+}>;
 /**
  * The full set of messages the bridge will accept. Discriminator is `type`.
  *
@@ -129,6 +410,185 @@ export declare const bridgeMessageSchema: z.ZodDiscriminatedUnion<"type", [z.Zod
     nodeName: string;
     branchIndex?: number | undefined;
     runIndex?: number | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"getInputFirst">;
+}, "strict", z.ZodTypeAny, {
+    type: "getInputFirst";
+}, {
+    type: "getInputFirst";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"getInputLast">;
+}, "strict", z.ZodTypeAny, {
+    type: "getInputLast";
+}, {
+    type: "getInputLast";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"getInputAll">;
+}, "strict", z.ZodTypeAny, {
+    type: "getInputAll";
+}, {
+    type: "getInputAll";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"getItems">;
+    nodeName: z.ZodOptional<z.ZodString>;
+    outputIndex: z.ZodOptional<z.ZodNumber>;
+    runIndex: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    type: "getItems";
+    nodeName?: string | undefined;
+    runIndex?: number | undefined;
+    outputIndex?: number | undefined;
+}, {
+    type: "getItems";
+    nodeName?: string | undefined;
+    runIndex?: number | undefined;
+    outputIndex?: number | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"fromAi">;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    valueType: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodUnknown;
+}, "strict", z.ZodTypeAny, {
+    type: "fromAi";
+    name?: string | undefined;
+    description?: string | undefined;
+    valueType?: string | undefined;
+    defaultValue?: unknown;
+}, {
+    type: "fromAi";
+    name?: string | undefined;
+    description?: string | undefined;
+    valueType?: string | undefined;
+    defaultValue?: unknown;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"getNodePairedItem">;
+    nodeName: z.ZodString;
+    itemIndex: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    type: "getNodePairedItem";
+    nodeName: string;
+    itemIndex?: number | undefined;
+}, {
+    type: "getNodePairedItem";
+    nodeName: string;
+    itemIndex?: number | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"getNodeItemMatching">;
+    nodeName: z.ZodString;
+    itemIndex: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    type: "getNodeItemMatching";
+    nodeName: string;
+    itemIndex?: number | undefined;
+}, {
+    type: "getNodeItemMatching";
+    nodeName: string;
+    itemIndex?: number | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"getNodeItem">;
+    nodeName: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    type: "getNodeItem";
+    nodeName: string;
+}, {
+    type: "getNodeItem";
+    nodeName: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"evaluateExpression">;
+    expression: z.ZodString;
+    itemIndex: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    type: "evaluateExpression";
+    expression: string;
+    itemIndex?: number | undefined;
+}, {
+    type: "evaluateExpression";
+    expression: string;
+    itemIndex?: number | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"getPairedItem">;
+    destinationNodeName: z.ZodString;
+    incomingSourceData: z.ZodNullable<z.ZodObject<{
+        previousNode: z.ZodString;
+        previousNodeOutput: z.ZodOptional<z.ZodNumber>;
+        previousNodeRun: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        previousNode: string;
+        previousNodeOutput?: number | undefined;
+        previousNodeRun?: number | undefined;
+    }, {
+        previousNode: string;
+        previousNodeOutput?: number | undefined;
+        previousNodeRun?: number | undefined;
+    }>>;
+    initialPairedItem: z.ZodObject<{
+        item: z.ZodNumber;
+        input: z.ZodOptional<z.ZodNumber>;
+        sourceOverwrite: z.ZodOptional<z.ZodObject<{
+            previousNode: z.ZodString;
+            previousNodeOutput: z.ZodOptional<z.ZodNumber>;
+            previousNodeRun: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            previousNode: string;
+            previousNodeOutput?: number | undefined;
+            previousNodeRun?: number | undefined;
+        }, {
+            previousNode: string;
+            previousNodeOutput?: number | undefined;
+            previousNodeRun?: number | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        item: number;
+        input?: number | undefined;
+        sourceOverwrite?: {
+            previousNode: string;
+            previousNodeOutput?: number | undefined;
+            previousNodeRun?: number | undefined;
+        } | undefined;
+    }, {
+        item: number;
+        input?: number | undefined;
+        sourceOverwrite?: {
+            previousNode: string;
+            previousNodeOutput?: number | undefined;
+            previousNodeRun?: number | undefined;
+        } | undefined;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    type: "getPairedItem";
+    destinationNodeName: string;
+    incomingSourceData: {
+        previousNode: string;
+        previousNodeOutput?: number | undefined;
+        previousNodeRun?: number | undefined;
+    } | null;
+    initialPairedItem: {
+        item: number;
+        input?: number | undefined;
+        sourceOverwrite?: {
+            previousNode: string;
+            previousNodeOutput?: number | undefined;
+            previousNodeRun?: number | undefined;
+        } | undefined;
+    };
+}, {
+    type: "getPairedItem";
+    destinationNodeName: string;
+    incomingSourceData: {
+        previousNode: string;
+        previousNodeOutput?: number | undefined;
+        previousNodeRun?: number | undefined;
+    } | null;
+    initialPairedItem: {
+        item: number;
+        input?: number | undefined;
+        sourceOverwrite?: {
+            previousNode: string;
+            previousNodeOutput?: number | undefined;
+            previousNodeRun?: number | undefined;
+        } | undefined;
+    };
 }>]>;
 export type BridgeMessage = z.infer<typeof bridgeMessageSchema>;
 //# sourceMappingURL=bridge-messages.d.ts.map

package/dist/cjs/bridge/bridge-messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bridge-messages.d.ts","sourceRoot":"","sources":["../../../src/bridge/bridge-messages.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;EAOtB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;EAOrB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;EAOpB,CAAC;AAEX;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAI9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}
+{"version":3,"file":"bridge-messages.d.ts","sourceRoot":"","sources":["../../../src/bridge/bridge-messages.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;EAOtB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;EAOrB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;EAOpB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;EAA0D,CAAC;AAE5F;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;EAAyD,CAAC;AAE1F;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;EAAwD,CAAC;AAExF;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;EAOlB,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;EAShB,CAAC;AAEX;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;EAM3B,CAAC;AAEX;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;EAM7B,CAAC;AAEX,eAAO,MAAM,kBAAkB;;;;;;;;;EAKrB,CAAC;AAEX;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;EAM5B,CAAC;AA4BX;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOvB,CAAC;AAEX;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAc9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/cjs/bridge/bridge-messages.js

@@ -27,7 +27,7 @@
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.bridgeMessageSchema = exports.getNodeAllMessage = exports.getNodeLastMessage = exports.getNodeFirstMessage = void 0;
+    exports.bridgeMessageSchema = exports.getPairedItemMessage = exports.evaluateExpressionMessage = exports.getNodeItemMessage = exports.getNodeItemMatchingMessage = exports.getNodePairedItemMessage = exports.fromAiMessage = exports.getItemsMessage = exports.getInputAllMessage = exports.getInputLastMessage = exports.getInputFirstMessage = exports.getNodeAllMessage = exports.getNodeLastMessage = exports.getNodeFirstMessage = void 0;
     const zod_1 = require("zod");
     /**
      * `$('NodeName').first(branchIndex?, runIndex?)` — fetch the first item of
@@ -65,6 +65,178 @@
         runIndex: zod_1.z.number().int().nonnegative().optional(),
     })
         .strict();
+    /**
+     * `$input.first()` — fetch the first item of the current node's input.
+     * Host enforces zero arguments; the schema has no fields besides `type`.
+     */
+    exports.getInputFirstMessage = zod_1.z.object({ type: zod_1.z.literal('getInputFirst') }).strict();
+    /**
+     * `$input.last()` — fetch the last item of the current node's input.
+     */
+    exports.getInputLastMessage = zod_1.z.object({ type: zod_1.z.literal('getInputLast') }).strict();
+    /**
+     * `$input.all()` — fetch every item of the current node's input.
+     */
+    exports.getInputAllMessage = zod_1.z.object({ type: zod_1.z.literal('getInputAll') }).strict();
+    /**
+     * `$items(nodeName?, outputIndex?, runIndex?)` — fetch the execution data of
+     * a node by name (or the current node's input if `nodeName` is omitted).
+     *
+     * `runIndex` accepts negative values: the host uses `-1` as a sentinel for
+     * "latest run" (see `WorkflowDataProxy.$items` —
+     * `runIndex === undefined ? -1 : runIndex`). The schema uses
+     * `z.number().int()` without `.nonnegative()` so expressions can pass `-1`
+     * explicitly if they need to.
+     */
+    exports.getItemsMessage = zod_1.z
+        .object({
+        type: zod_1.z.literal('getItems'),
+        nodeName: zod_1.z.string().optional(),
+        outputIndex: zod_1.z.number().int().nonnegative().optional(),
+        runIndex: zod_1.z.number().int().optional(),
+    })
+        .strict();
+    /**
+     * `$fromAI(name, description?, type?, defaultValue?)` — the AI-builder
+     * placeholder accessor (aliases: `$fromAi`, `$fromai`).
+     *
+     * Two deliberate looseness points in this schema, both to preserve host
+     * contract / parity:
+     *
+     * 1. `name` is `z.string().optional()` (not required) so a call missing
+     *    the argument or passing an empty string reaches the host, which
+     *    throws the user-friendly `ExpressionError("Add a key, e.g. $fromAI('placeholder_name')")`.
+     *    Requiring it here would replace that error with a generic zod
+     *    message. The host also validates the regex `[a-zA-Z0-9_-]{0,64}`;
+     *    we don't pre-empt that either.
+     * 2. `defaultValue` is `z.unknown()` because the host accepts any value
+     *    as the fallback return (`handleFromAi` returns it directly via
+     *    `??`). Structured-clone at the bridge boundary still prevents
+     *    functions and other non-cloneable values from crossing.
+     *
+     * `description` and `type` are forwarded even though the host currently
+     * ignores them (`_description`, `_type`), so the protocol matches the
+     * documented call signature.
+     */
+    exports.fromAiMessage = zod_1.z
+        .object({
+        type: zod_1.z.literal('fromAi'),
+        name: zod_1.z.string().optional(),
+        description: zod_1.z.string().optional(),
+        valueType: zod_1.z.string().optional(),
+        // `z.unknown()` already accepts `undefined`, so no `.optional()` needed.
+        defaultValue: zod_1.z.unknown(),
+    })
+        .strict();
+    /**
+     * `$('NodeName').pairedItem(itemIndex?)` / `.itemMatching(itemIndex)` /
+     * `.item` — resolve the paired item for a referenced node.
+     *
+     * All three host-side surface forms share one internal resolver
+     * (`pairedItemMethod` in `WorkflowDataProxy`), but the resolver closes
+     * over the literal property name the bridge accessed on the host proxy
+     * — so the error message and getter-vs-method form depend on *which*
+     * property the bridge reads. Three separate discriminators, each
+     * mapping a handler to a fixed literal property name, are the only way
+     * to preserve the host's friendly errors (e.g. "Missing item index for
+     * .itemMatching()") and the `.item` getter semantics without
+     * duplicating logic in-isolate.
+     *
+     * `itemIndex` is optional on all three at the schema level; the host
+     * throws the appropriate `ExpressionError` when it's missing for
+     * `.itemMatching()`, and applies the current-itemIndex default for
+     * `.pairedItem` and `.item`.
+     */
+    exports.getNodePairedItemMessage = zod_1.z
+        .object({
+        type: zod_1.z.literal('getNodePairedItem'),
+        nodeName: zod_1.z.string(),
+        itemIndex: zod_1.z.number().int().nonnegative().optional(),
+    })
+        .strict();
+    /**
+     * `itemIndex` is `.optional()` even though `.itemMatching()` requires it
+     * at the host. The host's `pairedItemMethod` closure throws the friendly
+     * `"Missing item index for .itemMatching()"` error when the field is
+     * absent — keeping the schema permissive lets that host error surface
+     * verbatim instead of being replaced by a generic zod parse failure.
+     */
+    exports.getNodeItemMatchingMessage = zod_1.z
+        .object({
+        type: zod_1.z.literal('getNodeItemMatching'),
+        nodeName: zod_1.z.string(),
+        itemIndex: zod_1.z.number().int().nonnegative().optional(),
+    })
+        .strict();
+    exports.getNodeItemMessage = zod_1.z
+        .object({
+        type: zod_1.z.literal('getNodeItem'),
+        nodeName: zod_1.z.string(),
+    })
+        .strict();
+    /**
+     * `$evaluateExpression(expression, itemIndex?)` — evaluate a nested
+     * expression string at runtime against the same execution context.
+     *
+     * The host recursively invokes the expression engine on the `expression`
+     * string — under the VM engine this re-enters the bridge with a fresh
+     * evaluation. `itemIndex` is optional and defaults to the current item;
+     * the schema mirrors the existing "nonnegative int" constraint used by
+     * the node-data RPCs.
+     */
+    exports.evaluateExpressionMessage = zod_1.z
+        .object({
+        type: zod_1.z.literal('evaluateExpression'),
+        expression: zod_1.z.string(),
+        itemIndex: zod_1.z.number().int().nonnegative().optional(),
+    })
+        .strict();
+    /**
+     * `ISourceData` — the source record that accompanies a paired-item
+     * traversal step. Mirrors the host interface used by
+     * `WorkflowDataProxy.getPairedItem`.
+     */
+    const sourceDataSchema = zod_1.z
+        .object({
+        previousNode: zod_1.z.string(),
+        previousNodeOutput: zod_1.z.number().int().nonnegative().optional(),
+        previousNodeRun: zod_1.z.number().int().nonnegative().optional(),
+    })
+        .strict();
+    /**
+     * `IPairedItemData` — one paired-item record. `sourceOverwrite` lets a
+     * node override the upstream source while the helper walks the ancestry
+     * chain; the field is optional and recurses through the same schema.
+     */
+    const pairedItemDataSchema = zod_1.z
+        .object({
+        item: zod_1.z.number().int().nonnegative(),
+        input: zod_1.z.number().int().nonnegative().optional(),
+        sourceOverwrite: sourceDataSchema.optional(),
+    })
+        .strict();
+    /**
+     * `$getPairedItem(destinationNodeName, incomingSourceData, initialPairedItem)` —
+     * traverse the paired-item ancestry chain back to the named upstream node
+     * and return the matching execution item.
+     *
+     * Two host-side fields are deliberately omitted from the schema:
+     * - `usedMethodName` defaults to `$getPairedItem` on the host; the isolate
+     *   has no reason to spoof a different method name in the error path.
+     * - `nodeBeforeLast` is an internal recursion argument; only the host
+     *   itself sets it during the recursive walk.
+     *
+     * `incomingSourceData` is nullable because the host's signature accepts
+     * `ISourceData | null` (and throws a paired-item-not-found error when null).
+     */
+    exports.getPairedItemMessage = zod_1.z
+        .object({
+        type: zod_1.z.literal('getPairedItem'),
+        destinationNodeName: zod_1.z.string(),
+        incomingSourceData: sourceDataSchema.nullable(),
+        initialPairedItem: pairedItemDataSchema,
+    })
+        .strict();
     /**
      * The full set of messages the bridge will accept. Discriminator is `type`.
      *
@@ -76,6 +248,16 @@
         exports.getNodeFirstMessage,
         exports.getNodeLastMessage,
         exports.getNodeAllMessage,
+        exports.getInputFirstMessage,
+        exports.getInputLastMessage,
+        exports.getInputAllMessage,
+        exports.getItemsMessage,
+        exports.fromAiMessage,
+        exports.getNodePairedItemMessage,
+        exports.getNodeItemMatchingMessage,
+        exports.getNodeItemMessage,
+        exports.evaluateExpressionMessage,
+        exports.getPairedItemMessage,
     ]);
 });
 //# sourceMappingURL=bridge-messages.js.map