@workflow/web 5.0.0-beta.2 → 5.0.0-beta.20

package/build/client/assets/encryption-g14N5vQl.js

@@ -0,0 +1,51 @@
+import { W as WorkflowRuntimeError, R as RuntimeDecryptionError } from "./index-B6-SzLmT.js";
+import "./index-BXZSIDEp.js";
+const NONCE_LENGTH = 12;
+const TAG_LENGTH = 128;
+const KEY_LENGTH = 32;
+async function importKey(raw, usages = ["encrypt", "decrypt"]) {
+  if (raw.byteLength !== KEY_LENGTH) {
+    throw new WorkflowRuntimeError(`Encryption key must be exactly ${KEY_LENGTH} bytes, got ${raw.byteLength}`);
+  }
+  return globalThis.crypto.subtle.importKey(
+    "raw",
+    raw,
+    "AES-GCM",
+    false,
+    // `KeyUsage` is a DOM-lib type that's not in scope under `es2022`.
+    // The `ReadonlyArray<'encrypt' | 'decrypt'>` parameter type matches
+    // a strict subset of `KeyUsage[]`, so this cast is sound.
+    usages
+  );
+}
+async function decrypt(key, data) {
+  const minLength = NONCE_LENGTH + TAG_LENGTH / 8;
+  if (data.byteLength < minLength) {
+    throw new RuntimeDecryptionError(`Encrypted data too short: expected at least ${minLength} bytes, got ${data.byteLength}`, {
+      context: {
+        operation: "decrypt",
+        byteLength: data.byteLength
+      }
+    });
+  }
+  const nonce = data.subarray(0, NONCE_LENGTH);
+  const ciphertext = data.subarray(NONCE_LENGTH);
+  let plaintext;
+  try {
+    plaintext = await globalThis.crypto.subtle.decrypt({ name: "AES-GCM", iv: nonce, tagLength: TAG_LENGTH }, key, ciphertext);
+  } catch (cause) {
+    const causeMsg = cause instanceof Error ? cause.message : String(cause);
+    throw new RuntimeDecryptionError(`AES-256-GCM decryption failed: ${causeMsg}`, {
+      cause,
+      context: {
+        operation: "decrypt",
+        byteLength: data.byteLength
+      }
+    });
+  }
+  return new Uint8Array(plaintext);
+}
+export {
+  decrypt,
+  importKey
+};

package/build/client/assets/{entry.client-BWsSsWQm.js → entry.client-DOJDY_4b.js}

@@ -1,4 +1,4 @@
-import { a as requireReact, b as requireReactDom, m as matchRoutes, s as shouldHydrateRouteLoader, E as ErrorResponseImpl, N as NO_BODY_STATUS_CODES, R as ReactExports, i as isRouteErrorResponse, r as reactExports, c as invariant, u as useFogOFWarDiscovery, F as FrameworkContext, d as RemixErrorBoundary, e as RouterProvider, f as reactDomExports, g as decodeViaTurboStream, h as createClientRoutes, k as createRouter, l as getPatchRoutesOnNavigationFunction, n as getTurboStreamSingleFetchDataStrategy, o as createBrowserHistory, p as createClientRoutesWithHMRRevalidationOptOut, q as mapRouteProperties, t as hydrationRouteProperties, j as jsxRuntimeExports } from "./index-DQa-BExo.js";
+import { a as requireReact, b as requireReactDom, m as matchRoutes, s as shouldHydrateRouteLoader, E as ErrorResponseImpl, N as NO_BODY_STATUS_CODES, R as ReactExports, i as isRouteErrorResponse, r as reactExports, c as invariant, u as useFogOFWarDiscovery, F as FrameworkContext, d as RemixErrorBoundary, e as RouterProvider, f as reactDomExports, h as decodeViaTurboStream, k as createClientRoutes, l as createRouter, n as getPatchRoutesOnNavigationFunction, o as getTurboStreamSingleFetchDataStrategy, p as createBrowserHistory, q as createClientRoutesWithHMRRevalidationOptOut, t as mapRouteProperties, v as hydrationRouteProperties, j as jsxRuntimeExports } from "./index-BXZSIDEp.js";
 var client = { exports: {} };
 var reactDomClient_production = {};
 var scheduler = { exports: {} };

