@pretable/stream-adapter 0.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Brian Love
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,74 @@
+# @pretable/stream-adapter
+
+RAF-batched streaming integration for [pretable](https://pretable.dev/). Bridges async streams (HTTP SSE, WebSocket, partial-JSON from LLMs) into the grid with predictable per-frame batching.
+
+## When to reach for this
+
+Use `@pretable/stream-adapter` when you need to drive a grid from a live data stream and want one DOM mutation per animation frame regardless of incoming stream rate. The package ships:
+
+- A **batcher** ([`createBatcher`](#createbatcher)) that coalesces `add` / `update` / `remove` into one `applyTransaction` per RAF tick.
+- Two **connect** functions that wire an `AsyncIterable` source through the batcher into a grid.
+- Two **parse** functions that turn raw UTF-8 string streams (e.g., `fetch().body`) into typed row iterables.
+
+If you only need one-shot row mounting, use `<Pretable>` from `@pretable/react` instead — this package is for live streams.
+
+## Install
+
+```sh
+npm install @pretable/stream-adapter
+# or pnpm add @pretable/stream-adapter, yarn add @pretable/stream-adapter
+```
+
+## Minimal example — element stream
+
+```ts
+import { connectElementStream, parseElementStream } from "@pretable/stream-adapter";
+import { createGrid } from "@pretable/core";
+
+const grid = createGrid({ columns: [...], rows: [] });
+
+const response = await fetch("/api/rows");
+const stringStream = response.body!.pipeThrough(new TextDecoderStream());
+const rowStream = parseElementStream<MyRow>(stringStream);
+
+const connection = connectElementStream(grid, rowStream);
+await connection.done; // resolves when the server closes the response
+```
+
+## Minimal example — partial-update stream (e.g., LLM)
+
+When an LLM is streaming partial JSON, every chunk is an incomplete row. `connectPartialStream` upserts by row id so each chunk visibly fills out the corresponding row.
+
+```ts
+import {
+  connectPartialStream,
+  parsePartialStream,
+} from "@pretable/stream-adapter";
+
+const partialStream = parsePartialStream<MyRow>(stringStream);
+const connection = connectPartialStream(grid, partialStream, { rowId: "id" });
+```
+
+## API
+
+See **[`stream-adapter.api.md`](./stream-adapter.api.md)** for the full generated public-API report.
+
+### `createBatcher`
+
+Returns a `TransactionBatcher` that buffers add / update / remove calls and applies them once per `requestAnimationFrame`. Use directly when you have a custom stream source that doesn't fit the `connect*Stream` shape.
+
+### `connectElementStream` / `parseElementStream`
+
+`connectElementStream(grid, stream)` drives a grid from an `AsyncIterable<TRow>`. `parseElementStream(stream)` turns a string stream into an `AsyncIterable<TRow>` by parsing top-level array elements.
+
+### `connectPartialStream` / `parsePartialStream`
+
+Same shape, but for incremental field updates: `parsePartialStream` emits `Partial<TRow>` values as the streaming parser fills each element; `connectPartialStream` upserts by `options.rowId`.
+
+### Types
+
+`GridLike<TRow>` is the structural grid contract — any object with `applyTransaction({ add?, update?, remove? })` works, including a custom adapter. `TransactionBatcher<TRow>` and `StreamConnection` are the handle types returned by the constructors above. `PartialStreamOptions` is the options bag for `connectPartialStream`.
+
+## License
+
+MIT — see [LICENSE](../../LICENSE).

package/dist/index.cjs

@@ -0,0 +1,230 @@
+'use strict';
+
+var jsonStream = require('@cacheplane/json-stream');
+
+// src/create-batcher.ts
+function createBatcher(grid) {
+  let addBuffer = [];
+  let updateBuffer = [];
+  let removeBuffer = [];
+  let rafId = null;
+  let disposed = false;
+  function scheduleFlush() {
+    if (rafId !== null || disposed) return;
+    rafId = requestAnimationFrame(() => {
+      rafId = null;
+      applyBuffered();
+    });
+  }
+  function applyBuffered() {
+    if (addBuffer.length === 0 && updateBuffer.length === 0 && removeBuffer.length === 0) {
+      return;
+    }
+    const tx = {};
+    if (addBuffer.length > 0) {
+      tx.add = addBuffer;
+      addBuffer = [];
+    }
+    if (updateBuffer.length > 0) {
+      tx.update = updateBuffer;
+      updateBuffer = [];
+    }
+    if (removeBuffer.length > 0) {
+      tx.remove = removeBuffer;
+      removeBuffer = [];
+    }
+    grid.applyTransaction(tx);
+  }
+  return {
+    add(rows) {
+      if (disposed) return;
+      addBuffer.push(...rows);
+      scheduleFlush();
+    },
+    update(patches) {
+      if (disposed) return;
+      updateBuffer.push(...patches);
+      scheduleFlush();
+    },
+    remove(ids) {
+      if (disposed) return;
+      removeBuffer.push(...ids);
+      scheduleFlush();
+    },
+    flush() {
+      if (disposed) return;
+      if (rafId !== null) {
+        cancelAnimationFrame(rafId);
+        rafId = null;
+      }
+      applyBuffered();
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      if (rafId !== null) {
+        cancelAnimationFrame(rafId);
+        rafId = null;
+      }
+      addBuffer = [];
+      updateBuffer = [];
+      removeBuffer = [];
+    }
+  };
+}
+
+// src/connect-element-stream.ts
+function connectElementStream(grid, stream) {
+  const batcher = createBatcher(grid);
+  let disposed = false;
+  let resolveDone;
+  let rejectDone;
+  const done = new Promise((resolve, reject) => {
+    resolveDone = resolve;
+    rejectDone = reject;
+  });
+  done.catch(() => void 0);
+  (async () => {
+    try {
+      for await (const element of stream) {
+        if (disposed) break;
+        batcher.add([element]);
+      }
+      batcher.flush();
+      batcher.dispose();
+      resolveDone();
+    } catch (err) {
+      batcher.flush();
+      batcher.dispose();
+      rejectDone(err);
+    }
+  })();
+  return {
+    done,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      batcher.flush();
+      batcher.dispose();
+      resolveDone();
+    }
+  };
+}
+
+// src/connect-partial-stream.ts
+function connectPartialStream(grid, stream, options) {
+  const batcher = createBatcher(grid);
+  let disposed = false;
+  let resolveDone;
+  let rejectDone;
+  const done = new Promise((resolve, reject) => {
+    resolveDone = resolve;
+    rejectDone = reject;
+  });
+  done.catch(() => void 0);
+  (async () => {
+    try {
+      for await (const partial of stream) {
+        if (disposed) break;
+        batcher.update([{ ...partial, id: options.rowId }]);
+      }
+      batcher.flush();
+      batcher.dispose();
+      resolveDone();
+    } catch (err) {
+      batcher.flush();
+      batcher.dispose();
+      rejectDone(err);
+    }
+  })();
+  return {
+    done,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      batcher.flush();
+      batcher.dispose();
+      resolveDone();
+    }
+  };
+}
+async function* parseElementStream(stream) {
+  let state = jsonStream.create();
+  let yieldedCount = 0;
+  for await (const chunk of stream) {
+    state = jsonStream.push(state, chunk);
+    if (state.error) {
+      throw new Error(state.error.message);
+    }
+    if (state.rootId !== null) {
+      const root = state.nodes[state.rootId];
+      if (!jsonStream.isArrayNode(root)) {
+        throw new Error(
+          `parseElementStream expects root to be an array, got "${root.kind}"`
+        );
+      }
+      while (yieldedCount < root.children.length) {
+        const childNode = state.nodes[root.children[yieldedCount]];
+        if (!jsonStream.isComplete(childNode)) break;
+        if (childNode.value !== void 0) {
+          yield childNode.value;
+        }
+        yieldedCount++;
+      }
+    }
+  }
+  state = jsonStream.finish(state);
+  if (state.error) {
+    throw new Error(state.error.message);
+  }
+  if (state.rootId !== null) {
+    const root = state.nodes[state.rootId];
+    if (jsonStream.isArrayNode(root)) {
+      while (yieldedCount < root.children.length) {
+        const childNode = state.nodes[root.children[yieldedCount]];
+        if (jsonStream.isComplete(childNode) && childNode.value !== void 0) {
+          yield childNode.value;
+        }
+        yieldedCount++;
+      }
+    }
+  }
+}
+async function* parsePartialStream(stream) {
+  let state = jsonStream.create();
+  let lastValue;
+  for await (const chunk of stream) {
+    state = jsonStream.push(state, chunk);
+    if (state.error) {
+      throw new Error(state.error.message);
+    }
+    if (state.rootId !== null) {
+      const root = state.nodes[state.rootId];
+      if (!jsonStream.isObjectNode(root)) {
+        throw new Error(
+          `parsePartialStream expects root to be an object, got "${root.kind}"`
+        );
+      }
+      if (root.value !== void 0 && root.value !== lastValue && Object.keys(root.value).length > 0) {
+        lastValue = root.value;
+        yield root.value;
+      }
+    }
+  }
+  state = jsonStream.finish(state);
+  if (state.error) {
+    throw new Error(state.error.message);
+  }
+  if (state.rootId !== null) {
+    const root = state.nodes[state.rootId];
+    if (jsonStream.isObjectNode(root) && root.value !== void 0 && root.value !== lastValue && Object.keys(root.value).length > 0) {
+      yield root.value;
+    }
+  }
+}
+
+exports.connectElementStream = connectElementStream;
+exports.connectPartialStream = connectPartialStream;
+exports.createBatcher = createBatcher;
+exports.parseElementStream = parseElementStream;
+exports.parsePartialStream = parsePartialStream;

package/dist/index.d.cts

@@ -0,0 +1,129 @@
+/**
+ * Structural type for any grid that supports `applyTransaction`. Avoids
+ * hard coupling to `@pretable-internal/grid-core` so consumers can wire
+ * up streaming against a custom grid implementation that conforms to the
+ * same shape.
+ *
+ * @public
+ */
+interface GridLike<TRow extends Record<string, unknown>> {
+    applyTransaction(transaction: {
+        add?: TRow[];
+        update?: Partial<TRow>[];
+        remove?: string[];
+    }): void;
+}
+/**
+ * RAF-batched mutator returned by {@link createBatcher}. Buffer
+ * `add` / `update` / `remove` calls; the batcher coalesces them into a
+ * single `applyTransaction` per animation frame. `flush()` forces an
+ * immediate apply; `dispose()` cancels any pending RAF and stops
+ * accepting new calls.
+ *
+ * @public
+ */
+interface TransactionBatcher<TRow extends Record<string, unknown>> {
+    add(rows: TRow[]): void;
+    update(patches: Partial<TRow>[]): void;
+    remove(ids: string[]): void;
+    flush(): void;
+    dispose(): void;
+}
+/**
+ * Handle returned by the `connect*Stream` functions. `done` resolves
+ * when the source stream ends (or rejects on stream error); `dispose()`
+ * cancels the active read loop and resolves `done` immediately.
+ *
+ * @public
+ */
+interface StreamConnection {
+    done: Promise<void>;
+    dispose(): void;
+}
+
+/**
+ * Create a `requestAnimationFrame`-batched mutator that coalesces
+ * `add` / `update` / `remove` calls into a single `applyTransaction` per
+ * frame. Use this when driving a grid from a stream that emits faster
+ * than the browser can render — batching keeps DOM mutations to one per
+ * frame regardless of stream rate.
+ *
+ * @example
+ * ```ts
+ * const batcher = createBatcher(grid);
+ * batcher.add([{ id: "1", name: "Ada" }]);
+ * batcher.update([{ id: "1", age: 36 }]);
+ * batcher.flush(); // optional — RAF will flush automatically
+ * ```
+ *
+ * @public
+ */
+declare function createBatcher<TRow extends Record<string, unknown>>(grid: GridLike<TRow>): TransactionBatcher<TRow>;
+
+/**
+ * Drive a grid from an `AsyncIterable<TRow>`. Each yielded row is added
+ * via a {@link createBatcher | RAF batcher}; the returned
+ * {@link StreamConnection} resolves `done` when the stream ends and
+ * supports `dispose()` for early cancellation.
+ *
+ * Pair with {@link parseElementStream} to turn a raw UTF-8 string stream
+ * (e.g., from `fetch().body`) into a row stream end-to-end.
+ *
+ * @public
+ */
+declare function connectElementStream<TRow extends Record<string, unknown>>(grid: GridLike<TRow>, stream: AsyncIterable<TRow>): StreamConnection;
+
+/**
+ * Options for {@link connectPartialStream}. `rowId` names the field on
+ * each partial row used to identify it for upsert (the field must be
+ * present in every emitted partial — partials missing the rowId are
+ * ignored).
+ *
+ * @public
+ */
+interface PartialStreamOptions {
+    rowId: string;
+}
+/**
+ * Drive a grid from an `AsyncIterable<Partial<TRow>>`. Each yielded
+ * partial is upserted by `options.rowId` — new rowIds are added,
+ * existing rowIds are merged via `applyTransaction.update`. Useful when
+ * a stream emits incremental field updates (e.g., partial JSON parses)
+ * rather than complete rows.
+ *
+ * Pair with {@link parsePartialStream} for end-to-end partial-update
+ * streaming over UTF-8 strings.
+ *
+ * @public
+ */
+declare function connectPartialStream<TRow extends Record<string, unknown> & {
+    id: string;
+}>(grid: GridLike<TRow>, stream: AsyncIterable<Partial<TRow>>, options: PartialStreamOptions): StreamConnection;
+
+/**
+ * Parse a UTF-8 string stream into an `AsyncIterable<TRow>`. Built on
+ * `@cacheplane/json-stream`'s incremental JSON parser; emits each
+ * complete top-level array element as a typed row.
+ *
+ * Pair with {@link connectElementStream} for end-to-end element-stream
+ * → grid wiring.
+ *
+ * @public
+ */
+declare function parseElementStream<TRow>(stream: AsyncIterable<string>): AsyncIterable<TRow>;
+
+/**
+ * Parse a UTF-8 string stream into an `AsyncIterable<Partial<TRow>>`.
+ * Emits incremental partial rows as a streaming JSON parse fills out
+ * each top-level array element — useful when an LLM is streaming
+ * partial JSON and you want field-by-field updates instead of waiting
+ * for each row to complete.
+ *
+ * Pair with {@link connectPartialStream} for end-to-end partial-stream
+ * → grid wiring.
+ *
+ * @public
+ */
+declare function parsePartialStream<TRow>(stream: AsyncIterable<string>): AsyncIterable<Partial<TRow>>;
+
+export { type GridLike, type PartialStreamOptions, type StreamConnection, type TransactionBatcher, connectElementStream, connectPartialStream, createBatcher, parseElementStream, parsePartialStream };

package/dist/index.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Structural type for any grid that supports `applyTransaction`. Avoids
+ * hard coupling to `@pretable-internal/grid-core` so consumers can wire
+ * up streaming against a custom grid implementation that conforms to the
+ * same shape.
+ *
+ * @public
+ */
+interface GridLike<TRow extends Record<string, unknown>> {
+    applyTransaction(transaction: {
+        add?: TRow[];
+        update?: Partial<TRow>[];
+        remove?: string[];
+    }): void;
+}
+/**
+ * RAF-batched mutator returned by {@link createBatcher}. Buffer
+ * `add` / `update` / `remove` calls; the batcher coalesces them into a
+ * single `applyTransaction` per animation frame. `flush()` forces an
+ * immediate apply; `dispose()` cancels any pending RAF and stops
+ * accepting new calls.
+ *
+ * @public
+ */
+interface TransactionBatcher<TRow extends Record<string, unknown>> {
+    add(rows: TRow[]): void;
+    update(patches: Partial<TRow>[]): void;
+    remove(ids: string[]): void;
+    flush(): void;
+    dispose(): void;
+}
+/**
+ * Handle returned by the `connect*Stream` functions. `done` resolves
+ * when the source stream ends (or rejects on stream error); `dispose()`
+ * cancels the active read loop and resolves `done` immediately.
+ *
+ * @public
+ */
+interface StreamConnection {
+    done: Promise<void>;
+    dispose(): void;
+}
+
+/**
+ * Create a `requestAnimationFrame`-batched mutator that coalesces
+ * `add` / `update` / `remove` calls into a single `applyTransaction` per
+ * frame. Use this when driving a grid from a stream that emits faster
+ * than the browser can render — batching keeps DOM mutations to one per
+ * frame regardless of stream rate.
+ *
+ * @example
+ * ```ts
+ * const batcher = createBatcher(grid);
+ * batcher.add([{ id: "1", name: "Ada" }]);
+ * batcher.update([{ id: "1", age: 36 }]);
+ * batcher.flush(); // optional — RAF will flush automatically
+ * ```
+ *
+ * @public
+ */
+declare function createBatcher<TRow extends Record<string, unknown>>(grid: GridLike<TRow>): TransactionBatcher<TRow>;
+
+/**
+ * Drive a grid from an `AsyncIterable<TRow>`. Each yielded row is added
+ * via a {@link createBatcher | RAF batcher}; the returned
+ * {@link StreamConnection} resolves `done` when the stream ends and
+ * supports `dispose()` for early cancellation.
+ *
+ * Pair with {@link parseElementStream} to turn a raw UTF-8 string stream
+ * (e.g., from `fetch().body`) into a row stream end-to-end.
+ *
+ * @public
+ */
+declare function connectElementStream<TRow extends Record<string, unknown>>(grid: GridLike<TRow>, stream: AsyncIterable<TRow>): StreamConnection;
+
+/**
+ * Options for {@link connectPartialStream}. `rowId` names the field on
+ * each partial row used to identify it for upsert (the field must be
+ * present in every emitted partial — partials missing the rowId are
+ * ignored).
+ *
+ * @public
+ */
+interface PartialStreamOptions {
+    rowId: string;
+}
+/**
+ * Drive a grid from an `AsyncIterable<Partial<TRow>>`. Each yielded
+ * partial is upserted by `options.rowId` — new rowIds are added,
+ * existing rowIds are merged via `applyTransaction.update`. Useful when
+ * a stream emits incremental field updates (e.g., partial JSON parses)
+ * rather than complete rows.
+ *
+ * Pair with {@link parsePartialStream} for end-to-end partial-update
+ * streaming over UTF-8 strings.
+ *
+ * @public
+ */
+declare function connectPartialStream<TRow extends Record<string, unknown> & {
+    id: string;
+}>(grid: GridLike<TRow>, stream: AsyncIterable<Partial<TRow>>, options: PartialStreamOptions): StreamConnection;
+
+/**
+ * Parse a UTF-8 string stream into an `AsyncIterable<TRow>`. Built on
+ * `@cacheplane/json-stream`'s incremental JSON parser; emits each
+ * complete top-level array element as a typed row.
+ *
+ * Pair with {@link connectElementStream} for end-to-end element-stream
+ * → grid wiring.
+ *
+ * @public
+ */
+declare function parseElementStream<TRow>(stream: AsyncIterable<string>): AsyncIterable<TRow>;
+
+/**
+ * Parse a UTF-8 string stream into an `AsyncIterable<Partial<TRow>>`.
+ * Emits incremental partial rows as a streaming JSON parse fills out
+ * each top-level array element — useful when an LLM is streaming
+ * partial JSON and you want field-by-field updates instead of waiting
+ * for each row to complete.
+ *
+ * Pair with {@link connectPartialStream} for end-to-end partial-stream
+ * → grid wiring.
+ *
+ * @public
+ */
+declare function parsePartialStream<TRow>(stream: AsyncIterable<string>): AsyncIterable<Partial<TRow>>;
+
+export { type GridLike, type PartialStreamOptions, type StreamConnection, type TransactionBatcher, connectElementStream, connectPartialStream, createBatcher, parseElementStream, parsePartialStream };

package/dist/index.mjs

@@ -0,0 +1,224 @@
+import { create, push, isArrayNode, isComplete, finish, isObjectNode } from '@cacheplane/json-stream';
+
+// src/create-batcher.ts
+function createBatcher(grid) {
+  let addBuffer = [];
+  let updateBuffer = [];
+  let removeBuffer = [];
+  let rafId = null;
+  let disposed = false;
+  function scheduleFlush() {
+    if (rafId !== null || disposed) return;
+    rafId = requestAnimationFrame(() => {
+      rafId = null;
+      applyBuffered();
+    });
+  }
+  function applyBuffered() {
+    if (addBuffer.length === 0 && updateBuffer.length === 0 && removeBuffer.length === 0) {
+      return;
+    }
+    const tx = {};
+    if (addBuffer.length > 0) {
+      tx.add = addBuffer;
+      addBuffer = [];
+    }
+    if (updateBuffer.length > 0) {
+      tx.update = updateBuffer;
+      updateBuffer = [];
+    }
+    if (removeBuffer.length > 0) {
+      tx.remove = removeBuffer;
+      removeBuffer = [];
+    }
+    grid.applyTransaction(tx);
+  }
+  return {
+    add(rows) {
+      if (disposed) return;
+      addBuffer.push(...rows);
+      scheduleFlush();
+    },
+    update(patches) {
+      if (disposed) return;
+      updateBuffer.push(...patches);
+      scheduleFlush();
+    },
+    remove(ids) {
+      if (disposed) return;
+      removeBuffer.push(...ids);
+      scheduleFlush();
+    },
+    flush() {
+      if (disposed) return;
+      if (rafId !== null) {
+        cancelAnimationFrame(rafId);
+        rafId = null;
+      }
+      applyBuffered();
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      if (rafId !== null) {
+        cancelAnimationFrame(rafId);
+        rafId = null;
+      }
+      addBuffer = [];
+      updateBuffer = [];
+      removeBuffer = [];
+    }
+  };
+}
+
+// src/connect-element-stream.ts
+function connectElementStream(grid, stream) {
+  const batcher = createBatcher(grid);
+  let disposed = false;
+  let resolveDone;
+  let rejectDone;
+  const done = new Promise((resolve, reject) => {
+    resolveDone = resolve;
+    rejectDone = reject;
+  });
+  done.catch(() => void 0);
+  (async () => {
+    try {
+      for await (const element of stream) {
+        if (disposed) break;
+        batcher.add([element]);
+      }
+      batcher.flush();
+      batcher.dispose();
+      resolveDone();
+    } catch (err) {
+      batcher.flush();
+      batcher.dispose();
+      rejectDone(err);
+    }
+  })();
+  return {
+    done,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      batcher.flush();
+      batcher.dispose();
+      resolveDone();
+    }
+  };
+}
+
+// src/connect-partial-stream.ts
+function connectPartialStream(grid, stream, options) {
+  const batcher = createBatcher(grid);
+  let disposed = false;
+  let resolveDone;
+  let rejectDone;
+  const done = new Promise((resolve, reject) => {
+    resolveDone = resolve;
+    rejectDone = reject;
+  });
+  done.catch(() => void 0);
+  (async () => {
+    try {
+      for await (const partial of stream) {
+        if (disposed) break;
+        batcher.update([{ ...partial, id: options.rowId }]);
+      }
+      batcher.flush();
+      batcher.dispose();
+      resolveDone();
+    } catch (err) {
+      batcher.flush();
+      batcher.dispose();
+      rejectDone(err);
+    }
+  })();
+  return {
+    done,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      batcher.flush();
+      batcher.dispose();
+      resolveDone();
+    }
+  };
+}
+async function* parseElementStream(stream) {
+  let state = create();
+  let yieldedCount = 0;
+  for await (const chunk of stream) {
+    state = push(state, chunk);
+    if (state.error) {
+      throw new Error(state.error.message);
+    }
+    if (state.rootId !== null) {
+      const root = state.nodes[state.rootId];
+      if (!isArrayNode(root)) {
+        throw new Error(
+          `parseElementStream expects root to be an array, got "${root.kind}"`
+        );
+      }
+      while (yieldedCount < root.children.length) {
+        const childNode = state.nodes[root.children[yieldedCount]];
+        if (!isComplete(childNode)) break;
+        if (childNode.value !== void 0) {
+          yield childNode.value;
+        }
+        yieldedCount++;
+      }
+    }
+  }
+  state = finish(state);
+  if (state.error) {
+    throw new Error(state.error.message);
+  }
+  if (state.rootId !== null) {
+    const root = state.nodes[state.rootId];
+    if (isArrayNode(root)) {
+      while (yieldedCount < root.children.length) {
+        const childNode = state.nodes[root.children[yieldedCount]];
+        if (isComplete(childNode) && childNode.value !== void 0) {
+          yield childNode.value;
+        }
+        yieldedCount++;
+      }
+    }
+  }
+}
+async function* parsePartialStream(stream) {
+  let state = create();
+  let lastValue;
+  for await (const chunk of stream) {
+    state = push(state, chunk);
+    if (state.error) {
+      throw new Error(state.error.message);
+    }
+    if (state.rootId !== null) {
+      const root = state.nodes[state.rootId];
+      if (!isObjectNode(root)) {
+        throw new Error(
+          `parsePartialStream expects root to be an object, got "${root.kind}"`
+        );
+      }
+      if (root.value !== void 0 && root.value !== lastValue && Object.keys(root.value).length > 0) {
+        lastValue = root.value;
+        yield root.value;
+      }
+    }
+  }
+  state = finish(state);
+  if (state.error) {
+    throw new Error(state.error.message);
+  }
+  if (state.rootId !== null) {
+    const root = state.nodes[state.rootId];
+    if (isObjectNode(root) && root.value !== void 0 && root.value !== lastValue && Object.keys(root.value).length > 0) {
+      yield root.value;
+    }
+  }
+}
+
+export { connectElementStream, connectPartialStream, createBatcher, parseElementStream, parsePartialStream };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@pretable/stream-adapter",
+  "version": "0.0.3",
+  "description": "Streaming row adapters for Pretable.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cacheplane/pretable.git",
+    "directory": "packages/stream-adapter"
+  },
+  "homepage": "https://pretable.ai/docs/streaming",
+  "bugs": {
+    "url": "https://github.com/cacheplane/pretable/issues"
+  },
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "dependencies": {
+    "@cacheplane/json-stream": "0.0.3"
+  },
+  "scripts": {
+    "api": "api-extractor run --local --config api-extractor.json",
+    "api:check": "api-extractor run --config api-extractor.json",
+    "build": "pnpm --filter @cacheplane/json-stream build && tsup",
+    "lint": "eslint src --ext .ts",
+    "lint:packaging": "publint --strict && attw --pack",
+    "test": "pnpm --filter @cacheplane/json-stream build && vitest run --passWithNoTests",
+    "typecheck": "pnpm --filter @cacheplane/json-stream build && tsc -b --pretty false"
+  }
+}