@workglow/tasks 0.0.90 → 0.0.91

package/dist/browser.js

@@ -622,6 +622,534 @@ var fileLoader = (input, config) => {
 };
 Workflow2.prototype.fileLoader = CreateWorkflow2(FileLoaderTask);
 
+// src/task/adaptive.ts
+import { CreateAdaptiveWorkflow, Workflow as Workflow12 } from "@workglow/task-graph";
+
+// src/task/scalar/ScalarAddTask.ts
+import { CreateWorkflow as CreateWorkflow3, Task as Task2, Workflow as Workflow3 } from "@workglow/task-graph";
+
+// src/task/scalar/sumPrecise.ts
+function kahanSum(values) {
+  let sum = 0;
+  let compensation = 0;
+  for (const value of values) {
+    const y = value - compensation;
+    const t = sum + y;
+    compensation = t - sum - y;
+    sum = t;
+  }
+  return sum;
+}
+var nativeSumPrecise = typeof Math.sumPrecise === "function" ? Math.sumPrecise : undefined;
+var sumPrecise = nativeSumPrecise ? nativeSumPrecise.bind(Math) : kahanSum;
+
+// src/task/scalar/ScalarAddTask.ts
+var inputSchema3 = {
+  type: "object",
+  properties: {
+    a: {
+      type: "number",
+      title: "A",
+      description: "First number"
+    },
+    b: {
+      type: "number",
+      title: "B",
+      description: "Second number"
+    }
+  },
+  required: ["a", "b"],
+  additionalProperties: false
+};
+var outputSchema3 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Sum of a and b"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarAddTask extends Task2 {
+  static type = "ScalarAddTask";
+  static category = "Math";
+  static title = "Add";
+  static description = "Returns the sum of two numbers";
+  static inputSchema() {
+    return inputSchema3;
+  }
+  static outputSchema() {
+    return outputSchema3;
+  }
+  async execute(input, _context) {
+    return { result: sumPrecise([input.a, input.b]) };
+  }
+}
+Workflow3.prototype.scalarAdd = CreateWorkflow3(ScalarAddTask);
+
+// src/task/scalar/ScalarDivideTask.ts
+import { CreateWorkflow as CreateWorkflow4, Task as Task3, Workflow as Workflow4 } from "@workglow/task-graph";
+var inputSchema4 = {
+  type: "object",
+  properties: {
+    a: {
+      type: "number",
+      title: "A",
+      description: "Numerator"
+    },
+    b: {
+      type: "number",
+      title: "B",
+      description: "Denominator"
+    }
+  },
+  required: ["a", "b"],
+  additionalProperties: false
+};
+var outputSchema4 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Quotient (a / b)"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarDivideTask extends Task3 {
+  static type = "ScalarDivideTask";
+  static category = "Math";
+  static title = "Divide";
+  static description = "Returns the quotient of two numbers (a / b)";
+  static inputSchema() {
+    return inputSchema4;
+  }
+  static outputSchema() {
+    return outputSchema4;
+  }
+  async execute(input, _context) {
+    return { result: input.a / input.b };
+  }
+}
+Workflow4.prototype.scalarDivide = CreateWorkflow4(ScalarDivideTask);
+
+// src/task/scalar/ScalarMultiplyTask.ts
+import { CreateWorkflow as CreateWorkflow5, Task as Task4, Workflow as Workflow5 } from "@workglow/task-graph";
+var inputSchema5 = {
+  type: "object",
+  properties: {
+    a: {
+      type: "number",
+      title: "A",
+      description: "First number"
+    },
+    b: {
+      type: "number",
+      title: "B",
+      description: "Second number"
+    }
+  },
+  required: ["a", "b"],
+  additionalProperties: false
+};
+var outputSchema5 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Product of a and b"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarMultiplyTask extends Task4 {
+  static type = "ScalarMultiplyTask";
+  static category = "Math";
+  static title = "Multiply";
+  static description = "Returns the product of two numbers";
+  static inputSchema() {
+    return inputSchema5;
+  }
+  static outputSchema() {
+    return outputSchema5;
+  }
+  async execute(input, _context) {
+    return { result: input.a * input.b };
+  }
+}
+Workflow5.prototype.scalarMultiply = CreateWorkflow5(ScalarMultiplyTask);
+
+// src/task/scalar/ScalarSubtractTask.ts
+import { CreateWorkflow as CreateWorkflow6, Task as Task5, Workflow as Workflow6 } from "@workglow/task-graph";
+var inputSchema6 = {
+  type: "object",
+  properties: {
+    a: {
+      type: "number",
+      title: "A",
+      description: "First number"
+    },
+    b: {
+      type: "number",
+      title: "B",
+      description: "Second number"
+    }
+  },
+  required: ["a", "b"],
+  additionalProperties: false
+};
+var outputSchema6 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Difference (a - b)"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarSubtractTask extends Task5 {
+  static type = "ScalarSubtractTask";
+  static category = "Math";
+  static title = "Subtract";
+  static description = "Returns the difference of two numbers (a - b)";
+  static inputSchema() {
+    return inputSchema6;
+  }
+  static outputSchema() {
+    return outputSchema6;
+  }
+  async execute(input, _context) {
+    return { result: input.a - input.b };
+  }
+}
+Workflow6.prototype.scalarSubtract = CreateWorkflow6(ScalarSubtractTask);
+
+// src/task/scalar/ScalarSumTask.ts
+import { CreateWorkflow as CreateWorkflow7, Task as Task6, Workflow as Workflow7 } from "@workglow/task-graph";
+var inputSchema7 = {
+  type: "object",
+  properties: {
+    values: {
+      type: "array",
+      items: { type: "number" },
+      title: "Values",
+      description: "Array of numbers to sum"
+    }
+  },
+  required: ["values"],
+  additionalProperties: false
+};
+var outputSchema7 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Sum of all values"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarSumTask extends Task6 {
+  static type = "ScalarSumTask";
+  static category = "Math";
+  static title = "Sum";
+  static description = "Returns the sum of an array of numbers";
+  static inputSchema() {
+    return inputSchema7;
+  }
+  static outputSchema() {
+    return outputSchema7;
+  }
+  async execute(input, _context) {
+    return { result: sumPrecise(input.values) };
+  }
+}
+Workflow7.prototype.scalarSum = CreateWorkflow7(ScalarSumTask);
+
+// src/task/vector/VectorDivideTask.ts
+import { CreateWorkflow as CreateWorkflow8, Task as Task7, Workflow as Workflow8 } from "@workglow/task-graph";
+import {
+  createTypedArrayFrom,
+  TypedArraySchema
+} from "@workglow/util";
+var inputSchema8 = {
+  type: "object",
+  properties: {
+    vectors: {
+      type: "array",
+      items: TypedArraySchema({
+        title: "Vector",
+        description: "Vector (first is numerator, rest are denominators)"
+      }),
+      title: "Vectors",
+      description: "Array of vectors: vectors[0] / vectors[1] / vectors[2] / ..."
+    }
+  },
+  required: ["vectors"],
+  additionalProperties: false
+};
+var outputSchema8 = {
+  type: "object",
+  properties: {
+    result: TypedArraySchema({
+      title: "Result",
+      description: "Component-wise quotient"
+    })
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class VectorDivideTask extends Task7 {
+  static type = "VectorDivideTask";
+  static category = "Vector";
+  static title = "Divide";
+  static description = "Returns component-wise quotient: vectors[0] / vectors[1] / vectors[2] / ...";
+  static inputSchema() {
+    return inputSchema8;
+  }
+  static outputSchema() {
+    return outputSchema8;
+  }
+  async execute(input, _context) {
+    const { vectors } = input;
+    if (vectors.length < 2) {
+      throw new Error("At least two vectors are required");
+    }
+    const len = vectors[0].length;
+    for (let i = 1;i < vectors.length; i++) {
+      if (vectors[i].length !== len) {
+        throw new Error("All vectors must have the same length");
+      }
+    }
+    const values = Array.from({ length: len }, (_, i) => {
+      let acc = Number(vectors[0][i]);
+      for (let j = 1;j < vectors.length; j++) {
+        acc /= Number(vectors[j][i]);
+      }
+      return acc;
+    });
+    return { result: createTypedArrayFrom(vectors, values) };
+  }
+}
+Workflow8.prototype.vectorDivide = CreateWorkflow8(VectorDivideTask);
+
+// src/task/vector/VectorMultiplyTask.ts
+import { CreateWorkflow as CreateWorkflow9, Task as Task8, Workflow as Workflow9 } from "@workglow/task-graph";
+import {
+  createTypedArrayFrom as createTypedArrayFrom2,
+  TypedArraySchema as TypedArraySchema2
+} from "@workglow/util";
+var inputSchema9 = {
+  type: "object",
+  properties: {
+    vectors: {
+      type: "array",
+      items: TypedArraySchema2({
+        title: "Vector",
+        description: "Vector for component-wise product"
+      }),
+      title: "Vectors",
+      description: "Array of vectors to multiply component-wise"
+    }
+  },
+  required: ["vectors"],
+  additionalProperties: false
+};
+var outputSchema9 = {
+  type: "object",
+  properties: {
+    result: TypedArraySchema2({
+      title: "Result",
+      description: "Component-wise product (Hadamard product)"
+    })
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class VectorMultiplyTask extends Task8 {
+  static type = "VectorMultiplyTask";
+  static category = "Vector";
+  static title = "Multiply";
+  static description = "Returns the component-wise product (Hadamard product) of all vectors";
+  static inputSchema() {
+    return inputSchema9;
+  }
+  static outputSchema() {
+    return outputSchema9;
+  }
+  async execute(input, _context) {
+    const { vectors } = input;
+    if (vectors.length === 0) {
+      throw new Error("At least one vector is required");
+    }
+    const len = vectors[0].length;
+    for (let i = 1;i < vectors.length; i++) {
+      if (vectors[i].length !== len) {
+        throw new Error("All vectors must have the same length");
+      }
+    }
+    const values = Array.from({ length: len }, (_, i) => vectors.reduce((acc, v) => acc * Number(v[i]), 1));
+    return { result: createTypedArrayFrom2(vectors, values) };
+  }
+}
+Workflow9.prototype.vectorMultiply = CreateWorkflow9(VectorMultiplyTask);
+
+// src/task/vector/VectorSubtractTask.ts
+import { CreateWorkflow as CreateWorkflow10, Task as Task9, Workflow as Workflow10 } from "@workglow/task-graph";
+import {
+  createTypedArrayFrom as createTypedArrayFrom3,
+  TypedArraySchema as TypedArraySchema3
+} from "@workglow/util";
+var inputSchema10 = {
+  type: "object",
+  properties: {
+    vectors: {
+      type: "array",
+      items: TypedArraySchema3({
+        title: "Vector",
+        description: "Vector (first is minuend, rest are subtrahends)"
+      }),
+      title: "Vectors",
+      description: "Array of vectors: vectors[0] - vectors[1] - vectors[2] - ..."
+    }
+  },
+  required: ["vectors"],
+  additionalProperties: false
+};
+var outputSchema10 = {
+  type: "object",
+  properties: {
+    result: TypedArraySchema3({
+      title: "Result",
+      description: "Difference of vectors"
+    })
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class VectorSubtractTask extends Task9 {
+  static type = "VectorSubtractTask";
+  static category = "Vector";
+  static title = "Subtract";
+  static description = "Returns component-wise difference: vectors[0] - vectors[1] - vectors[2] - ...";
+  static inputSchema() {
+    return inputSchema10;
+  }
+  static outputSchema() {
+    return outputSchema10;
+  }
+  async execute(input, _context) {
+    const { vectors } = input;
+    if (vectors.length < 2) {
+      throw new Error("At least two vectors are required");
+    }
+    const len = vectors[0].length;
+    for (let i = 1;i < vectors.length; i++) {
+      if (vectors[i].length !== len) {
+        throw new Error("All vectors must have the same length");
+      }
+    }
+    const values = Array.from({ length: len }, (_, i) => {
+      let acc = Number(vectors[0][i]);
+      for (let j = 1;j < vectors.length; j++) {
+        acc -= Number(vectors[j][i]);
+      }
+      return acc;
+    });
+    return { result: createTypedArrayFrom3(vectors, values) };
+  }
+}
+Workflow10.prototype.vectorSubtract = CreateWorkflow10(VectorSubtractTask);
+
+// src/task/vector/VectorSumTask.ts
+import { CreateWorkflow as CreateWorkflow11, Task as Task10, Workflow as Workflow11 } from "@workglow/task-graph";
+import {
+  createTypedArrayFrom as createTypedArrayFrom4,
+  TypedArraySchema as TypedArraySchema4
+} from "@workglow/util";
+var inputSchema11 = {
+  type: "object",
+  properties: {
+    vectors: {
+      type: "array",
+      items: TypedArraySchema4({
+        title: "Vector",
+        description: "Vector to sum"
+      }),
+      title: "Vectors",
+      description: "Array of vectors to sum component-wise"
+    }
+  },
+  required: ["vectors"],
+  additionalProperties: false
+};
+var outputSchema11 = {
+  type: "object",
+  properties: {
+    result: TypedArraySchema4({
+      title: "Result",
+      description: "Sum of vectors"
+    })
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class VectorSumTask extends Task10 {
+  static type = "VectorSumTask";
+  static category = "Vector";
+  static title = "Sum";
+  static description = "Returns the component-wise sum of an array of vectors";
+  static inputSchema() {
+    return inputSchema11;
+  }
+  static outputSchema() {
+    return outputSchema11;
+  }
+  async execute(input, _context) {
+    const { vectors } = input;
+    if (vectors.length === 0) {
+      throw new Error("At least one vector is required");
+    }
+    const len = vectors[0].length;
+    for (let i = 1;i < vectors.length; i++) {
+      if (vectors[i].length !== len) {
+        throw new Error("All vectors must have the same length");
+      }
+    }
+    const values = Array.from({ length: len }, (_, i) => sumPrecise(vectors.map((v) => Number(v[i]))));
+    return { result: createTypedArrayFrom4(vectors, values) };
+  }
+}
+Workflow11.prototype.vectorSum = CreateWorkflow11(VectorSumTask);
+
+// src/task/adaptive.ts
+Workflow12.prototype.add = CreateAdaptiveWorkflow(ScalarAddTask, VectorSumTask);
+Workflow12.prototype.subtract = CreateAdaptiveWorkflow(ScalarSubtractTask, VectorSubtractTask);
+Workflow12.prototype.multiply = CreateAdaptiveWorkflow(ScalarMultiplyTask, VectorMultiplyTask);
+Workflow12.prototype.divide = CreateAdaptiveWorkflow(ScalarDivideTask, VectorDivideTask);
+Workflow12.prototype.sum = CreateAdaptiveWorkflow(ScalarSumTask, VectorSumTask);
+
 // src/task/ArrayTask.ts
 import {
   uuid4
@@ -656,12 +1184,12 @@ class ArrayTask extends GraphAsTask {
   regenerateGraph() {
     const arrayInputs = new Map;
     let hasArrayInputs = false;
-    const inputSchema3 = this.inputSchema();
-    if (typeof inputSchema3 !== "boolean") {
-      const keys = Object.keys(inputSchema3.properties || {});
+    const inputSchema12 = this.inputSchema();
+    if (typeof inputSchema12 !== "boolean") {
+      const keys = Object.keys(inputSchema12.properties || {});
       for (const inputId of keys) {
         const inputValue = this.runInputData[inputId];
-        const inputDef = inputSchema3.properties?.[inputId];
+        const inputDef = inputSchema12.properties?.[inputId];
         if (typeof inputDef === "object" && inputDef !== null && "x-replicate" in inputDef && inputDef["x-replicate"] === true && Array.isArray(inputValue) && inputValue.length > 1) {
           arrayInputs.set(inputId, inputValue);
           hasArrayInputs = true;
@@ -750,10 +1278,10 @@ class ArrayTaskRunner extends GraphAsTaskRunner {
   }
 }
 // src/task/DebugLogTask.ts
-import { CreateWorkflow as CreateWorkflow3, Task as Task2, Workflow as Workflow3 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow12, Task as Task11, Workflow as Workflow13 } from "@workglow/task-graph";
 var log_levels = ["dir", "log", "debug", "info", "warn", "error"];
 var DEFAULT_LOG_LEVEL = "log";
-var inputSchema3 = {
+var inputSchema12 = {
   type: "object",
   properties: {
     console: {
@@ -770,7 +1298,7 @@ var inputSchema3 = {
   },
   additionalProperties: false
 };
-var outputSchema3 = {
+var outputSchema12 = {
   type: "object",
   properties: {
     console: {
@@ -781,17 +1309,17 @@ var outputSchema3 = {
   additionalProperties: false
 };
 
-class DebugLogTask extends Task2 {
+class DebugLogTask extends Task11 {
   static type = "DebugLogTask";
   static category = "Utility";
   static title = "Debug Log";
   static description = "Logs messages to the console with configurable log levels for debugging task graphs";
   static cacheable = false;
   static inputSchema() {
-    return inputSchema3;
+    return inputSchema12;
   }
   static outputSchema() {
-    return outputSchema3;
+    return outputSchema12;
   }
   async executeReactive(input, output) {
     const { log_level = DEFAULT_LOG_LEVEL, console: messages } = input;
@@ -808,16 +1336,16 @@ var debugLog = (input, config = {}) => {
   const task = new DebugLogTask({}, config);
   return task.run(input);
 };
-Workflow3.prototype.debugLog = CreateWorkflow3(DebugLogTask);
+Workflow13.prototype.debugLog = CreateWorkflow12(DebugLogTask);
 // src/task/DelayTask.ts
 import {
-  CreateWorkflow as CreateWorkflow4,
-  Task as Task3,
+  CreateWorkflow as CreateWorkflow13,
+  Task as Task12,
   TaskAbortedError as TaskAbortedError2,
-  Workflow as Workflow4
+  Workflow as Workflow14
 } from "@workglow/task-graph";
 import { sleep } from "@workglow/util";
-var inputSchema4 = {
+var inputSchema13 = {
   type: "object",
   properties: {
     delay: {
@@ -832,22 +1360,22 @@ var inputSchema4 = {
   },
   additionalProperties: false
 };
-var outputSchema4 = {
+var outputSchema13 = {
   type: "object",
   properties: {},
   additionalProperties: true
 };
 
-class DelayTask extends Task3 {
+class DelayTask extends Task12 {
   static type = "DelayTask";
   static category = "Utility";
   static title = "Delay";
   static description = "Delays execution for a specified duration with progress tracking";
   static inputSchema() {
-    return inputSchema4;
+    return inputSchema13;
   }
   static outputSchema() {
-    return outputSchema4;
+    return outputSchema13;
   }
   async execute(input, executeContext) {
     const delay = input.delay ?? 0;
@@ -871,11 +1399,11 @@ var delay = (input, config = {}) => {
   const task = new DelayTask({}, config);
   return task.run(input);
 };
-Workflow4.prototype.delay = CreateWorkflow4(DelayTask);
+Workflow14.prototype.delay = CreateWorkflow13(DelayTask);
 // src/task/InputTask.ts
-import { CreateWorkflow as CreateWorkflow5, Task as Task4, Workflow as Workflow5 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow14, Task as Task13, Workflow as Workflow15 } from "@workglow/task-graph";
 
-class InputTask extends Task4 {
+class InputTask extends Task13 {
   static type = "InputTask";
   static category = "Flow Control";
   static title = "Input";
@@ -909,9 +1437,9 @@ class InputTask extends Task4 {
     return input;
   }
 }
-Workflow5.prototype.input = CreateWorkflow5(InputTask);
+Workflow15.prototype.input = CreateWorkflow14(InputTask);
 // src/task/JavaScriptTask.ts
-import { CreateWorkflow as CreateWorkflow6, Task as Task5, Workflow as Workflow6 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow15, Task as Task14, Workflow as Workflow16 } from "@workglow/task-graph";
 
 // src/util/acorn.js
 var options;
@@ -5374,7 +5902,7 @@ Interpreter["VALUE_IN_DESCRIPTOR"] = Interpreter.VALUE_IN_DESCRIPTOR;
 Interpreter["Status"] = Interpreter.Status;
 
 // src/task/JavaScriptTask.ts
-var inputSchema5 = {
+var inputSchema14 = {
   type: "object",
   properties: {
     javascript_code: {
@@ -5388,7 +5916,7 @@ var inputSchema5 = {
   required: ["javascript_code"],
   additionalProperties: true
 };
-var outputSchema5 = {
+var outputSchema14 = {
   type: "object",
   properties: {
     output: {
@@ -5400,16 +5928,16 @@ var outputSchema5 = {
   additionalProperties: false
 };
 
-class JavaScriptTask extends Task5 {
+class JavaScriptTask extends Task14 {
   static type = "JavaScriptTask";
   static category = "Utility";
   static title = "JavaScript Interpreter";
   static description = "Executes JavaScript code in a sandboxed interpreter environment";
   static inputSchema() {
-    return inputSchema5;
+    return inputSchema14;
   }
   static outputSchema() {
-    return outputSchema5;
+    return outputSchema14;
   }
   async executeReactive(input2, output) {
     if (input2.javascript_code) {
@@ -5428,18 +5956,18 @@ class JavaScriptTask extends Task5 {
 var javaScript = (input2, config = {}) => {
   return new JavaScriptTask({}, config).run(input2);
 };
-Workflow6.prototype.javaScript = CreateWorkflow6(JavaScriptTask);
+Workflow16.prototype.javaScript = CreateWorkflow15(JavaScriptTask);
 // src/task/JsonTask.ts
 import {
   createGraphFromDependencyJSON,
   createGraphFromGraphJSON,
-  CreateWorkflow as CreateWorkflow7,
+  CreateWorkflow as CreateWorkflow16,
   Dataflow,
   GraphAsTask as GraphAsTask2,
   TaskConfigurationError as TaskConfigurationError2,
-  Workflow as Workflow7
+  Workflow as Workflow17
 } from "@workglow/task-graph";
-var inputSchema6 = {
+var inputSchema15 = {
   type: "object",
   properties: {
     json: {
@@ -5450,7 +5978,7 @@ var inputSchema6 = {
   },
   additionalProperties: false
 };
-var outputSchema6 = {
+var outputSchema15 = {
   type: "object",
   properties: {
     output: {
@@ -5467,10 +5995,10 @@ class JsonTask extends GraphAsTask2 {
   static title = "JSON Task";
   static description = "A task that creates and manages task graphs from JSON configurations";
   static inputSchema() {
-    return inputSchema6;
+    return inputSchema15;
   }
   static outputSchema() {
-    return outputSchema6;
+    return outputSchema15;
   }
   regenerateGraph() {
     if (!this.runInputData.json)
@@ -5504,16 +6032,16 @@ class JsonTask extends GraphAsTask2 {
 var json = (input2, config = {}) => {
   return new JsonTask({}, config).run(input2);
 };
-Workflow7.prototype.json = CreateWorkflow7(JsonTask);
+Workflow17.prototype.json = CreateWorkflow16(JsonTask);
 // src/task/LambdaTask.ts
 import {
-  CreateWorkflow as CreateWorkflow8,
+  CreateWorkflow as CreateWorkflow17,
   DATAFLOW_ALL_PORTS,
-  Task as Task6,
+  Task as Task15,
   TaskConfigurationError as TaskConfigurationError3,
-  Workflow as Workflow8
+  Workflow as Workflow18
 } from "@workglow/task-graph";
-var inputSchema7 = {
+var inputSchema16 = {
   type: "object",
   properties: {
     [DATAFLOW_ALL_PORTS]: {
@@ -5523,7 +6051,7 @@ var inputSchema7 = {
   },
   additionalProperties: true
 };
-var outputSchema7 = {
+var outputSchema16 = {
   type: "object",
   properties: {
     [DATAFLOW_ALL_PORTS]: {
@@ -5534,17 +6062,17 @@ var outputSchema7 = {
   additionalProperties: true
 };
 
-class LambdaTask extends Task6 {
+class LambdaTask extends Task15 {
   static type = "LambdaTask";
   static title = "Lambda Task";
   static description = "A task that wraps a provided function and its input";
   static category = "Hidden";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema7;
+    return inputSchema16;
   }
   static outputSchema() {
-    return outputSchema7;
+    return outputSchema16;
   }
   constructor(input2 = {}, config = {}) {
     if (!config.execute && !config.executeReactive) {
@@ -5582,15 +6110,15 @@ function lambda(input2, config) {
   const task = new LambdaTask(input2, config);
   return task.run();
 }
-Workflow8.prototype.lambda = CreateWorkflow8(LambdaTask);
+Workflow18.prototype.lambda = CreateWorkflow17(LambdaTask);
 // src/task/MergeTask.ts
-import { CreateWorkflow as CreateWorkflow9, Task as Task7, Workflow as Workflow9 } from "@workglow/task-graph";
-var inputSchema8 = {
+import { CreateWorkflow as CreateWorkflow18, Task as Task16, Workflow as Workflow19 } from "@workglow/task-graph";
+var inputSchema17 = {
   type: "object",
   properties: {},
   additionalProperties: true
 };
-var outputSchema8 = {
+var outputSchema17 = {
   type: "object",
   properties: {
     output: {
@@ -5602,17 +6130,17 @@ var outputSchema8 = {
   additionalProperties: false
 };
 
-class MergeTask extends Task7 {
+class MergeTask extends Task16 {
   static type = "MergeTask";
   static category = "Utility";
   static title = "Merge";
   static description = "Merges multiple inputs into a single array output";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema8;
+    return inputSchema17;
   }
   static outputSchema() {
-    return outputSchema8;
+    return outputSchema17;
   }
   async execute(input2, _context) {
     const keys = Object.keys(input2).sort();
@@ -5626,11 +6154,11 @@ var merge = (input2, config = {}) => {
   const task = new MergeTask({}, config);
   return task.run(input2);
 };
-Workflow9.prototype.merge = CreateWorkflow9(MergeTask);
+Workflow19.prototype.merge = CreateWorkflow18(MergeTask);
 // src/task/OutputTask.ts
-import { CreateWorkflow as CreateWorkflow10, Task as Task8, Workflow as Workflow10 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow19, Task as Task17, Workflow as Workflow20 } from "@workglow/task-graph";
 
-class OutputTask extends Task8 {
+class OutputTask extends Task17 {
   static type = "OutputTask";
   static category = "Flow Control";
   static title = "Output";
@@ -5664,10 +6192,10 @@ class OutputTask extends Task8 {
     return input2;
   }
 }
-Workflow10.prototype.output = CreateWorkflow10(OutputTask);
+Workflow20.prototype.output = CreateWorkflow19(OutputTask);
 // src/task/SplitTask.ts
-import { CreateWorkflow as CreateWorkflow11, Task as Task9, Workflow as Workflow11 } from "@workglow/task-graph";
-var inputSchema9 = {
+import { CreateWorkflow as CreateWorkflow20, Task as Task18, Workflow as Workflow21 } from "@workglow/task-graph";
+var inputSchema18 = {
   type: "object",
   properties: {
     input: {
@@ -5677,13 +6205,13 @@ var inputSchema9 = {
   },
   additionalProperties: false
 };
-var outputSchema9 = {
+var outputSchema18 = {
   type: "object",
   properties: {},
   additionalProperties: true
 };
 
-class SplitTask extends Task9 {
+class SplitTask extends Task18 {
   static type = "SplitTask";
   static category = "Utility";
   static title = "Split";
@@ -5691,13 +6219,13 @@ class SplitTask extends Task9 {
   static hasDynamicSchemas = true;
   static cacheable = false;
   static inputSchema() {
-    return inputSchema9;
+    return inputSchema18;
   }
   static outputSchema() {
-    return outputSchema9;
+    return outputSchema18;
   }
   outputSchema() {
-    return outputSchema9;
+    return outputSchema18;
   }
   async executeReactive(input2) {
     const inputValue = input2.input;
@@ -5716,7 +6244,528 @@ var split = (input2, config = {}) => {
   const task = new SplitTask({}, config);
   return task.run(input2);
 };
-Workflow11.prototype.split = CreateWorkflow11(SplitTask);
+Workflow21.prototype.split = CreateWorkflow20(SplitTask);
+// src/task/scalar/ScalarAbsTask.ts
+import { CreateWorkflow as CreateWorkflow21, Task as Task19, Workflow as Workflow22 } from "@workglow/task-graph";
+var inputSchema19 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "number",
+      title: "Value",
+      description: "Input number"
+    }
+  },
+  required: ["value"],
+  additionalProperties: false
+};
+var outputSchema19 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Absolute value"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarAbsTask extends Task19 {
+  static type = "ScalarAbsTask";
+  static category = "Math";
+  static title = "Abs";
+  static description = "Returns the absolute value of a number";
+  static inputSchema() {
+    return inputSchema19;
+  }
+  static outputSchema() {
+    return outputSchema19;
+  }
+  async execute(input2, _context) {
+    return { result: Math.abs(input2.value) };
+  }
+}
+Workflow22.prototype.scalarAbs = CreateWorkflow21(ScalarAbsTask);
+// src/task/scalar/ScalarCeilTask.ts
+import { CreateWorkflow as CreateWorkflow22, Task as Task20, Workflow as Workflow23 } from "@workglow/task-graph";
+var inputSchema20 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "number",
+      title: "Value",
+      description: "Input number"
+    }
+  },
+  required: ["value"],
+  additionalProperties: false
+};
+var outputSchema20 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Ceiling value"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarCeilTask extends Task20 {
+  static type = "ScalarCeilTask";
+  static category = "Math";
+  static title = "Ceil";
+  static description = "Returns the smallest integer greater than or equal to a number";
+  static inputSchema() {
+    return inputSchema20;
+  }
+  static outputSchema() {
+    return outputSchema20;
+  }
+  async execute(input2, _context) {
+    return { result: Math.ceil(input2.value) };
+  }
+}
+Workflow23.prototype.scalarCeil = CreateWorkflow22(ScalarCeilTask);
+// src/task/scalar/ScalarFloorTask.ts
+import { CreateWorkflow as CreateWorkflow23, Task as Task21, Workflow as Workflow24 } from "@workglow/task-graph";
+var inputSchema21 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "number",
+      title: "Value",
+      description: "Input number"
+    }
+  },
+  required: ["value"],
+  additionalProperties: false
+};
+var outputSchema21 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Floored value"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarFloorTask extends Task21 {
+  static type = "ScalarFloorTask";
+  static category = "Math";
+  static title = "Floor";
+  static description = "Returns the largest integer less than or equal to a number";
+  static inputSchema() {
+    return inputSchema21;
+  }
+  static outputSchema() {
+    return outputSchema21;
+  }
+  async execute(input2, _context) {
+    return { result: Math.floor(input2.value) };
+  }
+}
+Workflow24.prototype.scalarFloor = CreateWorkflow23(ScalarFloorTask);
+// src/task/scalar/ScalarMaxTask.ts
+import { CreateWorkflow as CreateWorkflow24, Task as Task22, Workflow as Workflow25 } from "@workglow/task-graph";
+var inputSchema22 = {
+  type: "object",
+  properties: {
+    values: {
+      type: "array",
+      items: { type: "number" },
+      title: "Values",
+      description: "Array of numbers"
+    }
+  },
+  required: ["values"],
+  additionalProperties: false
+};
+var outputSchema22 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Maximum value"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarMaxTask extends Task22 {
+  static type = "ScalarMaxTask";
+  static category = "Math";
+  static title = "Max";
+  static description = "Returns the largest of the given numbers";
+  static inputSchema() {
+    return inputSchema22;
+  }
+  static outputSchema() {
+    return outputSchema22;
+  }
+  async execute(input2, _context) {
+    return { result: Math.max(...input2.values) };
+  }
+}
+Workflow25.prototype.scalarMax = CreateWorkflow24(ScalarMaxTask);
+// src/task/scalar/ScalarMinTask.ts
+import { CreateWorkflow as CreateWorkflow25, Task as Task23, Workflow as Workflow26 } from "@workglow/task-graph";
+var inputSchema23 = {
+  type: "object",
+  properties: {
+    values: {
+      type: "array",
+      items: { type: "number" },
+      title: "Values",
+      description: "Array of numbers"
+    }
+  },
+  required: ["values"],
+  additionalProperties: false
+};
+var outputSchema23 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Minimum value"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarMinTask extends Task23 {
+  static type = "ScalarMinTask";
+  static category = "Math";
+  static title = "Min";
+  static description = "Returns the smallest of the given numbers";
+  static inputSchema() {
+    return inputSchema23;
+  }
+  static outputSchema() {
+    return outputSchema23;
+  }
+  async execute(input2, _context) {
+    return { result: Math.min(...input2.values) };
+  }
+}
+Workflow26.prototype.scalarMin = CreateWorkflow25(ScalarMinTask);
+// src/task/scalar/ScalarRoundTask.ts
+import { CreateWorkflow as CreateWorkflow26, Task as Task24, Workflow as Workflow27 } from "@workglow/task-graph";
+var inputSchema24 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "number",
+      title: "Value",
+      description: "Input number"
+    }
+  },
+  required: ["value"],
+  additionalProperties: false
+};
+var outputSchema24 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Rounded value"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarRoundTask extends Task24 {
+  static type = "ScalarRoundTask";
+  static category = "Math";
+  static title = "Round";
+  static description = "Returns the value of a number rounded to the nearest integer";
+  static inputSchema() {
+    return inputSchema24;
+  }
+  static outputSchema() {
+    return outputSchema24;
+  }
+  async execute(input2, _context) {
+    return { result: Math.round(input2.value) };
+  }
+}
+Workflow27.prototype.scalarRound = CreateWorkflow26(ScalarRoundTask);
+// src/task/scalar/ScalarTruncTask.ts
+import { CreateWorkflow as CreateWorkflow27, Task as Task25, Workflow as Workflow28 } from "@workglow/task-graph";
+var inputSchema25 = {
+  type: "object",
+  properties: {
+    value: {
+      type: "number",
+      title: "Value",
+      description: "Input number"
+    }
+  },
+  required: ["value"],
+  additionalProperties: false
+};
+var outputSchema25 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Truncated value"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class ScalarTruncTask extends Task25 {
+  static type = "ScalarTruncTask";
+  static category = "Math";
+  static title = "Truncate";
+  static description = "Returns the integer part of a number by removing fractional digits";
+  static inputSchema() {
+    return inputSchema25;
+  }
+  static outputSchema() {
+    return outputSchema25;
+  }
+  async execute(input2, _context) {
+    return { result: Math.trunc(input2.value) };
+  }
+}
+Workflow28.prototype.scalarTrunc = CreateWorkflow27(ScalarTruncTask);
+// src/task/vector/VectorDistanceTask.ts
+import { CreateWorkflow as CreateWorkflow28, Task as Task26, Workflow as Workflow29 } from "@workglow/task-graph";
+import {
+  TypedArraySchema as TypedArraySchema5
+} from "@workglow/util";
+var inputSchema26 = {
+  type: "object",
+  properties: {
+    vectors: {
+      type: "array",
+      items: TypedArraySchema5({
+        title: "Vector",
+        description: "Vector for distance computation"
+      }),
+      title: "Vectors",
+      description: "Array of two vectors to compute Euclidean distance"
+    }
+  },
+  required: ["vectors"],
+  additionalProperties: false
+};
+var outputSchema26 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Euclidean distance between vectors"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class VectorDistanceTask extends Task26 {
+  static type = "VectorDistanceTask";
+  static category = "Vector";
+  static title = "Distance";
+  static description = "Returns the Euclidean distance between the first two vectors";
+  static inputSchema() {
+    return inputSchema26;
+  }
+  static outputSchema() {
+    return outputSchema26;
+  }
+  async execute(input2, _context) {
+    const { vectors } = input2;
+    if (vectors.length < 2) {
+      throw new Error("Exactly two vectors are required for distance");
+    }
+    const [a, b] = vectors;
+    if (a.length !== b.length) {
+      throw new Error("Vectors must have the same length");
+    }
+    const diffs = Array.from({ length: a.length }, (_, i) => {
+      const d = Number(a[i]) - Number(b[i]);
+      return d * d;
+    });
+    return { result: Math.sqrt(sumPrecise(diffs)) };
+  }
+}
+Workflow29.prototype.vectorDistance = CreateWorkflow28(VectorDistanceTask);
+// src/task/vector/VectorDotProductTask.ts
+import { CreateWorkflow as CreateWorkflow29, Task as Task27, Workflow as Workflow30 } from "@workglow/task-graph";
+import {
+  TypedArraySchema as TypedArraySchema6
+} from "@workglow/util";
+var inputSchema27 = {
+  type: "object",
+  properties: {
+    vectors: {
+      type: "array",
+      items: TypedArraySchema6({
+        title: "Vector",
+        description: "Vector for dot product"
+      }),
+      title: "Vectors",
+      description: "Array of two vectors to compute dot product"
+    }
+  },
+  required: ["vectors"],
+  additionalProperties: false
+};
+var outputSchema27 = {
+  type: "object",
+  properties: {
+    result: {
+      type: "number",
+      title: "Result",
+      description: "Dot product of the vectors"
+    }
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class VectorDotProductTask extends Task27 {
+  static type = "VectorDotProductTask";
+  static category = "Vector";
+  static title = "Dot Product";
+  static description = "Returns the dot (inner) product of the first two vectors";
+  static inputSchema() {
+    return inputSchema27;
+  }
+  static outputSchema() {
+    return outputSchema27;
+  }
+  async execute(input2, _context) {
+    const { vectors } = input2;
+    if (vectors.length < 2) {
+      throw new Error("Exactly two vectors are required for dot product");
+    }
+    const [a, b] = vectors;
+    if (a.length !== b.length) {
+      throw new Error("Vectors must have the same length");
+    }
+    const products = Array.from({ length: a.length }, (_, i) => Number(a[i]) * Number(b[i]));
+    return { result: sumPrecise(products) };
+  }
+}
+Workflow30.prototype.vectorDotProduct = CreateWorkflow29(VectorDotProductTask);
+// src/task/vector/VectorNormalizeTask.ts
+import { CreateWorkflow as CreateWorkflow30, Task as Task28, Workflow as Workflow31 } from "@workglow/task-graph";
+import {
+  TypedArraySchema as TypedArraySchema7,
+  normalize
+} from "@workglow/util";
+var inputSchema28 = {
+  type: "object",
+  properties: {
+    vector: TypedArraySchema7({
+      title: "Vector",
+      description: "Input vector to normalize"
+    })
+  },
+  required: ["vector"],
+  additionalProperties: false
+};
+var outputSchema28 = {
+  type: "object",
+  properties: {
+    result: TypedArraySchema7({
+      title: "Result",
+      description: "L2-normalized vector"
+    })
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class VectorNormalizeTask extends Task28 {
+  static type = "VectorNormalizeTask";
+  static category = "Vector";
+  static title = "Normalize";
+  static description = "Returns the L2-normalized (unit length) vector";
+  static inputSchema() {
+    return inputSchema28;
+  }
+  static outputSchema() {
+    return outputSchema28;
+  }
+  async execute(input2, _context) {
+    return { result: normalize(input2.vector) };
+  }
+}
+Workflow31.prototype.vectorNormalize = CreateWorkflow30(VectorNormalizeTask);
+// src/task/vector/VectorScaleTask.ts
+import { CreateWorkflow as CreateWorkflow31, Task as Task29, Workflow as Workflow32 } from "@workglow/task-graph";
+import {
+  createTypedArrayFrom as createTypedArrayFrom5,
+  TypedArraySchema as TypedArraySchema8
+} from "@workglow/util";
+var inputSchema29 = {
+  type: "object",
+  properties: {
+    vector: TypedArraySchema8({
+      title: "Vector",
+      description: "Input vector"
+    }),
+    scalar: {
+      type: "number",
+      title: "Scalar",
+      description: "Scalar multiplier"
+    }
+  },
+  required: ["vector", "scalar"],
+  additionalProperties: false
+};
+var outputSchema29 = {
+  type: "object",
+  properties: {
+    result: TypedArraySchema8({
+      title: "Result",
+      description: "Scaled vector"
+    })
+  },
+  required: ["result"],
+  additionalProperties: false
+};
+
+class VectorScaleTask extends Task29 {
+  static type = "VectorScaleTask";
+  static category = "Vector";
+  static title = "Scale";
+  static description = "Multiplies each element of a vector by a scalar";
+  static inputSchema() {
+    return inputSchema29;
+  }
+  static outputSchema() {
+    return outputSchema29;
+  }
+  async execute(input2, _context) {
+    const { vector, scalar } = input2;
+    const values = Array.from(vector, (v) => Number(v) * scalar);
+    return { result: createTypedArrayFrom5([vector], values) };
+  }
+}
+Workflow32.prototype.vectorScale = CreateWorkflow31(VectorScaleTask);
 
 // src/common.ts
 import { TaskRegistry } from "@workglow/task-graph";
@@ -5731,7 +6780,27 @@ var registerCommonTasks = () => {
     LambdaTask,
     MergeTask,
     OutputTask,
-    SplitTask
+    SplitTask,
+    ScalarAbsTask,
+    ScalarAddTask,
+    ScalarCeilTask,
+    ScalarDivideTask,
+    ScalarFloorTask,
+    ScalarMaxTask,
+    ScalarMinTask,
+    ScalarMultiplyTask,
+    ScalarRoundTask,
+    ScalarSubtractTask,
+    ScalarSumTask,
+    ScalarTruncTask,
+    VectorSumTask,
+    VectorDistanceTask,
+    VectorDivideTask,
+    VectorDotProductTask,
+    VectorMultiplyTask,
+    VectorNormalizeTask,
+    VectorScaleTask,
+    VectorSubtractTask
   ];
   tasks.map(TaskRegistry.registerTask);
   return tasks;
@@ -5751,8 +6820,28 @@ export {
   fetchUrl,
   delay,
   debugLog,
+  VectorSumTask,
+  VectorSubtractTask,
+  VectorScaleTask,
+  VectorNormalizeTask,
+  VectorMultiplyTask,
+  VectorDotProductTask,
+  VectorDivideTask,
+  VectorDistanceTask,
   TypeReplicateArray,
   SplitTask,
+  ScalarTruncTask,
+  ScalarSumTask,
+  ScalarSubtractTask,
+  ScalarRoundTask,
+  ScalarMultiplyTask,
+  ScalarMinTask,
+  ScalarMaxTask,
+  ScalarFloorTask,
+  ScalarDivideTask,
+  ScalarCeilTask,
+  ScalarAddTask,
+  ScalarAbsTask,
   OutputTask,
   MergeTask,
   LambdaTask,
@@ -5767,4 +6856,4 @@ export {
   ArrayTask
 };
 
-//# debugId=D326EDEDA4D6BDB564756E2164756E21
+//# debugId=1C4F2D27323C353864756E2164756E21