package/build/client/assets/{highlighted-body-B3W2YXNL-DPWdt39H.js → highlighted-body-B3W2YXNL-LmACipCR.js}

@@ -1,5 +1,5 @@
-import { R, K as Ks, Q as Qe } from "./mermaid-3ZIDBTTL-B9v3aKRl.js";
-import { r as reactExports, j as jsxRuntimeExports } from "./index-DQa-BExo.js";
+import { R, K as Ks, Q as Qe } from "./mermaid-3ZIDBTTL-DndzaIEl.js";
+import { r as reactExports, j as jsxRuntimeExports } from "./index-BXZSIDEp.js";
 var L = ({ code: s, language: t, raw: e, className: n, ...d$1 }) => {
   let { shikiTheme: l } = reactExports.useContext(R), o = Ks(), [m, i] = reactExports.useState(e);
   return reactExports.useEffect(() => {

package/build/client/assets/{home-OcN-ARTU.js → home-B-QPEXVb.js}

@@ -1,16 +1,7 @@
-import { r as reactExports, C as ReactDOM, j as jsxRuntimeExports, z as Link, f as reactDomExports, B as useSearchParams, A as useNavigate, D as useLocation, w as withComponentProps } from "./index-DQa-BExo.js";
-import { R as ResolveHookModal, S as Send, a as Skeleton, u as unwrapOrThrow, W as WorkflowWebAPIError, b as RelativeTime, A as Alert, C as CircleAlert, c as AlertTitle, d as AlertDescription, g as getErrorMessage, e as CopyableText, D as DropdownMenu, f as DropdownMenuTrigger, E as Ellipsis, h as DropdownMenuContent, i as DropdownMenuItem, j as ChevronRight, r as resumeHook, k as createCollection, l as hideOthers, m as ReactRemoveScroll, n as useDirection, o as ChevronDown, p as ChevronUp, q as Check, X, s as useControllableState$1, P as Primitive$1, t as composeEventHandlers$1, v as Presence, w as useSize, x as createContextScope$1, y as cancelRun, z as reenqueueRun, B as parseWorkflowName, F as StatusBadge, Z as Zap, G as CircleX, H as RunActionsDropdownItems, I as unwrapServerActionResult, J as WorkflowGraphViewer, T as Tabs, K as TabsList, L as TabsTrigger, M as TabsContent, N as ErrorBoundary } from "./workflow-graph-viewer-BdFIMYrh.js";
-import { g as useLayoutEffect2, P as Primitive, c as createLucideIcon, h as useToast, d as cn, D as DEFAULT_PAGE_SIZE, i as fetchRuns, j as fetchHooks, k as getPaginationDisplay, T as Tooltip, a as TooltipTrigger, B as Button, b as TooltipContent, l as fetchEvents, m as useCallbackRef, n as useComposedRefs, A as Anchor, o as composeEventHandlers, p as useId, q as createPopperScope, s as DismissableLayer, v as createContextScope, w as createSlot, C as Content$1, x as useControllableState, y as Root2$1, V as VISUALLY_HIDDEN_STYLES, z as Arrow, E as useComposedRefs$1, u as useServerConfig, t as toast, L as LoaderCircle, F as fetchRun, G as cva, H as Presence$1, I as createContext2, J as fetchWorkflowsManifest } from "./mermaid-3ZIDBTTL-B9v3aKRl.js";
-var PORTAL_NAME$2 = "Portal";
-var Portal$2 = reactExports.forwardRef((props, forwardedRef) => {
-  var _a;
-  const { container: containerProp, ...portalProps } = props;
-  const [mounted, setMounted] = reactExports.useState(false);
-  useLayoutEffect2(() => setMounted(true), []);
-  const container = containerProp || mounted && ((_a = globalThis == null ? void 0 : globalThis.document) == null ? void 0 : _a.body);
-  return container ? ReactDOM.createPortal(/* @__PURE__ */ jsxRuntimeExports.jsx(Primitive.div, { ...portalProps, ref: forwardedRef }), container) : null;
-});
-Portal$2.displayName = PORTAL_NAME$2;
+import { r as reactExports, j as jsxRuntimeExports, A as Link, f as reactDomExports, C as useSearchParams, B as useNavigate, D as useLocation, w as withComponentProps } from "./index-BXZSIDEp.js";
+import { R as ResolveHookModal, S as Send, a as Skeleton, u as unwrapOrThrow, W as WorkflowWebAPIError, b as RelativeTime, A as Alert, C as CircleAlert, c as AlertTitle, d as AlertDescription, g as getErrorMessage, e as CopyableText, D as DropdownMenu, f as DropdownMenuTrigger, E as Ellipsis, h as DropdownMenuContent, i as DropdownMenuItem, j as ChevronRight, r as resumeHook, k as createCollection, l as hideOthers, m as ReactRemoveScroll, n as useDirection, o as ChevronDown, p as ChevronUp, q as Check, X, s as useControllableState$1, P as Primitive$1, t as composeEventHandlers$1, v as Presence, w as useSize, x as createContextScope$1, y as cancelRun, z as reenqueueRun, B as parseWorkflowName, F as StatusBadge, Z as Zap, G as CircleX, H as RunActionsDropdownItems, I as unwrapServerActionResult, J as WorkflowGraphViewer, T as Tabs, K as TabsList, L as TabsTrigger, M as TabsContent, N as ErrorBoundary } from "./workflow-graph-viewer-j7J3_oSH.js";
+import { c as createLucideIcon, h as useToast, e as cn, D as DEFAULT_PAGE_SIZE, i as fetchRuns, j as fetchHooks, k as getPaginationDisplay, T as Tooltip, a as TooltipTrigger, B as Button, b as TooltipContent, l as fetchEvents, m as useCallbackRef, n as useComposedRefs, P as Primitive, A as Anchor, o as composeEventHandlers, p as useLayoutEffect2, q as Portal$2, s as useId, v as createPopperScope, w as DismissableLayer, x as createContextScope, y as createSlot, C as Content$1, z as useControllableState, E as Root2$1, V as VISUALLY_HIDDEN_STYLES, F as Arrow, G as useComposedRefs$1, u as useServerConfig, t as toast, L as LoaderCircle, H as fetchRun, I as cva, J as Presence$1, M as createContext2, N as fetchWorkflowsManifest } from "./mermaid-3ZIDBTTL-DndzaIEl.js";
+import "./index-B6-SzLmT.js";
 /**
  * @license lucide-react v0.575.0 - ISC
  *

package/build/client/assets/index-B6-SzLmT.js

@@ -0,0 +1,308 @@
+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 { g as getDefaultExportFromCjs } from "./index-BXZSIDEp.js";
+var ms$1;
+var hasRequiredMs;
+function requireMs() {
+  if (hasRequiredMs) return ms$1;
+  hasRequiredMs = 1;
+  var s = 1e3;
+  var m = s * 60;
+  var h = m * 60;
+  var d = h * 24;
+  var w = d * 7;
+  var y = d * 365.25;
+  ms$1 = function(val, options) {
+    options = options || {};
+    var type = typeof val;
+    if (type === "string" && val.length > 0) {
+      return parse(val);
+    } else if (type === "number" && isFinite(val)) {
+      return options.long ? fmtLong(val) : fmtShort(val);
+    }
+    throw new Error(
+      "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+    );
+  };
+  function parse(str) {
+    str = String(str);
+    if (str.length > 100) {
+      return;
+    }
+    var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+      str
+    );
+    if (!match) {
+      return;
+    }
+    var n = parseFloat(match[1]);
+    var type = (match[2] || "ms").toLowerCase();
+    switch (type) {
+      case "years":
+      case "year":
+      case "yrs":
+      case "yr":
+      case "y":
+        return n * y;
+      case "weeks":
+      case "week":
+      case "w":
+        return n * w;
+      case "days":
+      case "day":
+      case "d":
+        return n * d;
+      case "hours":
+      case "hour":
+      case "hrs":
+      case "hr":
+      case "h":
+        return n * h;
+      case "minutes":
+      case "minute":
+      case "mins":
+      case "min":
+      case "m":
+        return n * m;
+      case "seconds":
+      case "second":
+      case "secs":
+      case "sec":
+      case "s":
+        return n * s;
+      case "milliseconds":
+      case "millisecond":
+      case "msecs":
+      case "msec":
+      case "ms":
+        return n;
+      default:
+        return void 0;
+    }
+  }
+  function fmtShort(ms2) {
+    var msAbs = Math.abs(ms2);
+    if (msAbs >= d) {
+      return Math.round(ms2 / d) + "d";
+    }
+    if (msAbs >= h) {
+      return Math.round(ms2 / h) + "h";
+    }
+    if (msAbs >= m) {
+      return Math.round(ms2 / m) + "m";
+    }
+    if (msAbs >= s) {
+      return Math.round(ms2 / s) + "s";
+    }
+    return ms2 + "ms";
+  }
+  function fmtLong(ms2) {
+    var msAbs = Math.abs(ms2);
+    if (msAbs >= d) {
+      return plural(ms2, msAbs, d, "day");
+    }
+    if (msAbs >= h) {
+      return plural(ms2, msAbs, h, "hour");
+    }
+    if (msAbs >= m) {
+      return plural(ms2, msAbs, m, "minute");
+    }
+    if (msAbs >= s) {
+      return plural(ms2, msAbs, s, "second");
+    }
+    return ms2 + " ms";
+  }
+  function plural(ms2, msAbs, n, name) {
+    var isPlural = msAbs >= n * 1.5;
+    return Math.round(ms2 / n) + " " + name + (isPlural ? "s" : "");
+  }
+  return ms$1;
+}
+var msExports = requireMs();
+const ms = /* @__PURE__ */ getDefaultExportFromCjs(msExports);
+function parseDurationToDate(param) {
+  if (typeof param === "string") {
+    const durationMs = ms(param);
+    if (typeof durationMs !== "number" || durationMs < 0) {
+      throw new Error(`Invalid duration: "${param}". Expected a valid duration string like "1s", "1m", "1h", etc.`);
+    }
+    return new Date(Date.now() + durationMs);
+  } else if (typeof param === "number") {
+    if (param < 0 || !Number.isFinite(param)) {
+      throw new Error(`Invalid duration: ${param}. Expected a non-negative finite number of milliseconds.`);
+    }
+    return new Date(Date.now() + param);
+  } else if (param instanceof Date || param && typeof param === "object" && typeof param.getTime === "function") {
+    return param instanceof Date ? param : new Date(param.getTime());
+  } else {
+    throw new Error(`Invalid duration parameter. Expected a duration string, number (milliseconds), or Date object.`);
+  }
+}
+const BASE_URL = "https://workflow-sdk.dev/err";
+function isError(value) {
+  return typeof value === "object" && value !== null && "name" in value && "message" in value;
+}
+function appendFramedDetails(title, details) {
+  if (details.length === 0)
+    return title;
+  const lines = [title];
+  details.forEach((detail, index) => {
+    const isLast = index === details.length - 1;
+    const head = isLast ? "╰▶ " : "├▶ ";
+    const cont = isLast ? "   " : "│  ";
+    const text = `${detail.label}: ${detail.value}`;
+    text.split("\n").forEach((line, i) => lines.push(`${i === 0 ? head : cont}${line}`));
+  });
+  return lines.join("\n");
+}
+function buildFramedDetails(hint, slug) {
+  const out = [];
+  if (slug)
+    out.push({ label: "docs", value: `${BASE_URL}/${slug}` });
+  return out;
+}
+const ERROR_SLUGS = {
+  HOOK_CONFLICT: "hook-conflict",
+  RUNTIME_DECRYPTION_FAILED: "runtime-decryption-failed"
+};
+class WorkflowError extends Error {
+  constructor(message, options) {
+    const msgDocs = appendFramedDetails(message, buildFramedDetails(void 0, options == null ? void 0 : options.slug));
+    super(msgDocs, { cause: options == null ? void 0 : options.cause });
+    __publicField(this, "cause");
+    if ((options == null ? void 0 : options.cause) !== void 0) {
+      this.cause = options.cause;
+    }
+    if ((options == null ? void 0 : options.cause) instanceof Error) {
+      this.stack = `${this.stack}
+Caused by: ${options.cause.stack}`;
+    }
+  }
+  static is(value) {
+    return isError(value) && value.name === "WorkflowError";
+  }
+}
+class WorkflowRuntimeError extends WorkflowError {
+  constructor(message, options) {
+    super(message, {
+      ...options
+    });
+    this.name = "WorkflowRuntimeError";
+  }
+  static is(value) {
+    return isError(value) && value.name === "WorkflowRuntimeError";
+  }
+}
+class RuntimeDecryptionError extends WorkflowRuntimeError {
+  constructor(message, options) {
+    super(message, {
+      cause: options == null ? void 0 : options.cause,
+      slug: ERROR_SLUGS.RUNTIME_DECRYPTION_FAILED
+    });
+    /** Optional structured context about the failed encrypt/decrypt call. */
+    __publicField(this, "context");
+    this.name = "RuntimeDecryptionError";
+    if ((options == null ? void 0 : options.context) !== void 0) {
+      this.context = options.context;
+    }
+  }
+  static is(value) {
+    return isError(value) && value.name === "RuntimeDecryptionError";
+  }
+}
+class HookConflictError extends WorkflowError {
+  constructor(token, conflictingRunId) {
+    super(`Hook token "${token}" is already in use by another workflow${conflictingRunId ? ` (run "${conflictingRunId}")` : ""}`, {
+      slug: ERROR_SLUGS.HOOK_CONFLICT
+    });
+    __publicField(this, "token");
+    // TODO: Make this required once all persisted hook_conflict events and World
+    // implementations always include the active hook owner's run ID.
+    __publicField(this, "conflictingRunId");
+    this.name = "HookConflictError";
+    this.token = token;
+    if (conflictingRunId !== void 0) {
+      this.conflictingRunId = conflictingRunId;
+    }
+  }
+  static is(value) {
+    return isError(value) && value.name === "HookConflictError";
+  }
+}
+class FatalError extends Error {
+  constructor(message) {
+    super(message);
+    __publicField(this, "fatal", true);
+    this.name = "FatalError";
+  }
+  static is(value) {
+    if (!isError(value))
+      return false;
+    if (value.name === "FatalError")
+      return true;
+    return value.fatal === true;
+  }
+}
+class RetryableError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    /**
+     * The Date when the step should be retried.
+     */
+    __publicField(this, "retryAfter");
+    this.name = "RetryableError";
+    if (options.retryAfter !== void 0) {
+      this.retryAfter = parseDurationToDate(options.retryAfter);
+    } else {
+      this.retryAfter = new Date(Date.now() + 1e3);
+    }
+  }
+  static is(value) {
+    return isError(value) && value.name === "RetryableError";
+  }
+}
+const VERCEL_403_ERROR_MESSAGE = "Your current vercel account does not have access to this resource. Use `vercel login` or `vercel switch` to ensure you are linked to the right account.";
+const FATAL_ERROR_KEY = Symbol.for("@workflow/errors//FatalError");
+const RETRYABLE_ERROR_KEY = Symbol.for("@workflow/errors//RetryableError");
+const HOOK_CONFLICT_ERROR_KEY = Symbol.for("@workflow/errors//HookConflictError");
+const RUNTIME_DECRYPTION_ERROR_KEY = Symbol.for("@workflow/errors//RuntimeDecryptionError");
+if (typeof globalThis !== "undefined") {
+  if (!Object.hasOwn(globalThis, FATAL_ERROR_KEY)) {
+    Object.defineProperty(globalThis, FATAL_ERROR_KEY, {
+      value: FatalError,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  if (!Object.hasOwn(globalThis, RETRYABLE_ERROR_KEY)) {
+    Object.defineProperty(globalThis, RETRYABLE_ERROR_KEY, {
+      value: RetryableError,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  if (!Object.hasOwn(globalThis, HOOK_CONFLICT_ERROR_KEY)) {
+    Object.defineProperty(globalThis, HOOK_CONFLICT_ERROR_KEY, {
+      value: HookConflictError,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  if (!Object.hasOwn(globalThis, RUNTIME_DECRYPTION_ERROR_KEY)) {
+    Object.defineProperty(globalThis, RUNTIME_DECRYPTION_ERROR_KEY, {
+      value: RuntimeDecryptionError,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+}
+export {
+  RuntimeDecryptionError as R,
+  VERCEL_403_ERROR_MESSAGE as V,
+  WorkflowRuntimeError as W
+};

package/build/client/assets/{index-DQa-BExo.js → index-BXZSIDEp.js}

@@ -9388,15 +9388,15 @@ function useViewTransitionState(to, { relative } = {}) {
 var reactDomExports = requireReactDom();
 const ReactDOM = /* @__PURE__ */ getDefaultExportFromCjs(reactDomExports);
 export {
-  useNavigate as A,
-  useSearchParams as B,
-  ReactDOM as C,
+  Link as A,
+  useNavigate as B,
+  useSearchParams as C,
   useLocation as D,
   ErrorResponseImpl as E,
   FrameworkContext as F,
-  useParams as G,
-  React as H,
-  getDefaultExportFromCjs as I,
+  ReactDOM as G,
+  useParams as H,
+  React as I,
   Links as L,
   Meta as M,
   NO_BODY_STATUS_CODES as N,
@@ -9409,24 +9409,24 @@ export {
   RemixErrorBoundary as d,
   RouterProvider as e,
   reactDomExports as f,
-  decodeViaTurboStream as g,
-  createClientRoutes as h,
+  getDefaultExportFromCjs as g,
+  decodeViaTurboStream as h,
   isRouteErrorResponse as i,
   jsxRuntimeExports as j,
-  createRouter as k,
-  getPatchRoutesOnNavigationFunction as l,
+  createClientRoutes as k,
+  createRouter as l,
   matchRoutes as m,
-  getTurboStreamSingleFetchDataStrategy as n,
-  createBrowserHistory as o,
-  createClientRoutesWithHMRRevalidationOptOut as p,
-  mapRouteProperties as q,
+  getPatchRoutesOnNavigationFunction as n,
+  getTurboStreamSingleFetchDataStrategy as o,
+  createBrowserHistory as p,
+  createClientRoutesWithHMRRevalidationOptOut as q,
   reactExports as r,
   shouldHydrateRouteLoader as s,
-  hydrationRouteProperties as t,
+  mapRouteProperties as t,
   useFogOFWarDiscovery as u,
-  withErrorBoundaryProps as v,
+  hydrationRouteProperties as v,
   withComponentProps as w,
-  Scripts as x,
-  useRouteError as y,
-  Link as z
+  withErrorBoundaryProps as x,
+  Scripts as y,
+  useRouteError as z
 };

package/build/client/assets/index-C7C6cDW5.js

@@ -0,0 +1,200 @@
+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$1, dctxPtr, inPtr, inCap, outPtr, outCap, bufPtr) {
+    this.exports = exports$1;
+    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$1 = instance.exports;
+    const dctxPtr = exports$1.dctx_new();
+    if (!dctxPtr)
+      throw new Error("zstd: failed to allocate decompression context");
+    const inCap = exports$1.dstream_in_size();
+    const outCap = exports$1.dstream_out_size();
+    const inPtr = exports$1.zstd_malloc(inCap);
+    const outPtr = exports$1.zstd_malloc(outCap);
+    const bufPtr = exports$1.zstd_malloc(BUF_LAYOUT.SIZE);
+    if (!inPtr || !outPtr || !bufPtr) {
+      throw new Error("zstd: failed to allocate streaming buffers");
+    }
+    return new ZstdDecoder(exports$1, 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
+};

package/build/client/assets/manifest-225d97da.js

@@ -0,0 +1 @@
+window.__reactRouterManifest={"entry":{"module":"/assets/entry.client-DOJDY_4b.js","imports":["/assets/index-BXZSIDEp.js"],"css":[]},"routes":{"root":{"id":"root","path":"","hasAction":true,"hasLoader":true,"hasClientAction":false,"hasClientLoader":false,"hasClientMiddleware":false,"hasDefaultExport":true,"hasErrorBoundary":true,"module":"/assets/root--Sg25-Lb.js","imports":["/assets/index-BXZSIDEp.js","/assets/mermaid-3ZIDBTTL-DndzaIEl.js"],"css":["/assets/root-1hd8ZXAx.css","/assets/mermaid-3ZIDBTTL-DDxQhcP4.css"]},"routes/home":{"id":"routes/home","parentId":"root","index":true,"hasAction":false,"hasLoader":false,"hasClientAction":false,"hasClientLoader":false,"hasClientMiddleware":false,"hasDefaultExport":true,"hasErrorBoundary":false,"module":"/assets/home-B-QPEXVb.js","imports":["/assets/index-BXZSIDEp.js","/assets/workflow-graph-viewer-j7J3_oSH.js","/assets/mermaid-3ZIDBTTL-DndzaIEl.js","/assets/index-B6-SzLmT.js"],"css":["/assets/workflow-graph-viewer-DnlNuQQH.css","/assets/mermaid-3ZIDBTTL-DDxQhcP4.css"]},"routes/run-detail":{"id":"routes/run-detail","parentId":"root","path":"run/:runId","hasAction":false,"hasLoader":false,"hasClientAction":false,"hasClientLoader":false,"hasClientMiddleware":false,"hasDefaultExport":true,"hasErrorBoundary":false,"module":"/assets/run-detail-Djwnox1v.js","imports":["/assets/index-BXZSIDEp.js","/assets/workflow-graph-viewer-j7J3_oSH.js","/assets/mermaid-3ZIDBTTL-DndzaIEl.js","/assets/encryption-g14N5vQl.js","/assets/index-B6-SzLmT.js"],"css":["/assets/workflow-graph-viewer-DnlNuQQH.css","/assets/mermaid-3ZIDBTTL-DDxQhcP4.css"]},"routes/api.rpc":{"id":"routes/api.rpc","parentId":"root","path":"api/rpc","hasAction":true,"hasLoader":true,"hasClientAction":false,"hasClientLoader":false,"hasClientMiddleware":false,"hasDefaultExport":false,"hasErrorBoundary":false,"module":"/assets/api.rpc-l0sNRNKZ.js","imports":[],"css":[]},"routes/api.stream.$streamId":{"id":"routes/api.stream.$streamId","parentId":"root","path":"api/stream/:streamId","hasAction":false,"hasLoader":true,"hasClientAction":false,"hasClientLoader":false,"hasClientMiddleware":false,"hasDefaultExport":false,"hasErrorBoundary":false,"module":"/assets/api.stream._streamId-l0sNRNKZ.js","imports":[],"css":[]}},"url":"/assets/manifest-225d97da.js","version":"225d97da"};