@workflow/web 5.0.0-beta.5 → 5.0.0-beta.51

package/build/server/assets/wrapper-BxY6HvLW.js

@@ -0,0 +1,69 @@
+import { createRequire as __wkfCreateRequire } from "node:module";
+if (typeof require === "undefined") {
+  globalThis.require = __wkfCreateRequire(import.meta.url);
+}
+import { W as WebSocket } from "./websocket-server-D2905vlr.js";
+import { p, r, s, w, a, e, b } from "./websocket-server-D2905vlr.js";
+import "./app-8hyjFpMO.js";
+import "node:stream";
+import "stream";
+import "util";
+import "crypto";
+import "async_hooks";
+import "node:crypto";
+import "node:process";
+import "node:path";
+import "node:url";
+import "module";
+import "node:fs/promises";
+import "node:module";
+import "node:util";
+import "node:async_hooks";
+import "node:fs";
+import "node:os";
+import "node:child_process";
+import "node:timers/promises";
+import "node:buffer";
+import "node:http";
+import "node:https";
+import "node:zlib";
+import "events";
+import "node:assert";
+import "node:net";
+import "node:querystring";
+import "node:events";
+import "node:diagnostics_channel";
+import "node:tls";
+import "node:perf_hooks";
+import "node:util/types";
+import "node:sqlite";
+import "node:worker_threads";
+import "node:console";
+import "node:timers";
+import "node:dns";
+import "path";
+import "fs";
+import "constants";
+import "assert";
+import "os";
+import "assert/strict";
+import "net";
+import "node:assert/strict";
+import "express";
+import "http";
+import "buffer";
+import "zlib";
+import "https";
+import "tls";
+import "url";
+export {
+  p as PerMessageDeflate,
+  r as Receiver,
+  s as Sender,
+  WebSocket,
+  w as WebSocketServer,
+  a as createWebSocketStream,
+  WebSocket as default,
+  e as extension,
+  b as subprotocol
+};

package/build/server/assets/ws-transport-nlG6b7qI.js

