@workglow/task-graph 0.2.23 → 0.2.25

package/dist/bun.js

@@ -1133,26 +1133,159 @@ function addBoundaryNodesToDependencyJson(items, graph) {
   }
   return [...prependItems, ...items, ...appendItems];
 }
+var TYPED_ARRAY_FORMAT_PREFIX = "TypedArray";
+function schemaHasTypedArrayFormat(schema) {
+  if (typeof schema === "boolean")
+    return false;
+  if (!schema || typeof schema !== "object" || Array.isArray(schema))
+    return false;
+  const s = schema;
+  if (typeof s.format === "string" && s.format.startsWith(TYPED_ARRAY_FORMAT_PREFIX)) {
+    return true;
+  }
+  const checkUnion = (schemas) => {
+    if (!Array.isArray(schemas))
+      return false;
+    return schemas.some((sub) => schemaHasTypedArrayFormat(sub));
+  };
+  if (checkUnion(s.oneOf) || checkUnion(s.anyOf))
+    return true;
+  const items = s.items;
+  if (items && typeof items === "object" && !Array.isArray(items)) {
+    if (schemaHasTypedArrayFormat(items))
+      return true;
+  }
+  return false;
+}
+function hasVectorOutput(task) {
+  const outputSchema = task.outputSchema();
+  if (typeof outputSchema === "boolean" || !outputSchema?.properties)
+    return false;
+  return Object.values(outputSchema.properties).some((prop) => schemaHasTypedArrayFormat(prop));
+}
+function hasVectorLikeInput(input) {
+  if (!input || typeof input !== "object")
+    return false;
+  const v = input.vectors;
+  return Array.isArray(v) && v.length > 0 && typeof v[0] === "object" && v[0] !== null && ArrayBuffer.isView(v[0]);
+}
+function updateBoundaryTaskSchemas(graph) {
+  const tasks = graph.getTasks();
+  for (const task of tasks) {
+    if (task.type === "InputTask") {
+      const existingConfig = task.config;
+      const existingSchema = existingConfig?.inputSchema ?? existingConfig?.outputSchema;
+      if (existingSchema && typeof existingSchema === "object" && existingSchema["x-ui-manual"] === true) {
+        continue;
+      }
+      const outgoing = graph.getTargetDataflows(task.id);
+      if (outgoing.length === 0)
+        continue;
+      const properties = {};
+      const required = [];
+      for (const df of outgoing) {
+        const targetTask = graph.getTask(df.targetTaskId);
+        if (!targetTask)
+          continue;
+        const targetSchema = targetTask.inputSchema();
+        if (typeof targetSchema === "boolean")
+          continue;
+        const prop = targetSchema.properties?.[df.targetTaskPortId];
+        if (prop && typeof prop !== "boolean") {
+          properties[df.sourceTaskPortId] = prop;
+          if (targetSchema.required?.includes(df.targetTaskPortId)) {
+            if (!required.includes(df.sourceTaskPortId)) {
+              required.push(df.sourceTaskPortId);
+            }
+          }
+        }
+      }
+      const schema = {
+        type: "object",
+        properties,
+        ...required.length > 0 ? { required } : {},
+        additionalProperties: false
+      };
+      task.config = {
+        ...task.config,
+        inputSchema: schema,
+        outputSchema: schema
+      };
+    }
+    if (task.type === "OutputTask") {
+      const incoming = graph.getSourceDataflows(task.id);
+      if (incoming.length === 0)
+        continue;
+      const properties = {};
+      const required = [];
+      for (const df of incoming) {
+        const sourceTask = graph.getTask(df.sourceTaskId);
+        if (!sourceTask)
+          continue;
+        const sourceSchema = sourceTask.outputSchema();
+        if (typeof sourceSchema === "boolean")
+          continue;
+        let prop = sourceSchema.properties?.[df.sourceTaskPortId];
+        let propRequired = sourceSchema.required?.includes(df.sourceTaskPortId) ?? false;
+        if (!prop && sourceSchema.additionalProperties === true && sourceTask.constructor.passthroughInputsToOutputs === true) {
+          const upstreamDfs = graph.getSourceDataflows(sourceTask.id);
+          for (const udf of upstreamDfs) {
+            if (udf.targetTaskPortId !== df.sourceTaskPortId)
+              continue;
+            const upstreamTask = graph.getTask(udf.sourceTaskId);
+            if (!upstreamTask)
+              continue;
+            const upstreamSchema = upstreamTask.outputSchema();
+            if (typeof upstreamSchema === "boolean")
+              continue;
+            prop = upstreamSchema.properties?.[udf.sourceTaskPortId];
+            if (prop) {
+              propRequired = upstreamSchema.required?.includes(udf.sourceTaskPortId) ?? false;
+              break;
+            }
+          }
+        }
+        if (prop && typeof prop !== "boolean") {
+          properties[df.targetTaskPortId] = prop;
+          if (propRequired && !required.includes(df.targetTaskPortId)) {
+            required.push(df.targetTaskPortId);
+          }
+        }
+      }
+      const schema = {
+        type: "object",
+        properties,
+        ...required.length > 0 ? { required } : {},
+        additionalProperties: false
+      };
+      task.config = {
+        ...task.config,
+        inputSchema: schema,
+        outputSchema: schema
+      };
+    }
+  }
+}
 // src/task-graph/TaskGraph.ts
-import { EventEmitter as EventEmitter4, uuid4 as uuid44 } from "@workglow/util";
+import { EventEmitter as EventEmitter4, uuid4 as uuid45 } from "@workglow/util";
 import { DirectedAcyclicGraph } from "@workglow/util/graph";
 
 // src/task/GraphAsTask.ts
-import { getLogger as getLogger4 } from "@workglow/util";
+import { getLogger as getLogger6 } from "@workglow/util";
 import { CycleError } from "@workglow/util/graph";
 import { compileSchema as compileSchema2 } from "@workglow/util/schema";
 
 // src/task-graph/TaskGraphRunner.ts
 import {
   collectPropertyValues,
-  getLogger as getLogger3,
+  getLogger as getLogger5,
   getTelemetryProvider as getTelemetryProvider2,
   globalServiceRegistry as globalServiceRegistry3,
+  ResourceScope as ResourceScope2,
   ServiceRegistry as ServiceRegistry2,
   SpanStatusCode as SpanStatusCode2,
-  uuid4 as uuid43
+  uuid4 as uuid44
 } from "@workglow/util";
-import { previewSource } from "@workglow/util/media";
 
 // src/storage/TaskOutputRepository.ts
 import { createServiceToken as createServiceToken2, EventEmitter as EventEmitter2 } from "@workglow/util";
@@ -1184,144 +1317,192 @@ class TaskOutputRepository {
   }
 }
 
-// src/task/ConditionalTask.ts
-import { getLogger as getLogger2 } from "@workglow/util";
+// src/task/EntitlementEnforcer.ts
+import { createServiceToken as createServiceToken4 } from "@workglow/util";
 
