@workglow/util 0.0.121 → 0.0.123

package/dist/browser.js

@@ -430,975 +430,6 @@ class BaseError {
     return `${this.name}: ${this.message}`;
   }
 }
-
-// src/graph/errors.ts
-class NodeAlreadyExistsError extends BaseError {
-  static type = "NodeAlreadyExistsError";
-  newNode;
-  oldNode;
-  identity;
-  constructor(newNode, oldNode, identity) {
-    super(`${JSON.stringify(newNode)} shares an identity (${String(identity)}) with ${JSON.stringify(oldNode)}`);
-    this.newNode = newNode;
-    this.oldNode = oldNode;
-    this.identity = identity;
-    this.name = "NodeAlreadyExistsError";
-    Object.setPrototypeOf(this, NodeAlreadyExistsError.prototype);
-  }
-}
-
-class NodeDoesntExistError extends BaseError {
-  static type = "NodeDoesntExistError";
-  identity;
-  constructor(identity) {
-    super(`A node with identity ${String(identity)} doesn't exist in the graph`);
-    this.identity = identity;
-    this.name = "NodeDoesntExistError";
-    Object.setPrototypeOf(this, NodeDoesntExistError.prototype);
-  }
-}
-
-class CycleError extends BaseError {
-  static type = "CycleError";
-  constructor(message) {
-    super(message);
-    this.name = "CycleError";
-    Object.setPrototypeOf(this, CycleError.prototype);
-  }
-}
-
-// src/graph/graph.ts
-class Graph {
-  nodes;
-  adjacency;
-  nodeIdentity;
-  edgeIdentity;
-  constructor(nodeIdentity, edgeIdentity) {
-    this.nodes = new Map;
-    this.adjacency = [];
-    this.nodeIdentity = nodeIdentity;
-    this.edgeIdentity = edgeIdentity;
-  }
-  events = new EventEmitter;
-  on(name, fn) {
-    this.events.on.call(this.events, name, fn);
-  }
-  off(name, fn) {
-    this.events.off.call(this.events, name, fn);
-  }
-  emit(name, ...args) {
-    this.events.emit(name, ...args);
-  }
-  insert(node) {
-    const id = this.nodeIdentity(node);
-    const isOverwrite = this.nodes.has(id);
-    if (isOverwrite) {
-      throw new NodeAlreadyExistsError(node, this.nodes.get(id), id);
-    }
-    this.nodes.set(id, node);
-    this.adjacency.map((adj) => adj.push(null));
-    this.adjacency.push(new Array(this.adjacency.length + 1).fill(null));
-    this.emit("node-added", id);
-    return id;
-  }
-  replace(node) {
-    const id = this.nodeIdentity(node);
-    const isOverwrite = this.nodes.has(id);
-    if (!isOverwrite) {
-      throw new NodeDoesntExistError(id);
-    }
-    this.nodes.set(id, node);
-    this.emit("node-replaced", id);
-  }
-  upsert(node) {
-    const id = this.nodeIdentity(node);
-    const isOverwrite = this.nodes.has(id);
-    this.nodes.set(id, node);
-    if (!isOverwrite) {
-      this.adjacency.map((adj) => adj.push(null));
-      this.adjacency.push(new Array(this.adjacency.length + 1).fill(null));
-      this.emit("node-added", id);
-    } else {
-      this.emit("node-replaced", id);
-    }
-    return id;
-  }
-  addEdge(node1Identity, node2Identity, edge) {
-    if (edge === undefined) {
-      edge = true;
-    }
-    const node1Exists = this.nodes.has(node1Identity);
-    const node2Exists = this.nodes.has(node2Identity);
-    if (!node1Exists) {
-      throw new NodeDoesntExistError(node1Identity);
-    }
-    if (!node2Exists) {
-      throw new NodeDoesntExistError(node2Identity);
-    }
-    const node1Index = Array.from(this.nodes.keys()).indexOf(node1Identity);
-    const node2Index = Array.from(this.nodes.keys()).indexOf(node2Identity);
-    if (this.adjacency[node1Index][node2Index] === null) {
-      this.adjacency[node1Index][node2Index] = [edge];
-    } else {
-      if (!this.adjacency[node1Index][node2Index].includes(edge)) {
-        this.adjacency[node1Index][node2Index].push(edge);
-      }
-    }
-    const id = this.edgeIdentity(edge, node1Identity, node2Identity);
-    this.emit("edge-added", id);
-    return id;
-  }
-  getNodes(compareFunc) {
-    const temp = Array.from(this.nodes.values());
-    if (compareFunc !== undefined) {
-      return temp.sort(compareFunc);
-    }
-    return temp;
-  }
-  getNode(nodeIdentity) {
-    return this.nodes.get(nodeIdentity);
-  }
-  hasNode(nodeIdentity) {
-    return this.nodes.has(nodeIdentity);
-  }
-  getEdges() {
-    const toReturn = [];
-    const nodeKeys = Array.from(this.nodes.keys());
-    this.adjacency.forEach((row, rowIndex) => {
-      const node1Identity = nodeKeys[rowIndex];
-      if (node1Identity != null) {
-        row.forEach((edges, colIndex) => {
-          if (edges !== null) {
-            const node2Identity = nodeKeys[colIndex];
-            if (node2Identity != null) {
-              for (const edge of edges) {
-                toReturn.push([node1Identity, node2Identity, edge]);
-              }
-            }
-          }
-        });
-      }
-    });
-    return toReturn;
-  }
-  outEdges(node1Identity) {
-    const nodeKeys = Array.from(this.nodes.keys());
-    const nodeIndex = nodeKeys.indexOf(node1Identity);
-    const toReturn = [];
-    this.adjacency[nodeIndex].forEach((edges, colIndex) => {
-      if (edges !== null) {
-        const node2Identity = nodeKeys[colIndex];
-        if (node2Identity != null) {
-          for (const edge of edges) {
-            toReturn.push([node1Identity, node2Identity, edge]);
-          }
-        }
-      }
-    });
-    return toReturn;
-  }
-  inEdges(node2Identity) {
-    const nodeKeys = Array.from(this.nodes.keys());
-    const node2Index = nodeKeys.indexOf(node2Identity);
-    const toReturn = [];
-    this.adjacency.forEach((row, rowIndex) => {
-      const node1Identity = nodeKeys[rowIndex];
-      const edges = row[node2Index];
-      if (edges !== null) {
-        for (const edge of edges) {
-          toReturn.push([node1Identity, node2Identity, edge]);
-        }
-      }
-    });
-    return toReturn;
-  }
-  nodeEdges(nodeIdentity) {
-    return [...this.outEdges(nodeIdentity), ...this.inEdges(nodeIdentity)];
-  }
-  removeEdge(node1Identity, node2Identity, edgeIdentity) {
-    const node1Exists = this.nodes.has(node1Identity);
-    const node2Exists = this.nodes.has(node2Identity);
-    if (!node1Exists) {
-      throw new NodeDoesntExistError(node1Identity);
-    }
-    if (!node2Exists) {
-      throw new NodeDoesntExistError(node2Identity);
-    }
-    const node1Index = Array.from(this.nodes.keys()).indexOf(node1Identity);
-    const node2Index = Array.from(this.nodes.keys()).indexOf(node2Identity);
-    if (edgeIdentity === undefined) {
-      this.adjacency[node1Index][node2Index] = null;
-    } else {
-      for (const row of this.adjacency) {
-        for (const edgelist of row) {
-          if (edgelist !== null) {
-            for (let edgeIndex = 0;edgeIndex < edgelist.length; edgeIndex++) {
-              if (this.edgeIdentity(edgelist[edgeIndex], node1Identity, node2Identity) === edgeIdentity) {
-                edgelist.splice(edgeIndex, 1);
-              }
-            }
-          }
-        }
-      }
-    }
-    this.emit("edge-removed", edgeIdentity);
-  }
-  remove(nodeIdentity) {
-    if (!this.nodes.has(nodeIdentity)) {
-      throw new NodeDoesntExistError(nodeIdentity);
-    }
-    this.nodes.delete(nodeIdentity);
-    const nodeIndex = Array.from(this.nodes.keys()).indexOf(nodeIdentity);
-    this.adjacency.splice(nodeIndex, 1);
-    this.adjacency.forEach((row) => row.splice(nodeIndex, 1));
-    this.emit("node-removed", nodeIdentity);
-  }
-  removeNode(nodeIdentity) {
-    return this.remove(nodeIdentity);
-  }
-  addNode(node) {
-    return this.insert(node);
-  }
-  addNodes(nodes) {
-    return nodes.map((node) => this.insert(node));
-  }
-  addEdges(edges) {
-    return edges.map(([node1Identity, node2Identity, edge]) => this.addEdge(node1Identity, node2Identity, edge));
-  }
-}
-
-// src/graph/directedGraph.ts
-class DirectedGraph extends Graph {
-  hasCycle = false;
-  isAcyclic() {
-    if (this.hasCycle !== undefined) {
-      return !this.hasCycle;
-    }
-    const nodeIndices = Array.from(this.nodes.keys());
-    const nodeInDegrees = new Map(Array.from(this.nodes.keys()).map((n) => [n, this.indegreeOfNode(n)]));
-    const toSearch = Array.from(nodeInDegrees).filter((pair) => pair[1] === 0);
-    let visitedNodes = 0;
-    while (toSearch.length > 0) {
-      const cur = toSearch.pop();
-      if (cur === undefined) {
-        continue;
-      }
-      const nodeIndex = nodeIndices.indexOf(cur[0]);
-      this.adjacency[nodeIndex].forEach((hasAdj, index) => {
-        if (hasAdj !== null) {
-          const currentInDegree = nodeInDegrees.get(nodeIndices[index]);
-          if (currentInDegree !== undefined) {
-            nodeInDegrees.set(nodeIndices[index], currentInDegree - 1);
-            if (currentInDegree - 1 === 0) {
-              toSearch.push([nodeIndices[index], currentInDegree - 1]);
-            }
-          }
-        }
-      });
-      visitedNodes++;
-    }
-    this.hasCycle = !(visitedNodes === this.nodes.size);
-    return visitedNodes === this.nodes.size;
-  }
-  indegreeOfNode(nodeID) {
-    const nodeIdentities = Array.from(this.nodes.keys());
-    const indexOfNode = nodeIdentities.indexOf(nodeID);
-    if (indexOfNode === -1) {
-      throw new NodeDoesntExistError(nodeID);
-    }
-    return this.adjacency.reduce((carry, row) => {
-      return carry + (row[indexOfNode] == null ? 0 : 1);
-    }, 0);
-  }
-  addEdge(sourceNodeIdentity, targetNodeIdentity, edge, skipUpdatingCyclicality = false) {
-    if (edge === undefined) {
-      edge = true;
-    }
-    if (this.hasCycle === false && !skipUpdatingCyclicality) {
-      this.hasCycle = this.wouldAddingEdgeCreateCycle(sourceNodeIdentity, targetNodeIdentity);
-    } else if (skipUpdatingCyclicality) {
-      this.hasCycle = undefined;
-    }
-    return super.addEdge(sourceNodeIdentity, targetNodeIdentity, edge);
-  }
-  canReachFrom(startNode, endNode) {
-    const nodeIdentities = Array.from(this.nodes.keys());
-    const startNodeIndex = nodeIdentities.indexOf(startNode);
-    const endNodeIndex = nodeIdentities.indexOf(endNode);
-    if (this.adjacency[startNodeIndex][endNodeIndex] != null) {
-      return true;
-    }
-    return this.adjacency[startNodeIndex].reduce((carry, edge, index) => {
-      if (carry || edge === null) {
-        return carry;
-      }
-      return this.canReachFrom(nodeIdentities[index], endNode);
-    }, false);
-  }
-  wouldAddingEdgeCreateCycle(sourceNodeIdentity, targetNodeIdentity) {
-    return this.hasCycle || sourceNodeIdentity === targetNodeIdentity || this.canReachFrom(targetNodeIdentity, sourceNodeIdentity);
-  }
-  getSubGraphStartingFrom(startNodeIdentity) {
-    const nodeIndices = Array.from(this.nodes.keys());
-    const initalNode = this.nodes.get(startNodeIdentity);
-    if (initalNode == null) {
-      throw new NodeDoesntExistError(startNodeIdentity);
-    }
-    const recur = (startNodeIdentity2, nodesToInclude) => {
-      let toReturn = [...nodesToInclude];
-      const nodeIndex = nodeIndices.indexOf(startNodeIdentity2);
-      this.adjacency[nodeIndex].forEach((hasAdj, index) => {
-        if (hasAdj !== null && nodesToInclude.find((n) => this.nodeIdentity(n) === nodeIndices[index]) == null) {
-          const newNode = this.nodes.get(nodeIndices[index]);
-          if (newNode != null) {
-            toReturn = [...recur(nodeIndices[index], toReturn), newNode];
-          }
-        }
-      });
-      return toReturn;
-    };
-    const newGraph = new DirectedGraph(this.nodeIdentity, this.edgeIdentity);
-    const nodeList = recur(startNodeIdentity, [initalNode]);
-    const includeIdents = nodeList.map((t) => this.nodeIdentity(t));
-    Array.from(this.nodes.values()).forEach((n) => {
-      if (includeIdents.includes(this.nodeIdentity(n))) {
-        newGraph.insert(n);
-      }
-    });
-    newGraph.adjacency = this.subAdj(nodeList);
-    return newGraph;
-  }
-  subAdj(include) {
-    const includeIdents = include.map((t) => this.nodeIdentity(t));
-    const nodeIndices = Array.from(this.nodes.keys());
-    return this.adjacency.reduce((carry, cur, index) => {
-      if (includeIdents.includes(nodeIndices[index])) {
-        return [...carry, cur.filter((_, index2) => includeIdents.includes(nodeIndices[index2]))];
-      } else {
-        return carry;
-      }
-    }, []);
-  }
-  getEdges() {
-    return super.getEdges();
-  }
-  removeEdge(sourceNodeIdentity, targetNodeIdentity, edgeIdentity) {
-    super.removeEdge(sourceNodeIdentity, targetNodeIdentity, edgeIdentity);
-    this.hasCycle = undefined;
-  }
-  remove(nodeIdentity) {
-    super.remove(nodeIdentity);
-    this.hasCycle = undefined;
-  }
-  addEdges(edges) {
-    return super.addEdges(edges);
-  }
-}
-
-// src/graph/directedAcyclicGraph.ts
-class DirectedAcyclicGraph extends DirectedGraph {
-  _topologicallySortedNodes;
-  static fromDirectedGraph(graph) {
-    if (!graph.isAcyclic()) {
-      throw new CycleError("Can't convert that graph to a DAG because it contains a cycle");
-    }
-    const toRet = new DirectedAcyclicGraph(graph.nodeIdentity, graph.edgeIdentity);
-    toRet.nodes = graph.nodes;
-    toRet.adjacency = graph.adjacency;
-    return toRet;
-  }
-  addEdge(sourceNodeIdentity, targetNodeIdentity, edge) {
-    if (edge === undefined) {
-      edge = true;
-    }
-    if (this.wouldAddingEdgeCreateCycle(sourceNodeIdentity, targetNodeIdentity)) {
-      throw new CycleError(`Can't add edge from ${String(sourceNodeIdentity)} to ${String(targetNodeIdentity)} it would create a cycle`);
-    }
-    this._topologicallySortedNodes = undefined;
-    return super.addEdge(sourceNodeIdentity, targetNodeIdentity, edge, true);
-  }
-  insert(node) {
-    if (this._topologicallySortedNodes !== undefined) {
-      this._topologicallySortedNodes = [node, ...this._topologicallySortedNodes];
-    }
-    return super.insert(node);
-  }
-  topologicallySortedNodes() {
-    if (this._topologicallySortedNodes !== undefined) {
-      return this._topologicallySortedNodes;
-    }
-    const nodeIndices = Array.from(this.nodes.keys());
-    const nodeInDegrees = new Map(Array.from(this.nodes.keys()).map((n) => [n, this.indegreeOfNode(n)]));
-    const adjCopy = this.adjacency.map((a) => [...a]);
-    const toSearch = Array.from(nodeInDegrees).filter((pair) => pair[1] === 0);
-    if (toSearch.length === this.nodes.size) {
-      const arrayOfNodes = Array.from(this.nodes.values());
-      this._topologicallySortedNodes = arrayOfNodes;
-      return arrayOfNodes;
-    }
-    const toReturn = [];
-    while (toSearch.length > 0) {
-      const n = toSearch.pop();
-      if (n === undefined) {
-        throw new Error("Unexpected empty array");
-      }
-      const curNode = this.nodes.get(n[0]);
-      if (curNode == null) {
-        throw new Error("This should never happen");
-      }
-      toReturn.push(curNode);
-      adjCopy[nodeIndices.indexOf(n[0])]?.forEach((edge, index) => {
-        if (edge !== null) {
-          adjCopy[nodeIndices.indexOf(n[0])][index] = null;
-          const target = nodeInDegrees.get(nodeIndices[index]);
-          if (target !== undefined) {
-            nodeInDegrees.set(nodeIndices[index], target - 1);
-            if (target - 1 === 0) {
-              toSearch.push([nodeIndices[index], 0]);
-            }
-          } else {
-            throw new Error("This should never happen");
-          }
-        }
-      });
-    }
-    this._topologicallySortedNodes = toReturn;
-    return toReturn;
-  }
-  getSubGraphStartingFrom(startNodeIdentity) {
-    return DirectedAcyclicGraph.fromDirectedGraph(super.getSubGraphStartingFrom(startNodeIdentity));
-  }
-  removeEdge(sourceNodeIdentity, targetNodeIdentity, edgeIdentity) {
-    super.removeEdge(sourceNodeIdentity, targetNodeIdentity, edgeIdentity);
-    this._topologicallySortedNodes = undefined;
-  }
-  remove(nodeIdentity) {
-    super.remove(nodeIdentity);
-    this._topologicallySortedNodes = undefined;
-  }
-}
-// src/json-schema/FromSchema.ts
-var FromSchemaDefaultOptions = {
-  parseNotKeyword: true,
-  parseIfThenElseKeywords: true,
-  keepDefaultedPropertiesOptional: true,
-  references: false,
-  deserialize: false
-};
-// src/json-schema/SchemaUtils.ts
-function areFormatStringsCompatible(sourceFormat, targetFormat) {
-  const formatPattern = /^[a-zA-Z][a-zA-Z0-9_-]*(?::[a-zA-Z][a-zA-Z0-9_-]*)?$/;
-  if (!formatPattern.test(sourceFormat) || !formatPattern.test(targetFormat)) {
-    return "incompatible";
-  }
-  const [sourceName, sourceNarrow] = sourceFormat.split(":");
-  const [targetName, targetNarrow] = targetFormat.split(":");
-  if (sourceName !== targetName) {
-    return "incompatible";
-  }
-  if (!sourceNarrow && !targetNarrow) {
-    return "static";
-  }
-  if (sourceNarrow && !targetNarrow) {
-    return "static";
-  }
-  if (!sourceNarrow && targetNarrow) {
-    return "runtime";
-  }
-  if (sourceNarrow === targetNarrow) {
-    return "static";
-  }
-  return "incompatible";
-}
-function isTypeStaticallyCompatible(sourceType, targetType) {
-  if (!targetType) {
-    return true;
-  }
-  if (!sourceType) {
-    return false;
-  }
-  const sourceTypes = Array.isArray(sourceType) ? sourceType : [sourceType];
-  const targetTypes = Array.isArray(targetType) ? targetType : [targetType];
-  return sourceTypes.some((st) => targetTypes.includes(st));
-}
-function mergeAllOfSchemas(schemas) {
-  if (schemas.length === 0)
-    return null;
-  if (schemas.length === 1)
-    return schemas[0];
-  let merged = {};
-  for (const schema of schemas) {
-    if (typeof schema === "boolean") {
-      if (schema === false)
-        return false;
-      continue;
-    }
-    const schemaObj = schema;
-    if (schemaObj.type !== undefined) {
-      if (merged.type === undefined) {
-        merged.type = schemaObj.type;
-      } else if (merged.type !== schemaObj.type) {
-        const mergedTypes = Array.isArray(merged.type) ? merged.type : [merged.type];
-        const schemaTypes = Array.isArray(schemaObj.type) ? schemaObj.type : [schemaObj.type];
-        const commonTypes = mergedTypes.filter((t) => schemaTypes.includes(t));
-        if (commonTypes.length === 0) {
-          return false;
-        }
-        merged.type = commonTypes.length === 1 ? commonTypes[0] : commonTypes;
-      }
-    }
-    const schemaFormat = schemaObj.format;
-    const mergedFormat = merged.format;
-    if (schemaFormat) {
-      if (!mergedFormat) {
-        merged.format = schemaFormat;
-      } else {
-        const formatCompat = areFormatStringsCompatible(mergedFormat, schemaFormat);
-        if (formatCompat === "incompatible") {
-          return false;
-        }
-        const mergedHasNarrow = mergedFormat.includes(":");
-        const schemaHasNarrow = schemaFormat.includes(":");
-        if (schemaHasNarrow && !mergedHasNarrow) {
-          merged.format = schemaFormat;
-        } else if (!schemaHasNarrow && mergedHasNarrow) {} else if (mergedFormat !== schemaFormat) {
-          return false;
-        }
-      }
-    }
-    if (schemaObj.properties && typeof schemaObj.properties === "object") {
-      if (!merged.properties) {
-        merged.properties = {};
-      }
-      const mergedProps = merged.properties;
-      const schemaProps = schemaObj.properties;
-      for (const [key, value] of Object.entries(schemaProps)) {
-        if (mergedProps[key]) {
-          const nestedMerged = mergeAllOfSchemas([mergedProps[key], value]);
-          if (nestedMerged === null || nestedMerged === false) {
-            return false;
-          }
-          mergedProps[key] = nestedMerged;
-        } else {
-          mergedProps[key] = value;
-        }
-      }
-    }
-    if (schemaObj.required && Array.isArray(schemaObj.required)) {
-      if (!merged.required) {
-        merged.required = [];
-      }
-      const mergedRequired = merged.required;
-      const schemaRequired = schemaObj.required;
-      merged.required = mergedRequired.filter((r) => schemaRequired.includes(r));
-    }
-    if (schemaObj.additionalProperties !== undefined) {
-      if (merged.additionalProperties === undefined) {
-        merged.additionalProperties = schemaObj.additionalProperties;
-      } else if (merged.additionalProperties === true && schemaObj.additionalProperties === false) {
-        merged.additionalProperties = false;
-      }
-    }
-    if (schemaObj.items !== undefined) {
-      if (merged.items === undefined) {
-        merged.items = schemaObj.items;
-      } else {
-        const mergedItems = mergeAllOfSchemas([
-          merged.items,
-          schemaObj.items
-        ]);
-        if (mergedItems === null || mergedItems === false) {
-          return false;
-        }
-        merged.items = mergedItems;
-      }
-    }
-  }
-  return merged;
-}
-function isCompatibleWithUnion(sourceSchema, unionSchemas) {
-  let hasStatic = false;
-  let hasRuntime = false;
-  for (const unionSchema of unionSchemas) {
-    const compatibility = areSemanticallyCompatible(sourceSchema, unionSchema);
-    if (compatibility === "static") {
-      hasStatic = true;
-    } else if (compatibility === "runtime") {
-      hasRuntime = true;
-    }
-  }
-  if (hasStatic)
-    return "static";
-  if (hasRuntime)
-    return "runtime";
-  return "incompatible";
-}
-function areSemanticallyCompatible(sourceSchema, targetSchema) {
-  if (sourceSchema === undefined || targetSchema === undefined) {
-    return "incompatible";
-  }
-  if (typeof targetSchema === "boolean") {
-    if (targetSchema === false)
-      return "incompatible";
-    if (targetSchema === true)
-      return "static";
-    return "incompatible";
-  }
-  if (typeof sourceSchema === "boolean") {
-    if (sourceSchema === false)
-      return "incompatible";
-    if (sourceSchema === true)
-      return "runtime";
-  }
-  if (sourceSchema.allOf && Array.isArray(sourceSchema.allOf)) {
-    const mergedSchema = mergeAllOfSchemas(sourceSchema.allOf);
-    if (mergedSchema === null || mergedSchema === false) {
-      return "incompatible";
-    }
-    return areSemanticallyCompatible(mergedSchema, targetSchema);
-  }
-  const sourceType = sourceSchema.type;
-  const targetType = targetSchema.type;
-  if (sourceSchema.oneOf && Array.isArray(sourceSchema.oneOf)) {
-    let hasStatic = false;
-    let hasRuntime = false;
-    for (const sourceOption of sourceSchema.oneOf) {
-      const compatibility = areSemanticallyCompatible(sourceOption, targetSchema);
-      if (compatibility === "static") {
-        hasStatic = true;
-      } else if (compatibility === "runtime") {
-        hasRuntime = true;
-      }
-    }
-    if (hasRuntime)
-      return "runtime";
-    if (hasStatic)
-      return "static";
-    return "incompatible";
-  }
-  if (sourceSchema.anyOf && Array.isArray(sourceSchema.anyOf)) {
-    let hasStatic = false;
-    let hasRuntime = false;
-    for (const sourceOption of sourceSchema.anyOf) {
-      const compatibility = areSemanticallyCompatible(sourceOption, targetSchema);
-      if (compatibility === "static") {
-        hasStatic = true;
-      } else if (compatibility === "runtime") {
-        hasRuntime = true;
-      }
-    }
-    if (hasRuntime)
-      return "runtime";
-    if (hasStatic)
-      return "static";
-    return "incompatible";
-  }
-  if (targetSchema.oneOf && Array.isArray(targetSchema.oneOf)) {
-    return isCompatibleWithUnion(sourceSchema, targetSchema.oneOf);
-  }
-  if (targetSchema.anyOf && Array.isArray(targetSchema.anyOf)) {
-    return isCompatibleWithUnion(sourceSchema, targetSchema.anyOf);
-  }
-  if (targetSchema.allOf && Array.isArray(targetSchema.allOf)) {
-    let hasStatic = false;
-    let hasRuntime = false;
-    for (const allOfSchema of targetSchema.allOf) {
-      const compatibility = areSemanticallyCompatible(sourceSchema, allOfSchema);
-      if (compatibility === "incompatible") {
-        return "incompatible";
-      } else if (compatibility === "static") {
-        hasStatic = true;
-      } else if (compatibility === "runtime") {
-        hasRuntime = true;
-      }
-    }
-    if (hasRuntime)
-      return "runtime";
-    if (hasStatic)
-      return "static";
-    return "incompatible";
-  }
-  if (sourceType === "object" && targetType === "object") {
-    const sourceProperties = sourceSchema.properties;
-    const targetProperties = targetSchema.properties;
-    if (!targetProperties) {
-      return "static";
-    }
-    if (!sourceProperties) {
-      if (targetSchema.additionalProperties === false) {
-        return "incompatible";
-      }
-      return "static";
-    }
-    const targetRequired = targetSchema.required || [];
-    let hasStatic = true;
-    let hasRuntime = false;
-    for (const propName of targetRequired) {
-      const targetProp = targetProperties?.[propName];
-      const sourceProp = sourceProperties?.[propName];
-      if (!sourceProp) {
-        return "incompatible";
-      }
-      if (targetProp) {
-        const propCompatibility = areSemanticallyCompatible(sourceProp, targetProp);
-        if (propCompatibility === "incompatible") {
-          return "incompatible";
-        } else if (propCompatibility === "runtime") {
-          hasRuntime = true;
-          hasStatic = false;
-        }
-      }
-    }
-    if (targetSchema.additionalProperties === false) {
-      const sourcePropNames = Object.keys(sourceProperties);
-      const targetPropNames = Object.keys(targetProperties);
-      const extraProps = sourcePropNames.filter((name) => !targetPropNames.includes(name));
-      if (extraProps.length > 0) {
-        return "incompatible";
-      }
-    }
-    if (hasRuntime)
-      return "runtime";
-    return "static";
-  }
-  if (sourceType === "array" && targetType === "array") {
-    const sourceFormat2 = sourceSchema?.format;
-    const targetFormat2 = targetSchema?.format;
-    let formatCompatibility = null;
-    if (sourceFormat2 && targetFormat2) {
-      formatCompatibility = areFormatStringsCompatible(sourceFormat2, targetFormat2);
-      if (formatCompatibility === "incompatible") {
-        return "incompatible";
-      }
-    }
-    if (sourceFormat2 && !targetFormat2) {
-      return "static";
-    }
-    if (!sourceFormat2 && targetFormat2) {
-      return "incompatible";
-    }
-    const sourceItems = sourceSchema.items;
-    const targetItems = targetSchema.items;
-    if (sourceItems && typeof sourceItems === "object" && !Array.isArray(sourceItems) && targetItems && typeof targetItems === "object" && !Array.isArray(targetItems)) {
-      const itemsCompatibility = areSemanticallyCompatible(sourceItems, targetItems);
-      if (formatCompatibility === "runtime") {
-        return "runtime";
-      }
-      return itemsCompatibility;
-    }
-    if (!targetItems) {
-      return "static";
-    }
-    if (!sourceItems) {
-      return "incompatible";
-    }
-    if (Array.isArray(targetItems)) {
-      return isCompatibleWithUnion(sourceItems, targetItems);
-    }
-    return "static";
-  }
-  if (!sourceType) {
-    const targetFormat2 = targetSchema?.format;
-    if (targetFormat2) {
-      return "runtime";
-    }
-    return "static";
-  }
-  if (!targetType) {
-    const targetFormat2 = targetSchema?.format;
-    if (targetFormat2) {
-      const sourceFormat2 = sourceSchema?.format;
-      if (!sourceFormat2) {
-        return "incompatible";
-      }
-      return areFormatStringsCompatible(sourceFormat2, targetFormat2);
-    }
-    return "static";
-  }
-  if (!isTypeStaticallyCompatible(sourceType, targetType)) {
-    return "incompatible";
-  }
-  const sourceFormat = sourceSchema?.format;
-  const targetFormat = targetSchema?.format;
-  if (sourceFormat && targetFormat) {
-    return areFormatStringsCompatible(sourceFormat, targetFormat);
-  }
-  if (sourceFormat && !targetFormat) {
-    return "static";
-  }
-  if (!sourceFormat && targetFormat) {
-    return "incompatible";
-  }
-  return "static";
-}
-function areObjectSchemasSemanticallyCompatible(sourceSchema, targetSchema) {
-  return areSemanticallyCompatible(sourceSchema, targetSchema);
-}
-// src/json-schema/SchemaValidation.ts
-import { compileSchema } from "@sroussey/json-schema-library";
-// src/json-schema/parsePartialJson.ts
-function parsePartialJson(text) {
-  const trimmed = text.trim();
-  if (!trimmed)
-    return;
-  try {
-    const result = JSON.parse(trimmed);
-    if (typeof result === "object" && result !== null && !Array.isArray(result)) {
-      return result;
-    }
-    return;
-  } catch {}
-  if (trimmed[0] !== "{")
-    return;
-  const repaired = repairJson(trimmed);
-  if (repaired === undefined)
-    return;
-  try {
-    const result = JSON.parse(repaired);
-    if (typeof result === "object" && result !== null && !Array.isArray(result)) {
-      return result;
-    }
-    return;
-  } catch {
-    return;
-  }
-}
-function repairJson(text) {
-  let result = "";
-  let i = 0;
-  const len = text.length;
-  const stack = [];
-  let inString = false;
-  let escaped = false;
-  let lastSafeEnd = 0;
-  while (i < len) {
-    const ch = text[i];
-    if (escaped) {
-      escaped = false;
-      result += ch;
-      i++;
-      continue;
-    }
-    if (ch === "\\") {
-      escaped = true;
-      result += ch;
-      i++;
-      continue;
-    }
-    if (inString) {
-      if (ch === '"') {
-        inString = false;
-        result += ch;
-        i++;
-        lastSafeEnd = result.length;
-        continue;
-      }
-      result += ch;
-      i++;
-      continue;
-    }
-    switch (ch) {
-      case '"':
-        inString = true;
-        result += ch;
-        i++;
-        break;
-      case "{":
-        stack.push("}");
-        result += ch;
-        i++;
-        break;
-      case "[":
-        stack.push("]");
-        result += ch;
-        i++;
-        break;
-      case "}":
-        if (stack.length > 0 && stack[stack.length - 1] === "}") {
-          stack.pop();
-          result += ch;
-          i++;
-          lastSafeEnd = result.length;
-        } else {
-          return closeStack(result, stack);
-        }
-        break;
-      case "]":
-        if (stack.length > 0 && stack[stack.length - 1] === "]") {
-          stack.pop();
-          result += ch;
-          i++;
-          lastSafeEnd = result.length;
-        } else {
-          return closeStack(result, stack);
-        }
-        break;
-      default:
-        result += ch;
-        i++;
-        break;
-    }
-  }
-  if (inString) {
-    result += '"';
-  }
-  if (stack.length === 0) {
-    return result;
-  }
-  return closeStack(cleanTrailing(result), stack);
-}
-function cleanTrailing(text) {
-  let s = text.trimEnd();
-  let changed = true;
-  while (changed) {
-    changed = false;
-    const trimmed = s.trimEnd();
-    if (trimmed.endsWith(",")) {
-      s = trimmed.slice(0, -1);
-      changed = true;
-      continue;
-    }
-    if (trimmed.endsWith(":")) {
-      const withoutColon = trimmed.slice(0, -1).trimEnd();
-      if (withoutColon.endsWith('"')) {
-        const keyStart = withoutColon.lastIndexOf('"', withoutColon.length - 2);
-        if (keyStart >= 0) {
-          let before = withoutColon.slice(0, keyStart).trimEnd();
-          if (before.endsWith(",")) {
-            before = before.slice(0, -1);
-          }
-          s = before;
-          changed = true;
-          continue;
-        }
-      }
-      s = withoutColon;
-      changed = true;
-      continue;
-    }
-    const bareTokenMatch = trimmed.match(/,\s*"[^"]*"\s*:\s*(?:tru|fal|nul|true|false|null|[\d.eE+-]+)$/);
-    if (bareTokenMatch) {
-      const valueStr = trimmed.slice(trimmed.lastIndexOf(":") + 1).trim();
-      try {
-        JSON.parse(valueStr);
-      } catch {
-        s = trimmed.slice(0, bareTokenMatch.index).trimEnd();
-        if (s.endsWith(","))
-          s = s.slice(0, -1);
-        changed = true;
-        continue;
-      }
-    }
-  }
-  return s;
-}
-function closeStack(text, stack) {
-  let result = text;
-  for (let i = stack.length - 1;i >= 0; i--) {
-    result += stack[i];
-  }
-  return result;
-}
 // src/utilities/objectOfArraysAsArrayOfObjects.ts
 function objectOfArraysAsArrayOfObjects(data) {
   const keys = Object.keys(data);
@@ -1705,236 +736,6 @@ function objectOfArraysAsArrayOfObjects(data) {
     }
   });
 }