@@ -0,0 +1,551 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { createRequire as __wkfCreateRequire } from "node:module";
+if (typeof require === "undefined") {
+  globalThis.require = __wkfCreateRequire(import.meta.url);
+}
+import { ba as isWsEventsTransportEnabled, bb as debugLog, bc as getHttpUrl, bd as globalSingleton, be as version, bf as getHttpConfig, bg as headersToRecord, bh as getRequestTimeoutMs, bi as injectTraceContextIntoHeaders, bj as withHttpClientSpan, bk as ErrorType, bl as WorkflowWsReconnectAttempt, bm as NetworkProtocolName, bn as WorkflowEventsTransport, bo as distExports, bp as decodeFrames } from "./app-8hyjFpMO.js";
+import { W as WebSocket } from "./websocket-server-D2905vlr.js";
+import "node:stream";
+import "stream";
+import "util";
+import "crypto";
+import "async_hooks";
+import "node:crypto";
+import "node:process";
+import "node:path";
+import "node:url";
+import "module";
+import "node:fs/promises";
+import "node:module";
+import "node:util";
+import "node:async_hooks";
+import "node:fs";
+import "node:os";
+import "node:child_process";
+import "node:timers/promises";
+import "node:buffer";
+import "node:http";
+import "node:https";
+import "node:zlib";
+import "events";
+import "node:assert";
+import "node:net";
+import "node:querystring";
+import "node:events";
+import "node:diagnostics_channel";
+import "node:tls";
+import "node:perf_hooks";
+import "node:util/types";
+import "node:sqlite";
+import "node:worker_threads";
+import "node:console";
+import "node:timers";
+import "node:dns";
+import "path";
+import "fs";
+import "constants";
+import "assert";
+import "os";
+import "assert/strict";
+import "net";
+import "node:assert/strict";
+import "express";
+import "http";
+import "buffer";
+import "zlib";
+import "https";
+import "tls";
+import "url";
+class WsTransportError extends Error {
+  constructor(message, opts) {
+    super(message, { cause: opts == null ? void 0 : opts.cause });
+    this.name = "WsTransportError";
+  }
+}
+const MALFORMED_FRAME_REQ_ID = -1;
+const RECONNECT_MAX_ATTEMPTS = 5;
+const RECONNECT_BASE_DELAY_MS = 100;
+const RECONNECT_MAX_DELAY_MS = 5e3;
+function readAuthorization(headers) {
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === "authorization")
+      return value;
+  }
+  return null;
+}
+async function decodeOneFrame(raw) {
+  const source = (async function* () {
+    yield raw;
+  })();
+  for await (const frame of decodeFrames(source)) {
+    return frame;
+  }
+  throw new Error("ws-transport: received an empty/unframed message");
+}
+function errorFrameMessage(body) {
+  if (body.byteLength === 0)
+    return "(no message)";
+  const text = new TextDecoder().decode(body);
+  try {
+    const parsed = JSON.parse(text);
+    return typeof parsed.message === "string" ? parsed.message : text;
+  } catch {
+    return text;
+  }
+}
+function describeError(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+class WsEventsTransport {
+  constructor(wsUrl, getHeaders) {
+    __publicField(this, "wsUrl");
+    __publicField(this, "getHeaders");
+    __publicField(this, "connection", null);
+    __publicField(this, "connecting", null);
+    __publicField(this, "reconnectAttempts", 0);
+    __publicField(this, "reconnectTimer", null);
+    /** Number of `open()` calls not yet matched by a `release()`. The socket goes
+     *  away at zero. A refcount rather than a flag because concurrent invocations
+     *  for one run share this instance; see `open`. */
+    __publicField(this, "openCount", 0);
+    /** Set by `close()`. Suppresses reconnects so an intentional teardown can't
+     *  be undone by the close handler it triggers. */
+    __publicField(this, "closed", false);
+    /** Reason from the most recent `drain`, consumed by the close that follows. */
+    __publicField(this, "lastDrainReason", null);
+    /** A drain said the *token* expired, not that the socket aged out, so the
+     *  next connect must not reuse the same bearer. */
+    __publicField(this, "needsFreshToken", false);
+    /** Authorization the current socket was opened with, so a forced refresh can
+     *  tell whether it actually produced a new one. */
+    __publicField(this, "lastAuthorization", null);
+    this.wsUrl = wsUrl;
+    this.getHeaders = getHeaders;
+  }
+  /** Send one request frame and wait for its matching reply. `buildFrame`
+   *  receives the reqId to embed in the meta before framing. */
+  async request(buildFrame) {
+    if (this.closed) {
+      throw new WsTransportError(`workflow-server events WS channel for ${this.wsUrl} is closed`);
+    }
+    const conn = await this.ensureConnected();
+    const reqId = conn.nextReqId++;
+    const frame = buildFrame(reqId);
+    const timeoutMs = getRequestTimeoutMs();
+    let deadline;
+    try {
+      return await new Promise((resolve, reject) => {
+        var _a;
+        conn.pending.set(reqId, { resolve, reject });
+        deadline = setTimeout(() => {
+          if (!conn.pending.delete(reqId))
+            return;
+          reject(new WsTransportError(`workflow-server events WS request ${reqId} to ${this.wsUrl} timed out after ${timeoutMs}ms with no reply`));
+          this.failConnection(conn, `workflow-server events WS connection to ${this.wsUrl} abandoned after request ${reqId} timed out`);
+        }, timeoutMs);
+        (_a = deadline.unref) == null ? void 0 : _a.call(deadline);
+        conn.ws.send(frame, (err) => {
+          if (!err)
+            return;
+          if (conn.pending.delete(reqId)) {
+            reject(new WsTransportError(`workflow-server events WS send failed: ${describeError(err)}`, { cause: err }));
+          }
+        });
+      });
+    } finally {
+      if (deadline !== void 0)
+        clearTimeout(deadline);
+    }
+  }
+  /**
+   * Claim the channel and start connecting. Called once per invocation that
+   * intends to write, at the point the run id is known. Connecting lazily on
+   * the first write instead bills the handshake (plus the OIDC mint riding it)
+   * to whichever event happens to be written first; when that's a `step_started`
+   * issued as the step body already runs, its server-recorded timestamp lands
+   * after the work it timestamps and the step reads as shorter than it was.
+   *
+   * Fire-and-forget: the connect is unawaited, and `request` awaits the same
+   * promise, so a write issued while the handshake is still in flight joins it
+   * rather than racing it.
+   *
+   * A failed connect closes the channel rather than leaving it registered for
+   * `request` to retry, which is what keeps this path from being *worse* than
+   * HTTP: writes resolve no channel and take the pooled HTTP route instead of
+   * paying another handshake attempt each.
+   *
+   * That de-opt covers the handshake only. A channel that connects and then
+   * fails every write stays registered and keeps taking the WS path, so the
+   * fallback is per-invocation rather than a circuit breaker. Tolerable while
+   * the transport is opt-in; defaulting it on needs a write-failure de-opt too.
+   */
+  open() {
+    if (this.closed)
+      return;
+    this.openCount++;
+    if (this.connection !== null || this.connecting !== null)
+      return;
+    void this.ensureConnected().catch(() => {
+      this.close("connect failed");
+    });
+  }
+  /**
+   * Give up this invocation's claim, dropping the socket once the last holder
+   * does. Concurrent invocations for one run share this instance (inline step
+   * executions ride the flow topic on per-step topics, so a run's steps can be
+   * separate invocations of the same container), and the first to finish must
+   * not tear the socket out from under the others.
+   *
+   * Unbalanced calls are inert: without a matching `open` there is nothing to
+   * release, and the count floors at zero rather than going negative and
+   * pinning the socket for the life of the process.
+   */
+  release(reason) {
+    if (this.openCount === 0)
+      return;
+    this.openCount--;
+    if (this.openCount === 0)
+      this.close(reason);
+  }
+  /**
+   * Drop the socket and evict this transport from the cache. Terminal, not a
+   * pause: the instance stays closed and a later `openWsChannel` for the same
+   * run constructs a fresh one. Idempotent. Safe with work in flight: those
+   * requests fail through the socket's own `close` handler, same as any other
+   * close.
+   */
+  close(reason) {
+    if (this.closed)
+      return;
+    this.closed = true;
+    this.openCount = 0;
+    if (this.reconnectTimer !== null) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (wsState.transports.get(this.wsUrl) === this) {
+      wsState.transports.delete(this.wsUrl);
+    }
+    const conn = this.connection;
+    this.connection = null;
+    conn == null ? void 0 : conn.ws.close(1e3, reason);
+  }
+  ensureConnected() {
+    const conn = this.connection;
+    if (conn && conn.ws.readyState === WebSocket.OPEN) {
+      return Promise.resolve(conn);
+    }
+    this.connecting ?? (this.connecting = this.connectWithSpan().finally(() => {
+      this.connecting = null;
+    }));
+    return this.connecting;
+  }
+  /**
+   * Resolve the headers for one upgrade request, once per socket, since the
+   * bearer only rides the upgrade. Re-resolving per socket is what lets a
+   * reconnect pick up a fresh token rather than replaying an expired one.
+   *
+   * Also the only place this transport can carry W3C trace context, which
+   * `CLAUDE.md` requires of every outgoing world-vercel request: frames are not
+   * HTTP requests and carry no headers of their own, so the server parents its
+   * event spans to whichever invocation opened the socket rather than to the
+   * individual write.
+   */
+  async resolveUpgradeHeaders() {
+    const forceRefresh = this.needsFreshToken;
+    const headers = await this.getHeaders({ forceRefresh });
+    const authorization = readAuthorization(headers);
+    if (forceRefresh && authorization === this.lastAuthorization) {
+      throw new WsTransportError(`workflow-server events WS connection to ${this.wsUrl} drained for auth expiry, but re-resolving the bearer produced the same token. Not reconnecting with a token the server has already rejected; the next event write will retry.`);
+    }
+    this.lastAuthorization = authorization;
+    this.needsFreshToken = false;
+    const carrier = new Headers();
+    await injectTraceContextIntoHeaders(carrier);
+    carrier.forEach((value, key) => {
+      headers[key] = value;
+    });
+    return headers;
+  }
+  consumeDrainReason() {
+    const reason = this.lastDrainReason;
+    this.lastDrainReason = null;
+    if (reason === "auth_expiry")
+      this.needsFreshToken = true;
+  }
+  /**
+   * The handshake, wrapped in its own CLIENT span.
+   *
+   * The upgrade is the one genuinely-HTTP request this transport makes, and
+   * until it had a span it was the invisible half of every WS write's latency:
+   * a write that waits on a handshake shows the wait inside its own span with
+   * nothing to attribute it to, and an eager reconnect between two writes shows
+   * up nowhere at all. Named for the operation rather than `http GET` so it
+   * doesn't land in the same bucket as the event writes it enables.
+   *
+   * It also puts `resolveUpgradeHeaders`' trace-context injection inside a
+   * client span, matching `makeRequest`'s contract (CLAUDE.md): the server's
+   * per-event spans parent to *this* span rather than directly to whichever
+   * invocation happened to open the socket, so the handshake and everything the
+   * server does over the connection hang together.
+   */
+  connectWithSpan() {
+    return withHttpClientSpan({
+      method: "GET",
+      url: this.wsUrl,
+      spanName: "workflow.events.ws.connect",
+      attributes: {
+        ...WorkflowEventsTransport("ws"),
+        ...NetworkProtocolName("websocket"),
+        ...WorkflowWsReconnectAttempt(this.reconnectAttempts)
+      }
+    }, async (span) => {
+      var _a;
+      try {
+        return await this.connect();
+      } catch (err) {
+        span == null ? void 0 : span.setAttributes({ ...ErrorType("TRANSPORT") });
+        if (err instanceof Error)
+          (_a = span == null ? void 0 : span.recordException) == null ? void 0 : _a.call(span, err);
+        throw err;
+      }
+    });
+  }
+  connect() {
+    return new Promise((resolve, reject) => {
+      void (async () => {
+        let conn;
+        try {
+          const headers = await this.resolveUpgradeHeaders();
+          const ws2 = new WebSocket(this.wsUrl, { headers });
+          ws2.binaryType = "nodebuffer";
+          conn = { ws: ws2, nextReqId: 1, pending: /* @__PURE__ */ new Map() };
+        } catch (err) {
+          console.error(`world-vercel: ws events transport could not open a connection to ${this.wsUrl}: ${describeError(err)}`);
+          reject(err instanceof WsTransportError ? err : new WsTransportError(`workflow-server events WS connection to ${this.wsUrl} could not be opened: ${describeError(err)}`, { cause: err }));
+          return;
+        }
+        const { ws } = conn;
+        let opened = false;
+        ws.on("open", () => {
+          opened = true;
+          if (this.closed) {
+            ws.close(1e3, "released while connecting");
+            reject(new WsTransportError(`workflow-server events WS connection to ${this.wsUrl} was released while connecting`));
+            return;
+          }
+          this.connection = conn;
+          this.reconnectAttempts = 0;
+          resolve(conn);
+        });
+        ws.on("message", (raw) => {
+          void this.handleMessage(conn, new Uint8Array(raw));
+        });
+        ws.on("error", (err) => {
+          console.error(`world-vercel: ws events transport socket error (${this.wsUrl}): ${describeError(err)}`);
+          if (!opened) {
+            reject(err);
+            return;
+          }
+          ws.close();
+        });
+        ws.on("close", (code) => {
+          const wasActive = this.connection === conn;
+          if (wasActive)
+            this.connection = null;
+          this.consumeDrainReason();
+          if (!opened) {
+            reject(new WsTransportError(`workflow-server events WS connection to ${this.wsUrl} closed before opening (code ${code})`));
+          }
+          this.failAllPending(conn, new WsTransportError(`workflow-server events WS connection closed (code ${code})`));
+          if (opened || this.reconnectAttempts > 0) {
+            this.scheduleReconnect(code);
+          }
+        });
+      })();
+    });
+  }
+  /**
+   * Reconnect eagerly rather than waiting for the next write: an unexpected
+   * close mid-run (broken pipe, or the server's drain → 1001) almost always
+   * means more writes are coming, and paying the handshake now keeps it off the
+   * next write's critical path.
+   */
+  scheduleReconnect(closeCode) {
+    var _a;
+    if (this.closed)
+      return;
+    if (this.connection !== null)
+      return;
+    if (this.reconnectTimer !== null)
+      return;
+    if (this.reconnectAttempts >= RECONNECT_MAX_ATTEMPTS) {
+      console.error(`world-vercel: ws events transport giving up eager reconnect to ${this.wsUrl} after ${RECONNECT_MAX_ATTEMPTS} attempts (last close code ${closeCode}); the next event write will retry.`);
+      return;
+    }
+    const delayMs = Math.min(RECONNECT_BASE_DELAY_MS * 2 ** this.reconnectAttempts, RECONNECT_MAX_DELAY_MS);
+    this.reconnectAttempts++;
+    const timer = setTimeout(() => {
+      this.reconnectTimer = null;
+      void this.ensureConnected().catch(() => {
+      });
+    }, delayMs);
+    (_a = timer.unref) == null ? void 0 : _a.call(timer);
+    this.reconnectTimer = timer;
+  }
+  async handleMessage(conn, raw) {
+    let decoded;
+    try {
+      decoded = await decodeOneFrame(raw);
+    } catch (err) {
+      const detail = `could not decode a ${raw.byteLength}-byte reply frame from ${this.wsUrl}: ${describeError(err)}`;
+      console.error(`world-vercel: ws events transport ${detail}`);
+      this.failConnection(conn, `workflow-server events WS transport ${detail}`);
+      return;
+    }
+    if (decoded.meta.type === "drain") {
+      const reason = decoded.meta.reason === "auth_expiry" ? "auth_expiry" : "max_duration";
+      this.lastDrainReason = reason;
+      debugLog(`world-vercel: ws events transport received a drain notice (reason: ${reason}, graceMs: ${decoded.meta.graceMs ?? "unspecified"}); connection will close soon.`);
+      return;
+    }
+    const reqId = decoded.meta.reqId;
+    if (reqId === MALFORMED_FRAME_REQ_ID) {
+      const detail = `received a malformed-frame error from ${this.wsUrl} (reserved reqId ${MALFORMED_FRAME_REQ_ID}, status ${String(decoded.meta.status ?? "unknown")}): ${errorFrameMessage(decoded.body)}. The server could not parse a frame this client sent, so the originating write cannot be identified`;
+      console.error(`world-vercel: ws events transport ${detail}.`);
+      this.failConnection(conn, `workflow-server events WS transport ${detail}`);
+      return;
+    }
+    if (typeof reqId !== "number") {
+      const detail = `received a reply frame with no numeric reqId from ${this.wsUrl} (type: ${String(decoded.meta.type ?? "absent")})`;
+      console.error(`world-vercel: ws events transport ${detail}.`);
+      this.failConnection(conn, `workflow-server events WS transport ${detail}`);
+      return;
+    }
+    const pending = conn.pending.get(reqId);
+    if (!pending) {
+      console.error(`world-vercel: ws events transport received a reply for unknown reqId ${reqId} from ${this.wsUrl} (already settled, or the request was failed by a send error or its deadline); dropping it.`);
+      return;
+    }
+    conn.pending.delete(reqId);
+    pending.resolve({ meta: decoded.meta, body: decoded.body });
+  }
+  failAllPending(conn, err) {
+    for (const pending of conn.pending.values()) {
+      pending.reject(err);
+    }
+    conn.pending.clear();
+  }
+  /**
+   * Fail every waiter on `conn` and drop the socket, for a reply that can't be
+   * correlated to a caller, and for a request that outlived its deadline. The
+   * whole connection goes because each case says the stream itself is no longer
+   * understood; logging and moving on would leave the originating request in
+   * `pending` with nothing able to answer it until the server drains (~680s),
+   * well past the waiting invocation's `maxDuration`. The socket's own `close`
+   * handler does the teardown and schedules the reconnect; failing the waiters
+   * here is what makes callers see this diagnosis, not a bare close code.
+   */
+  failConnection(conn, message) {
+    this.failAllPending(conn, new WsTransportError(message));
+    if (this.connection === conn)
+      this.connection = null;
+    conn.ws.close();
+  }
+}
+const wsState = globalSingleton(
+  // Keyed by package version, unlike the state that holds only plain data.
+  // Two different published versions of this package can share one process (a
+  // transitive dependency pinning an older `@workflow/core`, which depends on
+  // this package by exact version), and this Map holds `WsEventsTransport`
+  // instances. An unversioned key would hand one version's write path an object
+  // built by the other version's class, and `events-v4.ts` would then frame and
+  // parse against a protocol the other copy may not share. There is no version
+  // negotiation on this socket to catch that. `shapeVersion` cannot express it:
+  // the container shape is stable, the hazard is in the contents. Two versions
+  // therefore keep separate registries, which costs a second socket and is what
+  // happened before this package was bundled anyway.
+  `@workflow/world-vercel//wsEventsTransports@${version}`,
+  1,
+  () => ({
+    transports: /* @__PURE__ */ new Map(),
+    loggedWsProxyFallback: false,
+    loggedWsInUse: false
+  })
+);
+function getWsEventsTransport(wsUrl, getHeaders) {
+  let transport = wsState.transports.get(wsUrl);
+  if (!transport) {
+    transport = new WsEventsTransport(wsUrl, getHeaders);
+    wsState.transports.set(wsUrl, transport);
+  }
+  return transport;
+}
+function toEventsWsUrl(baseUrl, runId) {
+  const url = new URL(baseUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.pathname = `${url.pathname.replace(/\/$/, "")}/websockets/v1/runs/${encodeURIComponent(runId)}`;
+  return url.toString();
+}
+function openWsChannel(runId, config) {
+  if (!isWsEventsTransportEnabled())
+    return void 0;
+  const resolved = resolveChannelUrl(runId, config);
+  if (!resolved)
+    return void 0;
+  if (!wsState.loggedWsInUse) {
+    wsState.loggedWsInUse = true;
+    debugLog(`world-vercel: using ws events transport (${resolved}).`);
+  }
+  const transport = getWsEventsTransport(resolved, async ({ forceRefresh }) => {
+    if (forceRefresh)
+      await refreshOidcTokenBestEffort();
+    const { headers } = await getHttpConfig(config);
+    return headersToRecord(headers);
+  });
+  transport.open();
+  let released = false;
+  return () => {
+    if (released)
+      return;
+    released = true;
+    transport.release("invocation complete");
+  };
+}
+const OIDC_FORCE_REFRESH_BUFFER_MS = 24 * 60 * 60 * 1e3;
+async function refreshOidcTokenBestEffort() {
+  try {
+    await distExports.getVercelOidcToken({
+      expirationBufferMs: OIDC_FORCE_REFRESH_BUFFER_MS
+    });
+  } catch {
+  }
+}
+function resolveChannelUrl(runId, config) {
+  const { baseUrl, usingProxy } = getHttpUrl(config);
+  if (usingProxy) {
+    if (!wsState.loggedWsProxyFallback) {
+      wsState.loggedWsProxyFallback = true;
+      debugLog(`world-vercel: ws events transport unavailable for a World with projectConfig (api-workflow proxy, resolved baseUrl: ${baseUrl}) — falling back to HTTP.`);
+    }
+    return null;
+  }
+  return toEventsWsUrl(baseUrl, runId);
+}
+function resolveWsTransport(runId, config) {
+  const wsUrl = resolveChannelUrl(runId, config);
+  if (!wsUrl)
+    return null;
+  const transport = wsState.transports.get(wsUrl);
+  return transport ? { transport, wsUrl } : null;
+}
+export {
+  WsTransportError,
+  getWsEventsTransport,
+  isWsEventsTransportEnabled,
+  openWsChannel,
+  resolveWsTransport,
+  toEventsWsUrl
+};

package/build/server/assets/zstd-browser-decoder-Ce8lEOjC.js

@@ -0,0 +1,72 @@
+import { createRequire as __wkfCreateRequire } from "node:module";
+if (typeof require === "undefined") {
+  globalThis.require = __wkfCreateRequire(import.meta.url);
+}
+import { b9 as registerZstdDecoder } from "./app-8hyjFpMO.js";
+import "node:stream";
+import "stream";
+import "util";
+import "crypto";
+import "async_hooks";
+import "node:crypto";
+import "node:process";
+import "node:path";
+import "node:url";
+import "module";
+import "node:fs/promises";
+import "node:module";
+import "node:util";
+import "node:async_hooks";
+import "node:fs";
+import "node:os";
+import "node:child_process";
+import "node:timers/promises";
+import "node:buffer";
+import "node:http";
+import "node:https";
+import "node:zlib";
+import "events";
+import "node:assert";
+import "node:net";
+import "node:querystring";
+import "node:events";
+import "node:diagnostics_channel";
+import "node:tls";
+import "node:perf_hooks";
+import "node:util/types";
+import "node:sqlite";
+import "node:worker_threads";
+import "node:console";
+import "node:timers";
+import "node:dns";
+import "path";
+import "fs";
+import "constants";
+import "assert";
+import "os";
+import "assert/strict";
+import "net";
+import "node:assert/strict";
+import "express";
+let registered = false;
+let modulePromise;
+function loadWasmModule() {
+  if (!modulePromise) {
+    const url = new URL("@tootallnate/zstd-wasm/zstd.wasm", import.meta.url);
+    modulePromise = fetch(url).then((res) => res.arrayBuffer()).then((bytes) => WebAssembly.compile(bytes));
+  }
+  return modulePromise;
+}
+function ensureZstdDecoderRegistered() {
+  if (registered)
+    return;
+  registered = true;
+  registerZstdDecoder(async (payload) => {
+    const { decompressBytes } = await import("./index-BfLBLRRi.js");
+    const wasmModule = await loadWasmModule();
+    return decompressBytes(wasmModule, payload);
+  });
+}
+export {
+  ensureZstdDecoderRegistered
+};