@n8n/expression-runtime 0.15.0 → 0.16.0

package/dist/esm/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, {
+    expression: string;
+    type: "evaluateExpression";
+    itemIndex?: number | undefined;
+}, {
+    expression: string;
+    type: "evaluateExpression";
+    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, {
+    expression: string;
+    type: "evaluateExpression";
+    itemIndex?: number | undefined;
+}, {
+    expression: string;
+    type: "evaluateExpression";
+    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/esm/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/esm/bridge/bridge-messages.js

@@ -53,6 +53,178 @@ export const getNodeAllMessage = z
     runIndex: 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`.
+ */
+export const getInputFirstMessage = z.object({ type: z.literal('getInputFirst') }).strict();
+/**
+ * `$input.last()` — fetch the last item of the current node's input.
+ */
+export const getInputLastMessage = z.object({ type: z.literal('getInputLast') }).strict();
+/**
+ * `$input.all()` — fetch every item of the current node's input.
+ */
+export const getInputAllMessage = z.object({ type: 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.
+ */
+export const getItemsMessage = z
+    .object({
+    type: z.literal('getItems'),
+    nodeName: z.string().optional(),
+    outputIndex: z.number().int().nonnegative().optional(),
+    runIndex: 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.
+ */
+export const fromAiMessage = z
+    .object({
+    type: z.literal('fromAi'),
+    name: z.string().optional(),
+    description: z.string().optional(),
+    valueType: z.string().optional(),
+    // `z.unknown()` already accepts `undefined`, so no `.optional()` needed.
+    defaultValue: 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`.
+ */
+export const getNodePairedItemMessage = z
+    .object({
+    type: z.literal('getNodePairedItem'),
+    nodeName: z.string(),
+    itemIndex: 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.
+ */
+export const getNodeItemMatchingMessage = z
+    .object({
+    type: z.literal('getNodeItemMatching'),
+    nodeName: z.string(),
+    itemIndex: z.number().int().nonnegative().optional(),
+})
+    .strict();
+export const getNodeItemMessage = z
+    .object({
+    type: z.literal('getNodeItem'),
+    nodeName: 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.
+ */
+export const evaluateExpressionMessage = z
+    .object({
+    type: z.literal('evaluateExpression'),
+    expression: z.string(),
+    itemIndex: 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 = z
+    .object({
+    previousNode: z.string(),
+    previousNodeOutput: z.number().int().nonnegative().optional(),
+    previousNodeRun: 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 = z
+    .object({
+    item: z.number().int().nonnegative(),
+    input: 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).
+ */
+export const getPairedItemMessage = z
+    .object({
+    type: z.literal('getPairedItem'),
+    destinationNodeName: z.string(),
+    incomingSourceData: sourceDataSchema.nullable(),
+    initialPairedItem: pairedItemDataSchema,
+})
+    .strict();
 /**
  * The full set of messages the bridge will accept. Discriminator is `type`.
  *
@@ -64,5 +236,15 @@ export const bridgeMessageSchema = z.discriminatedUnion('type', [
     getNodeFirstMessage,
     getNodeLastMessage,
     getNodeAllMessage,
+    getInputFirstMessage,
+    getInputLastMessage,
+    getInputAllMessage,
+    getItemsMessage,
+    fromAiMessage,
+    getNodePairedItemMessage,
+    getNodeItemMatchingMessage,
+    getNodeItemMessage,
+    evaluateExpressionMessage,
+    getPairedItemMessage,
 ]);
 //# sourceMappingURL=bridge-messages.js.map

package/dist/esm/bridge/bridge-messages.js.map

@@ -1 +1 @@
-{"version":3,"file":"bridge-messages.js","sourceRoot":"","sources":["../../../src/bridge/bridge-messages.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC;KAClC,MAAM,CAAC;IACP,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC;IAC/B,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE;IACtD,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE;CACnD,CAAC;KACD,MAAM,EAAE,CAAC;AAEX;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC;KACjC,MAAM,CAAC;IACP,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC;IAC9B,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE;IACtD,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE;CACnD,CAAC;KACD,MAAM,EAAE,CAAC;AAEX;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC;KAChC,MAAM,CAAC;IACP,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC;IAC7B,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE;IACtD,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE;CACnD,CAAC;KACD,MAAM,EAAE,CAAC;AAEX;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,kBAAkB,CAAC,MAAM,EAAE;IAC/D,mBAAmB;IACnB,kBAAkB;IAClB,iBAAiB;CACjB,CAAC,CAAC"}
+{"version":3,"file":"bridge-messages.js","sourceRoot":"","sources":["../../../src/bridge/bridge-messages.ts"],"names":[],"mappings":"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"}