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

package/build/client/assets/index-HqNj_XIX.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, 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
+};

package/build/client/assets/{index-BsV8i_Jn.js → index-PFjW8YjQ.js}

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

package/build/client/assets/loader-circle-BX6ycuOI.js

@@ -0,0 +1,12 @@
+import { c as createLucideIcon } from "./mermaid-3ZIDBTTL-BKwl_LgA.js";
+/**
+ * @license lucide-react v0.575.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode = [["path", { d: "M21 12a9 9 0 1 1-6.219-8.56", key: "13zald" }]];
+const LoaderCircle = createLucideIcon("loader-circle", __iconNode);
+export {
+  LoaderCircle as L
+};

package/build/client/assets/manifest-34c486ef.js

@@ -0,0 +1 @@
+window.__reactRouterManifest={"entry":{"module":"/assets/entry.client-LwI3HNYl.js","imports":["/assets/index-PFjW8YjQ.js"],"css":[]},"routes":{"root":{"id":"root","path":"","hasAction":true,"hasLoader":true,"hasClientAction":false,"hasClientLoader":false,"hasClientMiddleware":false,"hasDefaultExport":true,"hasErrorBoundary":true,"module":"/assets/root-qx_45_fH.js","imports":["/assets/index-PFjW8YjQ.js","/assets/mermaid-3ZIDBTTL-BKwl_LgA.js","/assets/loader-circle-BX6ycuOI.js","/assets/arrow-up-right-CSovqivK.js"],"css":["/assets/root-Bl5xphvU.css","/assets/mermaid-3ZIDBTTL-D8CjRQta.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-BbyW_T74.js","imports":["/assets/index-PFjW8YjQ.js","/assets/workflow-graph-viewer-C-1D0sAn.js","/assets/mermaid-3ZIDBTTL-BKwl_LgA.js","/assets/loader-circle-BX6ycuOI.js"],"css":["/assets/workflow-graph-viewer-DnlNuQQH.css","/assets/mermaid-3ZIDBTTL-D8CjRQta.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-BoGFG1Fe.js","imports":["/assets/index-PFjW8YjQ.js","/assets/workflow-graph-viewer-C-1D0sAn.js","/assets/mermaid-3ZIDBTTL-BKwl_LgA.js","/assets/arrow-up-right-CSovqivK.js"],"css":["/assets/run-detail-CWoGxu_0.css","/assets/workflow-graph-viewer-DnlNuQQH.css","/assets/mermaid-3ZIDBTTL-D8CjRQta.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-34c486ef.js","version":"34c486ef"};