-// src/task/ConditionUtils.ts
-function evaluateCondition(fieldValue, operator, compareValue) {
-  if (fieldValue === null || fieldValue === undefined) {
-    switch (operator) {
-      case "is_empty":
-        return true;
-      case "is_not_empty":
-        return false;
-      case "is_true":
-        return false;
-      case "is_false":
-        return true;
-      default:
-        return false;
-    }
-  }
-  const strValue = String(fieldValue);
-  const numValue = Number(fieldValue);
-  switch (operator) {
-    case "equals":
-      if (!isNaN(numValue) && !isNaN(Number(compareValue))) {
-        return numValue === Number(compareValue);
-      }
-      return strValue === compareValue;
-    case "not_equals":
-      if (!isNaN(numValue) && !isNaN(Number(compareValue))) {
-        return numValue !== Number(compareValue);
-      }
-      return strValue !== compareValue;
-    case "greater_than":
-      return numValue > Number(compareValue);
-    case "greater_or_equal":
-      return numValue >= Number(compareValue);
-    case "less_than":
-      return numValue < Number(compareValue);
-    case "less_or_equal":
-      return numValue <= Number(compareValue);
-    case "contains":
-      return strValue.toLowerCase().includes(compareValue.toLowerCase());
-    case "starts_with":
-      return strValue.toLowerCase().startsWith(compareValue.toLowerCase());
-    case "ends_with":
-      return strValue.toLowerCase().endsWith(compareValue.toLowerCase());
-    case "is_empty":
-      return strValue === "" || Array.isArray(fieldValue) && fieldValue.length === 0;
-    case "is_not_empty":
-      return strValue !== "" && !(Array.isArray(fieldValue) && fieldValue.length === 0);
-    case "is_true":
-      return Boolean(fieldValue) === true;
-    case "is_false":
-      return Boolean(fieldValue) === false;
-    default:
-      return false;
-  }
+// src/task/EntitlementPolicy.ts
+var EMPTY_POLICY = Object.freeze({
+  deny: Object.freeze([]),
+  grant: Object.freeze([]),
+  ask: Object.freeze([])
+});
+function ruleCovers(rule, required) {
+  if (!entitlementCovers(rule.id, required.id))
+    return false;
+  return grantCoversResources(rule, required);
 }
-function getNestedValue(obj, path) {
-  const parts = path.split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current === null || current === undefined || typeof current !== "object") {
-      return;
+function evaluatePolicy(policy, required) {
+  const results = [];
+  for (const entitlement of required.entitlements) {
+    if (entitlement.optional)
+      continue;
+    const denyMatch = policy.deny.find((rule) => ruleCovers(rule, entitlement));
+    if (denyMatch) {
+      results.push({ verdict: "denied", entitlement, matchedRule: denyMatch });
+      continue;
     }
-    current = current[part];
-  }
-  return current;
-}
-
-// src/task/Task.ts
-import { deepEqual, EventEmitter as EventEmitter3, uuid4 as uuid42 } from "@workglow/util";
-import { compileSchema } from "@workglow/util/schema";
-
-// src/task/TaskRunner.ts
-import {
-  getLogger,
-  getTelemetryProvider,
-  globalServiceRegistry as globalServiceRegistry2,
-  SpanStatusCode
-} from "@workglow/util";
-import { getPortCodec } from "@workglow/util";
-
-// src/task/StreamTypes.ts
-function getPortStreamMode(schema, portId) {
-  if (typeof schema === "boolean")
-    return "none";
-  const prop = schema.properties?.[portId];
-  if (!prop || typeof prop === "boolean")
-    return "none";
-  const xStream = prop["x-stream"];
-  if (xStream === "append" || xStream === "replace" || xStream === "object")
-    return xStream;
-  return "none";
-}
-function getStreamingPorts(schema) {
-  if (typeof schema === "boolean")
-    return [];
-  const props = schema.properties;
-  if (!props)
-    return [];
-  const result = [];
-  for (const [name, prop] of Object.entries(props)) {
-    if (!prop || typeof prop === "boolean")
+    const grantMatch = policy.grant.find((rule) => ruleCovers(rule, entitlement));
+    if (grantMatch) {
+      results.push({ verdict: "granted", entitlement, matchedRule: grantMatch });
+      continue;
+    }
+    const askMatch = policy.ask.find((rule) => ruleCovers(rule, entitlement));
+    if (askMatch) {
+      results.push({ verdict: "ask", entitlement, matchedRule: askMatch });
       continue;
-    const xStream = prop["x-stream"];
-    if (xStream === "append" || xStream === "replace" || xStream === "object") {
-      result.push({ port: name, mode: xStream });
     }
+    results.push({ verdict: "denied", entitlement });
   }
+  return results;
+}
+function can(policy, id, resources) {
+  const required = resources !== undefined ? { id, resources } : { id };
+  const [result] = evaluatePolicy(policy, { entitlements: [required] });
   return result;
 }
-function getOutputStreamMode(outputSchema) {
-  const ports = getStreamingPorts(outputSchema);
-  if (ports.length === 0)
-    return "none";
-  const mode = ports[0].mode;
-  for (let i = 1;i < ports.length; i++) {
-    if (ports[i].mode !== mode) {
-      return "mixed";
-    }
+
+// src/task/EntitlementResolver.ts
+import { createServiceToken as createServiceToken3 } from "@workglow/util";
+var PERMISSIVE_RESOLVER = {
+  lookup: () => "grant",
+  prompt: async () => "grant",
+  save: () => {}
+};
+var DENY_ALL_RESOLVER = {
+  lookup: () => "deny",
+  prompt: async () => "deny",
+  save: () => {}
+};
+var ENTITLEMENT_RESOLVER = createServiceToken3("workglow.entitlementResolver");
+
+// src/task/EntitlementEnforcer.ts
+function formatEntitlementDenial(denial) {
+  switch (denial.reason) {
+    case "policy-deny":
+      return `${denial.entitlement.id} (denied by rule ${denial.matchedRule.id})`;
+    case "user-deny":
+      return `${denial.entitlement.id} (denied by user)`;
+    case "default-deny":
+      return `${denial.entitlement.id} (no matching grant)`;
   }
-  return mode;
-}
-function isTaskStreamable(task) {
-  if (typeof task.executeStream !== "function")
-    return false;
-  return getOutputStreamMode(task.outputSchema()) !== "none";
 }
-function getAppendPortId(schema) {
-  if (typeof schema === "boolean")
-    return;
-  const props = schema.properties;
-  if (!props)
-    return;
-  for (const [name, prop] of Object.entries(props)) {
-    if (!prop || typeof prop === "boolean")
-      continue;
+var PERMISSIVE_ENFORCER = {
+  checkAll: async () => [],
+  checkTask: async () => []
+};
+function createPolicyEnforcer(policy, resolver = PERMISSIVE_RESOLVER) {
+  async function resolveAsks(required, taskType, taskId) {
+    const results = evaluatePolicy(policy, required);
+    const denied = [];
+    for (const result of results) {
+      if (result.verdict === "denied") {
+        if (result.matchedRule) {
+          denied.push({
+            entitlement: result.entitlement,
+            reason: "policy-deny",
+            matchedRule: result.matchedRule
+          });
+        } else {
+          denied.push({ entitlement: result.entitlement, reason: "default-deny" });
+        }
+      } else if (result.verdict === "ask") {
+        const request = {
+          entitlement: result.entitlement,
+          taskType: taskType ?? "unknown",
+          taskId: taskId ?? "unknown"
+        };
+        let answer = resolver.lookup(request);
+        if (answer === undefined) {
+          answer = await resolver.prompt(request);
+          resolver.save(request, answer);
+        }
+        if (answer === "deny") {
+          if (!result.matchedRule) {
+            throw new Error(`Invariant violation: ask verdict for "${result.entitlement.id}" is missing matchedRule`);
+          }
+          denied.push({
+            entitlement: result.entitlement,
+            reason: "user-deny",
+            matchedRule: result.matchedRule
+          });
+        }
+      }
+    }
+    return denied;
+  }
+  return {
+    async checkAll(required) {
+      return resolveAsks(required);
+    },
+    async checkTask(task) {
+      const entitlements = task.entitlements();
+      return resolveAsks(entitlements, task.constructor.type, task.id);
+    }
+  };
+}
+function createScopedEnforcer(grants) {
+  return createPolicyEnforcer({ deny: [], grant: grants, ask: [] });
+}
+function createGrantListEnforcer(grants) {
+  return createScopedEnforcer(grants.map((id) => ({ id })));
+}
+var ENTITLEMENT_ENFORCER = createServiceToken4("workglow.entitlementEnforcer");
+
+// src/task/StreamTypes.ts
+function getPortStreamMode(schema, portId) {
+  if (typeof schema === "boolean")
+    return "none";
+  const prop = schema.properties?.[portId];
+  if (!prop || typeof prop === "boolean")
+    return "none";
+  const xStream = prop["x-stream"];
+  if (xStream === "append" || xStream === "replace" || xStream === "object")
+    return xStream;
+  return "none";
+}
+function getStreamingPorts(schema) {
+  if (typeof schema === "boolean")
+    return [];
+  const props = schema.properties;
+  if (!props)
+    return [];
+  const result = [];
+  for (const [name, prop] of Object.entries(props)) {
+    if (!prop || typeof prop === "boolean")
+      continue;
+    const xStream = prop["x-stream"];
+    if (xStream === "append" || xStream === "replace" || xStream === "object") {
+      result.push({ port: name, mode: xStream });
+    }
+  }
+  return result;
+}
+function getOutputStreamMode(outputSchema) {
+  const ports = getStreamingPorts(outputSchema);
+  if (ports.length === 0)
+    return "none";
+  const mode = ports[0].mode;
+  for (let i = 1;i < ports.length; i++) {
+    if (ports[i].mode !== mode) {
+      return "mixed";
+    }
+  }
+  return mode;
+}
+function isTaskStreamable(task) {
+  if (typeof task.executeStream !== "function")
+    return false;
+  return getOutputStreamMode(task.outputSchema()) !== "none";
+}
+function getAppendPortId(schema) {
+  if (typeof schema === "boolean")
+    return;
+  const props = schema.properties;
+  if (!props)
+    return;
+  for (const [name, prop] of Object.entries(props)) {
+    if (!prop || typeof prop === "boolean")
+      continue;
     if (prop["x-stream"] === "append")
       return name;
   }
@@ -1368,296 +1549,337 @@ function hasStructuredOutput(schema) {
   return getStructuredOutputSchemas(schema).size > 0;
 }
 
-// src/task/TaskRunner.ts
-async function serializeOutputPorts(output, schema) {
-  if (!schema?.properties)
-    return output;
-  const out = { ...output };
-  for (const [key, prop] of Object.entries(schema.properties)) {
-    const codec = prop.format ? getPortCodec(prop.format) : undefined;
-    if (codec && out[key] !== undefined) {
-      out[key] = await codec.serialize(out[key]);
-    }
+// src/task-graph/EdgeMaterializer.ts
+import { getLogger } from "@workglow/util";
+import { previewSource } from "@workglow/util/media";
+class EdgeMaterializer {
+  graph;
+  runner;
+  constructor(graph, runner) {
+    this.graph = graph;
+    this.runner = runner;
   }
-  return out;
-}
-async function deserializeOutputPorts(output, schema) {
-  if (!schema?.properties)
-    return output;
-  const out = { ...output };
-  for (const [key, prop] of Object.entries(schema.properties)) {
-    const codec = prop.format ? getPortCodec(prop.format) : undefined;
-    if (codec && out[key] !== undefined) {
-      out[key] = await codec.deserialize(out[key]);
+  filterInputForTask(task, input) {
+    const sourceDataflows = this.graph.getSourceDataflows(task.id);
+    const connectedInputs = new Set(sourceDataflows.map((df) => df.targetTaskPortId));
+    const allPortsConnected = connectedInputs.has(DATAFLOW_ALL_PORTS);
+    const filteredInput = {};
+    for (const [key, value] of Object.entries(input)) {
+      if (!connectedInputs.has(key) && !allPortsConnected) {
+        filteredInput[key] = value;
+      }
     }
+    return filteredInput;
   }
-  return out;
-}
-async function normalizeInputsForCacheKey(inputs, schema) {
-  if (!schema?.properties)
-    return inputs;
-  const out = { ...inputs };
-  for (const [key, prop] of Object.entries(schema.properties)) {
-    const codec = prop.format ? getPortCodec(prop.format) : undefined;
-    if (codec && out[key] !== undefined) {
-      out[key] = await codec.serialize(out[key]);
+  copyInputFromEdgesToNode(task) {
+    const dataflows = this.graph.getSourceDataflows(task.id);
+    dataflows.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+    for (const dataflow of dataflows) {
+      const live = dataflow.getCurrentValue();
+      const port = dataflow.targetTaskPortId;
+      let portData;
+      if (port === DATAFLOW_ALL_PORTS) {
+        portData = live;
+      } else if (port === DATAFLOW_ERROR_PORT) {
+        portData = { [DATAFLOW_ERROR_PORT]: dataflow.error };
+      } else {
+        portData = { [port]: live };
+      }
+      this.runner.addInputData(task, portData);
     }
   }
-  return out;
-}
-function hasRunConfig(i) {
-  return i !== null && typeof i === "object" && "runConfig" in i;
-}
-
-class TaskRunner {
-  running = false;
-  previewRunning = false;
-  task;
-  abortController;
-  outputCache;
-  registry = globalServiceRegistry2;
-  resourceScope;
-  inputStreams;
-  timeoutTimer;
-  pendingTimeoutError;
-  shouldAccumulate = true;
-  telemetrySpan;
-  constructor(task) {
-    this.task = task;
-    this.own = this.own.bind(this);
-    this.handleProgress = this.handleProgress.bind(this);
-  }
-  async run(overrides = {}, config = {}) {
-    await this.handleStart(config);
-    const proto = Object.getPrototypeOf(this.task);
-    if (proto.execute === Task.prototype.execute && typeof proto.executeStream !== "function" && proto.executePreview !== Task.prototype.executePreview) {
-      throw new TaskConfigurationError(`Task "${this.task.type}" implements only executePreview() and cannot be run via run(). ` + `After the run/runPreview split, run() requires execute() (or executeStream()). ` + `See docs/technical/02-dual-mode-execution.md.`);
-    }
-    try {
-      this.task.setInput(overrides);
-      const configSchema = this.task.constructor.configSchema();
-      if (schemaHasFormatAnnotations(configSchema)) {
-        const source = this.task.originalConfig ?? this.task.config;
-        const resolved = await resolveSchemaInputs({ ...source }, configSchema, { registry: this.registry });
-        Object.assign(this.task.config, resolved);
-      }
-      const schema = this.task.constructor.inputSchema();
-      this.task.runInputData = await resolveSchemaInputs(this.task.runInputData, schema, { registry: this.registry });
-      const inputs = this.task.runInputData;
-      const isValid = await this.task.validateInput(inputs);
-      if (!isValid) {
-        throw new TaskInvalidInputError("Invalid input data");
-      }
-      if (this.abortController?.signal.aborted) {
-        await this.handleAbort();
-        throw new TaskAbortedError("Promise for task created and aborted before run");
-      }
-      let outputs;
-      const isStreamable = isTaskStreamable(this.task);
-      if (!isStreamable && typeof this.task.executeStream !== "function") {
-        const streamMode = getOutputStreamMode(this.task.outputSchema());
-        if (streamMode !== "none") {
-          getLogger().warn(`Task "${this.task.type}" declares streaming output (x-stream: "${streamMode}") ` + `but does not implement executeStream(). Falling back to non-streaming execute().`);
-        }
-      }
-      const inputSchema = this.task.constructor.inputSchema();
-      const outputSchema = this.task.constructor.outputSchema();
-      const inputsForKey = this.outputCache ? await normalizeInputsForCacheKey(inputs, inputSchema) : inputs;
-      if (this.task.cacheable) {
-        const cached = await this.outputCache?.getOutput(this.task.type, inputsForKey);
-        if (cached !== undefined) {
-          outputs = await deserializeOutputPorts(cached, outputSchema);
-          this.telemetrySpan?.addEvent("workglow.task.cache_hit");
-          if (isStreamable) {
-            this.task.runOutputData = outputs;
-            this.task.emit("stream_start");
-            this.task.emit("stream_chunk", { type: "finish", data: outputs });
-            this.task.emit("stream_end", outputs);
-          } else {
-            this.task.runOutputData = outputs;
-          }
+  async pushOutputFromNodeToEdges(node, results) {
+    const dataflows = this.graph.getTargetDataflows(node.id);
+    if (this.runner["previewRunning"] && Object.keys(results).length > 0) {
+      for (const port of Object.keys(results)) {
+        const value = results[port];
+        if (EdgeMaterializer.isImageValueShape(value)) {
+          results[port] = await previewSource(value);
         }
       }
-      if (!outputs) {
-        if (isStreamable) {
-          outputs = await this.executeStreamingTask(inputs);
-        } else {
-          outputs = await this.executeTask(inputs);
-        }
-        if (this.task.cacheable && outputs !== undefined) {
-          const wireOutputs = await serializeOutputPorts(outputs, outputSchema);
-          await this.outputCache?.saveOutput(this.task.type, inputsForKey, wireOutputs);
+    }
+    for (const dataflow of dataflows) {
+      if (dataflow.stream !== undefined)
+        continue;
+      const registry = this.runner["registry"];
+      const compatibility = dataflow.semanticallyCompatible(this.graph, dataflow, registry);
+      if (compatibility === "static") {
+        dataflow.setPortData(results);
+        await dataflow.applyTransforms(registry);
+      } else if (compatibility === "runtime") {
+        const task = this.graph.getTask(dataflow.targetTaskId);
+        const narrowed = await task.narrowInput({ ...results }, registry);
+        dataflow.setPortData(narrowed);
+        await dataflow.applyTransforms(registry);
+      } else {
+        const resultsKeys = Object.keys(results);
+        if (resultsKeys.length > 0) {
+          getLogger().warn("pushOutputFromNodeToEdge not compatible, not setting port data", {
+            dataflowId: dataflow.id,
+            compatibility,
+            resultsKeys
+          });
         }
-        this.task.runOutputData = outputs ?? {};
       }
-      await this.handleComplete();
-      return this.task.runOutputData;
-    } catch (err) {
-      await this.handleError(err);
-      throw this.task.error instanceof TaskTimeoutError ? this.task.error : err;
     }
   }
-  async runPreview(overrides = {}) {
-    if (this.task.status === TaskStatus.PROCESSING) {
-      return this.task.runOutputData;
+  pushErrorFromNodeToEdges(node) {
+    if (!node?.config?.id)
+      return;
+    this.graph.getTargetDataflows(node.id).forEach((dataflow) => {
+      dataflow.error = node.error;
+    });
+  }
+  hasErrorOutputEdges(task) {
+    const dataflows = this.graph.getTargetDataflows(task.id);
+    return dataflows.some((df) => df.sourceTaskPortId === DATAFLOW_ERROR_PORT);
+  }
+  pushErrorOutputToEdges(task) {
+    const taskError = task.error;
+    const errorData = {
+      error: taskError?.message ?? "Unknown error",
+      errorType: taskError?.constructor?.type ?? "TaskError"
+    };
+    const dataflows = this.graph.getTargetDataflows(task.id);
+    for (const df of dataflows) {
+      if (df.sourceTaskPortId === DATAFLOW_ERROR_PORT) {
+        df.value = errorData;
+        df.setStatus(TaskStatus.COMPLETED);
+      } else {
+        df.setStatus(TaskStatus.DISABLED);
+      }
     }
-    this.task.setInput(overrides);
-    const configSchema = this.task.constructor.configSchema();
-    if (schemaHasFormatAnnotations(configSchema)) {
-      const source = this.task.originalConfig ?? this.task.config;
-      const resolved = await resolveSchemaInputs({ ...source }, configSchema, { registry: this.registry });
-      Object.assign(this.task.config, resolved);
-    }
-    const schema = this.task.constructor.inputSchema();
-    this.task.runInputData = await resolveSchemaInputs(this.task.runInputData, schema, { registry: this.registry });
-    await this.handleStartPreview();
-    try {
-      const inputs = this.task.runInputData;
-      const isValid = await this.task.validateInput(inputs);
-      if (!isValid) {
-        throw new TaskInvalidInputError("Invalid input data");
-      }
-      const resultPreview = await this.executeTaskPreview(inputs);
-      if (resultPreview !== undefined) {
-        this.task.runOutputData = resultPreview;
-      }
-      await this.handleCompletePreview();
-    } catch (err) {
-      getLogger().debug("runPreview failed", { taskId: this.task.config?.id, error: err });
-      await this.handleErrorPreview();
-    } finally {
-      return this.task.runOutputData;
+    this.runner["runScheduler"].propagateDisabledStatus(this.runner["currentCtx"]);
+  }
+  resetTask(graph, task, runId) {
+    task.status = TaskStatus.PENDING;
+    task.resetInputData();
+    task.runOutputData = {};
+    task.error = undefined;
+    task.progress = 0;
+    task.runConfig = { ...task.runConfig, runnerId: runId };
+    this.runner["runScheduler"].pushStatusFromNodeToEdges(task, this.runner["currentCtx"], undefined, graph);
+    if (task?.config?.id) {
+      graph.getTargetDataflows(task.id).forEach((dataflow) => {
+        dataflow.error = task.error;
+      });
     }
+    task.emit("reset");
+    task.emit("status", task.status);
   }
-  async* runPreviewStream(overrides = {}) {
-    const graph = this.task.parentGraph;
-    const dataflowInfos = [];
-    if (graph) {
-      for (const df of graph.getSourceDataflows(this.task.id)) {
-        const upstream = graph.getTask(df.sourceTaskId);
-        if (upstream) {
-          dataflowInfos.push({
-            upstream,
-            sourcePort: df.sourceTaskPortId,
-            targetPort: df.targetTaskPortId
-          });
-        }
+  static isImageValueShape(v) {
+    if (v === null || typeof v !== "object")
+      return false;
+    const o = v;
+    return typeof o.width === "number" && typeof o.height === "number" && typeof o.previewScale === "number";
+  }
+}
+
+// src/task-graph/RunContext.ts
+import { uuid4 as uuid42 } from "@workglow/util";
+
+class RunContext {
+  runId;
+  abortController;
+  inProgressTasks = new Map;
+  inProgressFunctions = new Map;
+  failedTaskErrors = new Map;
+  telemetrySpan;
+  graphTimeoutTimer;
+  pendingGraphTimeoutError;
+  activeEnforcer;
+  parentSignalCleanup;
+  constructor(parentSignal) {
+    this.runId = uuid42();
+    this.abortController = new AbortController;
+    if (parentSignal) {
+      const onParentAbort = () => this.abortController.abort();
+      parentSignal.addEventListener("abort", onParentAbort, { once: true });
+      this.parentSignalCleanup = () => parentSignal.removeEventListener("abort", onParentAbort);
+      if (parentSignal.aborted) {
+        this.parentSignalCleanup();
+        this.parentSignalCleanup = undefined;
+        this.abortController.abort();
       }
     }
-    const upstreamTasks = new Set(dataflowInfos.map((d) => d.upstream));
-    const pendingUpstreams = new Set([...upstreamTasks].filter((u) => u.status === TaskStatus.STREAMING || u.status === TaskStatus.PENDING || u.status === TaskStatus.PROCESSING));
-    let dirty = true;
-    let wakeResolve;
-    const wakeNext = () => new Promise((resolve) => {
-      wakeResolve = resolve;
-    });
-    const wake = () => {
-      const r = wakeResolve;
-      wakeResolve = undefined;
-      if (r)
-        r();
-    };
-    const cleanupFns = [];
-    for (const upstream of pendingUpstreams) {
-      const myDataflows = dataflowInfos.filter((d) => d.upstream === upstream);
-      const onChunk = (event) => {
-        if (event.type !== "snapshot")
-          return;
-        const snapshotData = event.data;
-        if (snapshotData) {
-          for (const { sourcePort, targetPort } of myDataflows) {
-            const value = sourcePort === "*" ? snapshotData : snapshotData[sourcePort];
-            if (value !== undefined) {
-              this.task.runInputData[targetPort] = value;
-            }
-          }
-        }
-        dirty = true;
-        wake();
-      };
-      const onEnd = () => {
-        pendingUpstreams.delete(upstream);
-        wake();
-      };
-      const onStatus = (status) => {
-        if (status === TaskStatus.COMPLETED || status === TaskStatus.FAILED || status === TaskStatus.DISABLED) {
-          pendingUpstreams.delete(upstream);
-          wake();
-        }
-      };
-      upstream.on("stream_chunk", onChunk);
-      upstream.on("stream_end", onEnd);
-      upstream.on("status", onStatus);
-      cleanupFns.push(() => {
-        upstream.off("stream_chunk", onChunk);
-        upstream.off("stream_end", onEnd);
-        upstream.off("status", onStatus);
-      });
+  }
+  dispose() {
+    this.parentSignalCleanup?.();
+    this.parentSignalCleanup = undefined;
+  }
+}
+
+// src/task-graph/RunScheduler.ts
+import { getLogger as getLogger4 } from "@workglow/util";
+
+// src/task/ConditionalTask.ts
+import { getLogger as getLogger3 } from "@workglow/util";
+
+// src/task/ConditionUtils.ts
+function evaluateCondition(fieldValue, operator, compareValue) {
+  if (fieldValue === null || fieldValue === undefined) {
+    switch (operator) {
+      case "is_empty":
+        return true;
+      case "is_not_empty":
+        return false;
+      case "is_true":
+        return false;
+      case "is_false":
+        return true;
+      default:
+        return false;
     }
-    for (const upstream of [...pendingUpstreams]) {
-      if (upstream.status === TaskStatus.COMPLETED || upstream.status === TaskStatus.FAILED || upstream.status === TaskStatus.DISABLED) {
-        pendingUpstreams.delete(upstream);
+  }
+  const strValue = String(fieldValue);
+  const numValue = Number(fieldValue);
+  switch (operator) {
+    case "equals":
+      if (!isNaN(numValue) && !isNaN(Number(compareValue))) {
+        return numValue === Number(compareValue);
       }
-    }
-    try {
-      while (true) {
-        if (dirty) {
-          dirty = false;
-          try {
-            const out = await this.runPreview(overrides);
-            yield out;
-          } catch (err) {
-            getLogger().debug("runPreviewStream iteration failed", {
-              taskId: this.task.config?.id,
-              error: err
-            });
-          }
-          continue;
-        }
-        if (pendingUpstreams.size === 0)
-          return;
-        await wakeNext();
+      return strValue === compareValue;
+    case "not_equals":
+      if (!isNaN(numValue) && !isNaN(Number(compareValue))) {
+        return numValue !== Number(compareValue);
       }
-    } finally {
-      for (const off of cleanupFns)
-        off();
+      return strValue !== compareValue;
+    case "greater_than":
+      return numValue > Number(compareValue);
+    case "greater_or_equal":
+      return numValue >= Number(compareValue);
+    case "less_than":
+      return numValue < Number(compareValue);
+    case "less_or_equal":
+      return numValue <= Number(compareValue);
+    case "contains":
+      return strValue.toLowerCase().includes(compareValue.toLowerCase());
+    case "starts_with":
+      return strValue.toLowerCase().startsWith(compareValue.toLowerCase());
+    case "ends_with":
+      return strValue.toLowerCase().endsWith(compareValue.toLowerCase());
+    case "is_empty":
+      return strValue === "" || Array.isArray(fieldValue) && fieldValue.length === 0;
+    case "is_not_empty":
+      return strValue !== "" && !(Array.isArray(fieldValue) && fieldValue.length === 0);
+    case "is_true":
+      return Boolean(fieldValue) === true;
+    case "is_false":
+      return Boolean(fieldValue) === false;
+    default:
+      return false;
+  }
+}
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === undefined || typeof current !== "object") {
+      return;
     }
+    current = current[part];
   }
-  abort() {
-    if (this.task.hasChildren()) {
-      this.task.subGraph.abort();
+  return current;
+}
+
+// src/task/Task.ts
+import { deepEqual, EventEmitter as EventEmitter3, uuid4 as uuid43 } from "@workglow/util";
+import { compileSchema } from "@workglow/util/schema";
+
+// src/task/TaskRunner.ts
+import {
+  getLogger as getLogger2,
+  getTelemetryProvider,
+  globalServiceRegistry as globalServiceRegistry2,
+  ResourceScope,
+  SpanStatusCode
+} from "@workglow/util";
+
+// src/task/CacheCoordinator.ts
+import { getPortCodec } from "@workglow/util";
+
+class CacheCoordinator {
+  task;
+  constructor(task) {
+    this.task = task;
+  }
+  async buildKey(inputs, outputCache) {
+    if (!outputCache)
+      return inputs;
+    const inputSchema = this.task.constructor.inputSchema();
+    return await CacheCoordinator.normalizeInputsForCacheKey(inputs, inputSchema);
+  }
+  async lookup(keyInputs, outputCache, isStreamable, ctx) {
+    if (!outputCache || !this.task.cacheable)
+      return;
+    const cached = await outputCache.getOutput(this.task.type, keyInputs);
+    if (cached === undefined)
+      return;
+    const outputSchema = this.task.constructor.outputSchema();
+    const outputs = await CacheCoordinator.deserializeOutputPorts(cached, outputSchema);
+    ctx.telemetrySpan?.addEvent("workglow.task.cache_hit");
+    if (isStreamable) {
+      this.task.runOutputData = outputs;
+      this.task.emit("stream_start");
+      this.task.emit("stream_chunk", { type: "finish", data: outputs });
+      this.task.emit("stream_end", outputs);
+    } else {
+      this.task.runOutputData = outputs;
     }
-    this.abortController?.abort();
+    return outputs;
   }
-  own(i) {
-    const task = ensureTask(i, { isOwned: true });
-    this.task.subGraph.addTask(task);
-    if (hasRunConfig(i)) {
-      Object.assign(i.runConfig, {
-        registry: this.registry,
-        signal: this.abortController?.signal,
-        resourceScope: this.resourceScope
-      });
+  async save(keyInputs, output, outputCache) {
+    if (!outputCache || !this.task.cacheable || output === undefined)
+      return;
+    const outputSchema = this.task.constructor.outputSchema();
+    const wireOutputs = await CacheCoordinator.serializeOutputPorts(output, outputSchema);
+    await outputCache.saveOutput(this.task.type, keyInputs, wireOutputs);
+  }
+  static async serializeOutputPorts(output, schema) {
+    if (!schema?.properties)
+      return output;
+    const out = { ...output };
+    for (const [key, prop] of Object.entries(schema.properties)) {
+      const codec = prop.format ? getPortCodec(prop.format) : undefined;
+      if (codec && out[key] !== undefined) {
+        out[key] = await codec.serialize(out[key]);
+      }
     }
-    if (this.task.constructor.hasDynamicEntitlements) {
-      this.task.emit("entitlementChange", this.task.entitlements());
+    return out;
+  }
+  static async deserializeOutputPorts(output, schema) {
+    if (!schema?.properties)
+      return output;
+    const out = { ...output };
+    for (const [key, prop] of Object.entries(schema.properties)) {
+      const codec = prop.format ? getPortCodec(prop.format) : undefined;
+      if (codec && out[key] !== undefined) {
+        out[key] = await codec.deserialize(out[key]);
+      }
     }
-    return i;
+    return out;
   }
-  async executeTask(input) {
-    const result = await this.task.execute(input, {
-      signal: this.abortController.signal,
-      updateProgress: this.handleProgress.bind(this),
-      own: this.own,
-      registry: this.registry,
-      resourceScope: this.resourceScope
-    });
-    return result;
+  static async normalizeInputsForCacheKey(inputs, schema) {
+    if (!schema?.properties)
+      return inputs;
+    const out = { ...inputs };
+    for (const [key, prop] of Object.entries(schema.properties)) {
+      const codec = prop.format ? getPortCodec(prop.format) : undefined;
+      if (codec && out[key] !== undefined) {
+        out[key] = await codec.serialize(out[key]);
+      }
+    }
+    return out;
   }
-  async executeTaskPreview(input) {
-    return this.task.executePreview?.(input, { own: this.own });
+}
+
+// src/task/StreamProcessor.ts
+class StreamProcessor {
+  task;
+  constructor(task) {
+    this.task = task;
   }
-  async executeStreamingTask(input) {
+  async run(input, ctx, deps) {
     const streamMode = getOutputStreamMode(this.task.outputSchema());
     if (streamMode === "append") {
       const ports = getStreamingPorts(this.task.outputSchema());
@@ -1671,18 +1893,18 @@ class TaskRunner {
         throw new TaskError(`Task ${this.task.type} declares object streaming but no output port has x-stream: "object"`);
       }
     }
-    const accumulated = this.shouldAccumulate ? new Map : undefined;
-    const accumulatedObjects = this.shouldAccumulate ? new Map : undefined;
+    const accumulated = ctx.shouldAccumulate ? new Map : undefined;
+    const accumulatedObjects = ctx.shouldAccumulate ? new Map : undefined;
     let streamingStarted = false;
     let finalOutput;
     this.task.emit("stream_start");
     const stream = this.task.executeStream(input, {
-      signal: this.abortController.signal,
-      updateProgress: this.handleProgress.bind(this),
-      own: this.own,
-      registry: this.registry,
-      resourceScope: this.resourceScope,
-      inputStreams: this.inputStreams
+      signal: ctx.abortController.signal,
+      updateProgress: deps.onProgress,
+      own: deps.own,
+      registry: deps.registry,
+      resourceScope: deps.resourceScope,
+      inputStreams: deps.inputStreams
     });
     for await (const event of stream) {
       if (event.type === "snapshot") {
@@ -1691,7 +1913,7 @@ class TaskRunner {
       switch (event.type) {
         case "phase": {
           this.task.emit("stream_chunk", event);
-          await this.handleProgress(event.progress, event.message);
+          await deps.onProgress(event.progress, event.message);
           break;
         }
         case "text-delta": {
@@ -1799,7 +2021,7 @@ class TaskRunner {
         }
       }
     }
-    if (this.abortController?.signal.aborted) {
+    if (ctx.abortController.signal.aborted) {
       throw new TaskAbortedError("Task aborted during streaming");
     }
     if (finalOutput !== undefined) {
@@ -1808,19 +2030,296 @@ class TaskRunner {
     this.task.emit("stream_end", this.task.runOutputData);
     return this.task.runOutputData;
   }
-  async handleStart(config = {}) {
-    if (this.task.status === TaskStatus.PROCESSING)
-      return;
-    this.running = true;
-    this.task.startedAt = new Date;
-    this.task.progress = 0;
-    this.task.status = TaskStatus.PROCESSING;
-    this.abortController = new AbortController;
-    this.abortController.signal.addEventListener("abort", () => {
-      this.handleAbort();
-    });
-    const cache = config.outputCache ?? this.task.runConfig?.outputCache;
-    if (cache === true) {
+}
+
+// src/task/TaskRunContext.ts
+class TaskRunContext {
+  abortController;
+  shouldAccumulate = true;
+  telemetrySpan;
+  timeoutTimer;
+  pendingTimeoutError;
+  parentSignalCleanup;
+  constructor(parentSignal) {
+    this.abortController = new AbortController;
+    if (parentSignal) {
+      const onParentAbort = () => this.abortController.abort();
+      parentSignal.addEventListener("abort", onParentAbort, { once: true });
+      this.parentSignalCleanup = () => parentSignal.removeEventListener("abort", onParentAbort);
+      if (parentSignal.aborted) {
+        this.parentSignalCleanup();
+        this.parentSignalCleanup = undefined;
+        this.abortController.abort();
+      }
+    }
+  }
+  dispose() {
+    this.parentSignalCleanup?.();
+    this.parentSignalCleanup = undefined;
+  }
+}
+
+// src/task/TaskRunner.ts
+function hasRunConfig(i) {
+  return i !== null && typeof i === "object" && "runConfig" in i;
+}
+
+class TaskRunner {
+  running = false;
+  previewRunning = false;
+  task;
+  currentCtx;
+  outputCache;
+  cacheCoordinator;
+  streamProcessor;
+  registry = globalServiceRegistry2;
+  resourceScope;
+  ownsResourceScope = false;
+  inputStreams;
+  constructor(task) {
+    this.task = task;
+    this.own = this.own.bind(this);
+    this.handleProgress = this.handleProgress.bind(this);
+    this.cacheCoordinator = new CacheCoordinator(task);
+    this.streamProcessor = new StreamProcessor(task);
+  }
+  async run(overrides = {}, config = {}) {
+    if (this.task.status === TaskStatus.PROCESSING) {
+      throw new TaskConfigurationError(`Task "${this.task.type}" is already running. Concurrent run() calls on the same TaskRunner are not supported.`);
+    }
+    const ownsScope = config.resourceScope === undefined;
+    const effectiveConfig = ownsScope ? { ...config, resourceScope: new ResourceScope } : config;
+    this.ownsResourceScope = ownsScope;
+    try {
+      await this.handleStart(effectiveConfig);
+      const ctx = this.currentCtx;
+      const proto = Object.getPrototypeOf(this.task);
+      if (proto.execute === Task.prototype.execute && typeof proto.executeStream !== "function" && proto.executePreview !== Task.prototype.executePreview) {
+        throw new TaskConfigurationError(`Task "${this.task.type}" implements only executePreview() and cannot be run via run(). ` + `After the run/runPreview split, run() requires execute() (or executeStream()). ` + `See docs/technical/02-dual-mode-execution.md.`);
+      }
+      try {
+        this.task.setInput(overrides);
+        await this.resolveSchemas();
+        const inputs = this.task.runInputData;
+        const isValid = await this.task.validateInput(inputs);
+        if (!isValid) {
+          throw new TaskInvalidInputError("Invalid input data");
+        }
+        if (ctx.abortController.signal.aborted) {
+          await this.handleAbort();
+          throw new TaskAbortedError("Promise for task created and aborted before run");
+        }
+        const isStreamable = isTaskStreamable(this.task);
+        if (!isStreamable && typeof this.task.executeStream !== "function") {
+          const streamMode = getOutputStreamMode(this.task.outputSchema());
+          if (streamMode !== "none") {
+            getLogger2().warn(`Task "${this.task.type}" declares streaming output (x-stream: "${streamMode}") ` + `but does not implement executeStream(). Falling back to non-streaming execute().`);
+          }
+        }
+        const keyInputs = await this.cacheCoordinator.buildKey(inputs, this.outputCache);
+        let outputs = await this.cacheCoordinator.lookup(keyInputs, this.outputCache, isStreamable, ctx);
+        if (outputs === undefined) {
+          outputs = isStreamable ? await this.streamProcessor.run(inputs, ctx, {
+            registry: this.registry,
+            resourceScope: this.resourceScope,
+            inputStreams: this.inputStreams,
+            onProgress: this.handleProgress.bind(this),
+            own: this.own
+          }) : await this.executeTask(inputs, ctx);
+          await this.cacheCoordinator.save(keyInputs, outputs, this.outputCache);
+          this.task.runOutputData = outputs ?? {};
+        }
+        await this.handleComplete();
+        return this.task.runOutputData;
+      } catch (err) {
+        await this.handleError(err);
+        throw this.task.error instanceof TaskTimeoutError ? this.task.error : err;
+      }
+    } finally {
+      if (ownsScope) {
+        await effectiveConfig.resourceScope.disposeAll();
+        this.resourceScope = undefined;
+      }
+      this.ownsResourceScope = false;
+    }
+  }
+  async runPreview(overrides = {}) {
+    if (this.task.status === TaskStatus.PROCESSING) {
+      return this.task.runOutputData;
+    }
+    this.task.setInput(overrides);
+    await this.resolveSchemas();
+    await this.handleStartPreview();
+    const ctx = new TaskRunContext;
+    try {
+      const inputs = this.task.runInputData;
+      const isValid = await this.task.validateInput(inputs);
+      if (!isValid) {
+        throw new TaskInvalidInputError("Invalid input data");
+      }
+      const resultPreview = await this.executeTaskPreview(inputs, ctx);
+      if (resultPreview !== undefined) {
+        this.task.runOutputData = resultPreview;
+      }
+      await this.handleCompletePreview();
+    } catch (err) {
+      getLogger2().debug("runPreview failed", { taskId: this.task.config?.id, error: err });
+      await this.handleErrorPreview();
+    } finally {
+      ctx.dispose();
+      return this.task.runOutputData;
+    }
+  }
+  async* runPreviewStream(overrides = {}) {
+    const graph = this.task.parentGraph;
+    const dataflowInfos = [];
+    if (graph) {
+      for (const df of graph.getSourceDataflows(this.task.id)) {
+        const upstream = graph.getTask(df.sourceTaskId);
+        if (upstream) {
+          dataflowInfos.push({
+            upstream,
+            sourcePort: df.sourceTaskPortId,
+            targetPort: df.targetTaskPortId
+          });
+        }
+      }
+    }
+    const upstreamTasks = new Set(dataflowInfos.map((d) => d.upstream));
+    const pendingUpstreams = new Set([...upstreamTasks].filter((u) => u.status === TaskStatus.STREAMING || u.status === TaskStatus.PENDING || u.status === TaskStatus.PROCESSING));
+    let dirty = true;
+    let wakeResolve;
+    const wakeNext = () => new Promise((resolve) => {
+      wakeResolve = resolve;
+    });
+    const wake = () => {
+      const r = wakeResolve;
+      wakeResolve = undefined;
+      if (r)
+        r();
+    };
+    const cleanupFns = [];
+    for (const upstream of pendingUpstreams) {
+      const myDataflows = dataflowInfos.filter((d) => d.upstream === upstream);
+      const onChunk = (event) => {
+        if (event.type !== "snapshot")
+          return;
+        const snapshotData = event.data;
+        if (snapshotData) {
+          for (const { sourcePort, targetPort } of myDataflows) {
+            const value = sourcePort === "*" ? snapshotData : snapshotData[sourcePort];
+            if (value !== undefined) {
+              this.task.runInputData[targetPort] = value;
+            }
+          }
+        }
+        dirty = true;
+        wake();
+      };
+      const onEnd = () => {
+        pendingUpstreams.delete(upstream);
+        wake();
+      };
+      const onStatus = (status) => {
+        if (status === TaskStatus.COMPLETED || status === TaskStatus.FAILED || status === TaskStatus.DISABLED) {
+          pendingUpstreams.delete(upstream);
+          wake();
+        }
+      };
+      upstream.on("stream_chunk", onChunk);
+      upstream.on("stream_end", onEnd);
+      upstream.on("status", onStatus);
+      cleanupFns.push(() => {
+        upstream.off("stream_chunk", onChunk);
+        upstream.off("stream_end", onEnd);
+        upstream.off("status", onStatus);
+      });
+    }
+    for (const upstream of [...pendingUpstreams]) {
+      if (upstream.status === TaskStatus.COMPLETED || upstream.status === TaskStatus.FAILED || upstream.status === TaskStatus.DISABLED) {
+        pendingUpstreams.delete(upstream);
+      }
+    }
+    try {
+      while (true) {
+        if (dirty) {
+          dirty = false;
+          try {
+            const out = await this.runPreview(overrides);
+            yield out;
+          } catch (err) {
+            getLogger2().debug("runPreviewStream iteration failed", {
+              taskId: this.task.config?.id,
+              error: err
+            });
+          }
+          continue;
+        }
+        if (pendingUpstreams.size === 0)
+          return;
+        await wakeNext();
+      }
+    } finally {
+      for (const off of cleanupFns)
+        off();
+    }
+  }
+  abort() {
+    this.currentCtx?.abortController.abort();
+  }
+  own(i) {
+    const task = ensureTask(i, { isOwned: true });
+    this.task.subGraph.addTask(task);
+    if (hasRunConfig(i)) {
+      const stamp = {
+        registry: this.registry,
+        signal: this.currentCtx?.abortController.signal
+      };
+      if (!this.ownsResourceScope) {
+        stamp.resourceScope = this.resourceScope;
+      }
+      Object.assign(i.runConfig, stamp);
+    }
+    if (this.task.constructor.hasDynamicEntitlements) {
+      this.task.emit("entitlementChange", this.task.entitlements());
+    }
+    return i;
+  }
+  async executeTask(input, ctx) {
+    const result = await this.task.execute(input, {
+      signal: ctx.abortController.signal,
+      updateProgress: this.handleProgress.bind(this),
+      own: this.own,
+      registry: this.registry,
+      resourceScope: this.resourceScope
+    });
+    return result;
+  }
+  async executeTaskPreview(input, _ctx) {
+    return this.task.executePreview?.(input, { own: this.own });
+  }
+  async resolveSchemas() {
+    const configSchema = this.task.constructor.configSchema();
+    if (schemaHasFormatAnnotations(configSchema)) {
+      const source = this.task.originalConfig ?? this.task.config;
+      const resolved = await resolveSchemaInputs({ ...source }, configSchema, { registry: this.registry });
+      Object.assign(this.task.config, resolved);
+    }
+    const schema = this.task.constructor.inputSchema();
+    this.task.runInputData = await resolveSchemaInputs(this.task.runInputData, schema, { registry: this.registry });
+  }
+  async handleStart(config = {}) {
+    this.running = true;
+    this.task.startedAt = new Date;
+    this.task.progress = 0;
+    this.task.status = TaskStatus.PROCESSING;
+    const ctx = new TaskRunContext(config.signal);
+    this.currentCtx = ctx;
+    ctx.abortController.signal.addEventListener("abort", () => {
+      this.handleAbort();
+    });
+    const cache = config.outputCache ?? this.task.runConfig?.outputCache;
+    if (cache === true) {
       let instance = globalServiceRegistry2.get(TASK_OUTPUT_REPOSITORY);
       this.outputCache = instance;
     } else if (cache === false) {
@@ -1828,7 +2327,7 @@ class TaskRunner {
     } else if (cache instanceof TaskOutputRepository) {
       this.outputCache = cache;
     }
-    this.shouldAccumulate = config.shouldAccumulate !== false;
+    ctx.shouldAccumulate = config.shouldAccumulate !== false;
     if (config.updateProgress) {
       this.updateProgress = config.updateProgress;
     }
@@ -1838,25 +2337,18 @@ class TaskRunner {
     if (config.resourceScope) {
       this.resourceScope = config.resourceScope;
     }
-    if (config.signal) {
-      const onAbort = () => this.abortController.abort();
-      config.signal.addEventListener("abort", onAbort, { once: true });
-      if (config.signal.aborted) {
-        config.signal.removeEventListener("abort", onAbort);
-        this.abortController.abort();
-        return;
-      }
-    }
+    if (ctx.abortController.signal.aborted)
+      return;
     const timeout = this.task.config.timeout;
     if (timeout !== undefined && timeout > 0) {
-      this.pendingTimeoutError = new TaskTimeoutError(timeout);
-      this.timeoutTimer = setTimeout(() => {
+      ctx.pendingTimeoutError = new TaskTimeoutError(timeout);
+      ctx.timeoutTimer = setTimeout(() => {
         this.abort();
       }, timeout);
     }
     const telemetry = getTelemetryProvider();
     if (telemetry.isEnabled) {
-      this.telemetrySpan = telemetry.startSpan("workglow.task.run", {
+      ctx.telemetrySpan = telemetry.startSpan("workglow.task.run", {
         attributes: {
           "workglow.task.type": this.task.type,
           "workglow.task.id": String(this.task.config.id),
@@ -1873,32 +2365,34 @@ class TaskRunner {
     this.previewRunning = true;
   }
   clearTimeoutTimer() {
-    if (this.timeoutTimer !== undefined) {
-      clearTimeout(this.timeoutTimer);
-      this.timeoutTimer = undefined;
+    const ctx = this.currentCtx;
+    if (ctx?.timeoutTimer !== undefined) {
+      clearTimeout(ctx.timeoutTimer);
+      ctx.timeoutTimer = undefined;
     }
   }
   async handleAbort() {
     if (this.task.status === TaskStatus.ABORTING)
       return;
     this.clearTimeoutTimer();
+    const ctx = this.currentCtx;
     this.task.status = TaskStatus.ABORTING;
     await this.handleProgress(100);
-    this.task.error = this.pendingTimeoutError ?? new TaskAbortedError;
-    this.pendingTimeoutError = undefined;
-    if (this.telemetrySpan) {
-      this.telemetrySpan.setStatus(SpanStatusCode.ERROR, "aborted");
-      this.telemetrySpan.addEvent("workglow.task.aborted", {
+    this.task.error = ctx?.pendingTimeoutError ?? new TaskAbortedError;
+    if (ctx?.telemetrySpan) {
+      ctx.telemetrySpan.setStatus(SpanStatusCode.ERROR, "aborted");
+      ctx.telemetrySpan.addEvent("workglow.task.aborted", {
         "workglow.task.error": this.task.error.message
       });
-      this.telemetrySpan.end();
-      this.telemetrySpan = undefined;
+      ctx.telemetrySpan.end();
     }
     if (typeof this.task.cleanup === "function") {
       try {
         await this.task.cleanup();
       } catch {}
     }
+    ctx?.dispose();
+    this.currentCtx = undefined;
     this.task.emit("abort", this.task.error);
     this.task.emit("status", this.task.status);
   }
@@ -1909,34 +2403,36 @@ class TaskRunner {
     if (this.task.status === TaskStatus.COMPLETED)
       return;
     this.clearTimeoutTimer();
-    this.pendingTimeoutError = undefined;
+    const ctx = this.currentCtx;
     this.task.completedAt = new Date;
     this.task.status = TaskStatus.COMPLETED;
-    this.abortController = undefined;
     await this.handleProgress(100);
-    if (this.telemetrySpan) {
-      this.telemetrySpan.setStatus(SpanStatusCode.OK);
-      this.telemetrySpan.end();
-      this.telemetrySpan = undefined;
+    if (ctx?.telemetrySpan) {
+      ctx.telemetrySpan.setStatus(SpanStatusCode.OK);
+      ctx.telemetrySpan.end();
     }
+    ctx?.dispose();
+    this.currentCtx = undefined;
     this.task.emit("complete");
     this.task.emit("status", this.task.status);
   }
   async handleCompletePreview() {
     this.previewRunning = false;
   }
-  async handleDisable() {
+  async handleDisable(ctx) {
     if (this.task.status === TaskStatus.DISABLED)
       return;
     this.task.status = TaskStatus.DISABLED;
     await this.handleProgress(100);
     this.task.completedAt = new Date;
-    this.abortController = undefined;
+    ctx?.dispose();
+    if (this.currentCtx === ctx)
+      this.currentCtx = undefined;
     this.task.emit("disabled");
     this.task.emit("status", this.task.status);
   }
   async disable() {
-    await this.handleDisable();
+    await this.handleDisable(this.currentCtx);
   }
   async handleError(err) {
     if (err instanceof TaskAbortedError)
@@ -1944,7 +2440,7 @@ class TaskRunner {
     if (this.task.status === TaskStatus.FAILED)
       return;
     this.clearTimeoutTimer();
-    this.pendingTimeoutError = undefined;
+    const ctx = this.currentCtx;
     if (this.task.hasChildren()) {
       this.task.subGraph.abort();
     }
@@ -1959,14 +2455,14 @@ class TaskRunner {
       this.task.error.taskId ??= this.task.id;
     }
     this.task.status = TaskStatus.FAILED;
-    this.abortController = undefined;
     await this.handleProgress(100);
-    if (this.telemetrySpan) {
-      this.telemetrySpan.setStatus(SpanStatusCode.ERROR, this.task.error.message);
-      this.telemetrySpan.setAttributes({ "workglow.task.error": this.task.error.message });
-      this.telemetrySpan.end();
-      this.telemetrySpan = undefined;
+    if (ctx?.telemetrySpan) {
+      ctx.telemetrySpan.setStatus(SpanStatusCode.ERROR, this.task.error.message);
+      ctx.telemetrySpan.setAttributes({ "workglow.task.error": this.task.error.message });
+      ctx.telemetrySpan.end();
     }
+    ctx?.dispose();
+    this.currentCtx = undefined;
     this.task.emit("error", this.task.error);
     this.task.emit("status", this.task.status);
   }
@@ -2106,7 +2602,7 @@ class Task {
       ...title ? { title } : {}
     }, restConfig);
     if (baseConfig.id === undefined) {
-      baseConfig.id = uuid42();
+      baseConfig.id = uuid43();
     }
     this.config = this.validateAndApplyConfigDefaults(baseConfig);
     try {
@@ -2588,7 +3084,7 @@ class ConditionalTask extends Task {
           }
         }
       } catch (error) {
-        getLogger2().error(`Condition evaluation failed for branch "${branch.id}":`, { error });
+        getLogger3().error(`Condition evaluation failed for branch "${branch.id}":`, { error });
       }
     }
     if (this.activeBranches.size === 0 && defaultBranch) {
@@ -2712,215 +3208,420 @@ class ConditionalTask extends Task {
   }
 }
 
-// src/task/EntitlementEnforcer.ts
-import { createServiceToken as createServiceToken4 } from "@workglow/util";
-
-// src/task/EntitlementPolicy.ts
-var EMPTY_POLICY = Object.freeze({
-  deny: Object.freeze([]),
-  grant: Object.freeze([]),
-  ask: Object.freeze([])
-});
-function ruleCovers(rule, required) {
-  if (!entitlementCovers(rule.id, required.id))
-    return false;
-  return grantCoversResources(rule, required);
-}
-function evaluatePolicy(policy, required) {
-  const results = [];
-  for (const entitlement of required.entitlements) {
-    if (entitlement.optional)
-      continue;
-    const denyMatch = policy.deny.find((rule) => ruleCovers(rule, entitlement));
-    if (denyMatch) {
-      results.push({ verdict: "denied", entitlement, matchedRule: denyMatch });
-      continue;
-    }
-    const grantMatch = policy.grant.find((rule) => ruleCovers(rule, entitlement));
-    if (grantMatch) {
-      results.push({ verdict: "granted", entitlement, matchedRule: grantMatch });
-      continue;
-    }
-    const askMatch = policy.ask.find((rule) => ruleCovers(rule, entitlement));
-    if (askMatch) {
-      results.push({ verdict: "ask", entitlement, matchedRule: askMatch });
-      continue;
-    }
-    results.push({ verdict: "denied", entitlement });
+// src/task-graph/RunScheduler.ts
+class RunScheduler {
+  graph;
+  processScheduler;
+  facade;
+  constructor(graph, processScheduler, facade) {
+    this.graph = graph;
+    this.processScheduler = processScheduler;
+    this.facade = facade;
   }
-  return results;
-}
-function can(policy, id, resources) {
-  const required = resources !== undefined ? { id, resources } : { id };
-  const [result] = evaluatePolicy(policy, { entitlements: [required] });
-  return result;
-}
-
-// src/task/EntitlementResolver.ts
-import { createServiceToken as createServiceToken3 } from "@workglow/util";
-var PERMISSIVE_RESOLVER = {
-  lookup: () => "grant",
-  prompt: async () => "grant",
-  save: () => {}
-};
-var DENY_ALL_RESOLVER = {
-  lookup: () => "deny",
-  prompt: async () => "deny",
-  save: () => {}
-};
-var ENTITLEMENT_RESOLVER = createServiceToken3("workglow.entitlementResolver");
-
-// src/task/EntitlementEnforcer.ts
-function formatEntitlementDenial(denial) {
-  switch (denial.reason) {
-    case "policy-deny":
-      return `${denial.entitlement.id} (denied by rule ${denial.matchedRule.id})`;
-    case "user-deny":
-      return `${denial.entitlement.id} (denied by user)`;
-    case "default-deny":
-      return `${denial.entitlement.id} (no matching grant)`;
-  }
-}
-var PERMISSIVE_ENFORCER = {
-  checkAll: async () => [],
-  checkTask: async () => []
-};
-function createPolicyEnforcer(policy, resolver = PERMISSIVE_RESOLVER) {
-  async function resolveAsks(required, taskType, taskId) {
-    const results = evaluatePolicy(policy, required);
-    const denied = [];
-    for (const result of results) {
-      if (result.verdict === "denied") {
-        if (result.matchedRule) {
-          denied.push({
-            entitlement: result.entitlement,
-            reason: "policy-deny",
-            matchedRule: result.matchedRule
-          });
+  pushStatusFromNodeToEdges(node, ctx, status, graph = this.graph) {
+    if (!node?.config?.id)
+      return;
+    const dataflows = graph.getTargetDataflows(node.id);
+    const effectiveStatus = status ?? node.status;
+    if (node instanceof ConditionalTask && effectiveStatus === TaskStatus.COMPLETED) {
+      const branches = node.config.branches ?? [];
+      const portToBranch = new Map;
+      for (const branch of branches) {
+        portToBranch.set(branch.outputPort, branch.id);
+      }
+      const activeBranches = node.getActiveBranches();
+      for (const dataflow of dataflows) {
+        if (dataflow.status === TaskStatus.FAILED)
+          continue;
+        const branchId = portToBranch.get(dataflow.sourceTaskPortId);
+        if (branchId !== undefined) {
+          if (activeBranches.has(branchId)) {
+            dataflow.setStatus(TaskStatus.COMPLETED);
+          } else {
+            dataflow.setStatus(TaskStatus.DISABLED);
+          }
         } else {
-          denied.push({ entitlement: result.entitlement, reason: "default-deny" });
+          dataflow.setStatus(effectiveStatus);
         }
-      } else if (result.verdict === "ask") {
-        const request = {
-          entitlement: result.entitlement,
-          taskType: taskType ?? "unknown",
-          taskId: taskId ?? "unknown"
-        };
-        let answer = resolver.lookup(request);
-        if (answer === undefined) {
-          answer = await resolver.prompt(request);
-          resolver.save(request, answer);
+      }
+      this.propagateDisabledStatus(ctx, graph);
+      return;
+    }
+    dataflows.forEach((dataflow) => {
+      if (dataflow.status === TaskStatus.FAILED)
+        return;
+      dataflow.setStatus(effectiveStatus);
+    });
+  }
+  propagateDisabledStatus(_ctx, graph = this.graph) {
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const task of graph.getTasks()) {
+        if (task.status !== TaskStatus.PENDING) {
+          continue;
         }
-        if (answer === "deny") {
-          if (!result.matchedRule) {
-            throw new Error(`Invariant violation: ask verdict for "${result.entitlement.id}" is missing matchedRule`);
-          }
-          denied.push({
-            entitlement: result.entitlement,
-            reason: "user-deny",
-            matchedRule: result.matchedRule
+        const incomingDataflows = graph.getSourceDataflows(task.id);
+        if (incomingDataflows.length === 0) {
+          continue;
+        }
+        const allDisabled = incomingDataflows.every((df) => df.status === TaskStatus.DISABLED);
+        if (allDisabled) {
+          task.status = TaskStatus.DISABLED;
+          task.progress = 100;
+          task.completedAt = new Date;
+          task.emit("disabled");
+          task.emit("status", task.status);
+          graph.getTargetDataflows(task.id).forEach((dataflow) => {
+            dataflow.setStatus(TaskStatus.DISABLED);
           });
+          this.processScheduler.onTaskCompleted(task.id);
+          changed = true;
         }
       }
     }
-    return denied;
   }
-  return {
-    async checkAll(required) {
-      return resolveAsks(required);
-    },
-    async checkTask(task) {
-      const entitlements = task.entitlements();
-      return resolveAsks(entitlements, task.constructor.type, task.id);
+  async handleProgress(ctx, task, progress, message, ...args) {
+    const contributors = this.graph.getTasks().filter(taskPrototypeHasOwnExecute);
+    if (contributors.length > 1) {
+      const determinate = contributors.filter((t) => t.progress !== undefined);
+      if (determinate.length === 0) {
+        progress = undefined;
+      } else {
+        const sum = determinate.reduce((acc, t) => acc + t.progress, 0);
+        progress = Math.round(sum / determinate.length);
+      }
+    } else if (contributors.length === 1) {
+      const [only] = contributors;
+      progress = only.progress;
+    }
+    this.pushStatusFromNodeToEdges(task, ctx);
+    this.graph.emit("graph_progress", progress, message, args);
+    const isActive = task.status === TaskStatus.PROCESSING || task.status === TaskStatus.STREAMING;
+    if (isActive && task.runOutputData && Object.keys(task.runOutputData).length > 0) {
+      await this.facade["edgeMaterializer"].pushOutputFromNodeToEdges(task, task.runOutputData);
     }
-  };
-}
-function createScopedEnforcer(grants) {
-  return createPolicyEnforcer({ deny: [], grant: grants, ask: [] });
-}
-function createGrantListEnforcer(grants) {
-  return createScopedEnforcer(grants.map((id) => ({ id })));
-}
-var ENTITLEMENT_ENFORCER = createServiceToken4("workglow.entitlementEnforcer");
-
-// src/task-graph/TaskGraphScheduler.ts
-class TopologicalScheduler {
-  dag;
-  sortedNodes;
-  currentIndex;
-  constructor(dag) {
-    this.dag = dag;
-    this.sortedNodes = [];
-    this.currentIndex = 0;
-    this.reset();
   }
-  async* tasks() {
-    while (this.currentIndex < this.sortedNodes.length) {
-      yield this.sortedNodes[this.currentIndex++];
+  armGraphTimeout(timeoutMs, ctx) {
+    if (timeoutMs <= 0)
+      return;
+    ctx.pendingGraphTimeoutError = undefined;
+    ctx.graphTimeoutTimer = setTimeout(() => {
+      ctx.pendingGraphTimeoutError = new TaskGraphTimeoutError(timeoutMs);
+      ctx.abortController.abort();
+    }, timeoutMs);
+  }
+  clearGraphTimeout(ctx) {
+    if (ctx.graphTimeoutTimer !== undefined) {
+      clearTimeout(ctx.graphTimeoutTimer);
+      ctx.graphTimeoutTimer = undefined;
     }
   }
-  onTaskCompleted(_taskId) {}
-  onTaskStreaming(_taskId) {}
-  reset() {
-    this.sortedNodes = this.dag.topologicallySortedNodes();
-    this.currentIndex = 0;
+  async runLoop(input, config, ctx, edgeMat) {
+    const results = [];
+    try {
+      for await (const task of this.processScheduler.tasks()) {
+        if (ctx.abortController.signal.aborted) {
+          break;
+        }
+        if (ctx.failedTaskErrors.size > 0) {
+          break;
+        }
+        const isRootTask = this.graph.getSourceDataflows(task.id).length === 0;
+        const runAsync = async () => {
+          let errorRouted = false;
+          try {
+            const taskInput = isRootTask ? input : config?.matchAllEmptyInputs ? edgeMat.filterInputForTask(task, input) : {};
+            const taskPromise = this.facade["runTask"](task, taskInput);
+            ctx.inProgressTasks.set(task.id, taskPromise);
+            const taskResult = await taskPromise;
+            if (this.graph.getTargetDataflows(task.id).length === 0) {
+              results.push(taskResult);
+            }
+          } catch (error) {
+            if (edgeMat.hasErrorOutputEdges(task)) {
+              errorRouted = true;
+              edgeMat.pushErrorOutputToEdges(task);
+            } else {
+              ctx.failedTaskErrors.set(task.id, error);
+            }
+          } finally {
+            if (!errorRouted) {
+              this.pushStatusFromNodeToEdges(task, ctx);
+              edgeMat.pushErrorFromNodeToEdges(task);
+            }
+            this.processScheduler.onTaskCompleted(task.id);
+          }
+        };
+        ctx.inProgressFunctions.set(Symbol(task.id), runAsync());
+      }
+    } catch (err) {
+      getLogger4().error("Error running graph", { error: err });
+    }
+    await Promise.allSettled(Array.from(ctx.inProgressTasks.values()));
+    await Promise.allSettled(Array.from(ctx.inProgressFunctions.values()));
+    return results;
   }
 }
 
-class DependencyBasedScheduler {
-  dag;
-  completedTasks;
-  streamingTasks;
-  pendingTasks;
-  nextResolver = null;
-  constructor(dag) {
-    this.dag = dag;
-    this.completedTasks = new Set;
-    this.streamingTasks = new Set;
-    this.pendingTasks = new Set;
-    this.reset();
+// src/task-graph/StreamPump.ts
+class StreamPump {
+  graph;
+  processScheduler;
+  edgeMaterializer;
+  runScheduler;
+  constructor(graph, processScheduler, edgeMaterializer) {
+    this.graph = graph;
+    this.processScheduler = processScheduler;
+    this.edgeMaterializer = edgeMaterializer;
   }
-  isTaskReady(task) {
-    if (task.status === TaskStatus.DISABLED) {
-      return false;
-    }
-    const sourceDataflows = this.dag.getSourceDataflows(task.id);
-    if (sourceDataflows.length > 0) {
-      const allIncomingDisabled = sourceDataflows.every((df) => df.status === TaskStatus.DISABLED);
-      if (allIncomingDisabled) {
-        return false;
-      }
-    }
-    const activeDataflows = sourceDataflows.filter((df) => df.status !== TaskStatus.DISABLED);
-    return activeDataflows.every((df) => {
-      const depId = df.sourceTaskId;
-      if (this.completedTasks.has(depId))
-        return true;
-      if (this.streamingTasks.has(depId)) {
-        const sourceTask = this.dag.getTask(depId);
-        if (sourceTask) {
-          const sourceMode = getPortStreamMode(sourceTask.outputSchema(), df.sourceTaskPortId);
-          const targetMode = getPortStreamMode(task.inputSchema(), df.targetTaskPortId);
-          if (sourceMode !== "none" && sourceMode === targetMode) {
-            return true;
-          }
-        }
-      }
-      return false;
-    });
+  setRunScheduler(rs) {
+    this.runScheduler = rs;
   }
-  async waitForNextTask() {
-    if (this.pendingTasks.size === 0)
-      return null;
-    for (const task of Array.from(this.pendingTasks)) {
-      if (task.status === TaskStatus.DISABLED) {
-        this.pendingTasks.delete(task);
-      }
+  prepareStreamingInputs(task) {
+    const dataflows = this.graph.getSourceDataflows(task.id);
+    const streamingEdges = dataflows.filter((df) => df.stream !== undefined);
+    if (streamingEdges.length === 0)
+      return;
+    const inputStreams = new Map;
+    for (const df of streamingEdges) {
+      const stream = df.stream;
+      const [forwardCopy, materializeCopy] = stream.tee();
+      inputStreams.set(df.targetTaskPortId, forwardCopy);
+      df.setStream(materializeCopy);
     }
-    if (this.pendingTasks.size === 0)
-      return null;
-    const readyTask = Array.from(this.pendingTasks).find((task) => this.isTaskReady(task));
-    if (readyTask) {
+    task.runner.inputStreams = inputStreams;
+  }
+  async awaitStreamInputs(task, registry) {
+    const dataflows = this.graph.getSourceDataflows(task.id);
+    const streamingDataflows = dataflows.filter((df) => df.stream !== undefined);
+    if (streamingDataflows.length === 0)
+      return;
+    await Promise.all(streamingDataflows.map(async (df) => {
+      await df.awaitStreamValue();
+      await df.applyTransforms(registry);
+    }));
+  }
+  async runStreamingTask(task, input, ctx, options) {
+    if (!this.runScheduler) {
+      throw new Error("StreamPump.runStreamingTask called before setRunScheduler \u2014 facade construction is incomplete.");
+    }
+    const streamMode = getOutputStreamMode(task.outputSchema());
+    const shouldAccumulate = this.taskNeedsAccumulation(task, options.outputCache, options.accumulateLeafOutputs);
+    let streamingNotified = false;
+    const onStatus = (status) => {
+      if (status === TaskStatus.STREAMING && !streamingNotified) {
+        streamingNotified = true;
+        this.runScheduler.pushStatusFromNodeToEdges(task, ctx, TaskStatus.STREAMING);
+        this.pushStreamToEdges(task, streamMode);
+        this.processScheduler.onTaskStreaming(task.id);
+      }
+    };
+    const onStreamStart = () => {
+      this.graph.emit("task_stream_start", task.id);
+    };
+    const onStreamChunk = (event) => {
+      this.graph.emit("task_stream_chunk", task.id, event);
+    };
+    const onStreamEnd = (output) => {
+      this.graph.emit("task_stream_end", task.id, output);
+    };
+    task.on("status", onStatus);
+    task.on("stream_start", onStreamStart);
+    task.on("stream_chunk", onStreamChunk);
+    task.on("stream_end", onStreamEnd);
+    try {
+      const results = await task.runner.run(input, {
+        outputCache: options.outputCache ?? false,
+        shouldAccumulate,
+        updateProgress: options.updateProgress,
+        registry: options.registry,
+        resourceScope: options.resourceScope
+      });
+      await this.edgeMaterializer.pushOutputFromNodeToEdges(task, results);
+      return {
+        id: task.id,
+        type: task.constructor.runtype || task.constructor.type,
+        data: results
+      };
+    } finally {
+      task.off("status", onStatus);
+      task.off("stream_start", onStreamStart);
+      task.off("stream_chunk", onStreamChunk);
+      task.off("stream_end", onStreamEnd);
+    }
+  }
+  taskNeedsAccumulation(task, outputCache, accumulateLeafOutputs) {
+    if (outputCache)
+      return true;
+    const outEdges = this.graph.getTargetDataflows(task.id);
+    if (outEdges.length === 0)
+      return accumulateLeafOutputs;
+    const outSchema = task.outputSchema();
+    for (const df of outEdges) {
+      if (df.sourceTaskPortId === DATAFLOW_ALL_PORTS) {
+        if (getStreamingPorts(outSchema).length > 0)
+          return true;
+        continue;
+      }
+      const targetTask = this.graph.getTask(df.targetTaskId);
+      if (!targetTask)
+        continue;
+      const inSchema = targetTask.inputSchema();
+      if (edgeNeedsAccumulation(outSchema, df.sourceTaskPortId, inSchema, df.targetTaskPortId)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  static isPortDelta(event) {
+    return event.type === "text-delta" || event.type === "object-delta";
+  }
+  createStreamFromTaskEvents(task, portId, edgesForGroup) {
+    return new ReadableStream({
+      start: (controller) => {
+        const onChunk = (event) => {
+          try {
+            if (portId !== undefined && StreamPump.isPortDelta(event) && event.port !== portId) {
+              return;
+            }
+            if (event.type === "snapshot") {
+              const data = event.data;
+              if (data) {
+                for (const edge of edgesForGroup) {
+                  const portValue = edge.sourceTaskPortId === DATAFLOW_ALL_PORTS ? data : data[edge.sourceTaskPortId];
+                  edge.latestSnapshot = portValue;
+                }
+              }
+            }
+            controller.enqueue(event);
+          } catch {}
+        };
+        const onEnd = () => {
+          try {
+            controller.close();
+          } catch {}
+          task.off("stream_chunk", onChunk);
+          task.off("stream_end", onEnd);
+        };
+        task.on("stream_chunk", onChunk);
+        task.on("stream_end", onEnd);
+      }
+    });
+  }
+  pushStreamToEdges(task, _streamMode) {
+    const targetDataflows = this.graph.getTargetDataflows(task.id);
+    if (targetDataflows.length === 0)
+      return;
+    const groups = new Map;
+    for (const df of targetDataflows) {
+      const key = df.sourceTaskPortId;
+      let group = groups.get(key);
+      if (!group) {
+        group = [];
+        groups.set(key, group);
+      }
+      group.push(df);
+    }
+    for (const [portKey, edges] of groups) {
+      const filterPort = portKey === DATAFLOW_ALL_PORTS ? undefined : portKey;
+      const stream = this.createStreamFromTaskEvents(task, filterPort, edges);
+      if (edges.length === 1) {
+        edges[0].setStream(stream);
+      } else {
+        let currentStream = stream;
+        for (let i = 0;i < edges.length; i++) {
+          if (i === edges.length - 1) {
+            edges[i].setStream(currentStream);
+          } else {
+            const [s1, s2] = currentStream.tee();
+            edges[i].setStream(s1);
+            currentStream = s2;
+          }
+        }
+      }
+    }
+  }
+}
+
+// src/task-graph/TaskGraphScheduler.ts
+class TopologicalScheduler {
+  dag;
+  sortedNodes;
+  currentIndex;
+  constructor(dag) {
+    this.dag = dag;
+    this.sortedNodes = [];
+    this.currentIndex = 0;
+    this.reset();
+  }
+  async* tasks() {
+    while (this.currentIndex < this.sortedNodes.length) {
+      yield this.sortedNodes[this.currentIndex++];
+    }
+  }
+  onTaskCompleted(_taskId) {}
+  onTaskStreaming(_taskId) {}
+  reset() {
+    this.sortedNodes = this.dag.topologicallySortedNodes();
+    this.currentIndex = 0;
+  }
+}
+
+class DependencyBasedScheduler {
+  dag;
+  completedTasks;
+  streamingTasks;
+  pendingTasks;
+  nextResolver = null;
+  constructor(dag) {
+    this.dag = dag;
+    this.completedTasks = new Set;
+    this.streamingTasks = new Set;
+    this.pendingTasks = new Set;
+    this.reset();
+  }
+  isTaskReady(task) {
+    if (task.status === TaskStatus.DISABLED) {
+      return false;
+    }
+    const sourceDataflows = this.dag.getSourceDataflows(task.id);
+    if (sourceDataflows.length > 0) {
+      const allIncomingDisabled = sourceDataflows.every((df) => df.status === TaskStatus.DISABLED);
+      if (allIncomingDisabled) {
+        return false;
+      }
+    }
+    const activeDataflows = sourceDataflows.filter((df) => df.status !== TaskStatus.DISABLED);
+    return activeDataflows.every((df) => {
+      const depId = df.sourceTaskId;
+      if (this.completedTasks.has(depId))
+        return true;
+      if (this.streamingTasks.has(depId)) {
+        const sourceTask = this.dag.getTask(depId);
+        if (sourceTask) {
+          const sourceMode = getPortStreamMode(sourceTask.outputSchema(), df.sourceTaskPortId);
+          const targetMode = getPortStreamMode(task.inputSchema(), df.targetTaskPortId);
+          if (sourceMode !== "none" && sourceMode === targetMode) {
+            return true;
+          }
+        }
+      }
+      return false;
+    });
+  }
+  async waitForNextTask() {
+    if (this.pendingTasks.size === 0)
+      return null;
+    for (const task of Array.from(this.pendingTasks)) {
+      if (task.status === TaskStatus.DISABLED) {
+        this.pendingTasks.delete(task);
+      }
+    }
+    if (this.pendingTasks.size === 0)
+      return null;
+    const readyTask = Array.from(this.pendingTasks).find((task) => this.isTaskReady(task));
+    if (readyTask) {
       this.pendingTasks.delete(readyTask);
       return readyTask;
     }
@@ -2996,12 +3697,6 @@ function taskPrototypeHasOwnExecute(task) {
 }
 var PROPERTY_ARRAY = "PROPERTY_ARRAY";
 var GRAPH_RESULT_ARRAY = "GRAPH_RESULT_ARRAY";
-function isImageValueShape(v) {
-  if (v === null || typeof v !== "object")
-    return false;
-  const o = v;
-  return typeof o.width === "number" && typeof o.height === "number" && typeof o.previewScale === "number";
-}
 
 class TaskGraphRunner {
   processScheduler;
@@ -3013,89 +3708,56 @@ class TaskGraphRunner {
   accumulateLeafOutputs = true;
   registry = globalServiceRegistry3;
   resourceScope;
-  abortController;
-  inProgressTasks = new Map;
-  inProgressFunctions = new Map;
-  failedTaskErrors = new Map;
-  telemetrySpan;
-  graphTimeoutTimer;
-  pendingGraphTimeoutError;
-  activeEnforcer;
+  currentCtx;
+  edgeMaterializer;
+  streamPump;
+  runScheduler;
   constructor(graph, outputCache, processScheduler = new DependencyBasedScheduler(graph), previewScheduler = new TopologicalScheduler(graph)) {
     this.processScheduler = processScheduler;
     this.previewScheduler = previewScheduler;
     this.graph = graph;
+    this.outputCache = outputCache;
     graph.outputCache = outputCache;
-    this.handleProgress = this.handleProgress.bind(this);
+    this.edgeMaterializer = new EdgeMaterializer(graph, this);
+    this.streamPump = new StreamPump(graph, this.processScheduler, this.edgeMaterializer);
+    this.runScheduler = new RunScheduler(graph, this.processScheduler, this);
+    this.streamPump.setRunScheduler(this.runScheduler);
   }
-  runId = "";
   async runGraph(input = {}, config) {
-    await this.handleStart(config);
-    const results = [];
-    let error;
+    const ownsScope = config?.resourceScope === undefined;
+    const effectiveConfig = ownsScope ? { ...config, resourceScope: new ResourceScope2 } : config;
     try {
-      for await (const task of this.processScheduler.tasks()) {
-        if (this.abortController?.signal.aborted) {
-          break;
-        }
-        if (this.failedTaskErrors.size > 0) {
-          break;
-        }
-        const isRootTask = this.graph.getSourceDataflows(task.id).length === 0;
-        const runAsync = async () => {
-          let errorRouted = false;
-          try {
-            const taskInput = isRootTask ? input : config?.matchAllEmptyInputs ? this.filterInputForTask(task, input) : {};
-            const taskPromise = this.runTask(task, taskInput);
-            this.inProgressTasks.set(task.id, taskPromise);
-            const taskResult = await taskPromise;
-            if (this.graph.getTargetDataflows(task.id).length === 0) {
-              results.push(taskResult);
-            }
-          } catch (error2) {
-            if (this.hasErrorOutputEdges(task)) {
-              errorRouted = true;
-              this.pushErrorOutputToEdges(task);
-            } else {
-              this.failedTaskErrors.set(task.id, error2);
-            }
-          } finally {
-            if (!errorRouted) {
-              this.pushStatusFromNodeToEdges(this.graph, task);
-              this.pushErrorFromNodeToEdges(this.graph, task);
-            }
-            this.processScheduler.onTaskCompleted(task.id);
-          }
-        };
-        this.inProgressFunctions.set(Symbol(task.id), runAsync());
+      await this.handleStart(effectiveConfig);
+      const ctx = this.currentCtx;
+      const results = await this.runScheduler.runLoop(input, effectiveConfig, ctx, this.edgeMaterializer);
+      const pendingTimeout = ctx.pendingGraphTimeoutError;
+      if (pendingTimeout) {
+        await this.handleAbort();
+        throw pendingTimeout;
       }
-    } catch (err) {
-      error = err;
-      getLogger3().error("Error running graph", { error });
-    }
-    await Promise.allSettled(Array.from(this.inProgressTasks.values()));
-    await Promise.allSettled(Array.from(this.inProgressFunctions.values()));
-    if (this.pendingGraphTimeoutError) {
-      await this.handleAbort();
-      throw this.pendingGraphTimeoutError;
-    }
-    if (this.failedTaskErrors.size > 0) {
-      const latestError = this.failedTaskErrors.values().next().value;
-      this.handleError(latestError);
-      throw latestError;
-    }
-    if (this.abortController?.signal.aborted) {
-      await this.handleAbort();
-      throw new TaskAbortedError;
-    }
-    await this.handleComplete();
-    return this.filterLeafResults(results);
+      if (ctx.failedTaskErrors.size > 0) {
+        const latestError = ctx.failedTaskErrors.values().next().value;
+        await this.handleError(latestError);
+        throw latestError;
+      }
+      if (ctx.abortController.signal.aborted) {
+        await this.handleAbort();
+        throw new TaskAbortedError;
+      }
+      await this.handleComplete();
+      return this.filterLeafResults(results);
+    } finally {
+      if (ownsScope) {
+        await effectiveConfig.resourceScope.disposeAll();
+        this.resourceScope = undefined;
+      }
+    }
   }
   async runGraphPreview(input = {}, config) {
     await this.handleStartPreview(config);
     const telemetry = getTelemetryProvider2();
     const telemetryEnabled = telemetry.isEnabled;
-    const previewRunId = telemetryEnabled ? uuid43() : "";
+    const previewRunId = telemetryEnabled ? uuid44() : "";
     let previewSpan;
     if (telemetryEnabled) {
       previewSpan = telemetry.startSpan("workglow.graph.runPreview", {
@@ -3114,7 +3776,7 @@ class TaskGraphRunner {
         const isRootTask = this.graph.getSourceDataflows(task.id).length === 0;
         if (task.status === TaskStatus.PENDING) {
           task.resetInputData();
-          this.copyInputFromEdgesToNode(task);
+          this.edgeMaterializer.copyInputFromEdgesToNode(task);
         }
         const taskInput = isRootTask ? input : {};
         if (telemetryEnabled) {
@@ -3123,7 +3785,7 @@ class TaskGraphRunner {
           const taskResult = await task.runPreview(taskInput);
           const runPreviewMs = performance.now() - tPreview;
           const tPush = performance.now();
-          await this.pushOutputFromNodeToEdges(task, taskResult);
+          await this.edgeMaterializer.pushOutputFromNodeToEdges(task, taskResult);
           const pushOutputMs = performance.now() - tPush;
           taskTimings.push({ id: task.id, type: taskType, runPreviewMs, pushOutputMs });
           if (this.graph.getTargetDataflows(task.id).length === 0) {
@@ -3135,7 +3797,7 @@ class TaskGraphRunner {
           }
         } else {
           const taskResult = await task.runPreview(taskInput);
-          await this.pushOutputFromNodeToEdges(task, taskResult);
+          await this.edgeMaterializer.pushOutputFromNodeToEdges(task, taskResult);
           if (this.graph.getTargetDataflows(task.id).length === 0) {
             results.push({
               id: task.id,
@@ -3154,7 +3816,7 @@ class TaskGraphRunner {
         });
         previewSpan.setStatus(SpanStatusCode2.OK);
         previewSpan.end();
-        getLogger3().debug("task graph runPreview timings", {
+        getLogger5().debug("task graph runPreview timings", {
           previewRunId,
           totalMs: Math.round(totalMs * 1000) / 1000,
           taskTimings
@@ -3172,7 +3834,7 @@ class TaskGraphRunner {
         });
         previewSpan.setStatus(SpanStatusCode2.ERROR, message);
         previewSpan.end();
-        getLogger3().debug("task graph runPreview failed", {
+        getLogger5().debug("task graph runPreview failed", {
           previewRunId,
           totalMs: Math.round(totalMs * 1000) / 1000,
           taskTimings,
@@ -3183,23 +3845,11 @@ class TaskGraphRunner {
     }
   }
   abort() {
-    this.abortController?.abort();
+    this.currentCtx?.abortController.abort();
   }
   async disable() {
     await this.handleDisable();
   }
-  filterInputForTask(task, input) {
-    const sourceDataflows = this.graph.getSourceDataflows(task.id);
-    const connectedInputs = new Set(sourceDataflows.map((df) => df.targetTaskPortId));
-    const allPortsConnected = connectedInputs.has(DATAFLOW_ALL_PORTS);
-    const filteredInput = {};
-    for (const [key, value] of Object.entries(input)) {
-      if (!connectedInputs.has(key) && !allPortsConnected) {
-        filteredInput[key] = value;
-      }
-    }
-    return filteredInput;
-  }
   addInputData(task, overrides) {
     if (!overrides)
       return;
@@ -3235,351 +3885,45 @@ class TaskGraphRunner {
       return fixedOutput;
     }
     throw new TaskConfigurationError(`Unknown compound merge strategy: ${compoundMerge}`);
-  }
-  copyInputFromEdgesToNode(task) {
-    const dataflows = this.graph.getSourceDataflows(task.id);
-    dataflows.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
-    for (const dataflow of dataflows) {
-      const live = dataflow.getCurrentValue();
-      const port = dataflow.targetTaskPortId;
-      let portData;
-      if (port === DATAFLOW_ALL_PORTS) {
-        portData = live;
-      } else if (port === DATAFLOW_ERROR_PORT) {
-        portData = { [DATAFLOW_ERROR_PORT]: dataflow.error };
-      } else {
-        portData = { [port]: live };
-      }
-      this.addInputData(task, portData);
-    }
-  }
-  async pushOutputFromNodeToEdges(node, results) {
-    const dataflows = this.graph.getTargetDataflows(node.id);
-    if (this.previewRunning && Object.keys(results).length > 0) {
-      for (const port of Object.keys(results)) {
-        const value = results[port];
-        if (isImageValueShape(value)) {
-          results[port] = await previewSource(value);
-        }
-      }
-    }
-    for (const dataflow of dataflows) {
-      if (dataflow.stream !== undefined)
-        continue;
-      const compatibility = dataflow.semanticallyCompatible(this.graph, dataflow, this.registry);
-      if (compatibility === "static") {
-        dataflow.setPortData(results);
-        await dataflow.applyTransforms(this.registry);
-      } else if (compatibility === "runtime") {
-        const task = this.graph.getTask(dataflow.targetTaskId);
-        const narrowed = await task.narrowInput({ ...results }, this.registry);
-        dataflow.setPortData(narrowed);
-        await dataflow.applyTransforms(this.registry);
-      } else {
-        const resultsKeys = Object.keys(results);
-        if (resultsKeys.length > 0) {
-          getLogger3().warn("pushOutputFromNodeToEdge not compatible, not setting port data", {
-            dataflowId: dataflow.id,
-            compatibility,
-            resultsKeys
-          });
-        }
-      }
-    }
-  }
-  pushStatusFromNodeToEdges(graph, node, status) {
-    if (!node?.config?.id)
-      return;
-    const dataflows = graph.getTargetDataflows(node.id);
-    const effectiveStatus = status ?? node.status;
-    if (node instanceof ConditionalTask && effectiveStatus === TaskStatus.COMPLETED) {
-      const branches = node.config.branches ?? [];
-      const portToBranch = new Map;
-      for (const branch of branches) {
-        portToBranch.set(branch.outputPort, branch.id);
-      }
-      const activeBranches = node.getActiveBranches();
-      for (const dataflow of dataflows) {
-        if (dataflow.status === TaskStatus.FAILED)
-          continue;
-        const branchId = portToBranch.get(dataflow.sourceTaskPortId);
-        if (branchId !== undefined) {
-          if (activeBranches.has(branchId)) {
-            dataflow.setStatus(TaskStatus.COMPLETED);
-          } else {
-            dataflow.setStatus(TaskStatus.DISABLED);
-          }
-        } else {
-          dataflow.setStatus(effectiveStatus);
-        }
-      }
-      this.propagateDisabledStatus(graph);
-      return;
-    }
-    dataflows.forEach((dataflow) => {
-      if (dataflow.status === TaskStatus.FAILED)
-        return;
-      dataflow.setStatus(effectiveStatus);
-    });
-  }
-  pushErrorFromNodeToEdges(graph, node) {
-    if (!node?.config?.id)
-      return;
-    graph.getTargetDataflows(node.id).forEach((dataflow) => {
-      dataflow.error = node.error;
-    });
-  }
-  hasErrorOutputEdges(task) {
-    const dataflows = this.graph.getTargetDataflows(task.id);
-    return dataflows.some((df) => df.sourceTaskPortId === DATAFLOW_ERROR_PORT);
-  }
-  pushErrorOutputToEdges(task) {
-    const taskError = task.error;
-    const errorData = {
-      error: taskError?.message ?? "Unknown error",
-      errorType: taskError?.constructor?.type ?? "TaskError"
-    };
-    const dataflows = this.graph.getTargetDataflows(task.id);
-    for (const df of dataflows) {
-      if (df.sourceTaskPortId === DATAFLOW_ERROR_PORT) {
-        df.value = errorData;
-        df.setStatus(TaskStatus.COMPLETED);
-      } else {
-        df.setStatus(TaskStatus.DISABLED);
-      }
-    }
-    this.propagateDisabledStatus(this.graph);
-  }
-  propagateDisabledStatus(graph) {
-    let changed = true;
-    while (changed) {
-      changed = false;
-      for (const task of graph.getTasks()) {
-        if (task.status !== TaskStatus.PENDING) {
-          continue;
-        }
-        const incomingDataflows = graph.getSourceDataflows(task.id);
-        if (incomingDataflows.length === 0) {
-          continue;
-        }
-        const allDisabled = incomingDataflows.every((df) => df.status === TaskStatus.DISABLED);
-        if (allDisabled) {
-          task.status = TaskStatus.DISABLED;
-          task.progress = 100;
-          task.completedAt = new Date;
-          task.emit("disabled");
-          task.emit("status", task.status);
-          graph.getTargetDataflows(task.id).forEach((dataflow) => {
-            dataflow.setStatus(TaskStatus.DISABLED);
-          });
-          this.processScheduler.onTaskCompleted(task.id);
-          changed = true;
-        }
-      }
-    }
-  }
-  taskNeedsAccumulation(task) {
-    if (this.outputCache)
-      return true;
-    const outEdges = this.graph.getTargetDataflows(task.id);
-    if (outEdges.length === 0)
-      return this.accumulateLeafOutputs;
-    const outSchema = task.outputSchema();
-    for (const df of outEdges) {
-      if (df.sourceTaskPortId === DATAFLOW_ALL_PORTS) {
-        if (getStreamingPorts(outSchema).length > 0)
-          return true;
-        continue;
-      }
-      const targetTask = this.graph.getTask(df.targetTaskId);
-      if (!targetTask)
-        continue;
-      const inSchema = targetTask.inputSchema();
-      if (edgeNeedsAccumulation(outSchema, df.sourceTaskPortId, inSchema, df.targetTaskPortId)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  async runTask(task, input) {
-    const isStreamable = isTaskStreamable(task);
-    if (isStreamable) {
-      const dataflows = this.graph.getSourceDataflows(task.id);
-      const streamingEdges = dataflows.filter((df) => df.stream !== undefined);
-      if (streamingEdges.length > 0) {
-        const inputStreams = new Map;
-        for (const df of streamingEdges) {
-          const stream = df.stream;
-          const [forwardCopy, materializeCopy] = stream.tee();
-          inputStreams.set(df.targetTaskPortId, forwardCopy);
-          df.setStream(materializeCopy);
-        }
-        task.runner.inputStreams = inputStreams;
-      }
-    }
-    await this.awaitStreamInputs(task);
-    this.copyInputFromEdgesToNode(task);
-    if (this.activeEnforcer && task.constructor.hasDynamicEntitlements) {
-      const denied = await this.activeEnforcer.checkTask(task);
-      if (denied.length > 0) {
-        throw new TaskEntitlementError(`Task ${task.constructor.type} denied entitlements: ${denied.map(formatEntitlementDenial).join(", ")}`);
-      }
-    }
-    if (isStreamable) {
-      return this.runStreamingTask(task, input);
-    }
-    const results = await task.runner.run(input, {
-      outputCache: this.outputCache ?? false,
-      updateProgress: async (task2, progress, message, ...args) => await this.handleProgress(task2, progress, message, ...args),
-      registry: this.registry,
-      resourceScope: this.resourceScope
-    });
-    await this.pushOutputFromNodeToEdges(task, results);
-    return {
-      id: task.id,
-      type: task.constructor.runtype || task.constructor.type,
-      data: results
-    };
-  }
-  async awaitStreamInputs(task) {
-    const dataflows = this.graph.getSourceDataflows(task.id);
-    const streamingDataflows = dataflows.filter((df) => df.stream !== undefined);
-    if (streamingDataflows.length === 0)
-      return;
-    await Promise.all(streamingDataflows.map(async (df) => {
-      await df.awaitStreamValue();
-      await df.applyTransforms(this.registry);
-    }));
-  }
-  async runStreamingTask(task, input) {
-    const streamMode = getOutputStreamMode(task.outputSchema());
-    const shouldAccumulate = this.taskNeedsAccumulation(task);
-    let streamingNotified = false;
-    const onStatus = (status) => {
-      if (status === TaskStatus.STREAMING && !streamingNotified) {
-        streamingNotified = true;
-        this.pushStatusFromNodeToEdges(this.graph, task, TaskStatus.STREAMING);
-        this.pushStreamToEdges(task, streamMode);
-        this.processScheduler.onTaskStreaming(task.id);
-      }
-    };
-    const onStreamStart = () => {
-      this.graph.emit("task_stream_start", task.id);
-    };
-    const onStreamChunk = (event) => {
-      this.graph.emit("task_stream_chunk", task.id, event);
-    };
-    const onStreamEnd = (output) => {
-      this.graph.emit("task_stream_end", task.id, output);
-    };
-    task.on("status", onStatus);
-    task.on("stream_start", onStreamStart);
-    task.on("stream_chunk", onStreamChunk);
-    task.on("stream_end", onStreamEnd);
-    try {
-      const results = await task.runner.run(input, {
-        outputCache: this.outputCache ?? false,
-        shouldAccumulate,
-        updateProgress: async (task2, progress, message, ...args) => await this.handleProgress(task2, progress, message, ...args),
-        registry: this.registry,
-        resourceScope: this.resourceScope
-      });
-      await this.pushOutputFromNodeToEdges(task, results);
-      return {
-        id: task.id,
-        type: task.constructor.runtype || task.constructor.type,
-        data: results
-      };
-    } finally {
-      task.off("status", onStatus);
-      task.off("stream_start", onStreamStart);
-      task.off("stream_chunk", onStreamChunk);
-      task.off("stream_end", onStreamEnd);
-    }
-  }
-  static isPortDelta(event) {
-    return event.type === "text-delta" || event.type === "object-delta";
-  }
-  createStreamFromTaskEvents(task, portId, edgesForGroup) {
-    return new ReadableStream({
-      start: (controller) => {
-        const onChunk = (event) => {
-          try {
-            if (portId !== undefined && TaskGraphRunner.isPortDelta(event) && event.port !== portId) {
-              return;
-            }
-            if (event.type === "snapshot") {
-              const data = event.data;
-              if (data) {
-                for (const edge of edgesForGroup) {
-                  const portValue = edge.sourceTaskPortId === DATAFLOW_ALL_PORTS ? data : data[edge.sourceTaskPortId];
-                  edge.latestSnapshot = portValue;
-                }
-              }
-            }
-            controller.enqueue(event);
-          } catch {}
-        };
-        const onEnd = () => {
-          try {
-            controller.close();
-          } catch {}
-          task.off("stream_chunk", onChunk);
-          task.off("stream_end", onEnd);
-        };
-        task.on("stream_chunk", onChunk);
-        task.on("stream_end", onEnd);
-      }
-    });
-  }
-  pushStreamToEdges(task, _streamMode) {
-    const targetDataflows = this.graph.getTargetDataflows(task.id);
-    if (targetDataflows.length === 0)
-      return;
-    const groups = new Map;
-    for (const df of targetDataflows) {
-      const key = df.sourceTaskPortId;
-      let group = groups.get(key);
-      if (!group) {
-        group = [];
-        groups.set(key, group);
-      }
-      group.push(df);
-    }
-    for (const [portKey, edges] of groups) {
-      const filterPort = portKey === DATAFLOW_ALL_PORTS ? undefined : portKey;
-      const stream = this.createStreamFromTaskEvents(task, filterPort, edges);
-      if (edges.length === 1) {
-        edges[0].setStream(stream);
-      } else {
-        let currentStream = stream;
-        for (let i = 0;i < edges.length; i++) {
-          if (i === edges.length - 1) {
-            edges[i].setStream(currentStream);
-          } else {
-            const [s1, s2] = currentStream.tee();
-            edges[i].setStream(s1);
-            currentStream = s2;
-          }
-        }
+  }
+  async runTask(task, input) {
+    const isStreamable = isTaskStreamable(task);
+    if (isStreamable) {
+      this.streamPump.prepareStreamingInputs(task);
+    }
+    await this.streamPump.awaitStreamInputs(task, this.registry);
+    this.edgeMaterializer.copyInputFromEdgesToNode(task);
+    if (this.currentCtx?.activeEnforcer && task.constructor.hasDynamicEntitlements) {
+      const denied = await this.currentCtx.activeEnforcer.checkTask(task);
+      if (denied.length > 0) {
+        throw new TaskEntitlementError(`Task ${task.constructor.type} denied entitlements: ${denied.map(formatEntitlementDenial).join(", ")}`);
       }
     }
-  }
-  resetTask(graph, task, runId) {
-    task.status = TaskStatus.PENDING;
-    task.resetInputData();
-    task.runOutputData = {};
-    task.error = undefined;
-    task.progress = 0;
-    task.runConfig = { ...task.runConfig, runnerId: runId };
-    this.pushStatusFromNodeToEdges(graph, task);
-    this.pushErrorFromNodeToEdges(graph, task);
-    task.emit("reset");
-    task.emit("status", task.status);
+    if (isStreamable) {
+      return this.streamPump.runStreamingTask(task, input, this.currentCtx, {
+        registry: this.registry,
+        outputCache: this.outputCache,
+        resourceScope: this.resourceScope,
+        accumulateLeafOutputs: this.accumulateLeafOutputs,
+        updateProgress: (t, p, m, ...a) => this.runScheduler.handleProgress(this.currentCtx, t, p, m, ...a)
+      });
+    }
+    const results = await task.runner.run(input, {
+      outputCache: this.outputCache ?? false,
+      updateProgress: async (task2, progress, message, ...args) => await this.runScheduler.handleProgress(this.currentCtx, task2, progress, message, ...args),
+      registry: this.registry,
+      resourceScope: this.resourceScope
+    });
+    await this.edgeMaterializer.pushOutputFromNodeToEdges(task, results);
+    return {
+      id: task.id,
+      type: task.constructor.runtype || task.constructor.type,
+      data: results
+    };
   }
   resetGraph(graph, runnerId) {
     graph.getTasks().forEach((node) => {
-      this.resetTask(graph, node, runnerId);
+      this.edgeMaterializer.resetTask(graph, node, runnerId);
       node.regenerateGraph();
       if (node.hasChildren()) {
         this.resetGraph(node.subGraph, runnerId);
@@ -3615,34 +3959,18 @@ class TaskGraphRunner {
       throw new TaskConfigurationError("Graph is already running");
     }
     this.running = true;
-    this.abortController = new AbortController;
-    this.abortController.signal.addEventListener("abort", () => {
+    const ctx = new RunContext(config?.parentSignal);
+    this.currentCtx = ctx;
+    ctx.abortController.signal.addEventListener("abort", () => {
       this.handleAbort();
     });
-    if (config?.timeout !== undefined && config.timeout > 0) {
-      this.pendingGraphTimeoutError = undefined;
-      this.graphTimeoutTimer = setTimeout(() => {
-        this.pendingGraphTimeoutError = new TaskGraphTimeoutError(config.timeout);
-        this.abortController?.abort();
-      }, config.timeout);
-    }
-    if (config?.parentSignal) {
-      const onParentAbort = () => {
-        this.abortController?.abort();
-      };
-      config.parentSignal.addEventListener("abort", onParentAbort, { once: true });
-      if (config.parentSignal.aborted) {
-        config.parentSignal.removeEventListener("abort", onParentAbort);
-        this.abortController.abort();
-        return;
-      }
+    if (config?.timeout !== undefined) {
+      this.runScheduler.armGraphTimeout(config.timeout, ctx);
     }
-    this.runId = uuid43();
-    this.resetGraph(this.graph, this.runId);
+    if (ctx.abortController.signal.aborted)
+      return;
+    this.resetGraph(this.graph, ctx.runId);
     this.processScheduler.reset();
-    this.inProgressTasks.clear();
-    this.inProgressFunctions.clear();
-    this.failedTaskErrors.clear();
     try {
       if (config?.maxTasks !== undefined && config.maxTasks > 0) {
         const taskCount = this.graph.getTasks().length;
@@ -3659,25 +3987,20 @@ class TaskGraphRunner {
         if (denied.length > 0) {
           throw new TaskEntitlementError(`Denied entitlements: ${denied.map(formatEntitlementDenial).join(", ")}`);
         }
-        this.activeEnforcer = enforcer;
-      } else {
-        this.activeEnforcer = undefined;
+        ctx.activeEnforcer = enforcer;
       }
     } catch (err) {
-      if (this.graphTimeoutTimer !== undefined) {
-        clearTimeout(this.graphTimeoutTimer);
-        this.graphTimeoutTimer = undefined;
-      }
-      this.abortController = undefined;
-      this.activeEnforcer = undefined;
+      this.runScheduler.clearGraphTimeout(ctx);
+      ctx.dispose();
+      this.currentCtx = undefined;
       this.running = false;
       throw err;
     }
     const telemetry = getTelemetryProvider2();
     if (telemetry.isEnabled) {
-      this.telemetrySpan = telemetry.startSpan("workglow.graph.run", {
+      ctx.telemetrySpan = telemetry.startSpan("workglow.graph.run", {
         attributes: {
-          "workglow.graph.run_id": this.runId,
+          "workglow.graph.run_id": ctx.runId,
           "workglow.graph.task_count": this.graph.getTasks().length,
           "workglow.graph.dataflow_count": this.graph.getDataflows().length
         }
@@ -3702,20 +4025,20 @@ class TaskGraphRunner {
     this.previewRunning = true;
   }
   clearGraphTimeout() {
-    if (this.graphTimeoutTimer !== undefined) {
-      clearTimeout(this.graphTimeoutTimer);
-      this.graphTimeoutTimer = undefined;
+    if (this.currentCtx) {
+      this.runScheduler.clearGraphTimeout(this.currentCtx);
     }
   }
   async handleComplete() {
     this.clearGraphTimeout();
+    const ctx = this.currentCtx;
     this.running = false;
-    this.activeEnforcer = undefined;
-    if (this.telemetrySpan) {
-      this.telemetrySpan.setStatus(SpanStatusCode2.OK);
-      this.telemetrySpan.end();
-      this.telemetrySpan = undefined;
+    if (ctx?.telemetrySpan) {
+      ctx.telemetrySpan.setStatus(SpanStatusCode2.OK);
+      ctx.telemetrySpan.end();
     }
+    ctx?.dispose();
+    this.currentCtx = undefined;
     this.graph.emit("complete");
   }
   async handleCompletePreview() {
@@ -3728,34 +4051,38 @@ class TaskGraphRunner {
         return task.abort();
       }
     }));
+    const ctx = this.currentCtx;
     this.running = false;
-    this.activeEnforcer = undefined;
-    if (this.telemetrySpan) {
-      this.telemetrySpan.setStatus(SpanStatusCode2.ERROR, error.message);
-      this.telemetrySpan.setAttributes({ "workglow.graph.error": error.message });
-      this.telemetrySpan.end();
-      this.telemetrySpan = undefined;
+    if (ctx?.telemetrySpan) {
+      ctx.telemetrySpan.setStatus(SpanStatusCode2.ERROR, error.message);
+      ctx.telemetrySpan.setAttributes({ "workglow.graph.error": error.message });
+      ctx.telemetrySpan.end();
     }
+    ctx?.dispose();
+    this.currentCtx = undefined;
     this.graph.emit("error", error);
   }
   async handleErrorPreview() {
     this.previewRunning = false;
   }
   async handleAbort() {
+    if (!this.running)
+      return;
+    this.running = false;
     this.clearGraphTimeout();
     await Promise.allSettled(this.graph.getTasks().map(async (task) => {
       if (task.status === TaskStatus.PROCESSING || task.status === TaskStatus.STREAMING) {
         return task.abort();
       }
     }));
-    this.running = false;
-    this.activeEnforcer = undefined;
-    if (this.telemetrySpan) {
-      this.telemetrySpan.setStatus(SpanStatusCode2.ERROR, "aborted");
-      this.telemetrySpan.addEvent("workglow.graph.aborted");
-      this.telemetrySpan.end();
-      this.telemetrySpan = undefined;
-    }
+    const ctx = this.currentCtx;
+    if (ctx?.telemetrySpan) {
+      ctx.telemetrySpan.setStatus(SpanStatusCode2.ERROR, "aborted");
+      ctx.telemetrySpan.addEvent("workglow.graph.aborted");
+      ctx.telemetrySpan.end();
+    }
+    ctx?.dispose();
+    this.currentCtx = undefined;
     this.graph.emit("abort");
   }
   async handleAbortPreview() {
@@ -3770,27 +4097,6 @@ class TaskGraphRunner {
     this.running = false;
     this.graph.emit("disabled");
   }
-  async handleProgress(task, progress, message, ...args) {
-    const contributors = this.graph.getTasks().filter(taskPrototypeHasOwnExecute);
-    if (contributors.length > 1) {
-      const determinate = contributors.filter((t) => t.progress !== undefined);
-      if (determinate.length === 0) {
-        progress = undefined;
-      } else {
-        const sum = determinate.reduce((acc, t) => acc + t.progress, 0);
-        progress = Math.round(sum / determinate.length);
-      }
-    } else if (contributors.length === 1) {
-      const [only] = contributors;
-      progress = only.progress;
-    }
-    this.pushStatusFromNodeToEdges(this.graph, task);
-    this.graph.emit("graph_progress", progress, message, args);
-    const isActive = task.status === TaskStatus.PROCESSING || task.status === TaskStatus.STREAMING;
-    if (isActive && task.runOutputData && Object.keys(task.runOutputData).length > 0) {
-      await this.pushOutputFromNodeToEdges(task, task.runOutputData);
-    }
-  }
 }
 
 // src/task/GraphAsTaskRunner.ts
@@ -3800,7 +4106,7 @@ class GraphAsTaskRunner extends TaskRunner {
       this.handleProgress(progress, message, ...args);
     });
     const results = await this.task.subGraph.run(input, {
-      parentSignal: this.abortController?.signal,
+      parentSignal: this.currentCtx?.abortController.signal,
       outputCache: this.outputCache,
       registry: this.registry,
       resourceScope: this.resourceScope
@@ -3814,29 +4120,29 @@ class GraphAsTaskRunner extends TaskRunner {
       resourceScope: this.resourceScope
     });
   }
-  async handleDisable() {
+  async handleDisable(ctx) {
     if (this.task.hasChildren()) {
       await this.task.subGraph.disable();
     }
-    super.handleDisable();
+    await super.handleDisable(ctx);
   }
-  async executeTask(input) {
+  async executeTask(input, ctx) {
     if (this.task.hasChildren()) {
       const runExecuteOutputData = await this.executeTaskChildren(input);
       this.task.runOutputData = this.task.subGraph.mergeExecuteOutputsToRunOutput(runExecuteOutputData, this.task.compoundMerge);
     } else {
-      const result = await super.executeTask(input);
+      const result = await super.executeTask(input, ctx);
       this.task.runOutputData = result ?? {};
     }
     return this.task.runOutputData;
   }
-  async executeTaskPreview(input) {
+  async executeTaskPreview(input, ctx) {
     if (this.task.hasChildren()) {
       const previewResults = await this.executeTaskChildrenPreview();
       this.task.runOutputData = this.task.subGraph.mergeExecuteOutputsToRunOutput(previewResults, this.task.compoundMerge);
       return this.task.runOutputData;
     } else {
-      const previewResult = await super.executeTaskPreview(input);
+      const previewResult = await super.executeTaskPreview(input, ctx);
       if (previewResult !== undefined) {
         this.task.runOutputData = previewResult;
       }
@@ -3900,7 +4206,7 @@ class GraphAsTask extends Task {
         const schemaNode = Task.generateInputSchemaNode(dataPortSchema);
         this._inputSchemaNode = schemaNode;
       } catch (error) {
-        getLogger4().warn(`GraphAsTask "${this.type}" (${this.id}): Failed to compile input schema, ` + `falling back to permissive validation. Inputs will NOT be validated.`, { error, taskType: this.type, taskId: this.id });
+        getLogger6().warn(`GraphAsTask "${this.type}" (${this.id}): Failed to compile input schema, ` + `falling back to permissive validation. Inputs will NOT be validated.`, { error, taskType: this.type, taskId: this.id });
         this._inputSchemaNode = compileSchema2({});
       }
     }
@@ -4344,7 +4650,7 @@ class TaskGraph {
     return this._dag.removeNode(taskId);
   }
   resetGraph() {
-    this.runner.resetGraph(this, uuid44());
+    this.runner.resetGraph(this, uuid45());
   }
   toJSON(options) {
     const tasks = this.getTasks().map((node) => node.toJSON(options));
@@ -4572,7 +4878,7 @@ function serialGraph(tasks, inputHandle, outputHandle) {
   return graph;
 }
 // src/task-graph/Workflow.ts
-import { EventEmitter as EventEmitter5, getLogger as getLogger5, uuid4 as uuid46 } from "@workglow/util";
+import { EventEmitter as EventEmitter5 } from "@workglow/util";
 
 // src/task-graph/autoConnect.ts
 function autoConnect(graph, sourceTask, targetTask, options) {
@@ -4814,8 +5120,64 @@ function autoConnect(graph, sourceTask, targetTask, options) {
   };
 }
 
+// src/task-graph/LoopBuilderContext.ts
+import { getLogger as getLogger7 } from "@workglow/util";
+function runLoopAutoConnect(parentGraph, pending) {
+  const { parent, iteratorTask } = pending;
+  if (parentGraph.getTargetDataflows(parent.id).length !== 0)
+    return;
+  const nodes = parentGraph.getTasks();
+  const parentIndex = nodes.findIndex((n) => n.id === parent.id);
+  const earlierTasks = [];
+  for (let i = parentIndex - 1;i >= 0; i--) {
+    earlierTasks.push(nodes[i]);
+  }
+  const result = autoConnect(parentGraph, parent, iteratorTask, { earlierTasks });
+  if (result.error) {
+    const message = result.error + " Task not added.";
+    getLogger7().error(message);
+    parentGraph.removeTask(iteratorTask.id);
+    return message;
+  }
+  return;
+}
+
+class LoopBuilderContext {
+  parent;
+  iteratorTask;
+  pendingLoopConnect;
+  constructor(parent, iteratorTask) {
+    this.parent = parent;
+    this.iteratorTask = iteratorTask;
+  }
+  finalizeTemplate(childGraph) {
+    if (childGraph.getTasks().length === 0)
+      return;
+    this.iteratorTask.subGraph = childGraph;
+    this.iteratorTask.validateAcyclic();
+  }
+  consumePendingConnect() {
+    const pending = this.pendingLoopConnect;
+    if (!pending)
+      return;
+    const error = runLoopAutoConnect(this.parent.graph, pending);
+    this.pendingLoopConnect = undefined;
+    return error;
+  }
+  finalizeAndReturn(childGraph) {
+    this.finalizeTemplate(childGraph);
+    const error = this.consumePendingConnect();
+    if (error)
+      this.parent.builder.setError(error);
+    return this.parent;
+  }
+}
+
+// src/task-graph/WorkflowBuilder.ts
+import { getLogger as getLogger8, uuid4 as uuid47 } from "@workglow/util";
+
 // src/task-graph/ConditionalBuilder.ts
-import { uuid4 as uuid45 } from "@workglow/util";
+import { uuid4 as uuid46 } from "@workglow/util";
 class ConditionalBuilder {
   workflow;
   condition;
@@ -4854,7 +5216,7 @@ class ConditionalBuilder {
       });
     }
     const conditionalTask = new ConditionalTask({
-      id: uuid45(),
+      id: uuid46(),
       branches,
       exclusive: true,
       defaultBranch: this.elseSpec ? elsePort : undefined
@@ -4868,57 +5230,334 @@ class ConditionalBuilder {
       this.workflow.graph.addTask(elseTask);
       this.workflow.graph.addDataflow(new Dataflow(conditionalTask.id, elsePort, elseTask.id, "*"));
     }
-    return this.workflow;
+    return this.workflow;
+  }
+}
+function instantiate(spec) {
+  const config = {
+    id: uuid46(),
+    ...spec.config,
+    defaults: spec.input
+  };
+  return new spec.taskClass(config);
+}
+
+// src/task-graph/WorkflowPipe.ts
+function getLastTask(workflow) {
+  const tasks = workflow.graph.getTasks();
+  return tasks.length > 0 ? tasks[tasks.length - 1] : undefined;
+}
+function connect(source, target, workflow) {
+  workflow.graph.addDataflow(new Dataflow(source.id, DATAFLOW_ALL_PORTS, target.id, DATAFLOW_ALL_PORTS));
+}
+function pipe(args, workflow = new Workflow) {
+  let previousTask = getLastTask(workflow);
+  const tasks = args.map((arg) => ensureTask(arg));
+  tasks.forEach((task) => {
+    workflow.graph.addTask(task);
+    if (previousTask) {
+      connect(previousTask, task, workflow);
+    }
+    previousTask = task;
+  });
+  return workflow;
+}
+function parallel(args, mergeFn = PROPERTY_ARRAY, workflow = new Workflow) {
+  let previousTask = getLastTask(workflow);
+  const tasks = args.map((arg) => ensureTask(arg));
+  const config = {
+    compoundMerge: mergeFn
+  };
+  const name = `\u2016${args.map((_arg) => "\uD835\uDC53").join("\u2016")}\u2016`;
+
+  class ParallelTask extends GraphAsTask {
+    static type = name;
+  }
+  const mergeTask = new ParallelTask(config);
+  mergeTask.subGraph.addTasks(tasks);
+  workflow.graph.addTask(mergeTask);
+  if (previousTask) {
+    connect(previousTask, mergeTask, workflow);
+  }
+  return workflow;
+}
+
+// src/task-graph/WorkflowBuilder.ts
+class WorkflowBuilder {
+  _facade;
+  _dataFlows = [];
+  _error = "";
+  _registry;
+  _loopContext;
+  constructor(facade, registry, loopContext) {
+    this._facade = facade;
+    this._registry = registry;
+    this._loopContext = loopContext;
+  }
+  get error() {
+    return this._error;
+  }
+  get registry() {
+    return this._registry;
+  }
+  get loopContext() {
+    return this._loopContext;
+  }
+  setError(message) {
+    this._error = message;
+  }
+  resetState() {
+    this._dataFlows = [];
+    this._error = "";
+  }
+  addTaskInstance(taskClass, config) {
+    const task = new taskClass(config, this._registry ? { registry: this._registry } : undefined);
+    const id = this._facade.graph.addTask(task);
+    this._facade.events.emit("changed", id);
+    return task;
+  }
+  addTaskWithAutoConnect(taskClass, input = {}, config = {}) {
+    this._error = "";
+    const parent = getLastTask(this._facade);
+    const task = this.addTaskInstance(taskClass, {
+      id: uuid47(),
+      ...config,
+      defaults: input
+    });
+    if (this._dataFlows.length > 0) {
+      this._dataFlows.forEach((dataflow) => {
+        const taskSchema = task.inputSchema();
+        if (typeof taskSchema !== "boolean" && taskSchema.properties?.[dataflow.targetTaskPortId] === undefined && taskSchema.additionalProperties !== true || taskSchema === true && dataflow.targetTaskPortId !== DATAFLOW_ALL_PORTS) {
+          this._error = `Input ${dataflow.targetTaskPortId} not found on task ${task.id}`;
+          getLogger8().error(this._error);
+          return;
+        }
+        dataflow.targetTaskId = task.id;
+        this._facade.graph.addDataflow(dataflow);
+      });
+      this._dataFlows = [];
+    }
+    if (parent) {
+      const nodes = this._facade.graph.getTasks();
+      const parentIndex = nodes.findIndex((n) => n.id === parent.id);
+      const earlierTasks = [];
+      for (let i = parentIndex - 1;i >= 0; i--) {
+        earlierTasks.push(nodes[i]);
+      }
+      const providedInputKeys = new Set(Object.keys(input || {}));
+      const connectedInputKeys = new Set(this._facade.graph.getSourceDataflows(task.id).map((df) => df.targetTaskPortId));
+      const result = autoConnect(this._facade.graph, parent, task, {
+        providedInputKeys,
+        connectedInputKeys,
+        earlierTasks
+      });
+      if (result.error) {
+        if (this._loopContext !== undefined) {
+          this._error = result.error;
+          getLogger8().warn(this._error);
+        } else {
+          this._error = result.error + " Task not added.";
+          getLogger8().error(this._error);
+          this._facade.graph.removeTask(task.id);
+        }
+      }
+    }
+    if (!this._error) {
+      updateBoundaryTaskSchemas(this._facade.graph);
+    }
+    return this._facade;
+  }
+  addLoopTask(taskClass, config = {}) {
+    this._error = "";
+    const parent = getLastTask(this._facade);
+    const schema = taskClass.configSchema?.();
+    const required = typeof schema === "object" && schema !== null ? schema.required : undefined;
+    const needsMaxIterations = Array.isArray(required) && required.includes("maxIterations");
+    const resolvedConfig = needsMaxIterations && config.maxIterations === undefined ? { ...config, maxIterations: "unbounded" } : config;
+    const task = this.addTaskInstance(taskClass, { id: uuid47(), ...resolvedConfig });
+    if (this._dataFlows.length > 0) {
+      this._dataFlows.forEach((dataflow) => {
+        const taskSchema = task.inputSchema();
+        if (typeof taskSchema !== "boolean" && taskSchema.properties?.[dataflow.targetTaskPortId] === undefined && taskSchema.additionalProperties !== true || taskSchema === true && dataflow.targetTaskPortId !== DATAFLOW_ALL_PORTS) {
+          this._error = `Input ${dataflow.targetTaskPortId} not found on task ${task.id}`;
+          getLogger8().error(this._error);
+          return;
+        }
+        dataflow.targetTaskId = task.id;
+        this._facade.graph.addDataflow(dataflow);
+      });
+      this._dataFlows = [];
+    }
+    const FacadeCtor = this._facade.constructor;
+    const loopBuilder = new FacadeCtor(this._facade.outputCache(), this._facade, task, this._registry);
+    if (parent) {
+      const childCtx = loopBuilder.builder.loopContext;
+      if (childCtx) {
+        childCtx.pendingLoopConnect = { parent, iteratorTask: task };
+      }
+    }
+    return loopBuilder;
+  }
+  connect(sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId) {
+    const sourceTask = this._facade.graph.getTask(sourceTaskId);
+    const targetTask = this._facade.graph.getTask(targetTaskId);
+    if (!sourceTask || !targetTask) {
+      throw new WorkflowError("Source or target task not found");
+    }
+    const sourceSchema = sourceTask.outputSchema();
+    const targetSchema = targetTask.inputSchema();
+    if (typeof sourceSchema === "boolean") {
+      if (sourceSchema === false) {
+        throw new WorkflowError(`Source task has schema 'false' and outputs nothing`);
+      }
+    } else if (!sourceSchema.properties?.[sourceTaskPortId]) {
+      throw new WorkflowError(`Output ${sourceTaskPortId} not found on source task`);
+    }
+    if (typeof targetSchema === "boolean") {
+      if (targetSchema === false) {
+        throw new WorkflowError(`Target task has schema 'false' and accepts no inputs`);
+      }
+      if (targetSchema === true) {}
+    } else if (targetSchema.additionalProperties === true) {} else if (!targetSchema.properties?.[targetTaskPortId]) {
+      throw new WorkflowError(`Input ${targetTaskPortId} not found on target task`);
+    }
+    const dataflow = new Dataflow(sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId);
+    this._facade.graph.addDataflow(dataflow);
+  }
+  rename(source, target, indexOrOptions = -1) {
+    this._error = "";
+    const index = typeof indexOrOptions === "number" ? indexOrOptions : indexOrOptions.index ?? -1;
+    const transforms = typeof indexOrOptions === "number" ? undefined : indexOrOptions.transforms;
+    const nodes = this._facade.graph.getTasks();
+    if (-index > nodes.length) {
+      const errorMsg = `Back index greater than number of tasks`;
+      this._error = errorMsg;
+      getLogger8().error(this._error);
+      throw new WorkflowError(errorMsg);
+    }
+    const lastNode = nodes[nodes.length + index];
+    const outputSchema = lastNode.outputSchema();
+    if (typeof outputSchema === "boolean") {
+      if (outputSchema === false && source !== DATAFLOW_ALL_PORTS) {
+        const errorMsg = `Task ${lastNode.id} has schema 'false' and outputs nothing`;
+        this._error = errorMsg;
+        getLogger8().error(this._error);
+        throw new WorkflowError(errorMsg);
+      }
+    } else if (!outputSchema.properties?.[source] && source !== DATAFLOW_ALL_PORTS) {
+      const errorMsg = `Output ${source} not found on task ${lastNode.id}`;
+      this._error = errorMsg;
+      getLogger8().error(this._error);
+      throw new WorkflowError(errorMsg);
+    }
+    const df = new Dataflow(lastNode.id, source, undefined, target);
+    if (transforms && transforms.length > 0)
+      df.setTransforms(transforms);
+    this._dataFlows.push(df);
+  }
+  onError(handler) {
+    this._error = "";
+    const parent = getLastTask(this._facade);
+    if (!parent) {
+      this._error = "onError() requires a preceding task in the workflow";
+      getLogger8().error(this._error);
+      throw new WorkflowError(this._error);
+    }
+    const handlerTask = ensureTask(handler);
+    this._facade.graph.addTask(handlerTask);
+    const dataflow = new Dataflow(parent.id, DATAFLOW_ERROR_PORT, handlerTask.id, DATAFLOW_ALL_PORTS);
+    this._facade.graph.addDataflow(dataflow);
+    this._facade.events.emit("changed", handlerTask.id);
+  }
+  pop() {
+    this._error = "";
+    const nodes = this._facade.graph.getTasks();
+    if (nodes.length === 0) {
+      this._error = "No tasks to remove";
+      getLogger8().error(this._error);
+      return;
+    }
+    const lastNode = nodes[nodes.length - 1];
+    this._facade.graph.removeTask(lastNode.id);
+  }
+  createConditional(condition) {
+    return new ConditionalBuilder(this._facade, condition);
   }
-}
-function instantiate(spec) {
-  const config = {
-    id: uuid45(),
-    ...spec.config,
-    defaults: spec.input
-  };
-  return new spec.taskClass(config);
 }
 
-// src/task-graph/Workflow.ts
-function getLastTask(workflow) {
-  const tasks = workflow.graph.getTasks();
-  return tasks.length > 0 ? tasks[tasks.length - 1] : undefined;
-}
-function connect(source, target, workflow) {
-  workflow.graph.addDataflow(new Dataflow(source.id, "*", target.id, "*"));
+// src/task-graph/WorkflowCacheAdapter.ts
+class WorkflowCacheAdapter {
+  _outputCache;
+  constructor(cache) {
+    this._outputCache = cache;
+  }
+  outputCache() {
+    return this._outputCache;
+  }
 }
-function pipe(args, workflow = new Workflow) {
-  let previousTask = getLastTask(workflow);
-  const tasks = args.map((arg) => ensureTask(arg));
-  tasks.forEach((task) => {
-    workflow.graph.addTask(task);
-    if (previousTask) {
-      connect(previousTask, task, workflow);
-    }
-    previousTask = task;
-  });
-  return workflow;
+
+// src/task-graph/WorkflowEventBridge.ts
+class WorkflowEventBridge {
+  _events;
+  _attachedGraph;
+  _entitlementUnsub;
+  _onChanged;
+  constructor(events) {
+    this._events = events;
+    this._onChanged = (id) => this._events.emit("changed", id);
+  }
+  attach(graph) {
+    if (this._attachedGraph)
+      this.detach();
+    this._attachedGraph = graph;
+    graph.on("task_added", this._onChanged);
+    graph.on("task_replaced", this._onChanged);
+    graph.on("task_removed", this._onChanged);
+    graph.on("dataflow_added", this._onChanged);
+    graph.on("dataflow_replaced", this._onChanged);
+    graph.on("dataflow_removed", this._onChanged);
+    this._entitlementUnsub = graph.subscribeToTaskEntitlements((entitlements) => this._events.emit("entitlementChange", entitlements));
+  }
+  detach() {
+    const graph = this._attachedGraph;
+    if (!graph)
+      return;
+    graph.off("task_added", this._onChanged);
+    graph.off("task_replaced", this._onChanged);
+    graph.off("task_removed", this._onChanged);
+    graph.off("dataflow_added", this._onChanged);
+    graph.off("dataflow_replaced", this._onChanged);
+    graph.off("dataflow_removed", this._onChanged);
+    this._entitlementUnsub?.();
+    this._entitlementUnsub = undefined;
+    this._attachedGraph = undefined;
+  }
+  beginRun() {
+    const graph = this._attachedGraph;
+    if (!graph)
+      return;
+    return graph.subscribeToTaskStreaming({
+      onStreamStart: (taskId) => this._events.emit("stream_start", taskId),
+      onStreamChunk: (taskId, event) => this._events.emit("stream_chunk", taskId, event),
+      onStreamEnd: (taskId, output) => this._events.emit("stream_end", taskId, output)
+    });
+  }
 }
-function parallel(args, mergeFn = PROPERTY_ARRAY, workflow = new Workflow) {
-  let previousTask = getLastTask(workflow);
-  const tasks = args.map((arg) => ensureTask(arg));
-  const config = {
-    compoundMerge: mergeFn
-  };
-  const name = `\u2016${args.map((_arg) => "\uD835\uDC53").join("\u2016")}\u2016`;
 
-  class ParallelTask extends GraphAsTask {
-    static type = name;
+// src/task-graph/WorkflowRunContext.ts
+class WorkflowRunContext {
+  abortController;
+  unsubStreaming;
+  constructor() {
+    this.abortController = new AbortController;
   }
-  const mergeTask = new ParallelTask(config);
-  mergeTask.subGraph.addTasks(tasks);
-  workflow.graph.addTask(mergeTask);
-  if (previousTask) {
-    connect(previousTask, mergeTask, workflow);
+  dispose() {
+    this.unsubStreaming?.();
+    this.unsubStreaming = undefined;
   }
-  return workflow;
 }
+
+// src/task-graph/WorkflowFactories.ts
 function CreateWorkflow(taskClass) {
   return Workflow.createWorkflow(taskClass);
 }
@@ -4935,42 +5574,6 @@ function CreateEndLoopWorkflow(methodName) {
     return this.finalizeAndReturn();
   };
 }
-var TYPED_ARRAY_FORMAT_PREFIX = "TypedArray";
-function schemaHasTypedArrayFormat(schema) {
-  if (typeof schema === "boolean")
-    return false;
-  if (!schema || typeof schema !== "object" || Array.isArray(schema))
-    return false;
-  const s = schema;
-  if (typeof s.format === "string" && s.format.startsWith(TYPED_ARRAY_FORMAT_PREFIX)) {
-    return true;
-  }
-  const checkUnion = (schemas) => {
-    if (!Array.isArray(schemas))
-      return false;
-    return schemas.some((sub) => schemaHasTypedArrayFormat(sub));
-  };
-  if (checkUnion(s.oneOf) || checkUnion(s.anyOf))
-    return true;
-  const items = s.items;
-  if (items && typeof items === "object" && !Array.isArray(items)) {
-    if (schemaHasTypedArrayFormat(items))
-      return true;
-  }
-  return false;
-}
-function hasVectorOutput(task) {
-  const outputSchema = task.outputSchema();
-  if (typeof outputSchema === "boolean" || !outputSchema?.properties)
-    return false;
-  return Object.values(outputSchema.properties).some((prop) => schemaHasTypedArrayFormat(prop));
-}
-function hasVectorLikeInput(input) {
-  if (!input || typeof input !== "object")
-    return false;
-  const v = input.vectors;
-  return Array.isArray(v) && v.length > 0 && typeof v[0] === "object" && v[0] !== null && ArrayBuffer.isView(v[0]);
-}
 function CreateAdaptiveWorkflow(scalarClass, vectorClass) {
   const scalarHelper = Workflow.createWorkflow(scalarClass);
   const vectorHelper = Workflow.createWorkflow(vectorClass);
@@ -4984,90 +5587,45 @@ function CreateAdaptiveWorkflow(scalarClass, vectorClass) {
   };
 }
 
+// src/task-graph/WorkflowTask.ts
 class WorkflowTask extends GraphAsTask {
   static type = "Workflow";
   static compoundMerge = PROPERTY_ARRAY;
 }
 
+// src/task-graph/Workflow.ts
 class Workflow {
   constructor(cache, parent, iteratorTask, registry) {
-    this._outputCache = cache;
-    this._parentWorkflow = parent;
-    this._iteratorTask = iteratorTask;
-    this._registry = registry ?? parent?._registry;
-    this._graph = new TaskGraph({ outputCache: this._outputCache });
+    this._cache = new WorkflowCacheAdapter(cache);
+    this._graph = new TaskGraph({ outputCache: this._cache.outputCache() });
+    const loopContext = parent && iteratorTask ? new LoopBuilderContext(parent, iteratorTask) : undefined;
+    this._builder = new WorkflowBuilder(this, registry ?? parent?.builderRegistry, loopContext);
     if (!parent) {
-      this._onChanged = this._onChanged.bind(this);
-      this.setupEvents();
+      this._bridge = new WorkflowEventBridge(this.events);
+      this._bridge.attach(this._graph);
     }
   }
   _graph;
-  _dataFlows = [];
-  _error = "";
-  _outputCache;
-  _registry;
-  _entitlementUnsub;
-  _abortController;
-  _parentWorkflow;
-  _iteratorTask;
-  _pendingLoopConnect;
+  _cache;
+  _bridge;
+  _builder;
+  _currentRun;
+  get builderRegistry() {
+    return this._builder.registry;
+  }
+  get builder() {
+    return this._builder;
+  }
   outputCache() {
-    return this._outputCache;
+    return this._cache.outputCache();
   }
   get isLoopBuilder() {
-    return this._parentWorkflow !== undefined;
+    return this._builder.loopContext !== undefined;
   }
   events = new EventEmitter5;
   static createWorkflow(taskClass) {
     const helper = function(input = {}, config = {}) {
-      this._error = "";
-      const parent = getLastTask(this);
-      const task = this.addTaskToGraph(taskClass, {
-        id: uuid46(),
-        ...config,
-        defaults: input
-      });
-      if (this._dataFlows.length > 0) {
-        this._dataFlows.forEach((dataflow) => {
-          const taskSchema = task.inputSchema();
-          if (typeof taskSchema !== "boolean" && taskSchema.properties?.[dataflow.targetTaskPortId] === undefined && taskSchema.additionalProperties !== true || taskSchema === true && dataflow.targetTaskPortId !== DATAFLOW_ALL_PORTS) {
-            this._error = `Input ${dataflow.targetTaskPortId} not found on task ${task.id}`;
-            getLogger5().error(this._error);
-            return;
-          }
-          dataflow.targetTaskId = task.id;
-          this.graph.addDataflow(dataflow);
-        });
-        this._dataFlows = [];
-      }
-      if (parent) {
-        const nodes = this._graph.getTasks();
-        const parentIndex = nodes.findIndex((n) => n.id === parent.id);
-        const earlierTasks = [];
-        for (let i = parentIndex - 1;i >= 0; i--) {
-          earlierTasks.push(nodes[i]);
-        }
-        const providedInputKeys = new Set(Object.keys(input || {}));
-        const connectedInputKeys = new Set(this.graph.getSourceDataflows(task.id).map((df) => df.targetTaskPortId));
-        const result = Workflow.autoConnect(this.graph, parent, task, {
-          providedInputKeys,
-          connectedInputKeys,
-          earlierTasks
-        });
-        if (result.error) {
-          if (this.isLoopBuilder) {
-            this._error = result.error;
-            getLogger5().warn(this._error);
-          } else {
-            this._error = result.error + " Task not added.";
-            getLogger5().error(this._error);
-            this.graph.removeTask(task.id);
-          }
-        }
-      }
-      if (!this._error) {
-        Workflow.updateBoundaryTaskSchemas(this._graph);
-      }
+      this._builder.addTaskWithAutoConnect(taskClass, input, config);
       return this;
     };
     helper.type = taskClass.runtype ?? taskClass.type;
@@ -5082,15 +5640,14 @@ class Workflow {
     return this._graph;
   }
   set graph(value) {
-    this._dataFlows = [];
-    this._error = "";
-    this.clearEvents();
+    this._builder.resetState();
+    this._bridge?.detach();
     this._graph = value;
-    this.setupEvents();
+    this._bridge?.attach(this._graph);
     this.events.emit("reset");
   }
   get error() {
-    return this._error;
+    return this._builder.error;
   }
   on(name, fn) {
     this.events.on(name, fn);
@@ -5105,26 +5662,23 @@ class Workflow {
     return this.events.waitOn(name);
   }
   async run(input = {}, config) {
-    if (this.isLoopBuilder) {
-      this.finalizeTemplate();
-      if (this._pendingLoopConnect) {
-        this._parentWorkflow.autoConnectLoopTask(this._pendingLoopConnect);
-        this._pendingLoopConnect = undefined;
-      }
-      return this._parentWorkflow.run(input, config);
+    const loopContext = this._builder.loopContext;
+    if (loopContext) {
+      loopContext.finalizeTemplate(this._graph);
+      const error = loopContext.consumePendingConnect();
+      if (error)
+        loopContext.parent.builder.setError(error);
+      return loopContext.parent.run(input, config);
     }
     this.events.emit("start");
-    this._abortController = new AbortController;
-    const unsubStreaming = this.graph.subscribeToTaskStreaming({
-      onStreamStart: (taskId) => this.events.emit("stream_start", taskId),
-      onStreamChunk: (taskId, event) => this.events.emit("stream_chunk", taskId, event),
-      onStreamEnd: (taskId, output) => this.events.emit("stream_end", taskId, output)
-    });
+    const ctx = new WorkflowRunContext;
+    this._currentRun = ctx;
+    ctx.unsubStreaming = this._bridge?.beginRun();
     try {
       const output = await this.graph.run(input, {
-        parentSignal: this._abortController.signal,
-        outputCache: this._outputCache,
-        registry: config?.registry ?? this._registry,
+        parentSignal: ctx.abortController.signal,
+        outputCache: this._cache.outputCache(),
+        registry: config?.registry ?? this._builder.registry,
         resourceScope: config?.resourceScope
       });
       const results = this.graph.mergeExecuteOutputsToRunOutput(output, PROPERTY_ARRAY);
@@ -5134,26 +5688,20 @@ class Workflow {
       this.events.emit("error", String(error));
       throw error;
     } finally {
-      unsubStreaming();
-      this._abortController = undefined;
+      ctx.dispose();
+      if (this._currentRun === ctx)
+        this._currentRun = undefined;
     }
   }
   async abort() {
-    if (this._parentWorkflow) {
-      return this._parentWorkflow.abort();
+    const loopContext = this._builder.loopContext;
+    if (loopContext) {
+      return loopContext.parent.abort();
     }
-    this._abortController?.abort();
+    this._currentRun?.abortController.abort();
   }
   pop() {
-    this._error = "";
-    const nodes = this._graph.getTasks();
-    if (nodes.length === 0) {
-      this._error = "No tasks to remove";
-      getLogger5().error(this._error);
-      return this;
-    }
-    const lastNode = nodes[nodes.length - 1];
-    this._graph.removeTask(lastNode.id);
+    this._builder.pop();
     return this;
   }
   toJSON(options = { withBoundaryNodes: true }) {
@@ -5178,50 +5726,11 @@ class Workflow {
     return parallel(args, mergeFn ?? PROPERTY_ARRAY, new Workflow);
   }
   rename(source, target, indexOrOptions = -1) {
-    this._error = "";
-    const index = typeof indexOrOptions === "number" ? indexOrOptions : indexOrOptions.index ?? -1;
-    const transforms = typeof indexOrOptions === "number" ? undefined : indexOrOptions.transforms;
-    const nodes = this._graph.getTasks();
-    if (-index > nodes.length) {
-      const errorMsg = `Back index greater than number of tasks`;
-      this._error = errorMsg;
-      getLogger5().error(this._error);
-      throw new WorkflowError(errorMsg);
-    }
-    const lastNode = nodes[nodes.length + index];
-    const outputSchema = lastNode.outputSchema();
-    if (typeof outputSchema === "boolean") {
-      if (outputSchema === false && source !== DATAFLOW_ALL_PORTS) {
-        const errorMsg = `Task ${lastNode.id} has schema 'false' and outputs nothing`;
-        this._error = errorMsg;
-        getLogger5().error(this._error);
-        throw new WorkflowError(errorMsg);
-      }
-    } else if (!outputSchema.properties?.[source] && source !== DATAFLOW_ALL_PORTS) {
-      const errorMsg = `Output ${source} not found on task ${lastNode.id}`;
-      this._error = errorMsg;
-      getLogger5().error(this._error);
-      throw new WorkflowError(errorMsg);
-    }
-    const df = new Dataflow(lastNode.id, source, undefined, target);
-    if (transforms && transforms.length > 0)
-      df.setTransforms(transforms);
-    this._dataFlows.push(df);
+    this._builder.rename(source, target, indexOrOptions);
     return this;
   }
   onError(handler) {
-    this._error = "";
-    const parent = getLastTask(this);
-    if (!parent) {
-      this._error = "onError() requires a preceding task in the workflow";
-      getLogger5().error(this._error);
-      throw new WorkflowError(this._error);
-    }
-    const handlerTask = ensureTask(handler);
-    this.graph.addTask(handlerTask);
-    const dataflow = new Dataflow(parent.id, DATAFLOW_ERROR_PORT, handlerTask.id, DATAFLOW_ALL_PORTS);
-    this.graph.addDataflow(dataflow);
-    this.events.emit("changed", handlerTask.id);
+    this._builder.onError(handler);
     return this;
   }
   toTaskGraph() {
@@ -5233,248 +5742,58 @@ class Workflow {
     return task;
   }
   reset() {
-    if (this._parentWorkflow) {
+    if (this._builder.loopContext) {
       throw new WorkflowError("Cannot reset a loop workflow. Call reset() on the parent workflow.");
     }
-    this.clearEvents();
+    this._bridge?.detach();
     this._graph = new TaskGraph({
-      outputCache: this._outputCache
+      outputCache: this._cache.outputCache()
     });
-    this._dataFlows = [];
-    this._error = "";
-    this.setupEvents();
+    this._builder.resetState();
+    this._bridge?.attach(this._graph);
     this.events.emit("changed", undefined);
     this.events.emit("reset");
     return this;
   }
-  setupEvents() {
-    this._graph.on("task_added", this._onChanged);
-    this._graph.on("task_replaced", this._onChanged);
-    this._graph.on("task_removed", this._onChanged);
-    this._graph.on("dataflow_added", this._onChanged);
-    this._graph.on("dataflow_replaced", this._onChanged);
-    this._graph.on("dataflow_removed", this._onChanged);
-    this._entitlementUnsub = this._graph.subscribeToTaskEntitlements((entitlements) => this.events.emit("entitlementChange", entitlements));
-  }
-  clearEvents() {
-    this._graph.off("task_added", this._onChanged);
-    this._graph.off("task_replaced", this._onChanged);
-    this._graph.off("task_removed", this._onChanged);
-    this._graph.off("dataflow_added", this._onChanged);
-    this._graph.off("dataflow_replaced", this._onChanged);
-    this._graph.off("dataflow_removed", this._onChanged);
-    this._entitlementUnsub?.();
-    this._entitlementUnsub = undefined;
-  }
-  _onChanged(id) {
-    this.events.emit("changed", id);
-  }
   connect(sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId) {
-    const sourceTask = this.graph.getTask(sourceTaskId);
-    const targetTask = this.graph.getTask(targetTaskId);
-    if (!sourceTask || !targetTask) {
-      throw new WorkflowError("Source or target task not found");
-    }
-    const sourceSchema = sourceTask.outputSchema();
-    const targetSchema = targetTask.inputSchema();
-    if (typeof sourceSchema === "boolean") {
-      if (sourceSchema === false) {
-        throw new WorkflowError(`Source task has schema 'false' and outputs nothing`);
-      }
-    } else if (!sourceSchema.properties?.[sourceTaskPortId]) {
-      throw new WorkflowError(`Output ${sourceTaskPortId} not found on source task`);
-    }
-    if (typeof targetSchema === "boolean") {
-      if (targetSchema === false) {
-        throw new WorkflowError(`Target task has schema 'false' and accepts no inputs`);
-      }
-      if (targetSchema === true) {}
-    } else if (targetSchema.additionalProperties === true) {} else if (!targetSchema.properties?.[targetTaskPortId]) {
-      throw new WorkflowError(`Input ${targetTaskPortId} not found on target task`);
-    }
-    const dataflow = new Dataflow(sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId);
-    this.graph.addDataflow(dataflow);
+    this._builder.connect(sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId);
     return this;
   }
   addTaskToGraph(taskClass, config) {
-    const task = new taskClass(config, this._registry ? { registry: this._registry } : undefined);
-    const id = this.graph.addTask(task);
-    this.events.emit("changed", id);
-    return task;
+    return this._builder.addTaskInstance(taskClass, config);
   }
   addTask(taskClass, input, config) {
-    const helper = Workflow.createWorkflow(taskClass);
-    return helper.call(this, input, config);
+    return this._builder.addTaskWithAutoConnect(taskClass, input, config);
   }
   addLoopTask(taskClass, config = {}) {
-    this._error = "";
-    const parent = getLastTask(this);
-    const schema = taskClass.configSchema?.();
-    const required = typeof schema === "object" && schema !== null ? schema.required : undefined;
-    const needsMaxIterations = Array.isArray(required) && required.includes("maxIterations");
-    const resolvedConfig = needsMaxIterations && config.maxIterations === undefined ? { ...config, maxIterations: "unbounded" } : config;
-    const task = this.addTaskToGraph(taskClass, { id: uuid46(), ...resolvedConfig });
-    if (this._dataFlows.length > 0) {
-      this._dataFlows.forEach((dataflow) => {
-        const taskSchema = task.inputSchema();
-        if (typeof taskSchema !== "boolean" && taskSchema.properties?.[dataflow.targetTaskPortId] === undefined && taskSchema.additionalProperties !== true || taskSchema === true && dataflow.targetTaskPortId !== DATAFLOW_ALL_PORTS) {
-          this._error = `Input ${dataflow.targetTaskPortId} not found on task ${task.id}`;
-          getLogger5().error(this._error);
-          return;
-        }
-        dataflow.targetTaskId = task.id;
-        this.graph.addDataflow(dataflow);
-      });
-      this._dataFlows = [];
-    }
-    const loopBuilder = new Workflow(this.outputCache(), this, task, this._registry);
-    if (parent) {
-      loopBuilder._pendingLoopConnect = { parent, iteratorTask: task };
-    }
-    return loopBuilder;
+    return this._builder.addLoopTask(taskClass, config);
   }
   if(condition) {
-    return new ConditionalBuilder(this, condition);
+    return this._builder.createConditional(condition);
   }
   autoConnectLoopTask(pending) {
     if (!pending)
       return;
-    const { parent, iteratorTask } = pending;
-    if (this.graph.getTargetDataflows(parent.id).length === 0) {
-      const nodes = this._graph.getTasks();
-      const parentIndex = nodes.findIndex((n) => n.id === parent.id);
-      const earlierTasks = [];
-      for (let i = parentIndex - 1;i >= 0; i--) {
-        earlierTasks.push(nodes[i]);
-      }
-      const result = Workflow.autoConnect(this.graph, parent, iteratorTask, {
-        earlierTasks
-      });
-      if (result.error) {
-        this._error = result.error + " Task not added.";
-        getLogger5().error(this._error);
-        this.graph.removeTask(iteratorTask.id);
-      }
-    }
-  }
-  static updateBoundaryTaskSchemas(graph) {
-    const tasks = graph.getTasks();
-    for (const task of tasks) {
-      if (task.type === "InputTask") {
-        const existingConfig = task.config;
-        const existingSchema = existingConfig?.inputSchema ?? existingConfig?.outputSchema;
-        if (existingSchema && typeof existingSchema === "object" && existingSchema["x-ui-manual"] === true) {
-          continue;
-        }
-        const outgoing = graph.getTargetDataflows(task.id);
-        if (outgoing.length === 0)
-          continue;
-        const properties = {};
-        const required = [];
-        for (const df of outgoing) {
-          const targetTask = graph.getTask(df.targetTaskId);
-          if (!targetTask)
-            continue;
-          const targetSchema = targetTask.inputSchema();
-          if (typeof targetSchema === "boolean")
-            continue;
-          const prop = targetSchema.properties?.[df.targetTaskPortId];
-          if (prop && typeof prop !== "boolean") {
-            properties[df.sourceTaskPortId] = prop;
-            if (targetSchema.required?.includes(df.targetTaskPortId)) {
-              if (!required.includes(df.sourceTaskPortId)) {
-                required.push(df.sourceTaskPortId);
-              }
-            }
-          }
-        }
-        const schema = {
-          type: "object",
-          properties,
-          ...required.length > 0 ? { required } : {},
-          additionalProperties: false
-        };
-        task.config = {
-          ...task.config,
-          inputSchema: schema,
-          outputSchema: schema
-        };
-      }
-      if (task.type === "OutputTask") {
-        const incoming = graph.getSourceDataflows(task.id);
-        if (incoming.length === 0)
-          continue;
-        const properties = {};
-        const required = [];
-        for (const df of incoming) {
-          const sourceTask = graph.getTask(df.sourceTaskId);
-          if (!sourceTask)
-            continue;
-          const sourceSchema = sourceTask.outputSchema();
-          if (typeof sourceSchema === "boolean")
-            continue;
-          let prop = sourceSchema.properties?.[df.sourceTaskPortId];
-          let propRequired = sourceSchema.required?.includes(df.sourceTaskPortId) ?? false;
-          if (!prop && sourceSchema.additionalProperties === true && sourceTask.constructor.passthroughInputsToOutputs === true) {
-            const upstreamDfs = graph.getSourceDataflows(sourceTask.id);
-            for (const udf of upstreamDfs) {
-              if (udf.targetTaskPortId !== df.sourceTaskPortId)
-                continue;
-              const upstreamTask = graph.getTask(udf.sourceTaskId);
-              if (!upstreamTask)
-                continue;
-              const upstreamSchema = upstreamTask.outputSchema();
-              if (typeof upstreamSchema === "boolean")
-                continue;
-              prop = upstreamSchema.properties?.[udf.sourceTaskPortId];
-              if (prop) {
-                propRequired = upstreamSchema.required?.includes(udf.sourceTaskPortId) ?? false;
-                break;
-              }
-            }
-          }
-          if (prop && typeof prop !== "boolean") {
-            properties[df.targetTaskPortId] = prop;
-            if (propRequired && !required.includes(df.targetTaskPortId)) {
-              required.push(df.targetTaskPortId);
-            }
-          }
-        }
-        const schema = {
-          type: "object",
-          properties,
-          ...required.length > 0 ? { required } : {},
-          additionalProperties: false
-        };
-        task.config = {
-          ...task.config,
-          inputSchema: schema,
-          outputSchema: schema
-        };
-      }
-    }
+    const error = runLoopAutoConnect(this._graph, pending);
+    if (error)
+      this._builder.setError(error);
   }
   static AutoConnectOptions = Symbol("AutoConnectOptions");
   static autoConnect(graph, sourceTask, targetTask, options) {
     return autoConnect(graph, sourceTask, targetTask, options);
   }
   finalizeTemplate() {
-    if (!this._iteratorTask || this.graph.getTasks().length === 0) {
+    const ctx = this._builder.loopContext;
+    if (!ctx)
       return;
-    }
-    this._iteratorTask.subGraph = this.graph;
-    this._iteratorTask.validateAcyclic();
+    ctx.finalizeTemplate(this._graph);
   }
   finalizeAndReturn() {
-    if (!this._parentWorkflow) {
+    const ctx = this._builder.loopContext;
+    if (!ctx) {
       throw new WorkflowError("finalizeAndReturn() can only be called on loop workflows");
     }
-    this.finalizeTemplate();
-    if (this._pendingLoopConnect) {
-      this._parentWorkflow.autoConnectLoopTask(this._pendingLoopConnect);
-      this._pendingLoopConnect = undefined;
-    }
-    return this._parentWorkflow;
+    return ctx.finalizeAndReturn(this._graph);
   }
 }
 Workflow.prototype.group = CreateLoopWorkflow(GraphAsTask);
@@ -6160,13 +6479,13 @@ function getProfileGrants(profile) {
 }
 // src/task/FallbackTaskRunner.ts
 class FallbackTaskRunner extends GraphAsTaskRunner {
-  async executeTask(input) {
+  async executeTask(input, _ctx) {
     if (this.task.fallbackMode === "data") {
       return this.executeDataFallback(input);
     }
     return this.executeTaskFallback(input);
   }
-  async executeTaskPreview(input) {
+  async executeTaskPreview(input, _ctx) {
     return this.task.executePreview?.(input, { own: this.own });
   }
   async executeTaskFallback(input) {
@@ -6177,7 +6496,7 @@ class FallbackTaskRunner extends GraphAsTaskRunner {
     const errors = [];
     const totalAttempts = tasks.length;
     for (let i = 0;i < tasks.length; i++) {
-      if (this.abortController?.signal.aborted) {
+      if (this.currentCtx?.abortController.signal.aborted) {
         throw new TaskAbortedError("Fallback aborted");
       }
       const alternativeTask = tasks[i];
@@ -6214,7 +6533,7 @@ class FallbackTaskRunner extends GraphAsTaskRunner {
     const unsubscribeSubgraphProgress = this.task.subGraph.subscribe("graph_progress", onSubgraphProgress);
     try {
       for (let i = 0;i < alternatives.length; i++) {
-        if (this.abortController?.signal.aborted) {
+        if (this.currentCtx?.abortController.signal.aborted) {
           throw new TaskAbortedError("Fallback aborted");
         }
         currentAttemptIndex = i;
@@ -6225,7 +6544,7 @@ class FallbackTaskRunner extends GraphAsTaskRunner {
           this.resetSubgraph();
           const mergedInput = { ...input, ...alternative };
           const results = await this.task.subGraph.run(mergedInput, {
-            parentSignal: this.abortController?.signal,
+            parentSignal: this.currentCtx?.abortController.signal,
             outputCache: this.outputCache,
             registry: this.registry
           });
@@ -6447,12 +6766,12 @@ async function compactSchemaInputs(input, schema, config, visited = new Set) {
   return compacted;
 }
 // src/task/IteratorTaskRunner.ts
-import { uuid4 as uuid47 } from "@workglow/util";
+import { uuid4 as uuid48 } from "@workglow/util";
 class IteratorTaskRunner extends GraphAsTaskRunner {
   aggregatingParentMapProgress = false;
   mapPartialProgress = [];
   mapPartialIterationCount = 0;
-  async executeTask(input) {
+  async executeTask(input, _ctx) {
     let analysis = this.task.analyzeIterationInput(input);
     const maxIterations = resolveIterationBound(this.task.config.maxIterations);
     if (analysis.iterationCount > maxIterations) {
@@ -6464,7 +6783,7 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
     const result = this.task.isReduceTask() ? await this.executeReduceIterations(analysis) : await this.executeCollectIterations(analysis);
     return result;
   }
-  async executeTaskPreview(input) {
+  async executeTaskPreview(input, _ctx) {
     return this.task.executePreview?.(input, { own: this.own });
   }
   async executeCollectIterations(analysis) {
@@ -6480,7 +6799,7 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
     this.mapPartialProgress = new Array(iterationCount).fill(0);
     try {
       for (let batchStart = 0;batchStart < iterationCount; batchStart += batchSize) {
-        if (this.abortController?.signal.aborted) {
+        if (this.currentCtx?.abortController.signal.aborted) {
           break;
         }
         const batchEnd = Math.min(batchStart + batchSize, iterationCount);
@@ -6517,7 +6836,7 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
     const iterationCount = analysis.iterationCount;
     let accumulator = this.task.getInitialAccumulator();
     for (let index = 0;index < iterationCount; index++) {
-      if (this.abortController?.signal.aborted) {
+      if (this.currentCtx?.abortController.signal.aborted) {
         break;
       }
       const iterationInput = this.task.buildIterationRunInput(analysis, index, iterationCount, {
@@ -6536,7 +6855,7 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
     const workerCount = Math.max(1, Math.min(concurrency, indices.length));
     const workers = Array.from({ length: workerCount }, async () => {
       while (true) {
-        if (this.abortController?.signal.aborted) {
+        if (this.currentCtx?.abortController.signal.aborted) {
           return;
         }
         const position = cursor;
@@ -6559,7 +6878,7 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
     const idMap = new Map;
     for (const task of graph.getTasks()) {
       const ctor = task.constructor;
-      const newId = uuid47();
+      const newId = uuid48();
       idMap.set(task.config.id, newId);
       const clonedConfig = { ...task.config, id: newId };
       const newTask = new ctor({ ...clonedConfig, defaults: task.defaults }, task.runConfig);
@@ -6574,7 +6893,7 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
     return clone;
   }
   async executeSubgraphIteration(input, index, iterationCount) {
-    if (this.abortController?.signal.aborted) {
+    if (this.currentCtx?.abortController.signal.aborted) {
       return;
     }
     const graphClone = this.cloneGraph(this.task.subGraph);
@@ -6589,7 +6908,7 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
     const unsubscribeGraphProgress = graphClone.subscribe("graph_progress", onGraphProgress);
     try {
       const results = await graphClone.run(input, {
-        parentSignal: this.abortController?.signal,
+        parentSignal: this.currentCtx?.abortController.signal,
         outputCache: this.outputCache,
         registry: this.registry,
         resourceScope: this.resourceScope
@@ -7123,16 +7442,16 @@ class IteratorTask extends GraphAsTask {
 
 // src/task/WhileTaskRunner.ts
 class WhileTaskRunner extends GraphAsTaskRunner {
-  async executeTask(input) {
+  async executeTask(input, ctx) {
     const result = await this.task.execute(input, {
-      signal: this.abortController.signal,
+      signal: ctx.abortController.signal,
       updateProgress: this.handleProgress.bind(this),
       own: this.own,
       registry: this.registry
     });
     return result;
   }
-  async executeTaskPreview(input) {
+  async executeTaskPreview(input, _ctx) {
     return this.task.executePreview?.(input, { own: this.own });
   }
 }
@@ -7756,7 +8075,8 @@ var defaultJobQueueFactory = async ({
     deleteAfterCompletionMs: options?.deleteAfterCompletionMs,
     deleteAfterFailureMs: options?.deleteAfterFailureMs,
     deleteAfterDisabledMs: options?.deleteAfterDisabledMs,
-    cleanupIntervalMs: options?.cleanupIntervalMs
+    cleanupIntervalMs: options?.cleanupIntervalMs,
+    stopTimeoutMs: options?.stopTimeoutMs
   });
   const client = new JobQueueClient({
     storage,
@@ -7789,7 +8109,8 @@ function createJobQueueFactoryWithOptions(defaultOptions = {}) {
       deleteAfterCompletionMs: mergedOptions.deleteAfterCompletionMs,
       deleteAfterFailureMs: mergedOptions.deleteAfterFailureMs,
       deleteAfterDisabledMs: mergedOptions.deleteAfterDisabledMs,
-      cleanupIntervalMs: mergedOptions.cleanupIntervalMs
+      cleanupIntervalMs: mergedOptions.cleanupIntervalMs,
+      stopTimeoutMs: mergedOptions.stopTimeoutMs
     });
     const client = new JobQueueClient({
       storage,
@@ -8003,7 +8324,7 @@ queueMicrotask(() => {
 // src/task/TaskRegistry.ts
 import {
   createServiceToken as createServiceToken6,
-  getLogger as getLogger6,
+  getLogger as getLogger9,
   globalServiceRegistry as globalServiceRegistry5,
   registerInputCompactor,
   registerInputResolver
@@ -8026,7 +8347,7 @@ function registerTask(baseClass) {
     const result = validateSchema(schema);
     if (!result.valid) {
       const messages = result.errors.map((e) => `${e.path}: ${e.message}`).join("; ");
-      getLogger6().warn(`Task "${baseClass.type}" has invalid ${name}: ${messages}`, {
+      getLogger9().warn(`Task "${baseClass.type}" has invalid ${name}: ${messages}`, {
         taskType: baseClass.type,
         schemaName: name,
         errors: result.errors
@@ -8371,6 +8692,7 @@ export {
   wrapSchemaInArray,
   whileTaskConfigSchema,
   uppercaseTransform,
+  updateBoundaryTaskSchemas,
   unixToIsoDateTransform,
   truncateTransform,
   toBooleanTransform,
@@ -8384,6 +8706,7 @@ export {
   schemaAcceptsArray,
   scanGraphForFormat,
   scanGraphForCredentials,
+  runLoopAutoConnect,
   resourcePatternMatches,
   resolveSchemaInputs,
   resolveIterationBound,
@@ -8476,7 +8799,11 @@ export {
   addBoundaryNodesToGraphJson,
   addBoundaryNodesToDependencyJson,
   _resetPortCodecsForTests,
+  WorkflowRunContext,
+  WorkflowEventBridge,
   WorkflowError,
+  WorkflowCacheAdapter,
+  WorkflowBuilder,
   Workflow,
   WhileTaskRunner,
   WhileTask,
@@ -8485,6 +8812,7 @@ export {
   TaskTimeoutError,
   TaskStatus,
   TaskSerializationError,
+  TaskRunContext,
   TaskRegistry,
   TaskQueueRegistry,
   TaskOutputTabularRepository,
@@ -8511,12 +8839,17 @@ export {
   TASK_OUTPUT_REPOSITORY,
   TASK_GRAPH_REPOSITORY,
   TASK_CONSTRUCTORS,
+  StreamPump,
+  StreamProcessor,
   SERVER_GRANTS,
+  RunScheduler,
+  RunContext,
   ReduceTask,
   PROPERTY_ARRAY,
   PERMISSIVE_RESOLVER,
   PERMISSIVE_ENFORCER,
   MapTask,
+  LoopBuilderContext,
   JobTaskFailedError,
   JOB_QUEUE_FACTORY,
   IteratorTaskRunner,
@@ -8531,6 +8864,7 @@ export {
   EventTaskGraphToDagMapping,
   EventDagToTaskGraphMapping,
   Entitlements,
+  EdgeMaterializer,
   ENTITLEMENT_RESOLVER,
   ENTITLEMENT_ENFORCER,
   EMPTY_POLICY,
@@ -8546,7 +8880,8 @@ export {
   CreateEndLoopWorkflow,
   CreateAdaptiveWorkflow,
   ConditionalTask,
+  CacheCoordinator,
   BROWSER_GRANTS
 };
 
-//# debugId=84C93480A08A674564756E2164756E21
+//# debugId=732100600E6F7E9764756E2164756E21