@workflow/web 5.0.0-beta.3 → 5.0.0-beta.31

package/build/client/assets/zstd-browser-decoder-BFS0fmpR.js

@@ -0,0 +1,27 @@
+import { r as registerZstdDecoder, _ as __vitePreload } from "./mermaid-3ZIDBTTL-BxUZpfmG.js";
+import "./index-Q81MFBxC.js";
+let registered = false;
+let modulePromise;
+function loadWasmModule() {
+  if (!modulePromise) {
+    const url = new URL("/assets/zstd-B5R2yJjB.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 __vitePreload(async () => {
+      const { decompressBytes: decompressBytes2 } = await import("./index-HqNj_XIX.js");
+      return { decompressBytes: decompressBytes2 };
+    }, true ? [] : void 0);
+    const wasmModule = await loadWasmModule();
+    return decompressBytes(wasmModule, payload);
+  });
+}
+export {
+  ensureZstdDecoderRegistered
+};

package/build/server/assets/{app-Bh_7yjpl.js → app-BgN_e9S7.js}

@@ -1,6 +1,10 @@
 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 { Stream } from "stream";
 import express from "express";
 function _mergeNamespaces(n, m) {
@@ -481,7 +485,7 @@ var hasRequiredReact_development;
 function requireReact_development() {
   if (hasRequiredReact_development) return react_development.exports;
   hasRequiredReact_development = 1;
-  (function(module, exports$1) {
+  (function(module, exports) {
     "production" !== process.env.NODE_ENV && (function() {
       function defineDeprecationWarning(methodName, info) {
         Object.defineProperty(Component.prototype, methodName, {
@@ -1021,7 +1025,7 @@ function requireReact_development() {
           return resolveDispatcher().useMemoCache(size);
         }
       });
-      exports$1.Children = {
+      exports.Children = {
         map: mapChildren,
         forEach: function(children, forEachFunc, forEachContext) {
           mapChildren(
@@ -1052,15 +1056,15 @@ function requireReact_development() {
           return children;
         }
       };
-      exports$1.Component = Component;
-      exports$1.Fragment = REACT_FRAGMENT_TYPE;
-      exports$1.Profiler = REACT_PROFILER_TYPE;
-      exports$1.PureComponent = PureComponent;
-      exports$1.StrictMode = REACT_STRICT_MODE_TYPE;
-      exports$1.Suspense = REACT_SUSPENSE_TYPE;
-      exports$1.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
-      exports$1.__COMPILER_RUNTIME = deprecatedAPIs;
-      exports$1.act = function(callback) {
+      exports.Component = Component;
+      exports.Fragment = REACT_FRAGMENT_TYPE;
+      exports.Profiler = REACT_PROFILER_TYPE;
+      exports.PureComponent = PureComponent;
+      exports.StrictMode = REACT_STRICT_MODE_TYPE;
+      exports.Suspense = REACT_SUSPENSE_TYPE;
+      exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
+      exports.__COMPILER_RUNTIME = deprecatedAPIs;
+      exports.act = function(callback) {
         var prevActQueue = ReactSharedInternals.actQueue, prevActScopeDepth = actScopeDepth;
         actScopeDepth++;
         var queue = ReactSharedInternals.actQueue = null !== prevActQueue ? prevActQueue : [], didAwaitActCall = false;
@@ -1137,16 +1141,16 @@ function requireReact_development() {
           }
         };
       };
-      exports$1.cache = function(fn) {
+      exports.cache = function(fn) {
         return function() {
           return fn.apply(null, arguments);
         };
       };
-      exports$1.captureOwnerStack = function() {
+      exports.captureOwnerStack = function() {
         var getCurrentStack = ReactSharedInternals.getCurrentStack;
         return null === getCurrentStack ? null : getCurrentStack();
       };
-      exports$1.cloneElement = function(element, config, children) {
+      exports.cloneElement = function(element, config, children) {
         if (null === element || void 0 === element)
           throw Error(
             "The argument must be a React element, but you passed " + element + "."
@@ -1191,7 +1195,7 @@ function requireReact_development() {
           owner = arguments[key], isValidElement(owner) && owner._store && (owner._store.validated = 1);
         return props;
       };
-      exports$1.createContext = function(defaultValue) {
+      exports.createContext = function(defaultValue) {
         defaultValue = {
           $$typeof: REACT_CONTEXT_TYPE,
           _currentValue: defaultValue,
@@ -1209,7 +1213,7 @@ function requireReact_development() {
         defaultValue._currentRenderer2 = null;
         return defaultValue;
       };
-      exports$1.createElement = function(type, config, children) {
+      exports.createElement = function(type, config, children) {
         for (var i = 2; i < arguments.length; i++) {
           var node = arguments[i];
           isValidElement(node) && node._store && (node._store.validated = 1);
@@ -1248,12 +1252,12 @@ function requireReact_development() {
           propName ? createTask(getTaskName(type)) : unknownOwnerDebugTask
         );
       };
-      exports$1.createRef = function() {
+      exports.createRef = function() {
         var refObject = { current: null };
         Object.seal(refObject);
         return refObject;
       };
-      exports$1.forwardRef = function(render) {
+      exports.forwardRef = function(render) {
         null != render && render.$$typeof === REACT_MEMO_TYPE ? console.error(
           "forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))."
         ) : "function" !== typeof render ? console.error(
@@ -1280,15 +1284,15 @@ function requireReact_development() {
         });
         return elementType;
       };
-      exports$1.isValidElement = isValidElement;
-      exports$1.lazy = function(ctor) {
+      exports.isValidElement = isValidElement;
+      exports.lazy = function(ctor) {
         return {
           $$typeof: REACT_LAZY_TYPE,
           _payload: { _status: -1, _result: ctor },
           _init: lazyInitializer
         };
       };
-      exports$1.memo = function(type, compare) {
+      exports.memo = function(type, compare) {
         null == type && console.error(
           "memo: The first argument must be a component. Instead received: %s",
           null === type ? "null" : typeof type
@@ -1312,7 +1316,7 @@ function requireReact_development() {
         });
         return compare;
       };
-      exports$1.startTransition = function(scope) {
+      exports.startTransition = function(scope) {
         var prevTransition = ReactSharedInternals.T, currentTransition = {};
         ReactSharedInternals.T = currentTransition;
         currentTransition._updatedFibers = /* @__PURE__ */ new Set();
@@ -1328,36 +1332,36 @@ function requireReact_development() {
           )), ReactSharedInternals.T = prevTransition;
         }
       };
-      exports$1.unstable_useCacheRefresh = function() {
+      exports.unstable_useCacheRefresh = function() {
         return resolveDispatcher().useCacheRefresh();
       };
-      exports$1.use = function(usable) {
+      exports.use = function(usable) {
         return resolveDispatcher().use(usable);
       };
-      exports$1.useActionState = function(action, initialState, permalink) {
+      exports.useActionState = function(action, initialState, permalink) {
         return resolveDispatcher().useActionState(
           action,
           initialState,
           permalink
         );
       };
-      exports$1.useCallback = function(callback, deps) {
+      exports.useCallback = function(callback, deps) {
         return resolveDispatcher().useCallback(callback, deps);
       };
-      exports$1.useContext = function(Context) {
+      exports.useContext = function(Context) {
         var dispatcher = resolveDispatcher();
         Context.$$typeof === REACT_CONSUMER_TYPE && console.error(
           "Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?"
         );
         return dispatcher.useContext(Context);
       };
-      exports$1.useDebugValue = function(value, formatterFn) {
+      exports.useDebugValue = function(value, formatterFn) {
         return resolveDispatcher().useDebugValue(value, formatterFn);
       };
-      exports$1.useDeferredValue = function(value, initialValue) {
+      exports.useDeferredValue = function(value, initialValue) {
         return resolveDispatcher().useDeferredValue(value, initialValue);
       };
-      exports$1.useEffect = function(create, createDeps, update) {
+      exports.useEffect = function(create, createDeps, update) {
         null == create && console.warn(
           "React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?"
         );
@@ -1368,50 +1372,50 @@ function requireReact_development() {
           );
         return dispatcher.useEffect(create, createDeps);
       };
-      exports$1.useId = function() {
+      exports.useId = function() {
         return resolveDispatcher().useId();
       };
-      exports$1.useImperativeHandle = function(ref, create, deps) {
+      exports.useImperativeHandle = function(ref, create, deps) {
         return resolveDispatcher().useImperativeHandle(ref, create, deps);
       };
-      exports$1.useInsertionEffect = function(create, deps) {
+      exports.useInsertionEffect = function(create, deps) {
         null == create && console.warn(
           "React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?"
         );
         return resolveDispatcher().useInsertionEffect(create, deps);
       };
-      exports$1.useLayoutEffect = function(create, deps) {
+      exports.useLayoutEffect = function(create, deps) {
         null == create && console.warn(
           "React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?"
         );
         return resolveDispatcher().useLayoutEffect(create, deps);
       };
-      exports$1.useMemo = function(create, deps) {
+      exports.useMemo = function(create, deps) {
         return resolveDispatcher().useMemo(create, deps);
       };
-      exports$1.useOptimistic = function(passthrough, reducer) {
+      exports.useOptimistic = function(passthrough, reducer) {
         return resolveDispatcher().useOptimistic(passthrough, reducer);
       };
-      exports$1.useReducer = function(reducer, initialArg, init) {
+      exports.useReducer = function(reducer, initialArg, init) {
         return resolveDispatcher().useReducer(reducer, initialArg, init);
       };
-      exports$1.useRef = function(initialValue) {
+      exports.useRef = function(initialValue) {
         return resolveDispatcher().useRef(initialValue);
       };
-      exports$1.useState = function(initialState) {
+      exports.useState = function(initialState) {
         return resolveDispatcher().useState(initialState);
       };
-      exports$1.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
+      exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
         return resolveDispatcher().useSyncExternalStore(
           subscribe,
           getSnapshot,
           getServerSnapshot
         );
       };
-      exports$1.useTransition = function() {
+      exports.useTransition = function() {
         return resolveDispatcher().useTransition();
       };
-      exports$1.version = "19.1.0";
+      exports.version = "19.1.0";
       "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
     })();
   })(react_development, react_development.exports);
@@ -9174,9 +9178,9 @@ async function sendRemixResponse(res, nodeResponse) {
 }
 const app = express();
 app.all(
-  "*",
+  "/{*splat}",
   createRequestHandler({
-    build: () => import("./server-build-DztRAoMd.js").then((n) => n.G)
+    build: () => import("./server-build-CQLvkWL5.js").then((n) => n.aB)
   })
 );
 app.use(

package/build/server/assets/{highlighted-body-B3W2YXNL-Cdb-ypB4.js → highlighted-body-B3W2YXNL-CsR2wqX2.js}

@@ -1,5 +1,9 @@
-import { y as R, K as Ks, z as jsxRuntimeExports, A as Qe } from "./server-build-DztRAoMd.js";
-import { r as reactExports } from "./app-Bh_7yjpl.js";
+import { createRequire as __wkfCreateRequire } from "node:module";
+if (typeof require === "undefined") {
+  globalThis.require = __wkfCreateRequire(import.meta.url);
+}
+import { au as R, av as Ks, aw as jsxRuntimeExports, ax as Qe } from "./server-build-CQLvkWL5.js";
+import { r as reactExports } from "./app-BgN_e9S7.js";
 import "node:stream";
 import "util";
 import "crypto";
@@ -11,12 +15,12 @@ import "node:path";
 import "node:url";
 import "module";
 import "node:fs/promises";
-import "tty";
-import "os";
 import "node:module";
+import "node:util";
+import "node:async_hooks";
+import "node:os";
 import "node:fs";
 import "node:child_process";
-import "node:util";
 import "node:timers/promises";
 import "events";
 import "node:assert";
@@ -32,13 +36,12 @@ import "node:perf_hooks";
 import "node:util/types";
 import "node:sqlite";
 import "node:worker_threads";
-import "node:async_hooks";
 import "node:console";
 import "node:timers";
 import "node:dns";
 import "path";
 import "fs";
-import "node:os";
+import "os";
 import "net";
 import "express";
 var L = ({ code: s, language: t, raw: e, className: n, ...d$1 }) => {

package/build/server/assets/index-BbpsBsGO.js

@@ -0,0 +1,132 @@
+import { createRequire as __wkfCreateRequire } from "node:module";
+if (typeof require === "undefined") {
+  globalThis.require = __wkfCreateRequire(import.meta.url);
+}
+import { H as HookSchema } from "./server-build-CQLvkWL5.js";
+import { A, a, b, c, d, e, f, g, h, i, j, B, C, D, k, E, l, m, n, o, p, q, r, L, M, P, Q, s, R, t, S, u, v, w, x, y, z, F, G, I, T, J, K, O, U, V, W, X, Y, Z, _, $, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af, ag, ah, ai, aj, ak, al, am, an, ao, ap, aq, ar, as, at } from "./server-build-CQLvkWL5.js";
+import "./app-BgN_e9S7.js";
+import "stream";
+import "express";
+import "node: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:os";
+import "node:fs";
+import "node:child_process";
+import "node:timers/promises";
+import "events";
+import "node:assert";
+import "node:net";
+import "node:http";
+import "node:querystring";
+import "node:events";
+import "node:diagnostics_channel";
+import "node:tls";
+import "node:buffer";
+import "node:zlib";
+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 "os";
+import "net";
+export {
+  A as ATTRIBUTE_KEY_MAX_LENGTH,
+  a as ATTRIBUTE_MAX_PER_RUN,
+  b as ATTRIBUTE_VALUE_MAX_BYTES,
+  c as AnalyticsEventSchema,
+  d as AnalyticsHookSchema,
+  e as AnalyticsRunSchema,
+  f as AnalyticsStepSchema,
+  g as AnalyticsWaitSchema,
+  h as AttributeChangeSchema,
+  i as AttributeChangesSchema,
+  j as AttributeValidationError,
+  B as BaseEventSchema,
+  C as CHILD_ENTITY_CREATION_EVENT_TYPES,
+  D as DEFAULT_TIMESTAMP_THRESHOLD_FUTURE_MS,
+  k as DEFAULT_TIMESTAMP_THRESHOLD_PAST_MS,
+  E as EVENT_DATA_PAYLOAD_FIELD_BY_EVENT_TYPE,
+  l as EVENT_DATA_REF_FIELDS,
+  m as EventSchema,
+  n as EventTypeSchema,
+  o as HOOK_EVENTS_REQUIRING_EXISTENCE,
+  p as HOOK_LIFECYCLE_EVENT_TYPES,
+  q as HealthCheckPayloadSchema,
+  r as HookCreatedEventSchema,
+  HookSchema,
+  L as LegacySerializedDataSchemaV1,
+  M as MessageId,
+  P as PaginatedResponseSchema,
+  Q as QueuePayloadSchema,
+  s as QueuePrefix,
+  R as RESERVED_ATTRIBUTE_KEY_PREFIX,
+  t as RunInputSchema,
+  S as SPEC_VERSION_CURRENT,
+  u as SPEC_VERSION_LEGACY,
+  v as SPEC_VERSION_SUPPORTS_ATTRIBUTES,
+  w as SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT,
+  x as SPEC_VERSION_SUPPORTS_COMPRESSION,
+  y as STEP_EVENT_TYPES,
+  z as SerializedDataSchema,
+  F as StepInvokePayloadSchema,
+  G as StepSchema,
+  I as StepStatusSchema,
+  T as TERMINAL_RUN_EVENT_TYPES,
+  J as TERMINAL_STEP_EVENT_TYPES,
+  K as TERMINAL_STEP_STATUSES,
+  O as TERMINAL_WORKFLOW_RUN_STATUSES,
+  U as TerminalRunEventTypeSchema,
+  V as TerminalStepStatusSchema,
+  W as TerminalWorkflowRunStatusSchema,
+  X as ValidQueueName,
+  Y as WAIT_EVENT_TYPES,
+  Z as WaitSchema,
+  _ as WaitStatusSchema,
+  $ as WorkflowInvokePayloadSchema,
+  a0 as WorkflowRunBaseSchema,
+  a1 as WorkflowRunSchema,
+  a2 as WorkflowRunStatusSchema,
+  a3 as applyAttributeChanges,
+  a4 as envNumber,
+  a5 as getEventDataPayloadField,
+  a6 as getEventDataRefFields,
+  a7 as getQueueTopicPrefix,
+  a8 as isChildEntityCreationEvent,
+  a9 as isChildEntityCreationEventType,
+  aa as isHookEventRequiringExistence,
+  ab as isHookLifecycleEventType,
+  ac as isLegacySpecVersion,
+  ad as isStepEventType,
+  ae as isTerminalRunEventType,
+  af as isTerminalStepEventType,
+  ag as isTerminalStepStatus,
+  ah as isTerminalWorkflowRunStatus,
+  ai as isWaitEventType,
+  aj as parseQueueName,
+  ak as reenqueueActiveRuns,
+  al as requiresNewerWorld,
+  am as resolveQueueNamespace,
+  an as stripEventDataRefs,
+  ao as ulidToDate,
+  ap as validateAttributeChanges,
+  aq as validateAttributeKey,
+  ar as validateAttributeValue,
+  as as validateUlidTimestamp,
+  at as workflowRunIdSchema
+};

package/build/server/assets/index-BfLBLRRi.js

@@ -0,0 +1,204 @@
+import { createRequire as __wkfCreateRequire } from "node:module";
+if (typeof require === "undefined") {
+  globalThis.require = __wkfCreateRequire(import.meta.url);
+}
+const compiledCache = /* @__PURE__ */ new WeakMap();
+async function compileSource(source) {
+  const resolved = await source;
+  if (resolved instanceof WebAssembly.Module)
+    return resolved;
+  const buf = resolved;
+  const cacheKey = buf.buffer instanceof ArrayBuffer ? buf.buffer : buf;
+  const cached = compiledCache.get(cacheKey);
+  if (cached)
+    return cached;
+  const compiled = await WebAssembly.compile(buf);
+  compiledCache.set(cacheKey, compiled);
+  return compiled;
+}
+const BUF_LAYOUT = {
+  src: 0,
+  srcSize: 4,
+  srcPos: 8,
+  dst: 12,
+  dstSize: 16,
+  dstPos: 20,
+  SIZE: 24
+};
+function readCString(memory, ptr) {
+  const bytes = new Uint8Array(memory.buffer, ptr);
+  let end = 0;
+  while (bytes[end] !== 0 && end < bytes.length)
+    end++;
+  return new TextDecoder().decode(bytes.subarray(0, end));
+}
+class ZstdDecoder {
+  constructor(exports, dctxPtr, inPtr, inCap, outPtr, outCap, bufPtr) {
+    this.exports = exports;
+    this.dctxPtr = dctxPtr;
+    this.inPtr = inPtr;
+    this.inCap = inCap;
+    this.outPtr = outPtr;
+    this.outCap = outCap;
+    this.bufPtr = bufPtr;
+  }
+  /**
+   * Compile the bundled `zstd.wasm` (or a pre-compiled module) and
+   * return a ready-to-use `ZstdDecoder`.
+   */
+  static async create(wasm) {
+    const module = await compileSource(wasm);
+    const instance = await WebAssembly.instantiate(module, {});
+    const exports = instance.exports;
+    const dctxPtr = exports.dctx_new();
+    if (!dctxPtr)
+      throw new Error("zstd: failed to allocate decompression context");
+    const inCap = exports.dstream_in_size();
+    const outCap = exports.dstream_out_size();
+    const inPtr = exports.zstd_malloc(inCap);
+    const outPtr = exports.zstd_malloc(outCap);
+    const bufPtr = exports.zstd_malloc(BUF_LAYOUT.SIZE);
+    if (!inPtr || !outPtr || !bufPtr) {
+      throw new Error("zstd: failed to allocate streaming buffers");
+    }
+    return new ZstdDecoder(exports, dctxPtr, inPtr, inCap, outPtr, outCap, bufPtr);
+  }
+  dispose() {
+    if (!this.dctxPtr)
+      return;
+    const e = this.exports;
+    e.dctx_free(this.dctxPtr);
+    e.zstd_free(this.inPtr);
+    e.zstd_free(this.outPtr);
+    e.zstd_free(this.bufPtr);
+    this.dctxPtr = 0;
+  }
+  /**
+   * Get a fresh `Uint8Array` view of WASM linear memory.
+   *
+   * IMPORTANT: any call into WASM may grow `memory.buffer`, which
+   * detaches all existing `ArrayBuffer`-backed views. Always
+   * re-acquire views from this getter (and `bufView`) AFTER each
+   * WASM call rather than caching them.
+   */
+  get heap() {
+    return new Uint8Array(this.exports.memory.buffer);
+  }
+  get bufView() {
+    return new DataView(this.exports.memory.buffer, this.bufPtr, BUF_LAYOUT.SIZE);
+  }
+  checkError(ret) {
+    if (this.exports.is_error(ret) !== 0) {
+      const name = readCString(this.exports.memory, this.exports.get_error_name(ret));
+      throw new Error(`zstd: ${name} (code ${ret})`);
+    }
+  }
+  /**
+   * Feed `chunk` to the decoder and pull out as much decoded data
+   * as fits in our output buffer. Calls `onOutput` zero or more
+   * times with non-empty `Uint8Array` slices into the WASM memory.
+   *
+   * IMPORTANT: the slices passed to `onOutput` are views into WASM
+   * memory and are only valid until the next decoder call. Callers
+   * that need to keep the data must copy it (`.slice()` or
+   * `.set()` into their own buffer).
+   */
+  push(chunk, onOutput) {
+    const e = this.exports;
+    let chunkOffset = 0;
+    while (chunkOffset < chunk.length) {
+      const copyLen = Math.min(chunk.length - chunkOffset, this.inCap);
+      this.heap.set(chunk.subarray(chunkOffset, chunkOffset + copyLen), this.inPtr);
+      chunkOffset += copyLen;
+      let srcPos = 0;
+      while (srcPos < copyLen) {
+        let view = this.bufView;
+        view.setUint32(BUF_LAYOUT.src, this.inPtr, true);
+        view.setUint32(BUF_LAYOUT.srcSize, copyLen, true);
+        view.setUint32(BUF_LAYOUT.srcPos, srcPos, true);
+        view.setUint32(BUF_LAYOUT.dst, this.outPtr, true);
+        view.setUint32(BUF_LAYOUT.dstSize, this.outCap, true);
+        view.setUint32(BUF_LAYOUT.dstPos, 0, true);
+        const ret = e.decompress_stream(this.dctxPtr, this.bufPtr);
+        this.checkError(ret);
+        view = this.bufView;
+        const dstPos = view.getUint32(BUF_LAYOUT.dstPos, true);
+        if (dstPos > 0) {
+          onOutput(this.heap.subarray(this.outPtr, this.outPtr + dstPos));
+        }
+        const newSrcPos = view.getUint32(BUF_LAYOUT.srcPos, true);
+        if (newSrcPos === srcPos && dstPos === 0) {
+          throw new Error("zstd: decoder made no progress");
+        }
+        srcPos = newSrcPos;
+        if (ret === 0 && srcPos === copyLen)
+          break;
+      }
+    }
+  }
+  /**
+   * Decompress an entire compressed buffer in one shot. Convenient
+   * for small inputs; large inputs should prefer
+   * `ZstdDecompressStream` to avoid buffering everything in memory.
+   */
+  decode(compressed) {
+    const out = [];
+    let total = 0;
+    this.push(compressed, (chunk) => {
+      const copy = new Uint8Array(chunk);
+      out.push(copy);
+      total += copy.length;
+    });
+    const result = new Uint8Array(total);
+    let off = 0;
+    for (const c of out) {
+      result.set(c, off);
+      off += c.length;
+    }
+    return result;
+  }
+}
+class ZstdDecompressStream extends TransformStream {
+  constructor(wasm) {
+    let decoderPromise = null;
+    const getDecoder = () => {
+      if (!decoderPromise)
+        decoderPromise = ZstdDecoder.create(wasm);
+      return decoderPromise;
+    };
+    super({
+      async transform(chunk, controller) {
+        try {
+          const dec = await getDecoder();
+          dec.push(chunk, (out) => {
+            controller.enqueue(new Uint8Array(out));
+          });
+        } catch (err) {
+          controller.error(err);
+        }
+      },
+      async flush() {
+        if (decoderPromise) {
+          try {
+            const dec = await decoderPromise;
+            dec.dispose();
+          } catch {
+          }
+        }
+      }
+    });
+  }
+}
+async function decompressBytes(wasm, compressed) {
+  const dec = await ZstdDecoder.create(wasm);
+  try {
+    return dec.decode(compressed);
+  } finally {
+    dec.dispose();
+  }
+}
+export {
+  ZstdDecoder,
+  ZstdDecompressStream,
+  decompressBytes
+};