-// src/vector/TypedArray.ts
-function isTypedArray(value) {
-  return ArrayBuffer.isView(value) && !(value instanceof DataView);
-}
-var TypedArrayType = null;
-var TypedArraySchemaOptions = {
-  ...FromSchemaDefaultOptions,
-  deserialize: [
-    {
-      pattern: { type: "array", format: "TypedArray:Float64Array" },
-      output: Float64Array
-    },
-    {
-      pattern: { type: "array", format: "TypedArray:Float32Array" },
-      output: Float32Array
-    },
-    {
-      pattern: { type: "array", format: "TypedArray:Float16Array" },
-      output: Float16Array
-    },
-    {
-      pattern: { type: "array", format: "TypedArray:Int16Array" },
-      output: Int16Array
-    },
-    {
-      pattern: { type: "array", format: "TypedArray:Int8Array" },
-      output: Int8Array
-    },
-    {
-      pattern: { type: "array", format: "TypedArray:Uint8Array" },
-      output: Uint8Array
-    },
-    {
-      pattern: { type: "array", format: "TypedArray:Uint16Array" },
-      output: Uint16Array
-    },
-    {
-      pattern: { type: "array", format: "TypedArray" },
-      output: TypedArrayType
-    }
-  ]
-};
-var TypedArraySchema = (annotations = {}) => {
-  return {
-    type: "array",
-    format: "TypedArray",
-    title: "Typed Array",
-    description: "A typed array (Float32Array, Int8Array, etc.)",
-    ...annotations
-  };
-};
-
-// src/vector/Tensor.ts
-var TensorType = {
-  FLOAT16: "float16",
-  FLOAT32: "float32",
-  FLOAT64: "float64",
-  INT8: "int8",
-  UINT8: "uint8",
-  INT16: "int16",
-  UINT16: "uint16"
-};
-var TensorSchema = (annotations = {}) => ({
-  type: "object",
-  properties: {
-    type: {
-      type: "string",
-      enum: Object.values(TensorType),
-      title: "Type",
-      description: "The type of the tensor"
-    },
-    data: TypedArraySchema({
-      title: "Data",
-      description: "The data of the tensor"
-    }),
-    shape: {
-      type: "array",
-      items: { type: "number" },
-      title: "Shape",
-      description: "The shape of the tensor (dimensions)",
-      minItems: 1,
-      default: [1]
-    },
-    normalized: {
-      type: "boolean",
-      title: "Normalized",
-      description: "Whether the tensor data is normalized",
-      default: false
-    }
-  },
-  required: ["data"],
-  additionalProperties: false,
-  ...annotations
-});
-// src/vector/TypedArrayUtils.ts
-var WIDTH_RANK = {
-  Float64Array: 6,
-  Float32Array: 5,
-  Float16Array: 4,
-  Int16Array: 3,
-  Uint16Array: 3,
-  Int8Array: 2,
-  Uint8Array: 2
-};
-function getWidthRank(arr) {
-  return WIDTH_RANK[arr.constructor.name] ?? 0;
-}
-function widestConstructor(sources) {
-  let best = sources[0];
-  for (let i = 1;i < sources.length; i++) {
-    if (getWidthRank(sources[i]) > getWidthRank(best))
-      best = sources[i];
-  }
-  return best.constructor;
-}
-function createTypedArrayFrom(sources, values) {
-  const Ctor = widestConstructor(sources);
-  const result = new Ctor(values.length);
-  for (let i = 0;i < values.length; i++)
-    result[i] = values[i];
-  return result;
-}
-// src/vector/VectorSimilarityUtils.ts
-function cosineSimilarity(a, b) {
-  if (a.length !== b.length) {
-    throw new Error("Vectors must have the same length");
-  }
-  let dotProduct = 0;
-  let normA = 0;
-  let normB = 0;
-  for (let i = 0;i < a.length; i++) {
-    dotProduct += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
-  if (denominator === 0) {
-    return 0;
-  }
-  return dotProduct / denominator;
-}
-function jaccardSimilarity(a, b) {
-  if (a.length !== b.length) {
-    throw new Error("Vectors must have the same length");
-  }
-  let globalMin = a[0];
-  for (let i = 0;i < a.length; i++) {
-    globalMin = Math.min(globalMin, a[i], b[i]);
-  }
-  const shift = globalMin < 0 ? -globalMin : 0;
-  let minSum = 0;
-  let maxSum = 0;
-  for (let i = 0;i < a.length; i++) {
-    const shiftedA = a[i] + shift;
-    const shiftedB = b[i] + shift;
-    minSum += Math.min(shiftedA, shiftedB);
-    maxSum += Math.max(shiftedA, shiftedB);
-  }
-  return maxSum === 0 ? 0 : minSum / maxSum;
-}
-function hammingDistance(a, b) {
-  if (a.length !== b.length) {
-    throw new Error("Vectors must have the same length");
-  }
-  let differences = 0;
-  for (let i = 0;i < a.length; i++) {
-    if (a[i] !== b[i]) {
-      differences++;
-    }
-  }
-  return differences / a.length;
-}
-function hammingSimilarity(a, b) {
-  return 1 - hammingDistance(a, b);
-}
-// src/vector/VectorUtils.ts
-function magnitude(arr) {
-  return Math.sqrt(arr.reduce((acc, val) => acc + val * val, 0));
-}
-function inner(arr1, arr2) {
-  if (arr1.length !== arr2.length) {
-    throw new Error("Vectors must have the same length to compute inner product.");
-  }
-  return arr1.reduce((acc, val, i) => acc + val * arr2[i], 0);
-}
-function normalize(vector, throwOnZero = true, float32 = false) {
-  const mag = magnitude(vector);
-  if (mag === 0) {
-    if (throwOnZero) {
-      throw new Error("Cannot normalize a zero vector.");
-    }
-    return vector;
-  }
-  const normalized = Array.from(vector).map((val) => Number(val) / mag);
-  if (float32) {
-    return new Float32Array(normalized);
-  }
-  if (vector instanceof Float64Array) {
-    return new Float64Array(normalized);
-  }
-  if (vector instanceof Float16Array) {
-    return new Float16Array(normalized);
-  }
-  if (vector instanceof Float32Array) {
-    return new Float32Array(normalized);
-  }
-  if (vector instanceof Int8Array) {
-    return new Int8Array(normalized);
-  }
-  if (vector instanceof Uint8Array) {
-    return new Uint8Array(normalized);
-  }
-  if (vector instanceof Int16Array) {
-    return new Int16Array(normalized);
-  }
-  if (vector instanceof Uint16Array) {
-    return new Uint16Array(normalized);
-  }
-  return new Float32Array(normalized);
-}
-function normalizeNumberArray(values, throwOnZero = false) {
-  const norm = magnitude(values);
-  if (norm === 0) {
-    if (throwOnZero) {
-      throw new Error("Cannot normalize a zero vector.");
-    }
-    return values;
-  }
-  return values.map((v) => v / norm);
-}
 // src/worker/WorkerManager.ts
 class WorkerManager {
   workers = new Map;
@@ -1942,14 +743,26 @@ class WorkerManager {
   workerFunctions = new Map;
   workerStreamFunctions = new Map;
   workerReactiveFunctions = new Map;
-  registerWorker(name, worker) {
-    if (this.workers.has(name))
+  lazyFactories = new Map;
+  lazyInitPromises = new Map;
+  registerWorker(name, workerOrFactory) {
+    if (this.workers.has(name)) {
       throw new Error(`Worker ${name} is already registered.`);
-    this.workers.set(name, worker);
-    this.workers.set(name, worker);
-    worker.addEventListener("error", (event) => {
-      console.error("Worker Error:", event.message, "at", event.filename, "line:", event.lineno);
-    });
+    }
+    if (this.lazyFactories.has(name)) {
+      throw new Error(`Worker ${name} is already registered.`);
+    }
+    if (typeof workerOrFactory === "function") {
+      this.lazyFactories.set(name, workerOrFactory);
+    } else {
+      this.attachWorkerInstance(name, workerOrFactory);
+    }
+  }
+  attachWorkerInstance(name, worker) {
+    this.workers.set(name, worker);
+    worker.addEventListener("error", (event) => {
+      console.error("Worker Error:", event.message, "at", event.filename, "line:", event.lineno);
+    });
     worker.addEventListener("messageerror", (event) => {
       console.error("Worker message error:", event);
     });
@@ -1967,6 +780,29 @@ class WorkerManager {
     });
     this.readyWorkers.set(name, readyPromise);
   }
+  async ensureWorkerReady(name) {
+    if (this.workers.has(name)) {
+      await this.readyWorkers.get(name);
+      return;
+    }
+    const factory = this.lazyFactories.get(name);
+    if (!factory) {
+      throw new Error(`Worker ${name} not found.`);
+    }
+    let init = this.lazyInitPromises.get(name);
+    if (!init) {
+      init = (async () => {
+        const f = this.lazyFactories.get(name);
+        this.lazyFactories.delete(name);
+        const worker = f();
+        this.attachWorkerInstance(name, worker);
+      })();
+      this.lazyInitPromises.set(name, init);
+    }
+    await init;
+    await this.readyWorkers.get(name);
+    this.lazyInitPromises.delete(name);
+  }
   getWorker(name) {
     const worker = this.workers.get(name);
     if (!worker)
@@ -1974,6 +810,7 @@ class WorkerManager {
     return worker;
   }
   async callWorkerFunction(workerName, functionName, args, options) {
+    await this.ensureWorkerReady(workerName);
     const worker = this.workers.get(workerName);
     if (!worker)
       throw new Error(`Worker ${workerName} not found.`);
@@ -2019,6 +856,7 @@ class WorkerManager {
     });
   }
   async callWorkerReactiveFunction(workerName, functionName, args) {
+    await this.ensureWorkerReady(workerName);
     const worker = this.workers.get(workerName);
     if (!worker)
       return;
@@ -2050,6 +888,7 @@ class WorkerManager {
     });
   }
   async* callWorkerStreamFunction(workerName, functionName, args, options) {
+    await this.ensureWorkerReady(workerName);
     const worker = this.workers.get(workerName);
     if (!worker)
       throw new Error(`Worker ${workerName} not found.`);
@@ -2133,202 +972,6 @@ class WorkerManager {
 }
 var WORKER_MANAGER = createServiceToken("worker.manager");
 globalServiceRegistry.register(WORKER_MANAGER, () => new WorkerManager, true);
-// src/worker/WorkerServer.ts
-import { parentPort } from "@workglow/util";
-function extractTransferables(obj) {
-  const transferables = [];
-  const seen = new WeakSet;
-  function findTransferables(value) {
-    if (value && typeof value === "object" && seen.has(value)) {
-      return;
-    }
-    if (value && typeof value === "object") {
-      seen.add(value);
-    }
-    if (value instanceof Float32Array || value instanceof Int16Array) {
-      transferables.push(value.buffer);
-    } else if (value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array || value instanceof Uint16Array || value instanceof Int32Array || value instanceof Uint32Array || value instanceof Float64Array || value instanceof BigInt64Array || value instanceof BigUint64Array) {
-      transferables.push(value.buffer);
-    } else if (typeof OffscreenCanvas !== "undefined" && value instanceof OffscreenCanvas) {
-      transferables.push(value);
-    } else if (typeof ImageBitmap !== "undefined" && value instanceof ImageBitmap) {
-      transferables.push(value);
-    } else if (typeof VideoFrame !== "undefined" && value instanceof VideoFrame) {
-      transferables.push(value);
-    } else if (typeof MessagePort !== "undefined" && value instanceof MessagePort) {
-      transferables.push(value);
-    } else if (value instanceof ArrayBuffer) {
-      transferables.push(value);
-    } else if (Array.isArray(value)) {
-      value.forEach(findTransferables);
-    } else if (value && typeof value === "object") {
-      Object.values(value).forEach(findTransferables);
-    }
-  }
-  findTransferables(obj);
-  return transferables;
-}
-
-class WorkerServer {
-  constructor() {
-    parentPort?.addEventListener("message", async (event) => {
-      const msg = {
-        type: event.type,
-        data: event.data
-      };
-      await this.handleMessage(msg);
-    });
-  }
-  functions = {};
-  streamFunctions = {};
-  reactiveFunctions = {};
-  requestControllers = new Map;
-  completedRequests = new Set;
-  postResult = (id, result) => {
-    if (this.completedRequests.has(id)) {
-      return;
-    }
-    this.completedRequests.add(id);
-    const transferables = extractTransferables(result);
-    const uniqueTransferables = [...new Set(transferables)];
-    postMessage({ id, type: "complete", data: result }, uniqueTransferables);
-  };
-  postError = (id, errorMessage) => {
-    if (this.completedRequests.has(id)) {
-      return;
-    }
-    this.completedRequests.add(id);
-    postMessage({ id, type: "error", data: errorMessage });
-  };
-  postStreamChunk = (id, event) => {
-    if (this.completedRequests.has(id)) {
-      return;
-    }
-    postMessage({ id, type: "stream_chunk", data: event });
-  };
-  sendReady() {
-    postMessage({
-      type: "ready",
-      functions: Object.keys(this.functions),
-      streamFunctions: Object.keys(this.streamFunctions),
-      reactiveFunctions: Object.keys(this.reactiveFunctions)
-    });
-  }
-  registerFunction(name, fn) {
-    this.functions[name] = fn;
-  }
-  registerReactiveFunction(name, fn) {
-    this.reactiveFunctions[name] = fn;
-  }
-  registerStreamFunction(name, fn) {
-    this.streamFunctions[name] = fn;
-  }
-  async handleMessage(event) {
-    const { id, type, functionName, args, stream, reactive } = event.data;
-    if (type === "abort") {
-      return await this.handleAbort(id);
-    }
-    if (type === "call") {
-      if (stream) {
-        return await this.handleStreamCall(id, functionName, args);
-      }
-      if (reactive) {
-        return await this.handleReactiveCall(id, functionName, args);
-      }
-      return await this.handleCall(id, functionName, args);
-    }
-  }
-  async handleAbort(id) {
-    if (this.requestControllers.has(id)) {
-      const controller = this.requestControllers.get(id);
-      controller?.abort();
-      this.requestControllers.delete(id);
-      this.postError(id, "Operation aborted");
-    }
-  }
-  async handleReactiveCall(id, functionName, [input, output, model]) {
-    if (!(functionName in this.reactiveFunctions)) {
-      this.postResult(id, undefined);
-      return;
-    }
-    try {
-      const fn = this.reactiveFunctions[functionName];
-      const result = await fn(input, output, model);
-      this.postResult(id, result);
-    } catch (error) {
-      this.postError(id, error.message);
-    }
-  }
-  async handleCall(id, functionName, [input, model]) {
-    if (!(functionName in this.functions)) {
-      this.postError(id, `Function ${functionName} not found`);
-      return;
-    }
-    try {
-      const abortController = new AbortController;
-      this.requestControllers.set(id, abortController);
-      const fn = this.functions[functionName];
-      const postProgress = (progress, message, details) => {
-        if (!this.completedRequests.has(id)) {
-          postMessage({ id, type: "progress", data: { progress, message, details } });
-        }
-      };
-      const result = await fn(input, model, postProgress, abortController.signal);
-      this.postResult(id, result);
-    } catch (error) {
-      this.postError(id, error.message);
-    } finally {
-      this.requestControllers.delete(id);
-      setTimeout(() => {
-        this.completedRequests.delete(id);
-      }, 1000);
-    }
-  }
-  async handleStreamCall(id, functionName, [input, model]) {
-    if (functionName in this.streamFunctions) {
-      try {
-        const abortController = new AbortController;
-        this.requestControllers.set(id, abortController);
-        const fn = this.streamFunctions[functionName];
-        const iterable = fn(input, model, abortController.signal);
-        for await (const event of iterable) {
-          if (this.completedRequests.has(id))
-            break;
-          this.postStreamChunk(id, event);
-        }
-        this.postResult(id, undefined);
-      } catch (error) {
-        this.postError(id, error.message);
-      } finally {
-        this.requestControllers.delete(id);
-        setTimeout(() => {
-          this.completedRequests.delete(id);
-        }, 1000);
-      }
-    } else if (functionName in this.functions) {
-      try {
-        const abortController = new AbortController;
-        this.requestControllers.set(id, abortController);
-        const fn = this.functions[functionName];
-        const noopProgress = () => {};
-        const result = await fn(input, model, noopProgress, abortController.signal);
-        this.postStreamChunk(id, { type: "finish", data: result });
-        this.postResult(id, undefined);
-      } catch (error) {
-        this.postError(id, error.message);
-      } finally {
-        this.requestControllers.delete(id);
-        setTimeout(() => {
-          this.completedRequests.delete(id);
-        }, 1000);
-      }
-    } else {
-      this.postError(id, `Function ${functionName} not found`);
-    }
-  }
-}
-var WORKER_SERVER = createServiceToken("worker.server");
-globalServiceRegistry.register(WORKER_SERVER, () => new WorkerServer, true);
 // src/credentials/ICredentialStore.ts
 var CREDENTIAL_STORE = createServiceToken("credential.store");
 // src/credentials/InMemoryCredentialStore.ts
@@ -2569,518 +1212,6 @@ function base64ToBuf(b64) {
   }
   return buf;
 }
-// src/mcp/McpAuthTypes.ts
-var mcpAuthTypes = [
-  "none",
-  "bearer",
-  "client_credentials",
-  "private_key_jwt",
-  "static_private_key_jwt",
-  "authorization_code"
-];
-var mcpAuthConfigSchema = {
-  properties: {
-    auth_type: {
-      type: "string",
-      enum: mcpAuthTypes,
-      title: "Auth Type",
-      description: "Authentication method for connecting to the MCP server",
-      default: "none"
-    },
-    auth_token: {
-      type: "string",
-      format: "credential",
-      title: "Bearer Token",
-      description: "Static bearer token or API key (for bearer auth)"
-    },
-    auth_client_id: {
-      type: "string",
-      title: "Client ID",
-      description: "OAuth client ID (for OAuth auth types)"
-    },
-    auth_client_secret: {
-      type: "string",
-      format: "credential",
-      title: "Client Secret",
-      description: "OAuth client secret (for client_credentials auth)"
-    },
-    auth_private_key: {
-      type: "string",
-      format: "credential",
-      title: "Private Key",
-      description: "PEM or JWK private key (for private_key_jwt auth)"
-    },
-    auth_algorithm: {
-      type: "string",
-      title: "Algorithm",
-      description: "JWT signing algorithm, e.g. RS256, ES256 (for private_key_jwt auth)"
-    },
-    auth_jwt_bearer_assertion: {
-      type: "string",
-      format: "credential",
-      title: "JWT Assertion",
-      description: "Pre-built JWT assertion (for static_private_key_jwt auth)"
-    },
-    auth_redirect_url: {
-      type: "string",
-      format: "uri",
-      title: "Redirect URL",
-      description: "OAuth redirect URL (for authorization_code auth)"
-    },
-    auth_scope: {
-      type: "string",
-      title: "Scope",
-      description: "OAuth scope (space-separated)"
-    },
-    auth_client_name: {
-      type: "string",
-      title: "Client Name",
-      description: "Optional OAuth client display name"
-    },
-    auth_jwt_lifetime_seconds: {
-      type: "number",
-      title: "JWT Lifetime",
-      description: "JWT lifetime in seconds (default: 300)",
-      minimum: 1
-    }
-  },
-  allOf: [
-    {
-      if: { properties: { auth_type: { const: "bearer" } }, required: ["auth_type"] },
-      then: {
-        required: ["auth_token"],
-        properties: { auth_token: true }
-      }
-    },
-    {
-      if: {
-        properties: { auth_type: { const: "client_credentials" } },
-        required: ["auth_type"]
-      },
-      then: {
-        required: ["auth_client_id", "auth_client_secret"],
-        properties: {
-          auth_client_id: true,
-          auth_client_secret: true,
-          auth_client_name: true,
-          auth_scope: true
-        }
-      }
-    },
-    {
-      if: { properties: { auth_type: { const: "private_key_jwt" } }, required: ["auth_type"] },
-      then: {
-        required: ["auth_client_id", "auth_private_key", "auth_algorithm"],
-        properties: {
-          auth_client_id: true,
-          auth_private_key: true,
-          auth_algorithm: true,
-          auth_client_name: true,
-          auth_jwt_lifetime_seconds: true,
-          auth_scope: true
-        }
-      }
-    },
-    {
-      if: {
-        properties: { auth_type: { const: "static_private_key_jwt" } },
-        required: ["auth_type"]
-      },
-      then: {
-        required: ["auth_client_id", "auth_jwt_bearer_assertion"],
-        properties: {
-          auth_client_id: true,
-          auth_jwt_bearer_assertion: true,
-          auth_client_name: true,
-          auth_scope: true
-        }
-      }
-    },
-    {
-      if: { properties: { auth_type: { const: "authorization_code" } }, required: ["auth_type"] },
-      then: {
-        required: ["auth_client_id", "auth_redirect_url"],
-        properties: {
-          auth_client_id: true,
-          auth_client_secret: true,
-          auth_redirect_url: true,
-          auth_scope: true
-        }
-      }
-    }
-  ]
-};
-function isMcpAuthType(value) {
-  return typeof value === "string" && mcpAuthTypes.includes(value);
-}
-function asNonEmptyString(value) {
-  if (typeof value !== "string")
-    return;
-  const trimmed = value.trim();
-  return trimmed === "" ? undefined : trimmed;
-}
-function asNumber(value) {
-  return typeof value === "number" ? value : undefined;
-}
-function buildAuthConfig(flat) {
-  const rawAuthType = flat.auth_type;
-  if (!isMcpAuthType(rawAuthType) || rawAuthType === "none") {
-    return;
-  }
-  const authType = rawAuthType;
-  switch (authType) {
-    case "bearer": {
-      const token = asNonEmptyString(flat.auth_token);
-      if (!token)
-        return;
-      return { type: "bearer", token };
-    }
-    case "client_credentials": {
-      const client_id = asNonEmptyString(flat.auth_client_id);
-      const client_secret = asNonEmptyString(flat.auth_client_secret);
-      if (!client_id || !client_secret)
-        return;
-      return {
-        type: "client_credentials",
-        client_id,
-        client_secret,
-        client_name: asNonEmptyString(flat.auth_client_name),
-        scope: asNonEmptyString(flat.auth_scope)
-      };
-    }
-    case "private_key_jwt": {
-      const client_id = asNonEmptyString(flat.auth_client_id);
-      const private_key = asNonEmptyString(flat.auth_private_key);
-      const algorithm = asNonEmptyString(flat.auth_algorithm);
-      if (!client_id || !private_key || !algorithm)
-        return;
-      return {
-        type: "private_key_jwt",
-        client_id,
-        private_key,
-        algorithm,
-        client_name: asNonEmptyString(flat.auth_client_name),
-        jwt_lifetime_seconds: asNumber(flat.auth_jwt_lifetime_seconds),
-        scope: asNonEmptyString(flat.auth_scope)
-      };
-    }
-    case "static_private_key_jwt": {
-      const client_id = asNonEmptyString(flat.auth_client_id);
-      const jwt_bearer_assertion = asNonEmptyString(flat.auth_jwt_bearer_assertion);
-      if (!client_id || !jwt_bearer_assertion)
-        return;
-      return {
-        type: "static_private_key_jwt",
-        client_id,
-        jwt_bearer_assertion,
-        client_name: asNonEmptyString(flat.auth_client_name),
-        scope: asNonEmptyString(flat.auth_scope)
-      };
-    }
-    case "authorization_code": {
-      const client_id = asNonEmptyString(flat.auth_client_id);
-      const redirect_url = asNonEmptyString(flat.auth_redirect_url);
-      if (!client_id || !redirect_url)
-        return;
-      return {
-        type: "authorization_code",
-        client_id,
-        client_secret: asNonEmptyString(flat.auth_client_secret),
-        redirect_url,
-        scope: asNonEmptyString(flat.auth_scope)
-      };
-    }
-    default:
-      return;
-  }
-}
-// src/mcp/McpAuthProvider.ts
-import {
-  ClientCredentialsProvider,
-  PrivateKeyJwtProvider,
-  StaticPrivateKeyJwtProvider,
-  createPrivateKeyJwtAuth
-} from "@modelcontextprotocol/sdk/client/auth-extensions.js";
-import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
-function normalizeServerUrl(serverUrl) {
-  try {
-    const u = new URL(serverUrl);
-    return u.origin + u.pathname.replace(/\/+$/, "");
-  } catch {
-    return serverUrl;
-  }
-}
-function storeKey(serverUrl, suffix) {
-  return `mcp:oauth:${normalizeServerUrl(serverUrl)}:${suffix}`;
-}
-
-class CredentialStoreOAuthProvider {
-  store;
-  serverUrl;
-  _clientMetadata;
-  _redirectUrl;
-  _initialClientInfo;
-  prepareTokenRequest;
-  addClientAuthentication;
-  constructor(options) {
-    this.store = options.store;
-    this.serverUrl = options.serverUrl;
-    this._clientMetadata = options.clientMetadata;
-    this._redirectUrl = options.redirectUrl;
-    this._initialClientInfo = options.initialClientInfo;
-    if (options.prepareTokenRequest) {
-      this.prepareTokenRequest = options.prepareTokenRequest;
-    }
-    if (options.addClientAuthentication) {
-      this.addClientAuthentication = options.addClientAuthentication;
-    }
-  }
-  get redirectUrl() {
-    return this._redirectUrl;
-  }
-  get clientMetadata() {
-    return this._clientMetadata;
-  }
-  async clientInformation() {
-    const raw = await this.store.get(storeKey(this.serverUrl, "client_info"));
-    if (!raw)
-      return this._initialClientInfo;
-    return JSON.parse(raw);
-  }
-  async saveClientInformation(info) {
-    await this.store.put(storeKey(this.serverUrl, "client_info"), JSON.stringify(info));
-  }
-  async tokens() {
-    const raw = await this.store.get(storeKey(this.serverUrl, "tokens"));
-    if (!raw)
-      return;
-    return JSON.parse(raw);
-  }
-  async saveTokens(tokens) {
-    const expiresAt = tokens.expires_in != null ? new Date(Date.now() + tokens.expires_in * 1000) : undefined;
-    await this.store.put(storeKey(this.serverUrl, "tokens"), JSON.stringify(tokens), {
-      expiresAt
-    });
-  }
-  async redirectToAuthorization(authorizationUrl) {
-    throw new Error(`MCP OAuth authorization required. ` + `Open this URL to authorize: ${authorizationUrl.toString()}`);
-  }
-  async saveCodeVerifier(codeVerifier) {
-    await this.store.put(storeKey(this.serverUrl, "code_verifier"), codeVerifier);
-  }
-  async codeVerifier() {
-    const v = await this.store.get(storeKey(this.serverUrl, "code_verifier"));
-    if (!v)
-      throw new Error("No code verifier saved for this session");
-    return v;
-  }
-  async saveDiscoveryState(state) {
-    await this.store.put(storeKey(this.serverUrl, "discovery"), JSON.stringify(state));
-  }
-  async discoveryState() {
-    const raw = await this.store.get(storeKey(this.serverUrl, "discovery"));
-    if (!raw)
-      return;
-    return JSON.parse(raw);
-  }
-  async invalidateCredentials(scope) {
-    const deleteKey = async (suffix) => {
-      await this.store.delete(storeKey(this.serverUrl, suffix));
-    };
-    switch (scope) {
-      case "all":
-        await deleteKey("tokens");
-        await deleteKey("client_info");
-        await deleteKey("code_verifier");
-        await deleteKey("discovery");
-        break;
-      case "client":
-        await deleteKey("client_info");
-        break;
-      case "tokens":
-        await deleteKey("tokens");
-        break;
-      case "verifier":
-        await deleteKey("code_verifier");
-        break;
-      case "discovery":
-        await deleteKey("discovery");
-        break;
-    }
-  }
-}
-function createAuthProvider(auth, serverUrl, credentialStore) {
-  switch (auth.type) {
-    case "none":
-    case "bearer":
-      return;
-    case "client_credentials": {
-      if (!credentialStore) {
-        return new ClientCredentialsProvider({
-          clientId: auth.client_id,
-          clientSecret: auth.client_secret,
-          clientName: auth.client_name,
-          scope: auth.scope
-        });
-      }
-      const prepareTokenRequest = (scope) => {
-        const params = new URLSearchParams({ grant_type: "client_credentials" });
-        const effectiveScope = scope ?? auth.scope;
-        if (effectiveScope)
-          params.set("scope", effectiveScope);
-        return params;
-      };
-      return new CredentialStoreOAuthProvider({
-        store: credentialStore,
-        serverUrl,
-        clientMetadata: {
-          redirect_uris: [],
-          grant_types: ["client_credentials"],
-          token_endpoint_auth_method: "client_secret_basic",
-          client_name: auth.client_name
-        },
-        initialClientInfo: {
-          client_id: auth.client_id,
-          client_secret: auth.client_secret
-        },
-        prepareTokenRequest
-      });
-    }
-    case "private_key_jwt": {
-      if (!credentialStore) {
-        return new PrivateKeyJwtProvider({
-          clientId: auth.client_id,
-          privateKey: auth.private_key,
-          algorithm: auth.algorithm,
-          clientName: auth.client_name,
-          jwtLifetimeSeconds: auth.jwt_lifetime_seconds,
-          scope: auth.scope
-        });
-      }
-      const addClientAuth = createPrivateKeyJwtAuth({
-        issuer: auth.client_id,
-        subject: auth.client_id,
-        privateKey: auth.private_key,
-        alg: auth.algorithm,
-        lifetimeSeconds: auth.jwt_lifetime_seconds
-      });
-      const prepareTokenRequest = (scope) => {
-        const params = new URLSearchParams({ grant_type: "client_credentials" });
-        const effectiveScope = scope ?? auth.scope;
-        if (effectiveScope)
-          params.set("scope", effectiveScope);
-        return params;
-      };
-      return new CredentialStoreOAuthProvider({
-        store: credentialStore,
-        serverUrl,
-        clientMetadata: {
-          redirect_uris: [],
-          grant_types: ["client_credentials"],
-          token_endpoint_auth_method: "private_key_jwt",
-          client_name: auth.client_name
-        },
-        initialClientInfo: { client_id: auth.client_id },
-        prepareTokenRequest,
-        addClientAuthentication: addClientAuth
-      });
-    }
-    case "static_private_key_jwt": {
-      if (!credentialStore) {
-        return new StaticPrivateKeyJwtProvider({
-          clientId: auth.client_id,
-          jwtBearerAssertion: auth.jwt_bearer_assertion,
-          clientName: auth.client_name,
-          scope: auth.scope
-        });
-      }
-      const assertion = auth.jwt_bearer_assertion;
-      const addClientAuth = (_headers, params) => {
-        params.set("client_assertion_type", "urn:ietf:params:oauth:client-assertion-type:jwt-bearer");
-        params.set("client_assertion", assertion);
-      };
-      const prepareTokenRequest = (scope) => {
-        const params = new URLSearchParams({ grant_type: "client_credentials" });
-        const effectiveScope = scope ?? auth.scope;
-        if (effectiveScope)
-          params.set("scope", effectiveScope);
-        return params;
-      };
-      return new CredentialStoreOAuthProvider({
-        store: credentialStore,
-        serverUrl,
-        clientMetadata: {
-          redirect_uris: [],
-          grant_types: ["client_credentials"],
-          token_endpoint_auth_method: "private_key_jwt",
-          client_name: auth.client_name
-        },
-        initialClientInfo: { client_id: auth.client_id },
-        prepareTokenRequest,
-        addClientAuthentication: addClientAuth
-      });
-    }
-    case "authorization_code": {
-      if (!credentialStore) {
-        throw new Error("authorization_code auth requires a credential store for token persistence");
-      }
-      return new CredentialStoreOAuthProvider({
-        store: credentialStore,
-        serverUrl,
-        clientMetadata: {
-          redirect_uris: [auth.redirect_url],
-          grant_types: ["authorization_code", "refresh_token"],
-          token_endpoint_auth_method: auth.client_secret ? "client_secret_basic" : "none",
-          scope: auth.scope
-        },
-        initialClientInfo: {
-          client_id: auth.client_id,
-          ...auth.client_secret ? { client_secret: auth.client_secret } : {}
-        },
-        redirectUrl: auth.redirect_url
-      });
-    }
-    default:
-      return;
-  }
-}
-async function resolveAuthSecrets(auth, credentialStore) {
-  if (auth.type === "none")
-    return auth;
-  const store = credentialStore ?? getGlobalCredentialStore();
-  async function resolve(value) {
-    if (!value)
-      return value;
-    const resolved = await store.get(value);
-    return resolved ?? value;
-  }
-  switch (auth.type) {
-    case "bearer":
-      return { ...auth, token: await resolve(auth.token) ?? auth.token };
-    case "client_credentials":
-      return {
-        ...auth,
-        client_secret: await resolve(auth.client_secret) ?? auth.client_secret
-      };
-    case "private_key_jwt":
-      return {
-        ...auth,
-        private_key: await resolve(auth.private_key) ?? auth.private_key
-      };
-    case "static_private_key_jwt":
-      return {
-        ...auth,
-        jwt_bearer_assertion: await resolve(auth.jwt_bearer_assertion) ?? auth.jwt_bearer_assertion
-      };
-    case "authorization_code":
-      return {
-        ...auth,
-        client_secret: await resolve(auth.client_secret)
-      };
-    default:
-      return auth;
-  }
-}
 // src/telemetry/ITelemetryProvider.ts
 var SpanStatusCode = {
   UNSET: 0,
@@ -3234,167 +1365,209 @@ function getTelemetryProvider() {
 function setTelemetryProvider(provider) {
   globalServiceRegistry.registerInstance(TELEMETRY_PROVIDER, provider);
 }
-// src/compress/compress.browser.ts
-async function compress(input, algorithm = "gzip") {
-  const sourceBlob = new Blob([typeof input === "string" ? input : new Uint8Array(input)]);
-  const compressedStream = sourceBlob.stream().pipeThrough(new CompressionStream(algorithm));
-  const compressedBuffer = await new Response(compressedStream).arrayBuffer();
-  return new Uint8Array(compressedBuffer);
-}
-async function decompress(input, algorithm = "gzip") {
-  const sourceBlob = new Blob([new Uint8Array(input)]);
-  const decompressedStream = sourceBlob.stream().pipeThrough(new DecompressionStream(algorithm));
-  return await new Response(decompressedStream).text();
-}
-// src/mcp/McpClientUtil.browser.ts
-import { Client } from "@modelcontextprotocol/sdk/client";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-var mcpTransportTypes = ["streamable-http", "sse"];
-var mcpServerConfigSchema = {
-  properties: {
-    transport: {
-      type: "string",
-      enum: mcpTransportTypes,
-      title: "Transport",
-      description: "The transport type to use for connecting to the MCP server"
-    },
-    server_url: {
-      type: "string",
-      format: "uri",
-      title: "Server URL",
-      description: "The URL of the MCP server (for streamable-http transport)"
-    },
-    ...mcpAuthConfigSchema.properties
-  },
-  allOf: mcpAuthConfigSchema.allOf
-};
-async function createMcpClient(config, signal) {
-  let transport;
-  let auth = config.auth ?? buildAuthConfig({ ...config });
-  if (auth && auth.type !== "none") {
-    auth = await resolveAuthSecrets(auth, getGlobalCredentialStore());
-  }
-  const authProvider = config.authProvider ?? (auth && auth.type !== "none" && auth.type !== "bearer" ? createAuthProvider(auth, config.server_url ?? "", getGlobalCredentialStore()) : undefined);
-  const headers = {
-    ...auth?.type === "bearer" ? { Authorization: `Bearer ${auth.token}` } : {}
-  };
-  const requestInit = { headers };
-  switch (config.transport) {
-    case "sse": {
-      transport = new SSEClientTransport(new URL(config.server_url), {
-        authProvider,
-        requestInit
-      });
-      break;
-    }
-    case "streamable-http": {
-      transport = new StreamableHTTPClientTransport(new URL(config.server_url), {
-        authProvider,
-        requestInit
-      });
-      break;
+// src/worker/WorkerServerBase.ts
+var WORKER_SERVER = createServiceToken("worker.server");
+function extractTransferables(obj) {
+  const transferables = [];
+  const seen = new WeakSet;
+  function findTransferables(value) {
+    if (value && typeof value === "object" && seen.has(value)) {
+      return;
     }
-    default:
-      throw new Error(`Unsupported transport type: ${config.transport}`);
-  }
-  const client = new Client({ name: "workglow-mcp-client", version: "1.0.0" });
-  if (signal) {
-    signal.addEventListener("abort", () => {
-      client.close().catch(() => {});
-    }, { once: true });
-  }
-  try {
-    await client.connect(transport);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    const url = config.server_url ?? "";
-    const is405 = message.includes("405") || message.includes("Method Not Allowed") || typeof err === "object" && err !== null && "status" in err && err.status === 405;
-    if (is405) {
-      throw new Error(`MCP connection failed with 405 Method Not Allowed for ${url}. ` + `This usually means the server does not accept GET requests. `, { cause: err });
+    if (value && typeof value === "object") {
+      seen.add(value);
     }
-    const is406 = message.includes("406") || message.includes("Not Acceptable") || typeof err === "object" && err !== null && "code" in err && err.code === 406;
-    if (is406) {
-      throw new Error(`MCP connection failed with 406 Not Acceptable for ${url}. ` + `Try using transport "sse" instead of "streamable-http", or ensure the server accepts the request format (Accept: application/json, text/event-stream and MCP-Protocol-Version).`, { cause: err });
+    if (value instanceof Float32Array || value instanceof Int16Array) {
+      transferables.push(value.buffer);
+    } else if (value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array || value instanceof Uint16Array || value instanceof Int32Array || value instanceof Uint32Array || value instanceof Float64Array || value instanceof BigInt64Array || value instanceof BigUint64Array) {
+      transferables.push(value.buffer);
+    } else if (typeof OffscreenCanvas !== "undefined" && value instanceof OffscreenCanvas) {
+      transferables.push(value);
+    } else if (typeof ImageBitmap !== "undefined" && value instanceof ImageBitmap) {
+      transferables.push(value);
+    } else if (typeof VideoFrame !== "undefined" && value instanceof VideoFrame) {
+      transferables.push(value);
+    } else if (typeof MessagePort !== "undefined" && value instanceof MessagePort) {
+      transferables.push(value);
+    } else if (value instanceof ArrayBuffer) {
+      transferables.push(value);
+    } else if (Array.isArray(value)) {
+      value.forEach(findTransferables);
+    } else if (value && typeof value === "object") {
+      Object.values(value).forEach(findTransferables);
     }
-    throw err;
   }
-  return { client, transport };
-}
-var mcpClientFactory = {
-  create: createMcpClient
-};
-// src/media/image.ts
-function parseDataUri(dataUri) {
-  const match = dataUri.match(/^data:([^;]+);base64,(.+)$/);
-  if (!match) {
-    throw new Error("Invalid base64 data URI");
-  }
-  return {
-    mimeType: match[1],
-    base64: match[2]
-  };
+  findTransferables(obj);
+  return transferables;
 }
 
-// src/media/image.browser.ts
-var convertBlobToOffscreenCanvas = async (blob) => {
-  const img = await createImageBitmap(blob);
-  const ctx = new OffscreenCanvas(img.width, img.height).getContext("2d");
-  if (!ctx) {
-    throw new Error("Failed to get context.");
-  }
-  ctx.drawImage(img, 0, 0);
-  return ctx.canvas;
-};
-function dataUriToBlob(dataUri) {
-  const { mimeType, base64 } = parseDataUri(dataUri);
-  const binary = atob(base64);
-  const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
-  const blob = new Blob([bytes], { type: mimeType });
-  return blob;
-}
-async function convertImageDataToUseableForm(imageData, supports) {
-  if (imageData === null || imageData === undefined) {
-    throw new Error("Image data is null or undefined");
-  }
-  if (supports.includes("ImageBitmap") && imageData instanceof ImageBitmap) {
-    return imageData;
-  }
-  if (supports.includes("VideoFrame") && imageData instanceof VideoFrame) {
-    return imageData;
-  }
-  if (supports.includes("Blob") && imageData instanceof Blob) {
-    return imageData;
+class WorkerServerBase {
+  constructor() {}
+  functions = {};
+  streamFunctions = {};
+  reactiveFunctions = {};
+  requestControllers = new Map;
+  completedRequests = new Set;
+  postResult = (id, result) => {
+    if (this.completedRequests.has(id)) {
+      return;
+    }
+    this.completedRequests.add(id);
+    const transferables = extractTransferables(result);
+    const uniqueTransferables = [...new Set(transferables)];
+    postMessage({ id, type: "complete", data: result }, uniqueTransferables);
+  };
+  postError = (id, errorMessage) => {
+    if (this.completedRequests.has(id)) {
+      return;
+    }
+    this.completedRequests.add(id);
+    postMessage({ id, type: "error", data: errorMessage });
+  };
+  postStreamChunk = (id, event) => {
+    if (this.completedRequests.has(id)) {
+      return;
+    }
+    postMessage({ id, type: "stream_chunk", data: event });
+  };
+  sendReady() {
+    postMessage({
+      type: "ready",
+      functions: Object.keys(this.functions),
+      streamFunctions: Object.keys(this.streamFunctions),
+      reactiveFunctions: Object.keys(this.reactiveFunctions)
+    });
   }
-  if (supports.includes("ImageBinary") && typeof imageData === "object" && "data" in imageData && "width" in imageData && "height" in imageData && "channels" in imageData) {
-    return imageData;
+  registerFunction(name, fn) {
+    this.functions[name] = fn;
   }
-  if (supports.includes("ImageBitmap") && imageData instanceof Blob) {
-    return createImageBitmap(imageData);
+  registerReactiveFunction(name, fn) {
+    this.reactiveFunctions[name] = fn;
   }
-  if (supports.includes("OffscreenCanvas") && imageData instanceof Blob) {
-    return await convertBlobToOffscreenCanvas(imageData);
+  registerStreamFunction(name, fn) {
+    this.streamFunctions[name] = fn;
   }
-  if (supports.includes("ImageBitmap") && imageData instanceof OffscreenCanvas) {
-    return imageData.transferToImageBitmap();
+  async handleMessage(event) {
+    const { id, type, functionName, args, stream, reactive } = event.data;
+    if (type === "abort") {
+      return await this.handleAbort(id);
+    }
+    if (type === "call") {
+      if (stream) {
+        return await this.handleStreamCall(id, functionName, args);
+      }
+      if (reactive) {
+        return await this.handleReactiveCall(id, functionName, args);
+      }
+      return await this.handleCall(id, functionName, args);
+    }
   }
-  if (supports.includes("ImageBitmap") && typeof imageData === "string") {
-    return createImageBitmap(dataUriToBlob(imageData));
+  async handleAbort(id) {
+    if (this.requestControllers.has(id)) {
+      const controller = this.requestControllers.get(id);
+      controller?.abort();
+      this.requestControllers.delete(id);
+      this.postError(id, "Operation aborted");
+    }
   }
-  if (supports.includes("OffscreenCanvas") && typeof imageData === "string") {
-    return convertBlobToOffscreenCanvas(dataUriToBlob(imageData));
+  async handleReactiveCall(id, functionName, [input, output, model]) {
+    if (!(functionName in this.reactiveFunctions)) {
+      this.postResult(id, undefined);
+      return;
+    }
+    try {
+      const fn = this.reactiveFunctions[functionName];
+      const result = await fn(input, output, model);
+      this.postResult(id, result);
+    } catch (error) {
+      this.postError(id, error.message);
+    }
   }
-  if (supports.includes("Blob") && typeof imageData === "string") {
-    return dataUriToBlob(imageData);
+  async handleCall(id, functionName, [input, model]) {
+    if (!(functionName in this.functions)) {
+      this.postError(id, `Function ${functionName} not found`);
+      return;
+    }
+    try {
+      const abortController = new AbortController;
+      this.requestControllers.set(id, abortController);
+      const fn = this.functions[functionName];
+      const postProgress = (progress, message, details) => {
+        if (!this.completedRequests.has(id)) {
+          postMessage({ id, type: "progress", data: { progress, message, details } });
+        }
+      };
+      const result = await fn(input, model, postProgress, abortController.signal);
+      this.postResult(id, result);
+    } catch (error) {
+      this.postError(id, error.message);
+    } finally {
+      this.requestControllers.delete(id);
+      setTimeout(() => {
+        this.completedRequests.delete(id);
+      }, 1000);
+    }
   }
-  if (supports.includes("DataUri") && typeof imageData === "string" && imageData.startsWith("data:")) {
-    return imageData;
+  async handleStreamCall(id, functionName, [input, model]) {
+    if (functionName in this.streamFunctions) {
+      try {
+        const abortController = new AbortController;
+        this.requestControllers.set(id, abortController);
+        const fn = this.streamFunctions[functionName];
+        const iterable = fn(input, model, abortController.signal);
+        for await (const event of iterable) {
+          if (this.completedRequests.has(id))
+            break;
+          this.postStreamChunk(id, event);
+        }
+        this.postResult(id, undefined);
+      } catch (error) {
+        this.postError(id, error.message);
+      } finally {
+        this.requestControllers.delete(id);
+        setTimeout(() => {
+          this.completedRequests.delete(id);
+        }, 1000);
+      }
+    } else if (functionName in this.functions) {
+      try {
+        const abortController = new AbortController;
+        this.requestControllers.set(id, abortController);
+        const fn = this.functions[functionName];
+        const noopProgress = () => {};
+        const result = await fn(input, model, noopProgress, abortController.signal);
+        this.postStreamChunk(id, { type: "finish", data: result });
+        this.postResult(id, undefined);
+      } catch (error) {
+        this.postError(id, error.message);
+      } finally {
+        this.requestControllers.delete(id);
+        setTimeout(() => {
+          this.completedRequests.delete(id);
+        }, 1000);
+      }
+    } else {
+      this.postError(id, `Function ${functionName} not found`);
+    }
   }
-  throw new Error(`Unsupported image data type: ${typeof imageData} `);
 }
+
 // src/worker/Worker.browser.ts
 var Worker = globalThis.Worker;
-var parentPort2 = self;
+var parentPort = self;
+class WorkerServer extends WorkerServerBase {
+  constructor() {
+    parentPort?.addEventListener("message", async (event) => {
+      const msg = {
+        type: event.type,
+        data: event.data
+      };
+      await this.handleMessage(msg);
+    });
+    super();
+  }
+}
+globalServiceRegistry.register(WORKER_SERVER, () => new WorkerServer, true);
 export {
   uuid4,
   toSQLiteTimestamp,
@@ -3406,26 +1579,10 @@ export {
   setGlobalCredentialStore,
   serialize,
   resolveCredential,
-  resolveAuthSecrets,
   registerInputResolver,
-  parsePartialJson,
-  parseDataUri,
-  parentPort2 as parentPort,
+  parentPort,
   objectOfArraysAsArrayOfObjects,
-  normalizeNumberArray,
-  normalize,
-  mcpTransportTypes,
-  mcpServerConfigSchema,
-  mcpClientFactory,
-  mcpAuthTypes,
-  mcpAuthConfigSchema,
   makeFingerprint,
-  magnitude,
-  jaccardSimilarity,
-  isTypedArray,
-  inner,
-  hammingSimilarity,
-  hammingDistance,
   globalServiceRegistry,
   globalContainer,
   getTelemetryProvider,
@@ -3437,49 +1594,26 @@ export {
   deriveKey,
   deepEqual,
   decrypt,
-  decompress,
-  createTypedArrayFrom,
   createServiceToken,
-  createMcpClient,
-  createAuthProvider,
-  cosineSimilarity,
-  convertImageDataToUseableForm,
-  compress,
-  compileSchema,
   collectPropertyValues,
-  buildAuthConfig,
   bufToBase64,
   base64ToBuf,
-  areSemanticallyCompatible,
-  areObjectSchemasSemanticallyCompatible,
   WorkerServer,
   WorkerManager,
   Worker,
   WORKER_SERVER,
   WORKER_MANAGER,
-  UnauthorizedError,
-  TypedArraySchema,
-  TensorType,
-  TensorSchema,
   TELEMETRY_PROVIDER,
   SpanStatusCode,
   ServiceRegistry,
   OTelTelemetryProvider,
   NullLogger,
   NoopTelemetryProvider,
-  NodeDoesntExistError,
-  NodeAlreadyExistsError,
   LOGGER,
   InMemoryCredentialStore,
   INPUT_RESOLVERS,
-  Graph,
-  FromSchemaDefaultOptions,
   EventEmitter,
   EnvCredentialStore,
-  DirectedGraph,
-  DirectedAcyclicGraph,
-  CycleError,
-  CredentialStoreOAuthProvider,
   Container,
   ConsoleTelemetryProvider,
   ConsoleLogger,
@@ -3488,4 +1622,4 @@ export {
   BaseError
 };
 
-//# debugId=F92FC9473BBE2EE764756E2164756E21
+//# debugId=C665251EA27E791364756E2164756E21