awaitly 2.0.0 → 3.0.0

package/dist/streaming.cjs

@@ -0,0 +1,895 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/streaming-entry.ts
+var streaming_entry_exports = {};
+__export(streaming_entry_exports, {
+  STREAM_BACKPRESSURE_ERROR: () => STREAM_BACKPRESSURE_ERROR,
+  STREAM_CLOSE_ERROR: () => STREAM_CLOSE_ERROR,
+  STREAM_ENDED: () => STREAM_ENDED,
+  STREAM_READ_ERROR: () => STREAM_READ_ERROR,
+  STREAM_STORE_ERROR: () => STREAM_STORE_ERROR,
+  STREAM_WRITE_ERROR: () => STREAM_WRITE_ERROR,
+  chunk: () => chunk,
+  collect: () => collect,
+  createBackpressureController: () => createBackpressureController,
+  createFileStreamStore: () => createFileStreamStore,
+  createMemoryStreamStore: () => createMemoryStreamStore,
+  createTestableMemoryStreamStore: () => createTestableMemoryStreamStore,
+  filter: () => filter,
+  flatMap: () => flatMap,
+  flatMapAsync: () => flatMapAsync,
+  getStreamReader: () => getStreamReader,
+  isStreamBackpressureError: () => isStreamBackpressureError,
+  isStreamEnded: () => isStreamEnded,
+  isStreamReadError: () => isStreamReadError,
+  isStreamStoreError: () => isStreamStoreError,
+  isStreamWriteError: () => isStreamWriteError,
+  map: () => map,
+  mapAsync: () => mapAsync,
+  pipe: () => pipe,
+  reduce: () => reduce,
+  shouldApplyBackpressure: () => shouldApplyBackpressure,
+  skip: () => skip,
+  skipWhile: () => skipWhile,
+  streamBackpressureError: () => streamBackpressureError,
+  streamCloseError: () => streamCloseError,
+  streamEnded: () => streamEnded,
+  streamReadError: () => streamReadError,
+  streamStoreError: () => streamStoreError,
+  streamWriteError: () => streamWriteError,
+  take: () => take,
+  takeWhile: () => takeWhile,
+  toAsyncIterable: () => toAsyncIterable
+});
+module.exports = __toCommonJS(streaming_entry_exports);
+
+// src/streaming/types.ts
+var STREAM_WRITE_ERROR = "STREAM_WRITE_ERROR";
+var STREAM_READ_ERROR = "STREAM_READ_ERROR";
+var STREAM_CLOSE_ERROR = "STREAM_CLOSE_ERROR";
+var STREAM_STORE_ERROR = "STREAM_STORE_ERROR";
+var STREAM_ENDED = "STREAM_ENDED";
+var STREAM_BACKPRESSURE_ERROR = "STREAM_BACKPRESSURE_ERROR";
+function isStreamEnded(error) {
+  return typeof error === "object" && error !== null && error.type === STREAM_ENDED;
+}
+function isStreamWriteError(error) {
+  return typeof error === "object" && error !== null && error.type === STREAM_WRITE_ERROR;
+}
+function isStreamReadError(error) {
+  return typeof error === "object" && error !== null && error.type === STREAM_READ_ERROR;
+}
+function isStreamStoreError(error) {
+  return typeof error === "object" && error !== null && error.type === STREAM_STORE_ERROR;
+}
+function isStreamBackpressureError(error) {
+  return typeof error === "object" && error !== null && error.type === STREAM_BACKPRESSURE_ERROR;
+}
+function streamWriteError(reason, message, cause) {
+  return {
+    type: STREAM_WRITE_ERROR,
+    reason,
+    message,
+    ...cause !== void 0 ? { cause } : {}
+  };
+}
+function streamReadError(reason, message, cause) {
+  return {
+    type: STREAM_READ_ERROR,
+    reason,
+    message,
+    ...cause !== void 0 ? { cause } : {}
+  };
+}
+function streamCloseError(reason, message, cause) {
+  return {
+    type: STREAM_CLOSE_ERROR,
+    reason,
+    message,
+    ...cause !== void 0 ? { cause } : {}
+  };
+}
+function streamStoreError(reason, message, cause) {
+  return {
+    type: STREAM_STORE_ERROR,
+    reason,
+    message,
+    ...cause !== void 0 ? { cause } : {}
+  };
+}
+function streamEnded(finalPosition) {
+  return {
+    type: STREAM_ENDED,
+    finalPosition
+  };
+}
+function streamBackpressureError(bufferedCount, highWaterMark) {
+  return {
+    type: STREAM_BACKPRESSURE_ERROR,
+    bufferedCount,
+    highWaterMark
+  };
+}
+
+// src/streaming/backpressure.ts
+function createBackpressureController(options = {}) {
+  const highWaterMark = options.highWaterMark ?? 16;
+  const lowWaterMark = options.lowWaterMark ?? Math.floor(highWaterMark / 2);
+  const onStateChange = options.onStateChange;
+  let state = "flowing";
+  let bufferedCount = 0;
+  let drainResolvers = [];
+  function updateState(newState) {
+    if (state !== newState) {
+      state = newState;
+      onStateChange?.(newState);
+      if (newState === "flowing" && drainResolvers.length > 0) {
+        const resolvers = drainResolvers;
+        drainResolvers = [];
+        for (const resolve of resolvers) {
+          resolve();
+        }
+      }
+    }
+  }
+  function checkState() {
+    if (state === "flowing" && bufferedCount >= highWaterMark) {
+      updateState("paused");
+    } else if (state === "paused" && bufferedCount <= lowWaterMark) {
+      updateState("flowing");
+    }
+  }
+  return {
+    get state() {
+      return state;
+    },
+    get bufferedCount() {
+      return bufferedCount;
+    },
+    get highWaterMark() {
+      return highWaterMark;
+    },
+    get lowWaterMark() {
+      return lowWaterMark;
+    },
+    increment() {
+      bufferedCount++;
+      checkState();
+    },
+    decrement() {
+      if (bufferedCount > 0) {
+        bufferedCount--;
+        checkState();
+      }
+    },
+    setCount(count) {
+      bufferedCount = Math.max(0, count);
+      checkState();
+    },
+    waitForDrain() {
+      if (state === "flowing") {
+        return Promise.resolve();
+      }
+      return new Promise((resolve) => {
+        drainResolvers.push(resolve);
+      });
+    },
+    reset() {
+      bufferedCount = 0;
+      drainResolvers = [];
+      updateState("flowing");
+    }
+  };
+}
+function shouldApplyBackpressure(controller) {
+  return controller.state === "paused";
+}
+
+// src/core/index.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error, options) {
+  const cause = options?.cause;
+  return { ok: false, error, ...cause !== void 0 ? { cause } : {} };
+}
+
+// src/streaming/stores/memory.ts
+function createMemoryStreamStore(options = {}) {
+  const maxItemsPerStream = options.maxItemsPerStream ?? Infinity;
+  const streams = /* @__PURE__ */ new Map();
+  function getStreamKey(workflowId, namespace) {
+    return `${workflowId}:${namespace}`;
+  }
+  function getOrCreateStream(workflowId, namespace) {
+    const key = getStreamKey(workflowId, namespace);
+    let data = streams.get(key);
+    if (!data) {
+      data = {
+        metadata: {
+          id: key,
+          namespace,
+          workflowId,
+          length: 0,
+          closed: false,
+          createdAt: Date.now()
+        },
+        items: [],
+        subscribers: /* @__PURE__ */ new Set()
+      };
+      streams.set(key, data);
+    }
+    return data;
+  }
+  return {
+    async append(workflowId, namespace, item) {
+      try {
+        const data = getOrCreateStream(workflowId, namespace);
+        if (data.metadata.closed) {
+          return err(
+            streamStoreError("write_error", "Cannot write to closed stream")
+          );
+        }
+        if (data.items.length >= maxItemsPerStream) {
+          return err(
+            streamStoreError(
+              "write_error",
+              `Stream exceeded max items limit (${maxItemsPerStream})`
+            )
+          );
+        }
+        data.items.push(item);
+        data.metadata.length = data.items.length;
+        data.metadata.lastWriteAt = Date.now();
+        for (const callback of data.subscribers) {
+          try {
+            callback(item);
+          } catch {
+          }
+        }
+        return ok(void 0);
+      } catch (cause) {
+        return err(
+          streamStoreError("write_error", "Failed to append item", cause)
+        );
+      }
+    },
+    async read(workflowId, namespace, startIndex, limit) {
+      try {
+        const key = getStreamKey(workflowId, namespace);
+        const data = streams.get(key);
+        if (!data) {
+          return ok([]);
+        }
+        const endIndex = limit !== void 0 ? Math.min(startIndex + limit, data.items.length) : data.items.length;
+        const items = data.items.slice(startIndex, endIndex);
+        return ok(items);
+      } catch (cause) {
+        return err(streamStoreError("read_error", "Failed to read items", cause));
+      }
+    },
+    async getMetadata(workflowId, namespace) {
+      try {
+        const key = getStreamKey(workflowId, namespace);
+        const data = streams.get(key);
+        return ok(data?.metadata);
+      } catch (cause) {
+        return err(
+          streamStoreError("metadata_error", "Failed to get metadata", cause)
+        );
+      }
+    },
+    async closeStream(workflowId, namespace) {
+      try {
+        const key = getStreamKey(workflowId, namespace);
+        const data = streams.get(key);
+        if (data) {
+          data.metadata.closed = true;
+          data.metadata.closedAt = Date.now();
+        }
+        return ok(void 0);
+      } catch (cause) {
+        return err(
+          streamStoreError("close_error", "Failed to close stream", cause)
+        );
+      }
+    },
+    subscribe(workflowId, namespace, callback) {
+      const data = getOrCreateStream(workflowId, namespace);
+      const typedCallback = callback;
+      data.subscribers.add(typedCallback);
+      return () => {
+        data.subscribers.delete(typedCallback);
+      };
+    }
+  };
+}
+function createTestableMemoryStreamStore(options = {}) {
+  const streams = /* @__PURE__ */ new Map();
+  const maxItemsPerStream = options.maxItemsPerStream ?? Infinity;
+  function getStreamKey(workflowId, namespace) {
+    return `${workflowId}:${namespace}`;
+  }
+  function getOrCreateStream(workflowId, namespace) {
+    const key = getStreamKey(workflowId, namespace);
+    let data = streams.get(key);
+    if (!data) {
+      data = {
+        metadata: {
+          id: key,
+          namespace,
+          workflowId,
+          length: 0,
+          closed: false,
+          createdAt: Date.now()
+        },
+        items: [],
+        subscribers: /* @__PURE__ */ new Set()
+      };
+      streams.set(key, data);
+    }
+    return data;
+  }
+  const store = createMemoryStreamStore(options);
+  return {
+    ...store,
+    // Override to use our local streams map
+    async append(workflowId, namespace, item) {
+      try {
+        const data = getOrCreateStream(workflowId, namespace);
+        if (data.metadata.closed) {
+          return err(
+            streamStoreError("write_error", "Cannot write to closed stream")
+          );
+        }
+        if (data.items.length >= maxItemsPerStream) {
+          return err(
+            streamStoreError(
+              "write_error",
+              `Stream exceeded max items limit (${maxItemsPerStream})`
+            )
+          );
+        }
+        data.items.push(item);
+        data.metadata.length = data.items.length;
+        data.metadata.lastWriteAt = Date.now();
+        for (const callback of data.subscribers) {
+          try {
+            callback(item);
+          } catch {
+          }
+        }
+        return ok(void 0);
+      } catch (cause) {
+        return err(
+          streamStoreError("write_error", "Failed to append item", cause)
+        );
+      }
+    },
+    async read(workflowId, namespace, startIndex, limit) {
+      try {
+        const key = getStreamKey(workflowId, namespace);
+        const data = streams.get(key);
+        if (!data) {
+          return ok([]);
+        }
+        const endIndex = limit !== void 0 ? Math.min(startIndex + limit, data.items.length) : data.items.length;
+        const items = data.items.slice(startIndex, endIndex);
+        return ok(items);
+      } catch (cause) {
+        return err(streamStoreError("read_error", "Failed to read items", cause));
+      }
+    },
+    async getMetadata(workflowId, namespace) {
+      try {
+        const key = getStreamKey(workflowId, namespace);
+        const data = streams.get(key);
+        return ok(data?.metadata);
+      } catch (cause) {
+        return err(
+          streamStoreError("metadata_error", "Failed to get metadata", cause)
+        );
+      }
+    },
+    async closeStream(workflowId, namespace) {
+      try {
+        const key = getStreamKey(workflowId, namespace);
+        const data = streams.get(key);
+        if (data) {
+          data.metadata.closed = true;
+          data.metadata.closedAt = Date.now();
+        }
+        return ok(void 0);
+      } catch (cause) {
+        return err(
+          streamStoreError("close_error", "Failed to close stream", cause)
+        );
+      }
+    },
+    subscribe(workflowId, namespace, callback) {
+      const data = getOrCreateStream(workflowId, namespace);
+      const typedCallback = callback;
+      data.subscribers.add(typedCallback);
+      return () => {
+        data.subscribers.delete(typedCallback);
+      };
+    },
+    clear() {
+      streams.clear();
+    },
+    keys() {
+      return Array.from(streams.keys());
+    },
+    has(workflowId, namespace) {
+      return streams.has(getStreamKey(workflowId, namespace));
+    },
+    delete(workflowId, namespace) {
+      return streams.delete(getStreamKey(workflowId, namespace));
+    }
+  };
+}
+
+// src/streaming/stores/file.ts
+function createFileStreamStore(options) {
+  const { directory, fs } = options;
+  const subscribers = /* @__PURE__ */ new Map();
+  function getStreamDir(workflowId, namespace) {
+    return `${directory}/${workflowId}/${namespace}`;
+  }
+  function getMetadataPath(workflowId, namespace) {
+    return `${getStreamDir(workflowId, namespace)}/metadata.json`;
+  }
+  function getItemsPath(workflowId, namespace) {
+    return `${getStreamDir(workflowId, namespace)}/items.jsonl`;
+  }
+  function getSubscriberKey(workflowId, namespace) {
+    return `${workflowId}:${namespace}`;
+  }
+  async function ensureDir(workflowId, namespace) {
+    const dir = getStreamDir(workflowId, namespace);
+    await fs.mkdir(dir, { recursive: true });
+  }
+  async function readMetadata(workflowId, namespace) {
+    const metaPath = getMetadataPath(workflowId, namespace);
+    if (!await fs.exists(metaPath)) {
+      return void 0;
+    }
+    const content = await fs.readFile(metaPath);
+    return JSON.parse(content);
+  }
+  async function writeMetadata(workflowId, namespace, metadata) {
+    await ensureDir(workflowId, namespace);
+    const metaPath = getMetadataPath(workflowId, namespace);
+    await fs.writeFile(metaPath, JSON.stringify(metadata, null, 2));
+  }
+  async function appendItem(workflowId, namespace, item) {
+    await ensureDir(workflowId, namespace);
+    const itemsPath = getItemsPath(workflowId, namespace);
+    const line = JSON.stringify(item) + "\n";
+    let content = "";
+    if (await fs.exists(itemsPath)) {
+      content = await fs.readFile(itemsPath);
+    }
+    await fs.writeFile(itemsPath, content + line);
+  }
+  async function readItems(workflowId, namespace, startIndex, limit) {
+    const itemsPath = getItemsPath(workflowId, namespace);
+    if (!await fs.exists(itemsPath)) {
+      return [];
+    }
+    const content = await fs.readFile(itemsPath);
+    const lines = content.trim().split("\n").filter(Boolean);
+    const items = [];
+    for (const line of lines) {
+      const item = JSON.parse(line);
+      if (item.position >= startIndex) {
+        items.push(item);
+        if (limit !== void 0 && items.length >= limit) {
+          break;
+        }
+      }
+    }
+    return items;
+  }
+  return {
+    async append(workflowId, namespace, item) {
+      try {
+        let metadata = await readMetadata(workflowId, namespace);
+        if (!metadata) {
+          metadata = {
+            id: `${workflowId}:${namespace}`,
+            namespace,
+            workflowId,
+            length: 0,
+            closed: false,
+            createdAt: Date.now()
+          };
+        }
+        if (metadata.closed) {
+          return err(
+            streamStoreError("write_error", "Cannot write to closed stream")
+          );
+        }
+        const serializedItem = {
+          value: item.value,
+          position: item.position,
+          ts: item.ts
+        };
+        await appendItem(workflowId, namespace, serializedItem);
+        metadata.length++;
+        metadata.lastWriteAt = Date.now();
+        await writeMetadata(workflowId, namespace, metadata);
+        const key = getSubscriberKey(workflowId, namespace);
+        const subs = subscribers.get(key);
+        if (subs) {
+          for (const callback of subs) {
+            try {
+              callback(item);
+            } catch {
+            }
+          }
+        }
+        return ok(void 0);
+      } catch (cause) {
+        return err(
+          streamStoreError("write_error", "Failed to append item", cause)
+        );
+      }
+    },
+    async read(workflowId, namespace, startIndex, limit) {
+      try {
+        const serializedItems = await readItems(
+          workflowId,
+          namespace,
+          startIndex,
+          limit
+        );
+        const items = serializedItems.map((si) => ({
+          value: si.value,
+          position: si.position,
+          ts: si.ts
+        }));
+        return ok(items);
+      } catch (cause) {
+        return err(streamStoreError("read_error", "Failed to read items", cause));
+      }
+    },
+    async getMetadata(workflowId, namespace) {
+      try {
+        const meta = await readMetadata(workflowId, namespace);
+        if (!meta) {
+          return ok(void 0);
+        }
+        return ok({
+          id: meta.id,
+          namespace: meta.namespace,
+          workflowId: meta.workflowId,
+          length: meta.length,
+          closed: meta.closed,
+          createdAt: meta.createdAt,
+          lastWriteAt: meta.lastWriteAt,
+          closedAt: meta.closedAt
+        });
+      } catch (cause) {
+        return err(
+          streamStoreError("metadata_error", "Failed to get metadata", cause)
+        );
+      }
+    },
+    async closeStream(workflowId, namespace) {
+      try {
+        const metadata = await readMetadata(workflowId, namespace);
+        if (metadata) {
+          metadata.closed = true;
+          metadata.closedAt = Date.now();
+          await writeMetadata(workflowId, namespace, metadata);
+        }
+        return ok(void 0);
+      } catch (cause) {
+        return err(
+          streamStoreError("close_error", "Failed to close stream", cause)
+        );
+      }
+    },
+    subscribe(workflowId, namespace, callback) {
+      const key = getSubscriberKey(workflowId, namespace);
+      let subs = subscribers.get(key);
+      if (!subs) {
+        subs = /* @__PURE__ */ new Set();
+        subscribers.set(key, subs);
+      }
+      const typedCallback = callback;
+      subs.add(typedCallback);
+      return () => {
+        subs?.delete(typedCallback);
+        if (subs?.size === 0) {
+          subscribers.delete(key);
+        }
+      };
+    }
+  };
+}
+
+// src/streaming/transformers.ts
+async function* toAsyncIterable(reader) {
+  while (reader.readable) {
+    const result = await reader.read();
+    if (!result.ok) {
+      if (isStreamEnded(result.error)) {
+        break;
+      }
+      throw result.error;
+    }
+    yield result.value;
+  }
+}
+async function* map(source, fn) {
+  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
+  let index = 0;
+  for await (const item of iterable) {
+    yield await fn(item, index++);
+  }
+}
+async function* filter(source, predicate) {
+  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
+  let index = 0;
+  for await (const item of iterable) {
+    if (await predicate(item, index++)) {
+      yield item;
+    }
+  }
+}
+async function* chunk(source, size) {
+  if (size < 1) {
+    throw new Error("Chunk size must be at least 1");
+  }
+  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
+  let currentChunk = [];
+  for await (const item of iterable) {
+    currentChunk.push(item);
+    if (currentChunk.length >= size) {
+      yield currentChunk;
+      currentChunk = [];
+    }
+  }
+  if (currentChunk.length > 0) {
+    yield currentChunk;
+  }
+}
+async function* flatMap(source, fn) {
+  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
+  let index = 0;
+  for await (const item of iterable) {
+    const mapped = fn(item, index++);
+    if (Symbol.asyncIterator in mapped) {
+      for await (const subItem of mapped) {
+        yield subItem;
+      }
+    } else {
+      for (const subItem of mapped) {
+        yield subItem;
+      }
+    }
+  }
+}
+async function* flatMapAsync(source, fn) {
+  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
+  let index = 0;
+  for await (const item of iterable) {
+    const result = await fn(item, index++);
+    if (!result.ok) {
+      yield err(result.error);
+      return;
+    }
+    const mapped = result.value;
+    if (Symbol.asyncIterator in mapped) {
+      for await (const subItem of mapped) {
+        yield ok(subItem);
+      }
+    } else {
+      for (const subItem of mapped) {
+        yield ok(subItem);
+      }
+    }
+  }
+}
+async function* mapAsync(source, fn) {
+  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
+  let index = 0;
+  for await (const item of iterable) {
+    yield await fn(item, index++);
+  }
+}
+async function* take(source, count) {
+  if (count <= 0) return;
+  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
+  let taken = 0;
+  for await (const item of iterable) {
+    yield item;
+    taken++;
+    if (taken >= count) break;
+  }
+}
+async function* skip(source, count) {
+  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
+  let skipped = 0;
+  for await (const item of iterable) {
+    if (skipped < count) {
+      skipped++;
+      continue;
+    }
+    yield item;
+  }
+}
+async function* takeWhile(source, predicate) {
+  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
+  let index = 0;
+  for await (const item of iterable) {
+    if (!await predicate(item, index++)) break;
+    yield item;
+  }
+}
+async function* skipWhile(source, predicate) {
+  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
+  let skipping = true;
+  let index = 0;
+  for await (const item of iterable) {
+    if (skipping && await predicate(item, index++)) {
+      continue;
+    }
+    skipping = false;
+    yield item;
+  }
+}
+async function collect(source) {
+  const items = [];
+  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
+  for await (const item of iterable) {
+    items.push(item);
+  }
+  return items;
+}
+async function reduce(source, reducer, initial) {
+  let accumulator = initial;
+  const iterable = isStreamReader(source) ? toAsyncIterable(source) : source;
+  let index = 0;
+  for await (const item of iterable) {
+    accumulator = await reducer(accumulator, item, index++);
+  }
+  return accumulator;
+}
+function isStreamReader(value) {
+  return typeof value === "object" && value !== null && "read" in value && typeof value.read === "function" && "readable" in value;
+}
+function pipe(source, ...transformers) {
+  let result = isStreamReader(source) ? toAsyncIterable(source) : source;
+  for (const transformer of transformers) {
+    result = transformer(result);
+  }
+  return result;
+}
+
+// src/streaming/index.ts
+function getStreamReader(options) {
+  const {
+    store,
+    workflowId,
+    namespace = "default",
+    startIndex = 0,
+    pollInterval = 100,
+    pollTimeout = 3e4
+  } = options;
+  let position = startIndex;
+  let readable = true;
+  let closed = false;
+  let bufferedItems = [];
+  let bufferIndex = 0;
+  const reader = {
+    async read() {
+      if (closed) {
+        return err(streamReadError("closed", "Reader is closed"));
+      }
+      if (bufferIndex < bufferedItems.length) {
+        const item = bufferedItems[bufferIndex++];
+        position = item.position + 1;
+        return ok(item.value);
+      }
+      const pollStart = Date.now();
+      while (Date.now() - pollStart < pollTimeout) {
+        const result = await store.read(workflowId, namespace, position, 100);
+        if (!result.ok) {
+          return err(streamReadError("store_error", result.error.message, result.error));
+        }
+        const items = result.value;
+        if (items.length > 0) {
+          bufferedItems = items;
+          bufferIndex = 1;
+          const item = items[0];
+          position = item.position + 1;
+          return ok(item.value);
+        }
+        const metaResult = await store.getMetadata(workflowId, namespace);
+        if (metaResult.ok && metaResult.value?.closed) {
+          readable = false;
+          return err(streamEnded(position));
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      }
+      readable = false;
+      return err(streamEnded(position));
+    },
+    close() {
+      closed = true;
+      readable = false;
+      bufferedItems = [];
+    },
+    get readable() {
+      return readable;
+    },
+    get position() {
+      return position;
+    },
+    get namespace() {
+      return namespace;
+    }
+  };
+  return reader;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  STREAM_BACKPRESSURE_ERROR,
+  STREAM_CLOSE_ERROR,
+  STREAM_ENDED,
+  STREAM_READ_ERROR,
+  STREAM_STORE_ERROR,
+  STREAM_WRITE_ERROR,
+  chunk,
+  collect,
+  createBackpressureController,
+  createFileStreamStore,
+  createMemoryStreamStore,
+  createTestableMemoryStreamStore,
+  filter,
+  flatMap,
+  flatMapAsync,
+  getStreamReader,
+  isStreamBackpressureError,
+  isStreamEnded,
+  isStreamReadError,
+  isStreamStoreError,
+  isStreamWriteError,
+  map,
+  mapAsync,
+  pipe,
+  reduce,
+  shouldApplyBackpressure,
+  skip,
+  skipWhile,
+  streamBackpressureError,
+  streamCloseError,
+  streamEnded,
+  streamReadError,
+  streamStoreError,
+  streamWriteError,
+  take,
+  takeWhile,
+  toAsyncIterable
+});
+//# sourceMappingURL=streaming.cjs.map