@codemation/node-example 0.0.24 → 0.0.26

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @codemation/node-example
 
+## 0.0.26
+
+### Patch Changes
+
+- Updated dependencies [[`35b78bb`](https://github.com/MadeRelevant/codemation/commit/35b78bb4d8c7ee2998a8b8e51e5ffc3fd901e4c7), [`eb97e53`](https://github.com/MadeRelevant/codemation/commit/eb97e5376f4f620099c32c14d7797ed3039bf7bb)]:
+  - @codemation/core@0.4.0
+
+## 0.0.25
+
+### Patch Changes
+
+- Updated dependencies [[`bb2b3b8`](https://github.com/MadeRelevant/codemation/commit/bb2b3b89069697c6aa36aac1de7124c5eea65c3e)]:
+  - @codemation/core@0.3.0
+
 ## 0.0.24
 
 ### Patch Changes

package/dist/index.cjs

@@ -37,21 +37,17 @@ function __decorate(decorators, target, key, desc) {
 let ExampleUppercaseNode = class ExampleUppercaseNode$1 {
 	kind = "node";
 	outputPorts = ["main"];
-	async execute(items, ctx) {
-		const out = [];
-		for (let i = 0; i < items.length; i++) {
-			const item = items[i];
-			const json = typeof item.json === "object" && item.json !== null ? item.json : {};
-			const value = String(json[ctx.config.cfg.field] ?? "");
-			out.push({
-				...item,
-				json: {
-					...json,
-					[ctx.config.cfg.field]: value.toUpperCase()
-				}
-			});
-		}
-		return { main: out };
+	execute(args) {
+		const item = args.item;
+		const json = typeof item.json === "object" && item.json !== null ? item.json : {};
+		const value = String(json[args.ctx.config.cfg.field] ?? "");
+		return {
+			...item,
+			json: {
+				...json,
+				[args.ctx.config.cfg.field]: value.toUpperCase()
+			}
+		};
 	}
 };
 ExampleUppercaseNode = __decorate([(0, __codemation_core.node)({ packageName: "@codemation/node-example" })], ExampleUppercaseNode);

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["ExampleUppercaseNode","out: Item[]","name: string","cfg: { field: TField }","id?: string"],"sources":["../src/ExampleUppercaseNode.ts","../src/uppercase.ts"],"sourcesContent":["import type { Item, Items, Node, NodeExecutionContext, NodeOutputs } from \"@codemation/core\";\n\nimport { node } from \"@codemation/core\";\n\nimport { ExampleUppercase } from \"./uppercase\";\n\n@node({ packageName: \"@codemation/node-example\" })\nexport class ExampleUppercaseNode implements Node<ExampleUppercase<Record<string, unknown>, string>> {\n  kind = \"node\" as const;\n  outputPorts = [\"main\"] as const;\n\n  async execute(\n    items: Items,\n    ctx: NodeExecutionContext<ExampleUppercase<Record<string, unknown>, string>>,\n  ): Promise<NodeOutputs> {\n    const out: Item[] = [];\n    for (let i = 0; i < items.length; i++) {\n      const item = items[i]!;\n      const json = typeof item.json === \"object\" && item.json !== null ? (item.json as Record<string, unknown>) : {};\n      const value = String(json[ctx.config.cfg.field] ?? \"\");\n      out.push({ ...item, json: { ...json, [ctx.config.cfg.field]: value.toUpperCase() } });\n    }\n    return { main: out };\n  }\n}\n","import type { RunnableNodeConfig, TypeToken } from \"@codemation/core\";\n\nimport { ExampleUppercaseNode } from \"./ExampleUppercaseNode\";\n\nexport class ExampleUppercase<\n  TInputJson extends Record<string, unknown> = Record<string, unknown>,\n  TField extends keyof TInputJson & string = keyof TInputJson & string,\n> implements RunnableNodeConfig<TInputJson, TInputJson> {\n  readonly kind = \"node\" as const;\n  readonly type: TypeToken<unknown> = ExampleUppercaseNode;\n  constructor(\n    public readonly name: string,\n    public readonly cfg: { field: TField },\n    public readonly id?: string,\n  ) {}\n}\n\nexport { ExampleUppercaseNode } from \"./ExampleUppercaseNode\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOO,iCAAMA,uBAAwF;CACnG,OAAO;CACP,cAAc,CAAC,OAAO;CAEtB,MAAM,QACJ,OACA,KACsB;EACtB,MAAMC,MAAc,EAAE;AACtB,OAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;GACrC,MAAM,OAAO,MAAM;GACnB,MAAM,OAAO,OAAO,KAAK,SAAS,YAAY,KAAK,SAAS,OAAQ,KAAK,OAAmC,EAAE;GAC9G,MAAM,QAAQ,OAAO,KAAK,IAAI,OAAO,IAAI,UAAU,GAAG;AACtD,OAAI,KAAK;IAAE,GAAG;IAAM,MAAM;KAAE,GAAG;MAAO,IAAI,OAAO,IAAI,QAAQ,MAAM,aAAa;KAAE;IAAE,CAAC;;AAEvF,SAAO,EAAE,MAAM,KAAK;;;+DAhBlB,EAAE,aAAa,4BAA4B,CAAC;;;;ACFlD,IAAa,mBAAb,MAGwD;CACtD,AAAS,OAAO;CAChB,AAAS,OAA2B;CACpC,YACE,AAAgBC,MAChB,AAAgBC,KAChB,AAAgBC,IAChB;EAHgB;EACA;EACA"}
+{"version":3,"file":"index.cjs","names":["ExampleUppercaseNode","name: string","cfg: { field: TField }","id?: string"],"sources":["../src/ExampleUppercaseNode.ts","../src/uppercase.ts"],"sourcesContent":["import type { Item, RunnableNode, RunnableNodeExecuteArgs } from \"@codemation/core\";\n\nimport { node } from \"@codemation/core\";\n\nimport { ExampleUppercase } from \"./uppercase\";\n\n@node({ packageName: \"@codemation/node-example\" })\nexport class ExampleUppercaseNode implements RunnableNode<ExampleUppercase<Record<string, unknown>, string>> {\n  kind = \"node\" as const;\n  outputPorts = [\"main\"] as const;\n\n  execute(args: RunnableNodeExecuteArgs<ExampleUppercase<Record<string, unknown>, string>>): unknown {\n    const item = args.item as Item;\n    const json = typeof item.json === \"object\" && item.json !== null ? (item.json as Record<string, unknown>) : {};\n    const value = String(json[args.ctx.config.cfg.field] ?? \"\");\n    return { ...item, json: { ...json, [args.ctx.config.cfg.field]: value.toUpperCase() } };\n  }\n}\n","import type { RunnableNodeConfig, TypeToken } from \"@codemation/core\";\n\nimport { ExampleUppercaseNode } from \"./ExampleUppercaseNode\";\n\nexport class ExampleUppercase<\n  TInputJson extends Record<string, unknown> = Record<string, unknown>,\n  TField extends keyof TInputJson & string = keyof TInputJson & string,\n> implements RunnableNodeConfig<TInputJson, TInputJson> {\n  readonly kind = \"node\" as const;\n  readonly type: TypeToken<unknown> = ExampleUppercaseNode;\n  constructor(\n    public readonly name: string,\n    public readonly cfg: { field: TField },\n    public readonly id?: string,\n  ) {}\n}\n\nexport { ExampleUppercaseNode } from \"./ExampleUppercaseNode\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOO,iCAAMA,uBAAgG;CAC3G,OAAO;CACP,cAAc,CAAC,OAAO;CAEtB,QAAQ,MAA2F;EACjG,MAAM,OAAO,KAAK;EAClB,MAAM,OAAO,OAAO,KAAK,SAAS,YAAY,KAAK,SAAS,OAAQ,KAAK,OAAmC,EAAE;EAC9G,MAAM,QAAQ,OAAO,KAAK,KAAK,IAAI,OAAO,IAAI,UAAU,GAAG;AAC3D,SAAO;GAAE,GAAG;GAAM,MAAM;IAAE,GAAG;KAAO,KAAK,IAAI,OAAO,IAAI,QAAQ,MAAM,aAAa;IAAE;GAAE;;;+DATrF,EAAE,aAAa,4BAA4B,CAAC;;;;ACFlD,IAAa,mBAAb,MAGwD;CACtD,AAAS,OAAO;CAChB,AAAS,OAA2B;CACpC,YACE,AAAgBC,MAChB,AAAgBC,KAChB,AAAgBC,IAChB;EAHgB;EACA;EACA"}

package/dist/index.d.cts

@@ -128,10 +128,29 @@ interface NodeExecutionContext<TConfig extends NodeConfigBase = NodeConfigBase>
   config: TConfig;
   binary: NodeBinaryAttachmentService;
 }
-interface Node<TConfig extends NodeConfigBase = NodeConfigBase> {
-  kind: "node";
-  outputPorts: ReadonlyArray<OutputPortKey>;
-  execute(items: Items, ctx: NodeExecutionContext<TConfig>): Promise<NodeOutputs>;
+/**
+ * Per-item runnable node: return JSON, an array to fan-out on `main`, or {@link emitPorts} for multi-port emission.
+ * Engine applies `inputSchema.parse(item.json)` and passes the result as `args.input` (wire `item.json` is unchanged).
+ */
+interface RunnableNodeExecuteArgs<TConfig extends RunnableNodeConfig<any, any> = RunnableNodeConfig<any, any>, TInputJson$1 = unknown> {
+  readonly input: TInputJson$1;
+  readonly item: Item;
+  readonly itemIndex: number;
+  readonly items: Items;
+  readonly ctx: NodeExecutionContext<TConfig>;
+}
+interface RunnableNode<TConfig extends RunnableNodeConfig<any, any> = RunnableNodeConfig<any, any>, TInputJson$1 = unknown, _TOutputJson = unknown> {
+  readonly kind: "node";
+  /**
+   * Declared output ports (e.g. `["main"]`).
+   *
+   * Prefer describing dynamic router ports (Switch) and fixed multi-ports (If true/false)
+   * via {@link NodeConfigBase.declaredOutputPorts}. Engine defaults to `["main"]` when omitted.
+   */
+  readonly outputPorts?: ReadonlyArray<OutputPortKey>;
+  /** When omitted, engine uses {@link RunnableNodeConfig.inputSchema} or `z.unknown()`. */
+  readonly inputSchema?: ZodType<TInputJson$1>;
+  execute(args: RunnableNodeExecuteArgs<TConfig, TInputJson$1>): Promise<unknown> | unknown;
 }
 //#endregion
 //#region ../core/src/contracts/workflowTypes.d.ts
@@ -166,64 +185,41 @@ interface NodeConfigBase {
    * main batches skip downstream execution and propagate the empty path.
    */
   readonly continueWhenEmptyOutput?: boolean;
+  /**
+   * Declared I/O port names for canvas authoring (unioned with ports inferred from edges).
+   * Use for dynamic routers (Switch) and future error ports.
+   */
+  readonly declaredOutputPorts?: ReadonlyArray<OutputPortKey>;
+  readonly declaredInputPorts?: ReadonlyArray<InputPortKey>;
   getCredentialRequirements?(): ReadonlyArray<CredentialRequirement>;
 }
 declare const runnableNodeInputType: unique symbol;
 declare const runnableNodeOutputType: unique symbol;
-/** Phantom: JSON shape on the wire from upstream before {@link RunnableNodeConfig.mapInput}. */
-declare const runnableNodeWireType: unique symbol;
-/**
- * Read-only execution slice passed to {@link RunnableNodeConfig.mapInput} (aligned with the engine’s
- * node execution context for `runId`, `data`, etc.). Use **`ctx.data`** to read **any completed** upstream
- * node’s outputs in this run (e.g. `ctx.data.getOutputItems(nodeIdA, "main")` while mapping at D), not only
- * the immediate predecessor’s {@link ItemInputMapperArgs.item}.
- */
-interface ItemInputMapperContext {
-  readonly runId: RunId;
-  readonly workflowId: WorkflowId;
-  /** Node whose activation is being prepared (the consumer of `mapInput`). */
-  readonly nodeId: NodeId;
-  readonly activationId: NodeActivationId;
-  readonly parent?: ParentExecutionRef;
-  readonly data: RunDataSnapshot;
-}
-/**
- * Arguments for optional per-item input mapping applied by the engine before Zod validation.
- */
-interface ItemInputMapperArgs<TWireJson$1 = unknown> {
-  readonly item: Item<TWireJson$1>;
-  readonly itemIndex: number;
-  readonly items: Items<TWireJson$1>;
-  readonly ctx: ItemInputMapperContext;
-}
-/**
- * Per-item mapper before Zod validation. Uses a **bivariant** method signature so concrete
- * `ItemInputMapper<SpecificWire, TIn>` remains assignable to `RunnableNodeConfig` fields typed as
- * `ItemInputMapper<unknown, unknown>` (same pattern as React-style callbacks).
- */
-type ItemInputMapper<TWireJson$1 = unknown, TInputJson$1 = unknown> = {
-  bivarianceHack(args: ItemInputMapperArgs<TWireJson$1>): TInputJson$1 | Promise<TInputJson$1>;
-}["bivarianceHack"];
+type LineageCarryPolicy = "emitOnly" | "carryThrough";
 /**
- * Runnable node: **`TInputJson`** is the payload after `mapInput` (if any) + Zod validation — what {@link ItemNode}
- * `executeOne` receives. **`TOutputJson`** is emitted `item.json` on outputs. **`TWireJson`** is `item.json` from
- * upstream **before** `mapInput`; it defaults to **`TInputJson`** when there is no mapper or wire differs from execute input.
+ * Runnable node: **`TInputJson`** is what **`inputSchema`** validates on **`item.json`** (the wire payload).
+ * **`TOutputJson`** is emitted `item.json` on outputs.
  */
-interface RunnableNodeConfig<TInputJson$1 = unknown, TOutputJson$1 = unknown, TWireJson$1 = TInputJson$1> extends NodeConfigBase {
+interface RunnableNodeConfig<TInputJson$1 = unknown, TOutputJson$1 = unknown> extends NodeConfigBase {
   readonly kind: "node";
   readonly [runnableNodeInputType]?: TInputJson$1;
   readonly [runnableNodeOutputType]?: TOutputJson$1;
-  readonly [runnableNodeWireType]?: TWireJson$1;
   /**
-   * Optional Zod input contract for {@link ItemNode} when not set on the node class.
+   * Optional Zod input contract for {@link RunnableNode} when not set on the node class.
    * Resolution order: node instance `inputSchema`, then config `inputSchema`, then `z.unknown()`.
    */
   readonly inputSchema?: ZodType<TInputJson$1>;
   /**
-   * Optional per-item mapper: engine applies it before validating against the node’s `inputSchema`.
-   * When omitted, the engine validates `item.json` directly.
+   * Overrides default lineage propagation for `execute` outputs (binary/meta/paired).
+   * Routers with multiple {@link RunnableNode#outputPorts} default to **`carryThrough`**; others default to **`emitOnly`**.
+   */
+  readonly lineageCarry?: LineageCarryPolicy;
+  /**
+   * When an activation receives **zero** input items, the engine normally runs `execute` zero times.
+   * Set to **`runOnce`** to run `execute` once with an empty `items` batch (and a synthetic wire item for schema parsing).
+   * Used by batch-style callback nodes (built-in `Callback`) so `callback([], ctx)` still runs.
    */
-  readonly mapInput?: ItemInputMapper<TWireJson$1, TInputJson$1>;
+  readonly emptyBatchExecution?: "skip" | "runOnce";
 }
 type PairedItemRef = Readonly<{
   nodeId: NodeId;
@@ -297,10 +293,10 @@ type CredentialRequirement = Readonly<{
 }>;
 //#endregion
 //#region src/ExampleUppercaseNode.d.ts
-declare class ExampleUppercaseNode implements Node<ExampleUppercase<Record<string, unknown>, string>> {
+declare class ExampleUppercaseNode implements RunnableNode<ExampleUppercase<Record<string, unknown>, string>> {
   kind: "node";
   outputPorts: readonly ["main"];
-  execute(items: Items, ctx: NodeExecutionContext<ExampleUppercase<Record<string, unknown>, string>>): Promise<NodeOutputs>;
+  execute(args: RunnableNodeExecuteArgs<ExampleUppercase<Record<string, unknown>, string>>): unknown;
 }
 //#endregion
 //#region src/uppercase.d.ts

package/dist/index.d.ts

@@ -128,10 +128,29 @@ interface NodeExecutionContext<TConfig extends NodeConfigBase = NodeConfigBase>
   config: TConfig;
   binary: NodeBinaryAttachmentService;
 }
-interface Node<TConfig extends NodeConfigBase = NodeConfigBase> {
-  kind: "node";
-  outputPorts: ReadonlyArray<OutputPortKey>;
-  execute(items: Items, ctx: NodeExecutionContext<TConfig>): Promise<NodeOutputs>;
+/**
+ * Per-item runnable node: return JSON, an array to fan-out on `main`, or {@link emitPorts} for multi-port emission.
+ * Engine applies `inputSchema.parse(item.json)` and passes the result as `args.input` (wire `item.json` is unchanged).
+ */
+interface RunnableNodeExecuteArgs<TConfig extends RunnableNodeConfig<any, any> = RunnableNodeConfig<any, any>, TInputJson$1 = unknown> {
+  readonly input: TInputJson$1;
+  readonly item: Item;
+  readonly itemIndex: number;
+  readonly items: Items;
+  readonly ctx: NodeExecutionContext<TConfig>;
+}
+interface RunnableNode<TConfig extends RunnableNodeConfig<any, any> = RunnableNodeConfig<any, any>, TInputJson$1 = unknown, _TOutputJson = unknown> {
+  readonly kind: "node";
+  /**
+   * Declared output ports (e.g. `["main"]`).
+   *
+   * Prefer describing dynamic router ports (Switch) and fixed multi-ports (If true/false)
+   * via {@link NodeConfigBase.declaredOutputPorts}. Engine defaults to `["main"]` when omitted.
+   */
+  readonly outputPorts?: ReadonlyArray<OutputPortKey>;
+  /** When omitted, engine uses {@link RunnableNodeConfig.inputSchema} or `z.unknown()`. */
+  readonly inputSchema?: ZodType<TInputJson$1>;
+  execute(args: RunnableNodeExecuteArgs<TConfig, TInputJson$1>): Promise<unknown> | unknown;
 }
 //#endregion
 //#region ../core/src/contracts/workflowTypes.d.ts
@@ -166,64 +185,41 @@ interface NodeConfigBase {
    * main batches skip downstream execution and propagate the empty path.
    */
   readonly continueWhenEmptyOutput?: boolean;
+  /**
+   * Declared I/O port names for canvas authoring (unioned with ports inferred from edges).
+   * Use for dynamic routers (Switch) and future error ports.
+   */
+  readonly declaredOutputPorts?: ReadonlyArray<OutputPortKey>;
+  readonly declaredInputPorts?: ReadonlyArray<InputPortKey>;
   getCredentialRequirements?(): ReadonlyArray<CredentialRequirement>;
 }
 declare const runnableNodeInputType: unique symbol;
 declare const runnableNodeOutputType: unique symbol;
-/** Phantom: JSON shape on the wire from upstream before {@link RunnableNodeConfig.mapInput}. */
-declare const runnableNodeWireType: unique symbol;
-/**
- * Read-only execution slice passed to {@link RunnableNodeConfig.mapInput} (aligned with the engine’s
- * node execution context for `runId`, `data`, etc.). Use **`ctx.data`** to read **any completed** upstream
- * node’s outputs in this run (e.g. `ctx.data.getOutputItems(nodeIdA, "main")` while mapping at D), not only
- * the immediate predecessor’s {@link ItemInputMapperArgs.item}.
- */
-interface ItemInputMapperContext {
-  readonly runId: RunId;
-  readonly workflowId: WorkflowId;
-  /** Node whose activation is being prepared (the consumer of `mapInput`). */
-  readonly nodeId: NodeId;
-  readonly activationId: NodeActivationId;
-  readonly parent?: ParentExecutionRef;
-  readonly data: RunDataSnapshot;
-}
-/**
- * Arguments for optional per-item input mapping applied by the engine before Zod validation.
- */
-interface ItemInputMapperArgs<TWireJson$1 = unknown> {
-  readonly item: Item<TWireJson$1>;
-  readonly itemIndex: number;
-  readonly items: Items<TWireJson$1>;
-  readonly ctx: ItemInputMapperContext;
-}
-/**
- * Per-item mapper before Zod validation. Uses a **bivariant** method signature so concrete
- * `ItemInputMapper<SpecificWire, TIn>` remains assignable to `RunnableNodeConfig` fields typed as
- * `ItemInputMapper<unknown, unknown>` (same pattern as React-style callbacks).
- */
-type ItemInputMapper<TWireJson$1 = unknown, TInputJson$1 = unknown> = {
-  bivarianceHack(args: ItemInputMapperArgs<TWireJson$1>): TInputJson$1 | Promise<TInputJson$1>;
-}["bivarianceHack"];
+type LineageCarryPolicy = "emitOnly" | "carryThrough";
 /**
- * Runnable node: **`TInputJson`** is the payload after `mapInput` (if any) + Zod validation — what {@link ItemNode}
- * `executeOne` receives. **`TOutputJson`** is emitted `item.json` on outputs. **`TWireJson`** is `item.json` from
- * upstream **before** `mapInput`; it defaults to **`TInputJson`** when there is no mapper or wire differs from execute input.
+ * Runnable node: **`TInputJson`** is what **`inputSchema`** validates on **`item.json`** (the wire payload).
+ * **`TOutputJson`** is emitted `item.json` on outputs.
  */
-interface RunnableNodeConfig<TInputJson$1 = unknown, TOutputJson$1 = unknown, TWireJson$1 = TInputJson$1> extends NodeConfigBase {
+interface RunnableNodeConfig<TInputJson$1 = unknown, TOutputJson$1 = unknown> extends NodeConfigBase {
   readonly kind: "node";
   readonly [runnableNodeInputType]?: TInputJson$1;
   readonly [runnableNodeOutputType]?: TOutputJson$1;
-  readonly [runnableNodeWireType]?: TWireJson$1;
   /**
-   * Optional Zod input contract for {@link ItemNode} when not set on the node class.
+   * Optional Zod input contract for {@link RunnableNode} when not set on the node class.
    * Resolution order: node instance `inputSchema`, then config `inputSchema`, then `z.unknown()`.
    */
   readonly inputSchema?: ZodType<TInputJson$1>;
   /**
-   * Optional per-item mapper: engine applies it before validating against the node’s `inputSchema`.
-   * When omitted, the engine validates `item.json` directly.
+   * Overrides default lineage propagation for `execute` outputs (binary/meta/paired).
+   * Routers with multiple {@link RunnableNode#outputPorts} default to **`carryThrough`**; others default to **`emitOnly`**.
+   */
+  readonly lineageCarry?: LineageCarryPolicy;
+  /**
+   * When an activation receives **zero** input items, the engine normally runs `execute` zero times.
+   * Set to **`runOnce`** to run `execute` once with an empty `items` batch (and a synthetic wire item for schema parsing).
+   * Used by batch-style callback nodes (built-in `Callback`) so `callback([], ctx)` still runs.
    */
-  readonly mapInput?: ItemInputMapper<TWireJson$1, TInputJson$1>;
+  readonly emptyBatchExecution?: "skip" | "runOnce";
 }
 type PairedItemRef = Readonly<{
   nodeId: NodeId;
@@ -297,10 +293,10 @@ type CredentialRequirement = Readonly<{
 }>;
 //#endregion
 //#region src/ExampleUppercaseNode.d.ts
-declare class ExampleUppercaseNode implements Node<ExampleUppercase<Record<string, unknown>, string>> {
+declare class ExampleUppercaseNode implements RunnableNode<ExampleUppercase<Record<string, unknown>, string>> {
   kind: "node";
   outputPorts: readonly ["main"];
-  execute(items: Items, ctx: NodeExecutionContext<ExampleUppercase<Record<string, unknown>, string>>): Promise<NodeOutputs>;
+  execute(args: RunnableNodeExecuteArgs<ExampleUppercase<Record<string, unknown>, string>>): unknown;
 }
 //#endregion
 //#region src/uppercase.d.ts

package/dist/index.js

@@ -13,21 +13,17 @@ function __decorate(decorators, target, key, desc) {
 let ExampleUppercaseNode = class ExampleUppercaseNode$1 {
 	kind = "node";
 	outputPorts = ["main"];
-	async execute(items, ctx) {
-		const out = [];
-		for (let i = 0; i < items.length; i++) {
-			const item = items[i];
-			const json = typeof item.json === "object" && item.json !== null ? item.json : {};
-			const value = String(json[ctx.config.cfg.field] ?? "");
-			out.push({
-				...item,
-				json: {
-					...json,
-					[ctx.config.cfg.field]: value.toUpperCase()
-				}
-			});
-		}
-		return { main: out };
+	execute(args) {
+		const item = args.item;
+		const json = typeof item.json === "object" && item.json !== null ? item.json : {};
+		const value = String(json[args.ctx.config.cfg.field] ?? "");
+		return {
+			...item,
+			json: {
+				...json,
+				[args.ctx.config.cfg.field]: value.toUpperCase()
+			}
+		};
 	}
 };
 ExampleUppercaseNode = __decorate([node({ packageName: "@codemation/node-example" })], ExampleUppercaseNode);

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["ExampleUppercaseNode","out: Item[]","name: string","cfg: { field: TField }","id?: string"],"sources":["../src/ExampleUppercaseNode.ts","../src/uppercase.ts"],"sourcesContent":["import type { Item, Items, Node, NodeExecutionContext, NodeOutputs } from \"@codemation/core\";\n\nimport { node } from \"@codemation/core\";\n\nimport { ExampleUppercase } from \"./uppercase\";\n\n@node({ packageName: \"@codemation/node-example\" })\nexport class ExampleUppercaseNode implements Node<ExampleUppercase<Record<string, unknown>, string>> {\n  kind = \"node\" as const;\n  outputPorts = [\"main\"] as const;\n\n  async execute(\n    items: Items,\n    ctx: NodeExecutionContext<ExampleUppercase<Record<string, unknown>, string>>,\n  ): Promise<NodeOutputs> {\n    const out: Item[] = [];\n    for (let i = 0; i < items.length; i++) {\n      const item = items[i]!;\n      const json = typeof item.json === \"object\" && item.json !== null ? (item.json as Record<string, unknown>) : {};\n      const value = String(json[ctx.config.cfg.field] ?? \"\");\n      out.push({ ...item, json: { ...json, [ctx.config.cfg.field]: value.toUpperCase() } });\n    }\n    return { main: out };\n  }\n}\n","import type { RunnableNodeConfig, TypeToken } from \"@codemation/core\";\n\nimport { ExampleUppercaseNode } from \"./ExampleUppercaseNode\";\n\nexport class ExampleUppercase<\n  TInputJson extends Record<string, unknown> = Record<string, unknown>,\n  TField extends keyof TInputJson & string = keyof TInputJson & string,\n> implements RunnableNodeConfig<TInputJson, TInputJson> {\n  readonly kind = \"node\" as const;\n  readonly type: TypeToken<unknown> = ExampleUppercaseNode;\n  constructor(\n    public readonly name: string,\n    public readonly cfg: { field: TField },\n    public readonly id?: string,\n  ) {}\n}\n\nexport { ExampleUppercaseNode } from \"./ExampleUppercaseNode\";\n"],"mappings":";;;;;;;;;;;;AAOO,iCAAMA,uBAAwF;CACnG,OAAO;CACP,cAAc,CAAC,OAAO;CAEtB,MAAM,QACJ,OACA,KACsB;EACtB,MAAMC,MAAc,EAAE;AACtB,OAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;GACrC,MAAM,OAAO,MAAM;GACnB,MAAM,OAAO,OAAO,KAAK,SAAS,YAAY,KAAK,SAAS,OAAQ,KAAK,OAAmC,EAAE;GAC9G,MAAM,QAAQ,OAAO,KAAK,IAAI,OAAO,IAAI,UAAU,GAAG;AACtD,OAAI,KAAK;IAAE,GAAG;IAAM,MAAM;KAAE,GAAG;MAAO,IAAI,OAAO,IAAI,QAAQ,MAAM,aAAa;KAAE;IAAE,CAAC;;AAEvF,SAAO,EAAE,MAAM,KAAK;;;mCAhBvB,KAAK,EAAE,aAAa,4BAA4B,CAAC;;;;ACFlD,IAAa,mBAAb,MAGwD;CACtD,AAAS,OAAO;CAChB,AAAS,OAA2B;CACpC,YACE,AAAgBC,MAChB,AAAgBC,KAChB,AAAgBC,IAChB;EAHgB;EACA;EACA"}
+{"version":3,"file":"index.js","names":["ExampleUppercaseNode","name: string","cfg: { field: TField }","id?: string"],"sources":["../src/ExampleUppercaseNode.ts","../src/uppercase.ts"],"sourcesContent":["import type { Item, RunnableNode, RunnableNodeExecuteArgs } from \"@codemation/core\";\n\nimport { node } from \"@codemation/core\";\n\nimport { ExampleUppercase } from \"./uppercase\";\n\n@node({ packageName: \"@codemation/node-example\" })\nexport class ExampleUppercaseNode implements RunnableNode<ExampleUppercase<Record<string, unknown>, string>> {\n  kind = \"node\" as const;\n  outputPorts = [\"main\"] as const;\n\n  execute(args: RunnableNodeExecuteArgs<ExampleUppercase<Record<string, unknown>, string>>): unknown {\n    const item = args.item as Item;\n    const json = typeof item.json === \"object\" && item.json !== null ? (item.json as Record<string, unknown>) : {};\n    const value = String(json[args.ctx.config.cfg.field] ?? \"\");\n    return { ...item, json: { ...json, [args.ctx.config.cfg.field]: value.toUpperCase() } };\n  }\n}\n","import type { RunnableNodeConfig, TypeToken } from \"@codemation/core\";\n\nimport { ExampleUppercaseNode } from \"./ExampleUppercaseNode\";\n\nexport class ExampleUppercase<\n  TInputJson extends Record<string, unknown> = Record<string, unknown>,\n  TField extends keyof TInputJson & string = keyof TInputJson & string,\n> implements RunnableNodeConfig<TInputJson, TInputJson> {\n  readonly kind = \"node\" as const;\n  readonly type: TypeToken<unknown> = ExampleUppercaseNode;\n  constructor(\n    public readonly name: string,\n    public readonly cfg: { field: TField },\n    public readonly id?: string,\n  ) {}\n}\n\nexport { ExampleUppercaseNode } from \"./ExampleUppercaseNode\";\n"],"mappings":";;;;;;;;;;;;AAOO,iCAAMA,uBAAgG;CAC3G,OAAO;CACP,cAAc,CAAC,OAAO;CAEtB,QAAQ,MAA2F;EACjG,MAAM,OAAO,KAAK;EAClB,MAAM,OAAO,OAAO,KAAK,SAAS,YAAY,KAAK,SAAS,OAAQ,KAAK,OAAmC,EAAE;EAC9G,MAAM,QAAQ,OAAO,KAAK,KAAK,IAAI,OAAO,IAAI,UAAU,GAAG;AAC3D,SAAO;GAAE,GAAG;GAAM,MAAM;IAAE,GAAG;KAAO,KAAK,IAAI,OAAO,IAAI,QAAQ,MAAM,aAAa;IAAE;GAAE;;;mCAT1F,KAAK,EAAE,aAAa,4BAA4B,CAAC;;;;ACFlD,IAAa,mBAAb,MAGwD;CACtD,AAAS,OAAO;CAChB,AAAS,OAA2B;CACpC,YACE,AAAgBC,MAChB,AAAgBC,KAChB,AAAgBC,IAChB;EAHgB;EACA;EACA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemation/node-example",
-  "version": "0.0.24",
+  "version": "0.0.26",
   "publishConfig": {
     "access": "public"
   },
@@ -28,7 +28,7 @@
     }
   },
   "dependencies": {
-    "@codemation/core": "0.2.3"
+    "@codemation/core": "0.4.0"
   },
   "devDependencies": {
     "@types/node": "^25.3.5",
@@ -37,6 +37,7 @@
     "typescript": "^5.9.3"
   },
   "scripts": {
+    "changeset:verify": "pnpm --workspace-root run changeset:verify",
     "dev": "tsdown --watch",
     "build": "tsdown",
     "typecheck": "tsc -p tsconfig.json --noEmit",

package/src/ExampleUppercaseNode.ts

@@ -1,25 +1,18 @@
-import type { Item, Items, Node, NodeExecutionContext, NodeOutputs } from "@codemation/core";
+import type { Item, RunnableNode, RunnableNodeExecuteArgs } from "@codemation/core";
 
 import { node } from "@codemation/core";
 
 import { ExampleUppercase } from "./uppercase";
 
 @node({ packageName: "@codemation/node-example" })
-export class ExampleUppercaseNode implements Node<ExampleUppercase<Record<string, unknown>, string>> {
+export class ExampleUppercaseNode implements RunnableNode<ExampleUppercase<Record<string, unknown>, string>> {
   kind = "node" as const;
   outputPorts = ["main"] as const;
 
-  async execute(
-    items: Items,
-    ctx: NodeExecutionContext<ExampleUppercase<Record<string, unknown>, string>>,
-  ): Promise<NodeOutputs> {
-    const out: Item[] = [];
-    for (let i = 0; i < items.length; i++) {
-      const item = items[i]!;
-      const json = typeof item.json === "object" && item.json !== null ? (item.json as Record<string, unknown>) : {};
-      const value = String(json[ctx.config.cfg.field] ?? "");
-      out.push({ ...item, json: { ...json, [ctx.config.cfg.field]: value.toUpperCase() } });
-    }
-    return { main: out };
+  execute(args: RunnableNodeExecuteArgs<ExampleUppercase<Record<string, unknown>, string>>): unknown {
+    const item = args.item as Item;
+    const json = typeof item.json === "object" && item.json !== null ? (item.json as Record<string, unknown>) : {};
+    const value = String(json[args.ctx.config.cfg.field] ?? "");
+    return { ...item, json: { ...json, [args.ctx.config.cfg.field]: value.toUpperCase() } };
   }
 }