@workglow/util 0.0.102 → 0.0.104

package/dist/bun.js

@@ -1,4 +1,87 @@
 // @bun
+// 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/crypto/Crypto.ts
+async function sha256(data) {
+  const encoder = new TextEncoder;
+  const hashBuffer = await crypto.subtle.digest("SHA-256", encoder.encode(data));
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function makeFingerprint(input) {
+  const serializedObj = serialize(input);
+  const hash = await sha256(serializedObj);
+  return hash;
+}
+function uuid4() {
+  return crypto.randomUUID();
+}
 // src/di/Container.ts
 class Container {
   services = new Map;
@@ -144,6 +227,117 @@ class EventEmitter {
     return () => this.off(event, listener);
   }
 }
+// src/logging/ConsoleLogger.ts
+class ConsoleLogger {
+  bindings;
+  constructor(bindings = {}) {
+    this.bindings = bindings;
+  }
+  info(message, meta) {
+    const merged = this.merge(meta);
+    if (merged) {
+      console.info(message, merged);
+    } else {
+      console.info(message);
+    }
+  }
+  warn(message, meta) {
+    const merged = this.merge(meta);
+    if (merged) {
+      console.warn(message, merged);
+    } else {
+      console.warn(message);
+    }
+  }
+  error(message, meta) {
+    const merged = this.merge(meta);
+    if (merged) {
+      console.error(message, merged);
+    } else {
+      console.error(message);
+    }
+  }
+  debug(message, meta) {
+    const merged = this.merge(meta);
+    if (merged) {
+      console.debug(message, merged);
+    } else {
+      console.debug(message);
+    }
+  }
+  fatal(err, message, meta) {
+    const merged = this.merge(meta);
+    if (merged) {
+      console.error(message, { ...merged, error: err });
+    } else {
+      console.error(message, { error: err });
+    }
+  }
+  time(label, meta) {
+    const merged = this.merge(meta);
+    if (merged) {
+      console.info(`[time] ${label}`, merged);
+    }
+    console.time(label);
+  }
+  timeEnd(label, meta) {
+    console.timeEnd(label);
+    const merged = this.merge(meta);
+    if (merged) {
+      console.info(`[timeEnd] ${label}`, merged);
+    }
+  }
+  group(label, meta) {
+    const merged = this.merge(meta);
+    if (merged) {
+      console.group(label, merged);
+    } else {
+      console.group(label);
+    }
+  }
+  groupEnd() {
+    console.groupEnd();
+  }
+  child(bindings) {
+    return new ConsoleLogger({ ...this.bindings, ...bindings });
+  }
+  merge(meta) {
+    const hasBindings = Object.keys(this.bindings).length > 0;
+    if (!hasBindings && !meta)
+      return;
+    if (!hasBindings)
+      return meta;
+    if (!meta)
+      return this.bindings;
+    return { ...this.bindings, ...meta };
+  }
+}
+// src/logging/NullLogger.ts
+class NullLogger {
+  info(_message, _meta) {}
+  error(_message, _meta) {}
+  warn(_message, _meta) {}
+  debug(_message, _meta) {}
+  fatal(_err, _message, _meta) {}
+  time(_label, _meta) {}
+  timeEnd(_label, _meta) {}
+  group(_label, _meta) {}
+  groupEnd() {}
+  child(_bindings) {
+    return this;
+  }
+}
+// src/logging/LoggerRegistry.ts
+var LOGGER = createServiceToken("logger");
+if (!globalServiceRegistry.has(LOGGER)) {
+  globalServiceRegistry.register(LOGGER, () => new ConsoleLogger, true);
+}
+function getLogger() {
+  return globalServiceRegistry.get(LOGGER);
+}
+function setLogger(logger) {
+  globalServiceRegistry.registerInstance(LOGGER, logger);
+}
 // src/utilities/BaseError.ts
 class BaseError {
   static type = "BaseError";
@@ -978,72 +1172,168 @@ function areObjectSchemasSemanticallyCompatible(sourceSchema, targetSchema) {
 }
 // src/json-schema/SchemaValidation.ts
 import { compileSchema } from "@sroussey/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));
+// 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 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];
+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;
       }
-    });
-  });
-  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;
+      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 (typeof a !== "object" || typeof b !== "object" || a == null || b == null) {
-    return false;
+  if (inString) {
+    result += '"';
   }
-  const keysA = Object.keys(a);
-  const keysB = Object.keys(b);
-  if (keysA.length !== keysB.length) {
-    return false;
+  if (stack.length === 0) {
+    return result;
   }
-  for (const key of keysA) {
-    if (!keysB.includes(key)) {
-      return false;
+  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 (!deepEqual(a[key], b[key])) {
-      return false;
+    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 true;
+  return s;
 }
-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);
+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) {
@@ -1582,43 +1872,12 @@ function normalizeNumberArray(values, throwOnZero = false) {
   return values.map((v) => v / norm);
 }
 // src/worker/WorkerManager.ts
-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 WorkerManager {
   workers = new Map;
   readyWorkers = new Map;
+  workerFunctions = new Map;
+  workerStreamFunctions = new Map;
+  workerReactiveFunctions = new Map;
   registerWorker(name, worker) {
     if (this.workers.has(name))
       throw new Error(`Worker ${name} is already registered.`);
@@ -1634,6 +1893,9 @@ class WorkerManager {
       const handleReady = (event) => {
         if (event.data?.type === "ready") {
           worker.removeEventListener("message", handleReady);
+          this.workerFunctions.set(name, new Set(event.data.functions ?? []));
+          this.workerStreamFunctions.set(name, new Set(event.data.streamFunctions ?? []));
+          this.workerReactiveFunctions.set(name, new Set(event.data.reactiveFunctions ?? []));
           resolve();
         }
       };
@@ -1652,6 +1914,10 @@ class WorkerManager {
     if (!worker)
       throw new Error(`Worker ${workerName} not found.`);
     await this.readyWorkers.get(workerName);
+    const knownFunctions = this.workerFunctions.get(workerName);
+    if (knownFunctions && !knownFunctions.has(functionName)) {
+      throw new Error(`Function "${functionName}" is not registered on worker "${workerName}".`);
+    }
     return new Promise((resolve, reject) => {
       const requestId = crypto.randomUUID();
       const handleMessage = (event) => {
@@ -1680,8 +1946,7 @@ class WorkerManager {
         options.signal.addEventListener("abort", handleAbort, { once: true });
       }
       const message = { id: requestId, type: "call", functionName, args };
-      const transferables = extractTransferables(message);
-      worker.postMessage(message, transferables);
+      worker.postMessage(message);
     });
   }
   async callWorkerReactiveFunction(workerName, functionName, args) {
@@ -1689,6 +1954,9 @@ class WorkerManager {
     if (!worker)
       return;
     await this.readyWorkers.get(workerName);
+    const knownReactive = this.workerReactiveFunctions.get(workerName);
+    if (knownReactive && !knownReactive.has(functionName))
+      return;
     return new Promise((resolve) => {
       const requestId = crypto.randomUUID();
       const handleMessage = (event) => {
@@ -1708,8 +1976,7 @@ class WorkerManager {
       };
       worker.addEventListener("message", handleMessage);
       const message = { id: requestId, type: "call", functionName, args, reactive: true };
-      const transferables = extractTransferables(message);
-      worker.postMessage(message, transferables);
+      worker.postMessage(message);
     });
   }
   async* callWorkerStreamFunction(workerName, functionName, args, options) {
@@ -1717,6 +1984,11 @@ class WorkerManager {
     if (!worker)
       throw new Error(`Worker ${workerName} not found.`);
     await this.readyWorkers.get(workerName);
+    const knownStream = this.workerStreamFunctions.get(workerName);
+    const knownFns = this.workerFunctions.get(workerName);
+    if (knownStream && knownFns && !knownStream.has(functionName) && !knownFns.has(functionName)) {
+      throw new Error(`Function "${functionName}" is not registered on worker "${workerName}".`);
+    }
     const requestId = crypto.randomUUID();
     const queue = [];
     let waiting = null;
@@ -1758,8 +2030,7 @@ class WorkerManager {
       options.signal.addEventListener("abort", handleAbort, { once: true });
     }
     const message = { id: requestId, type: "call", functionName, args, stream: true };
-    const transferables = extractTransferables(message);
-    worker.postMessage(message, transferables);
+    worker.postMessage(message);
     let completedNormally = false;
     try {
       while (true) {
@@ -1791,7 +2062,7 @@ var WORKER_MANAGER = createServiceToken("worker.manager");
 globalServiceRegistry.register(WORKER_MANAGER, () => new WorkerManager, true);
 // src/worker/WorkerServer.ts
 import { parentPort } from "@workglow/util";
-function extractTransferables2(obj) {
+function extractTransferables(obj) {
   const transferables = [];
   const seen = new WeakSet;
   function findTransferables(value) {
@@ -1845,8 +2116,9 @@ class WorkerServer {
       return;
     }
     this.completedRequests.add(id);
-    const transferables = extractTransferables2(result);
-    postMessage({ id, type: "complete", data: result }, transferables);
+    const transferables = extractTransferables(result);
+    const uniqueTransferables = [...new Set(transferables)];
+    postMessage({ id, type: "complete", data: result }, uniqueTransferables);
   };
   postError = (id, errorMessage) => {
     if (this.completedRequests.has(id)) {
@@ -1861,6 +2133,14 @@ class WorkerServer {
     }
     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;
   }
@@ -1976,6 +2256,248 @@ class WorkerServer {
 }
 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
+class InMemoryCredentialStore {
+  store = new Map;
+  async get(key) {
+    const entry = this.store.get(key);
+    if (!entry)
+      return;
+    if (entry.metadata.expiresAt && entry.metadata.expiresAt <= new Date) {
+      this.store.delete(key);
+      return;
+    }
+    return entry.value;
+  }
+  async put(key, value, options) {
+    const now = new Date;
+    const existing = this.store.get(key);
+    const metadata = {
+      label: options?.label ?? existing?.metadata.label,
+      provider: options?.provider ?? existing?.metadata.provider,
+      createdAt: existing?.metadata.createdAt ?? now,
+      updatedAt: now,
+      expiresAt: options?.expiresAt ?? existing?.metadata.expiresAt
+    };
+    this.store.set(key, { key, value, metadata });
+  }
+  async delete(key) {
+    return this.store.delete(key);
+  }
+  async has(key) {
+    const entry = this.store.get(key);
+    if (!entry)
+      return false;
+    if (entry.metadata.expiresAt && entry.metadata.expiresAt <= new Date) {
+      this.store.delete(key);
+      return false;
+    }
+    return true;
+  }
+  async keys() {
+    const now = new Date;
+    const result = [];
+    for (const [key, entry] of this.store) {
+      if (entry.metadata.expiresAt && entry.metadata.expiresAt <= now) {
+        this.store.delete(key);
+        continue;
+      }
+      result.push(key);
+    }
+    return result;
+  }
+  async deleteAll() {
+    this.store.clear();
+  }
+}
+// src/credentials/EnvCredentialStore.ts
+class EnvCredentialStore {
+  keyToEnvVar;
+  prefix;
+  constructor(mapping = {}, prefix) {
+    this.keyToEnvVar = new Map(Object.entries(mapping));
+    this.prefix = prefix;
+  }
+  resolveEnvVar(key) {
+    const explicit = this.keyToEnvVar.get(key);
+    if (explicit)
+      return explicit;
+    if (this.prefix) {
+      return `${this.prefix}_${key.toUpperCase().replace(/-/g, "_")}`;
+    }
+    return key.toUpperCase().replace(/-/g, "_");
+  }
+  getEnv(envVar) {
+    if (typeof process !== "undefined" && process.env) {
+      return process.env[envVar];
+    }
+    return;
+  }
+  async get(key) {
+    const envVar = this.resolveEnvVar(key);
+    return this.getEnv(envVar);
+  }
+  async put(key, value, _options) {
+    const envVar = this.resolveEnvVar(key);
+    if (typeof process !== "undefined" && process.env) {
+      process.env[envVar] = value;
+    }
+    if (!this.keyToEnvVar.has(key)) {
+      this.keyToEnvVar.set(key, envVar);
+    }
+  }
+  async delete(key) {
+    const envVar = this.resolveEnvVar(key);
+    if (typeof process !== "undefined" && process.env && envVar in process.env) {
+      delete process.env[envVar];
+      return true;
+    }
+    return false;
+  }
+  async has(key) {
+    const envVar = this.resolveEnvVar(key);
+    return this.getEnv(envVar) !== undefined;
+  }
+  async keys() {
+    const result = [];
+    for (const [credKey] of this.keyToEnvVar) {
+      if (await this.has(credKey)) {
+        result.push(credKey);
+      }
+    }
+    return result;
+  }
+  async deleteAll() {
+    for (const [credKey] of this.keyToEnvVar) {
+      await this.delete(credKey);
+    }
+  }
+}
+// src/credentials/ChainedCredentialStore.ts
+class ChainedCredentialStore {
+  stores;
+  constructor(stores) {
+    this.stores = stores;
+    if (stores.length === 0) {
+      throw new Error("ChainedCredentialStore requires at least one store.");
+    }
+  }
+  async get(key) {
+    for (const store of this.stores) {
+      const value = await store.get(key);
+      if (value !== undefined)
+        return value;
+    }
+    return;
+  }
+  async put(key, value, options) {
+    await this.stores[0].put(key, value, options);
+  }
+  async delete(key) {
+    let deleted = false;
+    for (const store of this.stores) {
+      if (await store.delete(key)) {
+        deleted = true;
+      }
+    }
+    return deleted;
+  }
+  async has(key) {
+    for (const store of this.stores) {
+      if (await store.has(key))
+        return true;
+    }
+    return false;
+  }
+  async keys() {
+    const seen = new Set;
+    for (const store of this.stores) {
+      for (const key of await store.keys()) {
+        seen.add(key);
+      }
+    }
+    return [...seen];
+  }
+  async deleteAll() {
+    await Promise.all(this.stores.map((s) => s.deleteAll()));
+  }
+}
+// src/credentials/CredentialStoreRegistry.ts
+if (!globalServiceRegistry.has(CREDENTIAL_STORE)) {
+  globalServiceRegistry.register(CREDENTIAL_STORE, () => new InMemoryCredentialStore, true);
+}
+function getGlobalCredentialStore() {
+  return globalServiceRegistry.get(CREDENTIAL_STORE);
+}
+function setGlobalCredentialStore(store) {
+  globalServiceRegistry.registerInstance(CREDENTIAL_STORE, store);
+}
+async function resolveCredential(key, registry) {
+  const store = registry && registry.has(CREDENTIAL_STORE) ? registry.get(CREDENTIAL_STORE) : getGlobalCredentialStore();
+  return store.get(key);
+}
+registerInputResolver("credential", async (id, _format, registry) => {
+  return await resolveCredential(id, registry) ?? id;
+});
+// src/crypto/WebCrypto.ts
+var SALT_LENGTH = 16;
+async function deriveKey(passphrase, salt) {
+  const enc = new TextEncoder;
+  const keyMaterial = await crypto.subtle.importKey("raw", enc.encode(passphrase), "PBKDF2", false, [
+    "deriveKey"
+  ]);
+  return crypto.subtle.deriveKey({ name: "PBKDF2", salt, iterations: 1e5, hash: "SHA-256" }, keyMaterial, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
+}
+async function encrypt(plaintext, passphrase, keyCache) {
+  const enc = new TextEncoder;
+  const salt = crypto.getRandomValues(new Uint8Array(SALT_LENGTH));
+  const saltB64 = bufToBase64(salt);
+  let key = keyCache.get(saltB64);
+  if (!key) {
+    key = await deriveKey(passphrase, salt);
+    keyCache.set(saltB64, key);
+  }
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const rawCiphertext = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, enc.encode(plaintext));
+  const ciphertextBytes = new Uint8Array(rawCiphertext);
+  const combined = new Uint8Array(SALT_LENGTH + ciphertextBytes.length);
+  combined.set(salt, 0);
+  combined.set(ciphertextBytes, SALT_LENGTH);
+  return {
+    encrypted: bufToBase64(combined),
+    iv: bufToBase64(iv)
+  };
+}
+async function decrypt(encrypted, iv, passphrase, keyCache) {
+  const encryptedBuf = base64ToBuf(encrypted);
+  const salt = encryptedBuf.subarray(0, SALT_LENGTH);
+  const ciphertextBytes = encryptedBuf.subarray(SALT_LENGTH);
+  const saltB64 = bufToBase64(salt);
+  let key = keyCache.get(saltB64);
+  if (!key) {
+    key = await deriveKey(passphrase, salt);
+    keyCache.set(saltB64, key);
+  }
+  const plainBuf = await crypto.subtle.decrypt({ name: "AES-GCM", iv: base64ToBuf(iv) }, key, ciphertextBytes);
+  return new TextDecoder().decode(plainBuf);
+}
+function bufToBase64(buf) {
+  let binary = "";
+  for (let i = 0;i < buf.length; i++) {
+    binary += String.fromCharCode(buf[i]);
+  }
+  return btoa(binary);
+}
+function base64ToBuf(b64) {
+  const binary = atob(b64);
+  const buf = new Uint8Array(binary.length);
+  for (let i = 0;i < binary.length; i++) {
+    buf[i] = binary.charCodeAt(i);
+  }
+  return buf;
+}
 // src/compress/compress.node.ts
 import { promisify } from "util";
 import zlib from "zlib";
@@ -1995,18 +2517,6 @@ async function decompress(input, algorithm = "gzip") {
   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/mcp/McpClientUtil.node.ts
 import { Client } from "@modelcontextprotocol/sdk/client";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
@@ -2131,8 +2641,12 @@ export {
   sortObject,
   sleep,
   sha256,
+  setLogger,
+  setGlobalCredentialStore,
   serialize,
+  resolveCredential,
   registerInputResolver,
+  parsePartialJson,
   parseDataUri,
   parentPort2 as parentPort,
   objectOfArraysAsArrayOfObjects,
@@ -2150,9 +2664,14 @@ export {
   hammingDistance,
   globalServiceRegistry,
   globalContainer,
+  getLogger,
   getInputResolvers,
+  getGlobalCredentialStore,
   forceArray,
+  encrypt,
+  deriveKey,
   deepEqual,
+  decrypt,
   decompress,
   createTypedArrayFrom,
   createServiceToken,
@@ -2162,6 +2681,8 @@ export {
   compress,
   compileSchema,
   collectPropertyValues,
+  bufToBase64,
+  base64ToBuf,
   areSemanticallyCompatible,
   areObjectSchemasSemanticallyCompatible,
   WorkerServer,
@@ -2173,17 +2694,24 @@ export {
   TensorType,
   TensorSchema,
   ServiceRegistry,
+  NullLogger,
   NodeDoesntExistError,
   NodeAlreadyExistsError,
+  LOGGER,
+  InMemoryCredentialStore,
   INPUT_RESOLVERS,
   Graph,
   FromSchemaDefaultOptions,
   EventEmitter,
+  EnvCredentialStore,
   DirectedGraph,
   DirectedAcyclicGraph,
   CycleError,
   Container,
+  ConsoleLogger,
+  ChainedCredentialStore,
+  CREDENTIAL_STORE,
   BaseError
 };
 
-//# debugId=770F7BB2DD45EBAE64756E2164756E21
+//# debugId=4DD1902F8EFD47AB64756E2164756E21