@workglow/util 0.0.120 → 0.0.122

package/dist/worker-bun.js

@@ -0,0 +1,895 @@
+// @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/di/InputResolverRegistry.ts
+var INPUT_RESOLVERS = createServiceToken("task.input.resolvers");
+if (!globalServiceRegistry.has(INPUT_RESOLVERS)) {
+  globalServiceRegistry.register(INPUT_RESOLVERS, () => new Map, true);
+}
+function getInputResolvers() {
+  return globalServiceRegistry.get(INPUT_RESOLVERS);
+}
+function registerInputResolver(formatPrefix, resolver) {
+  const resolvers = getInputResolvers();
+  resolvers.set(formatPrefix, resolver);
+}
+// src/logging/ConsoleLogger.ts
+var LOG_LEVEL_ORDER = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  fatal: 4
+};
+
+class ConsoleLogger {
+  bindings;
+  level;
+  timings;
+  constructor(options = {}) {
+    this.bindings = options.bindings ?? {};
+    this.level = options.level ?? "debug";
+    this.timings = options.timings ?? false;
+  }
+  enabled(level) {
+    return LOG_LEVEL_ORDER[level] >= LOG_LEVEL_ORDER[this.level];
+  }
+  info(message, meta) {
+    if (!this.enabled("info"))
+      return;
+    const merged = this.merge(meta);
+    if (merged) {
+      console.info(message, merged);
+    } else {
+      console.info(message);
+    }
+  }
+  warn(message, meta) {
+    if (!this.enabled("warn"))
+      return;
+    const merged = this.merge(meta);
+    if (merged) {
+      console.warn(message, merged);
+    } else {
+      console.warn(message);
+    }
+  }
+  error(message, meta) {
+    if (!this.enabled("error"))
+      return;
+    const merged = this.merge(meta);
+    if (merged) {
+      console.error(message, merged);
+    } else {
+      console.error(message);
+    }
+  }
+  debug(message, meta) {
+    if (!this.enabled("debug"))
+      return;
+    const merged = this.merge(meta);
+    if (merged) {
+      console.debug(message, merged);
+    } else {
+      console.debug(message);
+    }
+  }
+  fatal(err, message, meta) {
+    if (!this.enabled("fatal"))
+      return;
+    const merged = this.merge(meta);
+    if (merged) {
+      console.error(message, { ...merged, error: err });
+    } else {
+      console.error(message, { error: err });
+    }
+  }
+  time(label, meta) {
+    if (!this.timings)
+      return;
+    const merged = this.merge(meta);
+    if (merged) {
+      console.info(`[time] ${label}`, merged);
+    }
+    console.time(label);
+  }
+  timeEnd(label, meta) {
+    if (!this.timings)
+      return;
+    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({
+      bindings: { ...this.bindings, ...bindings },
+      level: this.level,
+      timings: this.timings
+    });
+  }
+  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");
+var VALID_LOG_LEVELS = new Set([
+  "debug",
+  "info",
+  "warn",
+  "error",
+  "fatal"
+]);
+function getEnv(name) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[name];
+  }
+  return import.meta.env[name];
+}
+function isTruthy(value) {
+  return value !== undefined && value !== "" && value !== "0" && value !== "false";
+}
+function createDefaultLogger() {
+  const levelEnv = getEnv("LOGGER_LEVEL")?.toLowerCase();
+  if (levelEnv && VALID_LOG_LEVELS.has(levelEnv)) {
+    return new ConsoleLogger({
+      level: levelEnv,
+      timings: isTruthy(getEnv("LOGGER_TIMINGS"))
+    });
+  }
+  if (getEnv("DEV")) {
+    return new ConsoleLogger({
+      level: "debug",
+      timings: true
+    });
+  }
+  return new NullLogger;
+}
+if (!globalServiceRegistry.has(LOGGER)) {
+  globalServiceRegistry.register(LOGGER, createDefaultLogger, true);
+}
+function getLogger() {
+  return globalServiceRegistry.get(LOGGER);
+}
+function setLogger(logger) {
+  globalServiceRegistry.registerInstance(LOGGER, logger);
+}
+// 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;
+    }
+    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 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)
+    });
+  }
+  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`);
+    }
+  }
+}
+// src/worker/WorkerManager.ts
+class WorkerManager {
+  workers = new Map;
+  readyWorkers = new Map;
+  workerFunctions = new Map;
+  workerStreamFunctions = new Map;
+  workerReactiveFunctions = new Map;
+  lazyFactories = new Map;
+  lazyInitPromises = new Map;
+  registerWorker(name, workerOrFactory) {
+    if (this.workers.has(name)) {
+      throw new Error(`Worker ${name} is already registered.`);
+    }
+    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);
+    });
+    const readyPromise = new Promise((resolve) => {
+      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();
+        }
+      };
+      worker.addEventListener("message", handleReady);
+    });
+    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)
+      throw new Error(`Worker ${name} not found.`);
+    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.`);
+    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) => {
+        const { id, type, data } = event.data;
+        if (id !== requestId)
+          return;
+        if (type === "progress" && options?.onProgress) {
+          options.onProgress(data.progress, data.message, data.details);
+          getLogger().debug(`Worker ${workerName} function ${functionName} progress: ${data.progress}, `, { data });
+        } else if (type === "complete") {
+          cleanup();
+          getLogger().debug(`Worker ${workerName} function ${functionName} complete.`, { data });
+          resolve(data);
+        } else if (type === "error") {
+          cleanup();
+          getLogger().debug(`Worker ${workerName} function ${functionName} error.`, { data });
+          reject(new Error(data));
+        }
+      };
+      const handleAbort = () => {
+        worker.postMessage({ id: requestId, type: "abort" });
+        getLogger().info(`Worker ${workerName} function ${functionName} aborted.`);
+      };
+      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 });
+      }
+      const message = { id: requestId, type: "call", functionName, args };
+      worker.postMessage(message);
+      getLogger().info(`Worker ${workerName} function ${functionName} called.`);
+    });
+  }
+  async callWorkerReactiveFunction(workerName, functionName, args) {
+    await this.ensureWorkerReady(workerName);
+    const worker = this.workers.get(workerName);
+    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) => {
+        const { id, type, data } = event.data;
+        if (id !== requestId)
+          return;
+        if (type === "complete") {
+          cleanup();
+          resolve(data);
+        } else if (type === "error") {
+          cleanup();
+          resolve(undefined);
+        }
+      };
+      const cleanup = () => {
+        worker.removeEventListener("message", handleMessage);
+      };
+      worker.addEventListener("message", handleMessage);
+      const message = { id: requestId, type: "call", functionName, args, reactive: true };
+      worker.postMessage(message);
+      getLogger().info(`Worker ${workerName} reactive function ${functionName} called.`);
+    });
+  }
+  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.`);
+    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;
+    const notify = () => {
+      if (waiting) {
+        const resolve = waiting;
+        waiting = null;
+        resolve();
+      }
+    };
+    const handleMessage = (event) => {
+      const { id, type, data } = event.data;
+      if (id !== requestId)
+        return;
+      if (type === "stream_chunk") {
+        queue.push({ kind: "event", data });
+        notify();
+      } else if (type === "complete") {
+        queue.push({ kind: "done" });
+        notify();
+      } else if (type === "error") {
+        queue.push({ kind: "error", error: new Error(data) });
+        notify();
+      }
+    };
+    const handleAbort = () => {
+      worker.postMessage({ id: requestId, type: "abort" });
+      getLogger().info(`Worker ${workerName} stream function ${functionName} aborted.`);
+    };
+    const cleanup = () => {
+      worker.removeEventListener("message", handleMessage);
+      options?.signal?.removeEventListener("abort", handleAbort);
+    };
+    worker.addEventListener("message", handleMessage);
+    if (options?.signal) {
+      if (options.signal.aborted) {
+        cleanup();
+        throw new Error("Operation aborted");
+      }
+      options.signal.addEventListener("abort", handleAbort, { once: true });
+    }
+    const message = { id: requestId, type: "call", functionName, args, stream: true };
+    worker.postMessage(message);
+    getLogger().info(`Worker ${workerName} stream function ${functionName} called.`);
+    let completedNormally = false;
+    try {
+      while (true) {
+        while (queue.length > 0) {
+          const item = queue.shift();
+          if (item.kind === "event") {
+            yield item.data;
+          } else if (item.kind === "done") {
+            completedNormally = true;
+            return;
+          } else if (item.kind === "error") {
+            completedNormally = true;
+            throw item.error;
+          }
+        }
+        await new Promise((resolve) => {
+          waiting = resolve;
+        });
+      }
+    } finally {
+      if (!completedNormally) {
+        worker.postMessage({ id: requestId, type: "abort" });
+        getLogger().info(`Worker ${workerName} stream function ${functionName} aborted.`);
+      }
+      cleanup();
+    }
+  }
+}
+var WORKER_MANAGER = createServiceToken("worker.manager");
+globalServiceRegistry.register(WORKER_MANAGER, () => new WorkerManager, true);
+// 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/worker/Worker.bun.ts
+var Worker = globalThis.Worker;
+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 {
+  setLogger,
+  registerInputResolver,
+  parsePartialJson,
+  parentPort,
+  globalServiceRegistry,
+  globalContainer,
+  getLogger,
+  getInputResolvers,
+  createServiceToken,
+  WorkerServerBase,
+  WorkerServer,
+  WorkerManager,
+  Worker,
+  WORKER_SERVER,
+  WORKER_MANAGER,
+  ServiceRegistry,
+  NullLogger,
+  LOGGER,
+  INPUT_RESOLVERS,
+  Container,
+  ConsoleLogger
+};
+
+//# debugId=DC59A52E5EEAB5BF64756E2164756E21