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

package/build/server/assets/{highlighted-body-B3W2YXNL-CZjJIpdD.js → highlighted-body-B3W2YXNL-DY_BqM6l.js}

@@ -1,32 +1,37 @@
-import { x as R, K as Ks, y as jsxRuntimeExports, z as Qe } from "./server-build-DtcOUEHS.js";
-import { r as reactExports } from "./app-L1V62FgT.js";
+import { createRequire as __wkfCreateRequire } from "node:module";
+if (typeof require === "undefined") {
+  globalThis.require = __wkfCreateRequire(import.meta.url);
+}
+import { b4 as reactExports, b5 as R, b6 as Ks, b7 as jsxRuntimeExports, b8 as Qe } from "./app-8hyjFpMO.js";
 import "node:stream";
+import "stream";
 import "util";
 import "crypto";
 import "async_hooks";
-import "stream";
 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:module";
 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: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";
@@ -36,9 +41,12 @@ import "node:timers";
 import "node:dns";
 import "path";
 import "fs";
+import "constants";
+import "assert";
 import "os";
+import "assert/strict";
 import "net";
-import "node:os";
+import "node:assert/strict";
 import "express";
 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);

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

@@ -0,0 +1,174 @@
+import { createRequire as __wkfCreateRequire } from "node:module";
+if (typeof require === "undefined") {
+  globalThis.require = __wkfCreateRequire(import.meta.url);
+}
+import { H as HookSchema } from "./app-8hyjFpMO.js";
+import { A, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, B, r, s, t, u, C, D, v, E, w, x, y, F, z, G, I, J, K, L, M, O, P, Q, R, S, T, 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, au, av, aw, ax, ay, az, aA, aB, aC, aD, aE, aF, aG, aH, aI, aJ, aK, aL, aM, aN, aO, aP, aQ, aR, aS, aT, aU, aV, aW, aX, aY, aZ, a_, a$, b0, b1, b2, b3 } 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";
+export {
+  A as ANALYTICS_EVENTS_GET_MANY_LIMIT,
+  a as ANALYTICS_MAX_ATTRIBUTE_FILTERS,
+  b as ANALYTICS_PAGE_LIMIT,
+  c as ANALYTICS_RUN_SCOPED_PAGE_LIMIT,
+  d as ATTRIBUTE_KEY_MAX_LENGTH,
+  e as ATTRIBUTE_MAX_PER_RUN,
+  f as ATTRIBUTE_VALUE_MAX_BYTES,
+  g as AnalyticsAttributeKeySchema,
+  h as AnalyticsEventSchema,
+  i as AnalyticsHookSchema,
+  j as AnalyticsRunSchema,
+  k as AnalyticsStepSchema,
+  l as AnalyticsWaitSchema,
+  m as AttributeChangeSchema,
+  n as AttributeChangesSchema,
+  o as AttributeKeySchema,
+  p as AttributeValidationError,
+  q as AttributeValueSchema,
+  B as BULK_CANCEL_MAX_RUN_IDS,
+  r as BaseEventSchema,
+  s as BulkCancelWorkflowRunResultSchema,
+  t as BulkCancelWorkflowRunsRequestSchema,
+  u as BulkCancelWorkflowRunsResultSchema,
+  C as CHILD_ENTITY_CREATION_EVENT_TYPES,
+  D as DEFAULT_TIMESTAMP_THRESHOLD_FUTURE_MS,
+  v as DEFAULT_TIMESTAMP_THRESHOLD_PAST_MS,
+  E as EVENT_ID_BODY_LENGTH,
+  w as EVENT_ID_PREFIX,
+  x as EventSchema,
+  y as EventTypeSchema,
+  F as FIRST_EVENT_SLOT,
+  z as HOOK_EVENTS_REQUIRING_EXISTENCE,
+  G as HOOK_LIFECYCLE_EVENT_TYPES,
+  I as HOOK_RESUME_DEDUP_VERSION,
+  J as HOOK_RESUME_INPUT_VERSION,
+  K as HealthCheckPayloadSchema,
+  L as HookCreatedEventSchema,
+  M as HookResumeCapabilitiesSchema,
+  HookSchema,
+  O as LegacySerializedDataSchemaV1,
+  P as MessageId,
+  Q as NODE_HTTP_DEFAULT,
+  R as NODE_HTTP_ENV_VAR,
+  S as PARENT_RUN_ID_ATTRIBUTE,
+  T as PaginatedResponseSchema,
+  U as QueuePayloadSchema,
+  V as QueuePrefix,
+  W as RESERVED_ATTRIBUTE_KEY_PREFIX,
+  X as RETENTION_ATTRIBUTE,
+  Y as RETENTION_DEFAULT,
+  Z as RETENTION_ZERO,
+  _ as ROOT_RUN_ID_ATTRIBUTE,
+  $ as RUN_ENTITY_KEY,
+  a0 as RunInputSchema,
+  a1 as SEALED_LOG_ENV_VAR,
+  a2 as SPEC_VERSION_CURRENT,
+  a3 as SPEC_VERSION_LEGACY,
+  a4 as SPEC_VERSION_MAX_SUPPORTED,
+  a5 as SPEC_VERSION_SUPPORTS_ATTRIBUTES,
+  a6 as SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT,
+  a7 as SPEC_VERSION_SUPPORTS_COMPRESSION,
+  a8 as SPEC_VERSION_SUPPORTS_SEALED_LOG,
+  a9 as SPEC_VERSION_SUPPORTS_SLOT_IDENTITY,
+  aa as STEP_EVENT_TYPES,
+  ab as SerializedDataSchema,
+  ac as StepSchema,
+  ad as StepStatusSchema,
+  ae as StructuredErrorSchema,
+  af as TERMINAL_EVENT_CLASSES,
+  ag as TERMINAL_RUN_EVENT_TYPES,
+  ah as TERMINAL_STEP_EVENT_TYPES,
+  ai as TERMINAL_STEP_STATUSES,
+  aj as TERMINAL_WORKFLOW_RUN_STATUSES,
+  ak as TerminalRunEventTypeSchema,
+  al as TerminalStepStatusSchema,
+  am as TerminalWorkflowRunStatusSchema,
+  an as ValidQueueName,
+  ao as WAIT_EVENT_TYPES,
+  ap as WaitSchema,
+  aq as WaitStatusSchema,
+  ar as WorkflowInvokePayloadSchema,
+  as as WorkflowRunBaseSchema,
+  at as WorkflowRunSchema,
+  au as WorkflowRunStatusSchema,
+  av as applyAttributeChanges,
+  aw as classifyEntityEvent,
+  ax as entityEventClass,
+  ay as envFlag,
+  az as envNumber,
+  aA as eventIdToSlot,
+  aB as getEventDataPayloadField,
+  aC as getEventDataRefFields,
+  aD as getMaxEventsPerRun,
+  aE as getQueueTopicPrefix,
+  aF as isChildEntityCreationEvent,
+  aG as isChildEntityCreationEventType,
+  aH as isHookEventRequiringExistence,
+  aI as isHookLifecycleEventType,
+  aJ as isLegacySpecVersion,
+  aK as isNodeHttpEnabled,
+  aL as isSealedNoopEvent,
+  aM as isSlotBody,
+  aN as isSlotEventId,
+  aO as isStepEventType,
+  aP as isTerminalRunEventType,
+  aQ as isTerminalStepEventType,
+  aR as isTerminalStepStatus,
+  aS as isTerminalWorkflowRunStatus,
+  aT as isWaitEventType,
+  aU as mintedSpecVersion,
+  aV as parseQueueName,
+  aW as readRunRetention,
+  aX as reenqueueActiveRuns,
+  aY as requiresNewerWorld,
+  aZ as resolveQueueNamespace,
+  a_ as slotToEventId,
+  a$ as stripEventDataRefs,
+  b0 as ulidToDate,
+  b1 as validateAttributeChanges,
+  b2 as validateUlidTimestamp,
+  b3 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
+};