@workglow/util 0.0.52

package/dist/bun.js

@@ -0,0 +1,1558 @@
+// @bun
+// src/di/Container.ts
+class Container {
+  services = new Map;
+  factories = new Map;
+  singletons = new Set;
+  register(token, factory, singleton = true) {
+    this.factories.set(token, factory);
+    if (singleton) {
+      this.singletons.add(token);
+    }
+  }
+  registerInstance(token, instance) {
+    this.services.set(token, instance);
+    this.singletons.add(token);
+  }
+  get(token) {
+    if (this.services.has(token)) {
+      return this.services.get(token);
+    }
+    const factory = this.factories.get(token);
+    if (!factory) {
+      throw new Error(`Service not registered: ${String(token)}`);
+    }
+    const instance = factory();
+    if (this.singletons.has(token)) {
+      this.services.set(token, instance);
+    }
+    return instance;
+  }
+  has(token) {
+    return this.services.has(token) || this.factories.has(token);
+  }
+  remove(token) {
+    this.services.delete(token);
+    this.factories.delete(token);
+    this.singletons.delete(token);
+  }
+  createChildContainer() {
+    const child = new Container;
+    this.factories.forEach((factory, token) => {
+      child.factories.set(token, factory);
+      if (this.singletons.has(token)) {
+        child.singletons.add(token);
+      }
+    });
+    this.services.forEach((service, token) => {
+      if (this.singletons.has(token)) {
+        child.services.set(token, service);
+        child.singletons.add(token);
+      }
+    });
+    return child;
+  }
+}
+var globalContainer = new Container;
+// src/di/ServiceRegistry.ts
+function createServiceToken(id) {
+  return { id, _type: null };
+}
+
+class ServiceRegistry {
+  container;
+  constructor(container = globalContainer) {
+    this.container = container;
+  }
+  register(token, factory, singleton = true) {
+    this.container.register(token.id, factory, singleton);
+  }
+  registerInstance(token, instance) {
+    this.container.registerInstance(token.id, instance);
+  }
+  get(token) {
+    return this.container.get(token.id);
+  }
+  has(token) {
+    return this.container.has(token.id);
+  }
+}
+var globalServiceRegistry = new ServiceRegistry(globalContainer);
+// src/events/EventEmitter.ts
+class EventEmitter {
+  listeners = {};
+  removeAllListeners(event) {
+    if (event) {
+      delete this.listeners[event];
+    } else {
+      this.listeners = {};
+    }
+    return this;
+  }
+  on(event, listener) {
+    const listeners = this.listeners[event] || (this.listeners[event] = []);
+    listeners.push({ listener });
+    return this;
+  }
+  off(event, listener) {
+    const listeners = this.listeners[event];
+    if (!listeners)
+      return this;
+    const index = listeners.findIndex((l) => l.listener === listener);
+    if (index >= 0) {
+      listeners.splice(index, 1);
+    }
+    return this;
+  }
+  once(event, listener) {
+    const listeners = this.listeners[event] || (this.listeners[event] = []);
+    listeners.push({ listener, once: true });
+    return this;
+  }
+  waitOn(event) {
+    return new Promise((resolve, reject) => {
+      const listener = (...args) => {
+        resolve(args);
+      };
+      this.once(event, listener);
+    });
+  }
+  emit(event, ...args) {
+    const listeners = this.listeners[event];
+    if (listeners) {
+      listeners.forEach(({ listener, once }) => {
+        listener(...args);
+      });
+      this.listeners[event] = listeners.filter((l) => !l.once);
+    }
+  }
+  subscribe(event, listener) {
+    this.on(event, listener);
+    return () => this.off(event, listener);
+  }
+}
+// src/utilities/BaseError.ts
+class BaseError {
+  static type = "BaseError";
+  message;
+  name;
+  stack;
+  constructor(message = "") {
+    this.message = message;
+    const constructor = this.constructor;
+    this.name = constructor.type ?? this.constructor.name;
+    if (typeof Error !== "undefined" && Error.captureStackTrace) {
+      const temp = { stack: "" };
+      Error.captureStackTrace(temp, this.constructor);
+      this.stack = temp.stack;
+    } else {
+      try {
+        throw new Error(message);
+      } catch (err) {
+        if (err instanceof Error) {
+          this.stack = err.stack;
+        }
+      }
+    }
+  }
+  toString() {
+    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.call(this.events, 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: false,
+  keepDefaultedPropertiesOptional: true,
+  references: false,
+  deserialize: false
+};
+// src/json-schema/SchemaUtils.ts
+function areFormatStringsCompatible(sourceFormat, targetFormat) {
+  const formatPattern = /^\w+(:\w+)?$/;
+  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 "json-schema-library";
+// src/utilities/Misc.ts
+function forceArray(input) {
+  if (Array.isArray(input))
+    return input;
+  return [input];
+}
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function collectPropertyValues(input) {
+  const output = {};
+  (input || []).forEach((item) => {
+    Object.keys(item).forEach((key) => {
+      const value = item[key];
+      if (output[key]) {
+        output[key].push(value);
+      } else {
+        output[key] = [value];
+      }
+    });
+  });
+  return output;
+}
+function toSQLiteTimestamp(date) {
+  if (!date)
+    return null;
+  const pad = (number) => number < 10 ? "0" + number : number;
+  const year = date.getUTCFullYear();
+  const month = pad(date.getUTCMonth() + 1);
+  const day = pad(date.getUTCDate());
+  const hours = pad(date.getUTCHours());
+  const minutes = pad(date.getUTCMinutes());
+  const seconds = pad(date.getUTCSeconds());
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+}
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a == null || b == null) {
+    return false;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  for (const key of keysA) {
+    if (!keysB.includes(key)) {
+      return false;
+    }
+    if (!deepEqual(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function sortObject(obj) {
+  return Object.keys(obj).sort().reduce((result, key) => {
+    result[key] = obj[key];
+    return result;
+  }, {});
+}
+function serialize(obj) {
+  const sortedObj = sortObject(obj);
+  return JSON.stringify(sortedObj);
+}
+// src/utilities/objectOfArraysAsArrayOfObjects.ts
+function objectOfArraysAsArrayOfObjects(data) {
+  const keys = Object.keys(data);
+  const length = data[keys[0]].length;
+  for (const key of keys) {
+    if (data[key].length !== length) {
+      console.error("All arrays must have the same length", key, data[key].length, length, data);
+      throw new Error("All arrays must have the same length");
+    }
+  }
+  const indexSymbol = Symbol("index");
+  function createRowProxy(index) {
+    let currentIndex = index;
+    return new Proxy({}, {
+      get(_target, prop, receiver) {
+        if (currentIndex < 0 || currentIndex >= data[keys[0]].length) {
+          return;
+        }
+        if (typeof prop === "string" && keys.includes(prop)) {
+          return data[prop][currentIndex];
+        }
+        if (prop === indexSymbol) {
+          return currentIndex;
+        }
+        return Reflect.get(_target, prop, receiver);
+      },
+      set(_target, prop, value, receiver) {
+        if (currentIndex < 0 || currentIndex >= data[keys[0]].length) {
+          return false;
+        }
+        if (typeof prop === "string" && keys.includes(prop)) {
+          data[prop][currentIndex] = value;
+          return true;
+        }
+        if (prop === indexSymbol) {
+          currentIndex = value;
+          return true;
+        }
+        return Reflect.set(_target, prop, value, receiver);
+      },
+      ownKeys(_target) {
+        return keys;
+      },
+      getOwnPropertyDescriptor(_target, prop) {
+        if (typeof prop === "string" && keys.includes(prop)) {
+          return { enumerable: true, configurable: true };
+        }
+        return;
+      }
+    });
+  }
+  function createCursor() {
+    let currentIndex = 0;
+    const cursor = createRowProxy(0);
+    const obj = {
+      get length() {
+        return data[keys[0]].length;
+      },
+      next() {
+        if (currentIndex < length) {
+          cursor[indexSymbol] = currentIndex;
+          currentIndex++;
+          return { done: false, value: cursor };
+        } else {
+          return { done: true, value: undefined };
+        }
+      },
+      [Symbol.iterator]() {
+        currentIndex = 0;
+        cursor[indexSymbol] = currentIndex;
+        return obj;
+      }
+    };
+    return obj;
+  }
+  function shallowEqual(index, row) {
+    for (const key of keys) {
+      if (data[key][index] !== row[key])
+        return false;
+    }
+    return true;
+  }
+  return new Proxy([], {
+    get(target, prop, receiver) {
+      if (prop === "length") {
+        return data[keys[0]].length;
+      }
+      if (prop === "cursor") {
+        return function() {
+          return createCursor();
+        };
+      }
+      if (prop === "reverse") {
+        return function() {
+          for (const key of keys) {
+            data[key].reverse();
+          }
+          return receiver;
+        };
+      }
+      if (prop === "push") {
+        return function(...args) {
+          for (const item of args) {
+            for (const key of keys) {
+              data[key].push(item[key]);
+            }
+          }
+          return data[keys[0]].length;
+        };
+      }
+      if (prop === "pop") {
+        return function() {
+          const len = data[keys[0]].length;
+          if (len === 0)
+            return;
+          const poppedRow = {};
+          for (const key of keys) {
+            poppedRow[key] = data[key].pop();
+          }
+          return poppedRow;
+        };
+      }
+      if (prop === "unshift") {
+        return function(...args) {
+          for (let i = args.length - 1;i >= 0; i--) {
+            const item = args[i];
+            for (const key of keys) {
+              data[key].unshift(item[key]);
+            }
+          }
+          return data[keys[0]].length;
+        };
+      }
+      if (prop === "shift") {
+        return function() {
+          if (data[keys[0]].length === 0)
+            return;
+          const shiftedRow = {};
+          for (const key of keys) {
+            shiftedRow[key] = data[key].shift();
+          }
+          return shiftedRow;
+        };
+      }
+      if (prop === "splice") {
+        return function(start, deleteCount, ...items) {
+          const len = data[keys[0]].length;
+          if (start < 0) {
+            start = len + start;
+            if (start < 0)
+              start = 0;
+          }
+          if (deleteCount === undefined) {
+            deleteCount = len - start;
+          }
+          const removedByKey = {};
+          for (const key of keys) {
+            removedByKey[key] = data[key].splice(start, deleteCount, ...items.map((item) => item[key]));
+          }
+          const removed = [];
+          for (let i = 0;i < deleteCount; i++) {
+            const row = {};
+            for (const key of keys) {
+              row[key] = removedByKey[key][i];
+            }
+            removed.push(row);
+          }
+          return removed;
+        };
+      }
+      if (prop === "sort") {
+        return function(compareFn) {
+          const rows = [...receiver];
+          rows.sort(compareFn);
+          for (const key of keys) {
+            data[key] = rows.map((row) => row[key]);
+          }
+          return receiver;
+        };
+      }
+      if (prop === "includes") {
+        return function(searchElement, fromIndex) {
+          const len = data[keys[0]].length;
+          let start = fromIndex ?? 0;
+          if (start < 0) {
+            start = Math.max(0, len + start);
+          }
+          for (let i = start;i < len; i++) {
+            if (shallowEqual(i, searchElement))
+              return true;
+          }
+          return false;
+        };
+      }
+      if (prop === "indexOf") {
+        return function(searchElement, fromIndex) {
+          const len = data[keys[0]].length;
+          let start = fromIndex ?? 0;
+          if (start < 0) {
+            start = Math.max(0, len + start);
+          }
+          for (let i = start;i < len; i++) {
+            if (shallowEqual(i, searchElement))
+              return i;
+          }
+          return -1;
+        };
+      }
+      if (prop === "lastIndexOf") {
+        return function(searchElement, fromIndex) {
+          const len = data[keys[0]].length;
+          let start = fromIndex ?? len - 1;
+          if (start < 0) {
+            start = len + start;
+          }
+          for (let i = start;i >= 0; i--) {
+            if (shallowEqual(i, searchElement))
+              return i;
+          }
+          return -1;
+        };
+      }
+      if (prop === "forEach") {
+        return function(callback, thisArg) {
+          return [...receiver].forEach(callback, thisArg);
+        };
+      }
+      if (prop === "map") {
+        return function(callback, thisArg) {
+          return [...receiver].map(callback, thisArg);
+        };
+      }
+      if (prop === "filter") {
+        return function(callback, thisArg) {
+          return [...receiver].filter(callback, thisArg);
+        };
+      }
+      if (prop === "reduce") {
+        return function(callback, initialValue) {
+          return [...receiver].reduce(callback, initialValue);
+        };
+      }
+      if (prop === "find") {
+        return function(callback, thisArg) {
+          return [...receiver].find(callback, thisArg);
+        };
+      }
+      if (prop === "every") {
+        return function(callback, thisArg) {
+          return [...receiver].every(callback, thisArg);
+        };
+      }
+      if (prop === "some") {
+        return function(callback, thisArg) {
+          return [...receiver].some(callback, thisArg);
+        };
+      }
+      if (typeof prop === "string" && !isNaN(Number(prop))) {
+        const index = Number(prop);
+        if (index < 0 || index >= data[keys[0]].length) {
+          return;
+        }
+        return createRowProxy(index);
+      }
+      if (prop === Symbol.iterator) {
+        return function* () {
+          for (let i = 0;i < data[keys[0]].length; i++) {
+            yield createRowProxy(i);
+          }
+        };
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+    set(target, prop, value, receiver) {
+      if (typeof prop === "string" && !isNaN(Number(prop))) {
+        const index = Number(prop);
+        if (index === data[keys[0]].length) {
+          for (const key of keys) {
+            data[key].push(value[key]);
+          }
+          return true;
+        } else if (index < data[keys[0]].length) {
+          for (const key of keys) {
+            if (value.hasOwnProperty(key)) {
+              data[key][index] = value[key];
+            }
+          }
+          return true;
+        }
+      }
+      return Reflect.set(target, prop, value, receiver);
+    },
+    deleteProperty(target, prop) {
+      if (typeof prop === "string" && !isNaN(Number(prop))) {
+        const index = Number(prop);
+        if (index >= 0 && index < data[keys[0]].length) {
+          for (const key of keys) {
+            data[key].splice(index, 1);
+          }
+          return true;
+        }
+      }
+      return Reflect.deleteProperty(target, prop);
+    }
+  });
+}
+// src/worker/WorkerManager.ts
+class WorkerManager {
+  workers = new Map;
+  readyWorkers = new Map;
+  registerWorker(name, worker) {
+    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);
+    });
+    worker.addEventListener("messageerror", (event) => {
+      console.error("Worker message error:", event);
+    });
+    const readyPromise = new Promise((resolve) => {
+      const handleReady = (event) => {
+        if (event.data?.type === "ready") {
+          worker.removeEventListener("message", handleReady);
+          resolve();
+        }
+      };
+      worker.addEventListener("message", handleReady);
+    });
+    this.readyWorkers.set(name, readyPromise);
+  }
+  getWorker(name) {
+    const worker = this.workers.get(name);
+    if (!worker)
+      throw new Error(`Worker ${name} not found.`);
+    return worker;
+  }
+  async callWorkerFunction(workerName, functionName, args, options) {
+    const worker = this.workers.get(workerName);
+    if (!worker)
+      throw new Error(`Worker ${workerName} not found.`);
+    await this.readyWorkers.get(workerName);
+    return new Promise((resolve, reject) => {
+      const requestId = crypto.randomUUID();
+      const handleMessage = (event) => {
+        const { id, type, data } = event.data;
+        if (id !== requestId)
+          return;
+        if (type === "progress" && options?.onProgress) {
+          options.onProgress(data.progress, data.message, data.details);
+        } else if (type === "complete") {
+          cleanup();
+          resolve(data);
+        } else if (type === "error") {
+          cleanup();
+          reject(new Error(data));
+        }
+      };
+      const handleAbort = () => {
+        worker.postMessage({ id: requestId, type: "abort" });
+      };
+      const cleanup = () => {
+        worker.removeEventListener("message", handleMessage);
+        options?.signal?.removeEventListener("abort", handleAbort);
+      };
+      worker.addEventListener("message", handleMessage);
+      if (options?.signal) {
+        options.signal.addEventListener("abort", handleAbort, { once: true });
+      }
+      worker.postMessage({ id: requestId, type: "call", functionName, args });
+    });
+  }
+}
+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 = [];
+  function findTransferables(value) {
+    if (value instanceof Float32Array || value instanceof Int16Array) {
+      transferables.push(value.buffer);
+    } 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 = {};
+  postResult = (id, result) => {
+    const transferables = extractTransferables(result);
+    postMessage({ id, type: "complete", data: result }, transferables);
+  };
+  postError = (id, errorMessage) => {
+    postMessage({ id, type: "error", data: errorMessage });
+  };
+  requestControllers = new Map;
+  registerFunction(name, fn) {
+    this.functions[name] = fn;
+  }
+  async handleMessage(event) {
+    const { id, type, functionName, args } = event.data;
+    if (type === "abort") {
+      return await this.handleAbort(id);
+    }
+    if (type === "call") {
+      return await this.handleCall(id, functionName, args);
+    }
+  }
+  async handleAbort(id) {
+    if (this.requestControllers.has(id)) {
+      this.requestControllers.get(id)?.abort();
+    }
+  }
+  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) => {
+        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);
+    }
+  }
+}
+var WORKER_SERVER = createServiceToken("worker.server");
+globalServiceRegistry.register(WORKER_SERVER, () => new WorkerServer, true);
+// src/compress/compress.node.ts
+import { promisify } from "util";
+import zlib from "zlib";
+async function compress(input, algorithm = "gzip") {
+  const compressFn = algorithm === "br" ? zlib.brotliCompress : zlib.gzip;
+  const compressAsync = promisify(compressFn);
+  const compressAsyncTyped = compressAsync;
+  const sourceBuffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+  const result = await compressAsyncTyped(sourceBuffer);
+  return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
+}
+async function decompress(input, algorithm = "gzip") {
+  const decompressFn = algorithm === "br" ? zlib.brotliDecompress : zlib.gunzip;
+  const decompressAsync = promisify(decompressFn);
+  const decompressAsyncTyped = decompressAsync;
+  const sourceBuffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+  const resultBuffer = await decompressAsyncTyped(sourceBuffer);
+  return resultBuffer.toString();
+}
+// src/crypto/Crypto.bun.ts
+async function sha256(data) {
+  return new Bun.CryptoHasher("sha256").update(data).digest("hex");
+}
+async function makeFingerprint(input) {
+  const serializedObj = serialize(input);
+  const hash = await sha256(serializedObj);
+  return hash;
+}
+function uuid4() {
+  return crypto.randomUUID();
+}
+// src/worker/Worker.bun.ts
+var Worker = globalThis.Worker;
+var parentPort2 = self;
+export {
+  uuid4,
+  toSQLiteTimestamp,
+  sortObject,
+  sleep,
+  sha256,
+  serialize,
+  parentPort2 as parentPort,
+  objectOfArraysAsArrayOfObjects,
+  makeFingerprint,
+  globalServiceRegistry,
+  globalContainer,
+  forceArray,
+  deepEqual,
+  decompress,
+  createServiceToken,
+  compress,
+  compileSchema,
+  collectPropertyValues,
+  areSemanticallyCompatible,
+  areObjectSchemasSemanticallyCompatible,
+  WorkerServer,
+  WorkerManager,
+  Worker,
+  WORKER_SERVER,
+  WORKER_MANAGER,
+  ServiceRegistry,
+  NodeDoesntExistError,
+  NodeAlreadyExistsError,
+  Graph,
+  FromSchemaDefaultOptions,
+  EventEmitter,
+  DirectedGraph,
+  DirectedAcyclicGraph,
+  CycleError,
+  Container,
+  BaseError
+};
+
+//# debugId=367E927F3666D6AD64756E2164756E21