@statewalker/webrun-streams 0.1.1 → 0.2.1

package/dist/{index.mjs → index.js}

@@ -29,6 +29,19 @@ async function collectString(input) {
 	return result;
 }
 //#endregion
+//#region src/duplex.ts
+/**
+* Thrown by `emulateMux` and adapters when the underlying transport closes
+* while one or more `Duplex` calls are in flight. Consumers can catch by
+* `instanceof TransportClosedError` or by checking `error.name`.
+*/
+var TransportClosedError = class extends Error {
+	name = "TransportClosedError";
+	constructor(message = "transport closed") {
+		super(message);
+	}
+};
+//#endregion
 //#region src/errors.ts
 function serializeError(error) {
 	if (error instanceof Error) {
@@ -54,18 +67,118 @@ function deserializeError(error) {
 	return Object.assign(new Error(payload.message), payload);
 }
 //#endregion
-//#region src/emulate-mux.ts
+//#region src/flow-control.ts
+function newCreditLedger(initial = 0) {
+	let available = initial;
+	let failure;
+	const waiters = [];
+	const pump = () => {
+		while (waiters.length > 0 && available > 0) {
+			const next = waiters[0];
+			if (!next) return;
+			waiters.shift();
+			const granted = Math.min(next.upTo, available);
+			available -= granted;
+			next.resolve(granted);
+		}
+	};
+	return {
+		get available() {
+			return available;
+		},
+		reserve(upTo) {
+			if (failure) return Promise.reject(failure);
+			if (!(upTo >= 1)) return Promise.reject(/* @__PURE__ */ new RangeError(`newCreditLedger: reserve(${upTo}) — upTo must be at least 1`));
+			if (waiters.length === 0 && available > 0) {
+				const granted = Math.min(upTo, available);
+				available -= granted;
+				return Promise.resolve(granted);
+			}
+			return new Promise((resolve, reject) => {
+				waiters.push({
+					upTo,
+					resolve,
+					reject
+				});
+			});
+		},
+		grant(units) {
+			if (failure) return;
+			available += units;
+			pump();
+		},
+		fail(err) {
+			failure ??= err;
+			while (waiters.length > 0) waiters.shift()?.reject(err);
+		}
+	};
+}
 /**
-* Thrown by `emulateMux` and adapters when the underlying transport closes
-* while one or more `Duplex` calls are in flight. Consumers can catch by
-* `instanceof TransportClosedError` or by checking `error.name`.
+* Grants are batched: replenishing on every chunk while the receiver is
+* behind would reinvent the per-frame ACK this change exists to remove.
+* `threshold` is the fraction of the window that must drain before a grant is
+* emitted.
+*
+* The batch is flushed unconditionally once the receive queue is empty, even
+* below the threshold, so the receiver never sits on credit it owes. Note what
+* this is and is not: paired with a {@link CreditLedger}, a sender blocks only
+* at *exactly* zero credit, and at that point the receiver holds the entire
+* window as `pending` — above any threshold at or below the whole window — so
+* the threshold alone cannot deadlock that pairing. The flush is what keeps
+* that from being an argument about a global accounting identity: it is
+* locally decidable from one boolean, and it returns owed credit now rather
+* than at the next threshold crossing. It costs an extra frame only when the
+* consumer is keeping pace, which is exactly when the sender is not blocked
+* and the frame is cheap.
 */
-var TransportClosedError = class extends Error {
-	name = "TransportClosedError";
-	constructor(message = "transport closed") {
-		super(message);
-	}
-};
+function newCreditGrantor(window, threshold = .5) {
+	const trigger = Math.max(1, Math.floor(window * threshold));
+	let pending = 0;
+	return { consumed(units, queueEmpty) {
+		pending += units;
+		if (pending === 0) return 0;
+		if (pending < trigger && !queueEmpty) return 0;
+		const grant = pending;
+		pending = 0;
+		return grant;
+	} };
+}
+//#endregion
+//#region src/uint32.ts
+/**
+* Credit payloads are a single big-endian uint32, matching the frame header's
+* byte order.
+*
+* Deliberately **not** re-exported from `index.ts`: this is an internal codec
+* for the `emulateMux` wire format, not a compatibility commitment. Tests
+* import it by path.
+*/
+/** The largest credit a single frame can advertise or grant: 2^32 - 1. */
+const MAX_UINT32 = 4294967295;
+/**
+* Clamps rather than wraps. `n >>> 0` is the obvious spelling and it is wrong
+* here: 2^32 becomes **0**, so a 4 GiB window advertises *zero credit* and the
+* peer stalls forever with no error — the exact silent hang credit exists to
+* remove. 2^32 + 5 becomes 5, which looks like a working window and is worse.
+* Anything above the ceiling is advertised as the ceiling.
+*/
+function encodeUint32(n) {
+	const bytes = /* @__PURE__ */ new Uint8Array(4);
+	const clamped = Number.isFinite(n) ? Math.min(MAX_UINT32, Math.max(0, Math.floor(n))) : 0;
+	new DataView(bytes.buffer).setUint32(0, clamped, false);
+	return bytes;
+}
+/**
+* Returns `undefined` rather than a garbage number when the payload is too
+* short, so a truncated frame — or one from a peer predating credit — is
+* detectable at the call site instead of silently granting nonsense.
+*/
+function decodeUint32(bytes) {
+	if (bytes.byteLength < 4) return void 0;
+	return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(0, false);
+}
+//#endregion
+//#region src/emulate-mux.ts
 const TYPE_OPEN = 1;
 const TYPE_DATA = 2;
 const TYPE_ACK = 3;
@@ -81,6 +194,7 @@ function emulateMux(channel, opts = {}) {
 	const maxStreams = opts.maxStreams ?? DEFAULT_MAX_STREAMS;
 	const mtu = opts.mtu ?? DEFAULT_MTU;
 	const maxStreamBuffer = opts.maxStreamBuffer ?? DEFAULT_MAX_STREAM_BUFFER;
+	if (!(maxStreamBuffer >= 1)) throw new RangeError(`emulateMux: maxStreamBuffer must be at least 1, got ${maxStreamBuffer}`);
 	const side = opts.side ?? "initiator";
 	const streams = /* @__PURE__ */ new Map();
 	let nextLocalId = side === "initiator" ? 2 : 1;
@@ -101,13 +215,9 @@ function emulateMux(channel, opts = {}) {
 	const teardownStream = (s, err) => {
 		if (s.closed) return;
 		s.closed = true;
-		const resolve = s.resolveAck;
-		const reject = s.rejectAck;
-		s.resolveAck = null;
-		s.rejectAck = null;
-		if (reject && err) reject(err);
-		else resolve?.();
+		s.outboundCredit.fail(err ?? new TransportClosedError("emulateMux: stream closed"));
 		s.doneIn(err);
+		s.cancelInput?.();
 		streams.delete(s.id);
 	};
 	/**
@@ -141,8 +251,8 @@ function emulateMux(channel, opts = {}) {
 			}),
 			pushIn: queue.push,
 			doneIn: queue.done,
-			resolveAck: null,
-			rejectAck: null,
+			outboundCredit: newCreditLedger(0),
+			grantor: newCreditGrantor(maxStreamBuffer),
 			closed: false,
 			inDone: false,
 			outDone: false,
@@ -151,20 +261,24 @@ function emulateMux(channel, opts = {}) {
 		return state;
 	};
 	const pumpOutbound = async (s, input) => {
+		const iterator = input[Symbol.asyncIterator]?.() ?? input[Symbol.iterator]();
+		s.cancelInput = () => {
+			iterator.return?.(void 0);
+		};
 		try {
-			for await (const chunk of input) {
+			for (;;) {
+				const next = await iterator.next();
+				if (next.done === true) break;
+				const chunk = next.value;
 				if (s.closed || muxClosed) return;
 				if (chunk.byteLength === 0) continue;
 				let off = 0;
 				while (off < chunk.byteLength) {
 					if (s.closed || muxClosed) return;
-					const end = Math.min(off + mtu, chunk.byteLength);
-					const piece = chunk.subarray(off, end);
-					sendFrame(s.id, TYPE_DATA, piece);
-					await new Promise((resolve, reject) => {
-						s.resolveAck = resolve;
-						s.rejectAck = reject;
-					});
+					const take = await s.outboundCredit.reserve(Math.min(mtu, chunk.byteLength - off));
+					if (s.closed || muxClosed) return;
+					const end = off + take;
+					sendFrame(s.id, TYPE_DATA, chunk.subarray(off, end));
 					off = end;
 				}
 			}
@@ -222,6 +336,9 @@ function emulateMux(channel, opts = {}) {
 			}
 			const s = createStream(id);
 			streams.set(id, s);
+			const advertised = decodeUint32(payload);
+			if (advertised !== void 0) s.outboundCredit.grant(advertised);
+			sendFrame(id, TYPE_ACK, encodeUint32(maxStreamBuffer));
 			runHandler(s, handler);
 			return;
 		}
@@ -239,15 +356,15 @@ function emulateMux(channel, opts = {}) {
 				const copy = payload.byteLength === 0 ? payload : new Uint8Array(payload);
 				s.pushIn(copy).then((handled) => {
 					s.queuedBytes -= copy.byteLength;
-					if (handled && !s.closed && !muxClosed) sendFrame(id, TYPE_ACK);
+					if (!handled || s.closed || muxClosed) return;
+					const grant = s.grantor.consumed(copy.byteLength, s.queuedBytes === 0);
+					if (grant > 0) sendFrame(id, TYPE_ACK, encodeUint32(grant));
 				});
 				return;
 			}
 			case TYPE_ACK: {
-				const r = s.resolveAck;
-				s.resolveAck = null;
-				s.rejectAck = null;
-				r?.();
+				const granted = decodeUint32(payload);
+				if (granted !== void 0) s.outboundCredit.grant(granted);
 				return;
 			}
 			case TYPE_END:
@@ -284,7 +401,7 @@ function emulateMux(channel, opts = {}) {
 		nextLocalId += 2;
 		const s = createStream(id);
 		streams.set(id, s);
-		sendFrame(id, TYPE_OPEN);
+		sendFrame(id, TYPE_OPEN, encodeUint32(maxStreamBuffer));
 		pumpOutbound(s, input);
 		return s.inbound;
 	};
@@ -641,30 +758,63 @@ function describe(value) {
 }
 //#endregion
 //#region src/readable-streams.ts
+/**
+* The iterator ↔ `ReadableStream` boundary.
+*
+* Both adapters must carry CANCELLATION, not just data: a response body leaves
+* a handler as a `ReadableStream`, crosses a transport as an iterator, and
+* becomes a `ReadableStream` again at the caller — so when the caller walks
+* away, the only path back to the handler's producer runs through both of
+* these functions. Teardown that stops at an adapter leaves a producer running
+* for ever.
+*/
 function toReadableStream(it) {
-	return new ReadableStream({ async pull(controller) {
-		let handled = false;
-		try {
-			while (true) {
+	return new ReadableStream({
+		/**
+		* One chunk per pull. An earlier version drained the whole iterator inside
+		* a single `pull`, which defeated the stream's own backpressure (every
+		* chunk was enqueued as fast as the producer could make them, however slow
+		* the reader was) and left no point between chunks at which a cancellation
+		* could take effect.
+		*/
+		async pull(controller) {
+			try {
 				const slot = await it.next();
-				if (!slot || slot.done) break;
-				const value = await slot.value;
-				controller.enqueue(value);
+				if (!slot || slot.done) {
+					controller.close();
+					return;
+				}
+				controller.enqueue(await slot.value);
+			} catch (error) {
+				controller.error(error);
 			}
-		} catch (error) {
-			handled = true;
-			controller.error(error);
-		} finally {
-			if (!handled) controller.close();
+		},
+		/**
+		* Release the source. NOT awaited: `.return()` on an async generator that
+		* is parked awaiting its own source is queued behind that pending
+		* `next()`, so awaiting it here would hang `reader.cancel()` on exactly
+		* the producers that most need cancelling.
+		*/
+		cancel(reason) {
+			Promise.resolve(it.return?.(reason)).catch(() => {});
 		}
-	} });
+	});
 }
 async function* fromReadableStream(stream) {
 	const reader = stream.getReader();
-	while (true) {
-		const { done, value } = await reader.read();
-		if (done) break;
-		if (value !== void 0) yield value;
+	let drained = false;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) {
+				drained = true;
+				break;
+			}
+			if (value !== void 0) yield value;
+		}
+	} finally {
+		if (drained) reader.releaseLock();
+		else await reader.cancel().catch(() => {});
 	}
 }
 //#endregion
@@ -764,6 +914,4 @@ function toChunks(size = DEFAULT_CHUNK_SIZE) {
 	};
 }
 //#endregion
-export { TransportClosedError, collect, collectBytes, collectString, decodeJsonl, decodeText, deserializeError, emulateMux, encodeJsonl, encodeText, fromReadableStream, joinLines, map, newAsyncGenerator, normalizeToUint8Array, recieveIterator, sendIterator, serializeError, splitLines, toChunks, toReadableStream };
-
-//# sourceMappingURL=index.mjs.map
+export { TransportClosedError, collect, collectBytes, collectString, decodeJsonl, decodeText, deserializeError, emulateMux, encodeJsonl, encodeText, fromReadableStream, joinLines, map, newAsyncGenerator, newCreditGrantor, newCreditLedger, normalizeToUint8Array, recieveIterator, sendIterator, serializeError, splitLines, toChunks, toReadableStream };

package/dist/jsonl.d.ts

@@ -0,0 +1,5 @@
+/** Encode each value as a JSON line (terminated by \n). */
+export declare function encodeJsonl<T>(input: AsyncIterable<T>): AsyncGenerator<string>;
+/** Decode each line as a JSON value. Skips empty lines. */
+export declare function decodeJsonl<T>(input: AsyncIterable<string>): AsyncGenerator<T>;
+//# sourceMappingURL=jsonl.d.ts.map

package/dist/jsonl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl.d.ts","sourceRoot":"","sources":["../src/jsonl.ts"],"names":[],"mappings":"AAGA,2DAA2D;AAC3D,wBAAuB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,CAErF;AAED,2DAA2D;AAC3D,wBAAuB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAKrF"}

package/dist/lines.d.ts

@@ -0,0 +1,5 @@
+/** Split a stream of string chunks into individual lines (delimited by \n). */
+export declare function splitLines(input: AsyncIterable<string>): AsyncGenerator<string>;
+/** Append \n to each string in the stream. */
+export declare function joinLines(input: AsyncIterable<string>): AsyncGenerator<string>;
+//# sourceMappingURL=lines.d.ts.map

package/dist/lines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lines.d.ts","sourceRoot":"","sources":["../src/lines.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,wBAAuB,UAAU,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,CAYtF;AAED,8CAA8C;AAC9C,wBAAuB,SAAS,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,CAIrF"}

package/dist/map.d.ts

@@ -0,0 +1,3 @@
+/** Apply a sync or async function to each item in a stream. */
+export declare function map<I, O>(input: AsyncIterable<I>, fn: (item: I) => O | Promise<O>): AsyncGenerator<O>;
+//# sourceMappingURL=map.d.ts.map

package/dist/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../src/map.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,wBAAuB,GAAG,CAAC,CAAC,EAAE,CAAC,EAC7B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAC9B,cAAc,CAAC,CAAC,CAAC,CAInB"}

package/dist/new-async-generator.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The newAsyncGenerator function creates async generators from callback-based initialization
+ * functions, providing a bridge between imperative event handling and declarative async
+ * iteration patterns.
+ *
+ * The initialization function receives two callback functions that control the generator's
+ * behavior. The `next` function yields values to consumers, while the `done` function
+ * signals completion or error conditions. The initialization function can return a cleanup
+ * function that will be called when the generator is closed or an error occurs.
+ *
+ * The generator manages an internal queue of values and completion signals, ensuring that
+ * producers can yield values without overwhelming consumers. Proper backpressure is implemented
+ * by having the `next` and `done` functions return promises that resolve only after the
+ * consumer has processed the values. This prevents memory leaks and ensures that producers
+ * are aware of whether their values were successfully handled.
+ * The generator also handles cleanup by draining any remaining items in the queue and notifying
+ * producers that their values were not processed if the generator is closed early. This ensures
+ * that resources are properly managed and that no memory leaks occur.
+ *
+ * Example usage:
+ * ```typescript
+ * const asyncGen = newAsyncGenerator<number>((next, done) => {
+ *   let count = 0;
+ *   const interval = setInterval(() => {
+ *     if (count < 5) {
+ *       next(count++);
+ *     } else {
+ *       done();
+ *       clearInterval(interval);
+ *     }
+ *   }, 1000);
+ *   return () => clearInterval(interval); // Cleanup function
+ * });
+ * (async () => {
+ *   for await (const num of asyncGen) {
+ *     console.log(num); // Logs numbers 0 to 4 at 1 second intervals
+ *   }
+ *   console.log("Completed");
+ * })();
+ * ```
+ * @template T The type of values yielded by the generator
+ * @template E The type of errors that can be thrown; defaults to Error
+ * @param init Initialization function that sets up the generator behavior with next/done callbacks;
+ *  The first parameter - `next` function - is used to yield values to consumers;
+ *  It returns a Promise<boolean> indicating whether the value was successfully handled;
+ *  The second parameter - `done` function - is used to signal completion or error;
+ *  It returns a Promise<boolean> indicating whether the completion was successfully handled;
+ *  The initialization function can optionally return a cleanup function that will be called
+ *  when the generator is closed or an error occurs;
+ * @param skipValues If true, only the most recent value is kept in the queue,
+ * skipping intermediate values (not consumed values are considered skipped);
+ * This is useful for scenarios where only the latest value matters, such as UI updates.
+ * Defaults to false, meaning all values are queued and processed in order.
+ * @returns AsyncGenerator that properly manages backpressure and resource cleanup
+ */
+export declare function newAsyncGenerator<T, E = Error>(
+/**
+ * Initialization function that sets up the async generator behavior.
+ * @param next - Function to yield values to consumers. Returns a Promise<boolean>
+ *               indicating whether the value was successfully handled.
+ * @param done - Function to signal completion or error. Optional error parameter
+ *               will cause the generator to throw that error.
+ * @returns Optional cleanup function that will be called when the generator terminates.
+ */
+init: (next: (value: T) => Promise<boolean>, done: (err?: E) => Promise<boolean>) => void | (() => void | Promise<void>), 
+/**
+ * Skipping queue implementation that maintains only the most recent value.
+ */
+skipValues?: boolean): AsyncGenerator<T>;
+//# sourceMappingURL=new-async-generator.d.ts.map

package/dist/new-async-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"new-async-generator.d.ts","sourceRoot":"","sources":["../src/new-async-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,wBAAuB,iBAAiB,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK;AACnD;;;;;;;GAOG;AACH,IAAI,EAAE,CACJ,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,EACpC,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,KAChC,IAAI,GAAG,CAAC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAExC;;GAEG;AACH,UAAU,UAAQ,GACjB,cAAc,CAAC,CAAC,CAAC,CA6InB"}

package/dist/normalize.d.ts

@@ -0,0 +1,8 @@
+export type ByteLike = Uint8Array | ArrayBuffer | ArrayBufferView | Blob | string;
+/**
+ * Coerce common byte-like inputs into a `Uint8Array`. Strings encode as UTF-8.
+ * Blobs return a `Promise<Uint8Array>`; every other input returns synchronously.
+ * Throws `TypeError` for anything else.
+ */
+export declare function normalizeToUint8Array(data: ByteLike): Uint8Array | Promise<Uint8Array>;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../src/normalize.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,QAAQ,GAAG,UAAU,GAAG,WAAW,GAAG,eAAe,GAAG,IAAI,GAAG,MAAM,CAAC;AAElF;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAatF"}

package/dist/readable-streams.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The iterator ↔ `ReadableStream` boundary.
+ *
+ * Both adapters must carry CANCELLATION, not just data: a response body leaves
+ * a handler as a `ReadableStream`, crosses a transport as an iterator, and
+ * becomes a `ReadableStream` again at the caller — so when the caller walks
+ * away, the only path back to the handler's producer runs through both of
+ * these functions. Teardown that stops at an adapter leaves a producer running
+ * for ever.
+ */
+export declare function toReadableStream(it: AsyncIterator<Uint8Array>): ReadableStream<Uint8Array>;
+export declare function fromReadableStream(stream: ReadableStream<Uint8Array>): AsyncGenerator<Uint8Array, void, unknown>;
+//# sourceMappingURL=readable-streams.d.ts.map

package/dist/readable-streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readable-streams.d.ts","sourceRoot":"","sources":["../src/readable-streams.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,cAAc,CAAC,UAAU,CAAC,CA+B1F;AAED,wBAAuB,kBAAkB,CACvC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GACjC,cAAc,CAAC,UAAU,EAAE,IAAI,EAAE,OAAO,CAAC,CAoB3C"}

package/dist/recieve-iterator.d.ts

@@ -0,0 +1,14 @@
+import type { IteratorChunk } from "./send-iterator.js";
+export type ChunkReceiver<T> = (chunk?: IteratorChunk<T>) => Promise<boolean>;
+export type ReceiverInstaller<T> = (deliver: ChunkReceiver<T>) => (() => void | Promise<void>) | undefined | void;
+/**
+ * Inverse of {@link sendIterator}: turns a sequence of `{done, value, error}`
+ * chunks (delivered to the supplied callback by `installer`) into an async
+ * generator.
+ *
+ * The `installer` is given a `deliver` function. It should call `deliver`
+ * once for each incoming chunk and may return a cleanup callback that
+ * runs when the consumer stops iterating.
+ */
+export declare function recieveIterator<T>(installer: ReceiverInstaller<T>): AsyncGenerator<T>;
+//# sourceMappingURL=recieve-iterator.d.ts.map

package/dist/recieve-iterator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recieve-iterator.d.ts","sourceRoot":"","sources":["../src/recieve-iterator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAC9E,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CACjC,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,KACtB,CAAC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC;AAErD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,SAAS,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAerF"}

package/dist/send-iterator.d.ts

@@ -0,0 +1,15 @@
+export interface IteratorChunk<T> {
+    done: boolean;
+    value?: T;
+    error?: unknown;
+}
+export type ChunkSender<T> = (chunk: IteratorChunk<T>) => void | Promise<void>;
+/**
+ * Drain an async iterator into a sink that consumes one chunk at a time.
+ *
+ * Each yielded value becomes `{ done: false, value }`. Completion emits
+ * `{ done: true }`. If the iterator throws, the error is caught and the
+ * final `done` chunk carries it so the peer can rethrow on its side.
+ */
+export declare function sendIterator<T>(send: ChunkSender<T>, it: AsyncIterable<T> | Iterable<T>): Promise<void>;
+//# sourceMappingURL=send-iterator.d.ts.map

package/dist/send-iterator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send-iterator.d.ts","sourceRoot":"","sources":["../src/send-iterator.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa,CAAC,CAAC;IAC9B,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,CAAC,EAAE,CAAC,CAAC;IACV,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE/E;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAClC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EACpB,EAAE,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,GACjC,OAAO,CAAC,IAAI,CAAC,CAWf"}

package/dist/text.d.ts

@@ -0,0 +1,5 @@
+/** Decode Uint8Array chunks to string chunks via TextDecoder, handling split multi-byte characters. */
+export declare function decodeText(input: AsyncIterable<Uint8Array>): AsyncGenerator<string>;
+/** Encode string chunks to Uint8Array chunks via TextEncoder. */
+export declare function encodeText(input: AsyncIterable<string>): AsyncGenerator<Uint8Array>;
+//# sourceMappingURL=text.d.ts.map

package/dist/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../src/text.ts"],"names":[],"mappings":"AAAA,uGAAuG;AACvG,wBAAuB,UAAU,CAAC,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,CAQ1F;AAED,iEAAiE;AACjE,wBAAuB,UAAU,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,cAAc,CAAC,UAAU,CAAC,CAK1F"}

package/dist/to-chunks.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Curried `Duplex`-shaped transformer that splits incoming `Uint8Array`s into
+ * chunks no larger than `size` bytes. Empty input chunks are skipped; small
+ * input chunks pass through unchanged (zero-copy `subarray` views are used
+ * when splitting, so no allocation per chunk).
+ *
+ * Use to respect transport MTUs before reaching `channel.send`. Reassembly on
+ * the receive side is not needed — consumers iterate a continuous byte stream.
+ */
+export declare function toChunks(size?: number): (input: AsyncIterable<Uint8Array> | Iterable<Uint8Array>) => AsyncGenerator<Uint8Array>;
+//# sourceMappingURL=to-chunks.d.ts.map

package/dist/to-chunks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-chunks.d.ts","sourceRoot":"","sources":["../src/to-chunks.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CACtB,IAAI,GAAE,MAA2B,GAChC,CAAC,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,KAAK,cAAc,CAAC,UAAU,CAAC,CAmBzF"}

package/dist/uint32.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Credit payloads are a single big-endian uint32, matching the frame header's
+ * byte order.
+ *
+ * Deliberately **not** re-exported from `index.ts`: this is an internal codec
+ * for the `emulateMux` wire format, not a compatibility commitment. Tests
+ * import it by path.
+ */
+/** The largest credit a single frame can advertise or grant: 2^32 - 1. */
+export declare const MAX_UINT32 = 4294967295;
+/**
+ * Clamps rather than wraps. `n >>> 0` is the obvious spelling and it is wrong
+ * here: 2^32 becomes **0**, so a 4 GiB window advertises *zero credit* and the
+ * peer stalls forever with no error — the exact silent hang credit exists to
+ * remove. 2^32 + 5 becomes 5, which looks like a working window and is worse.
+ * Anything above the ceiling is advertised as the ceiling.
+ */
+export declare function encodeUint32(n: number): Uint8Array;
+/**
+ * Returns `undefined` rather than a garbage number when the payload is too
+ * short, so a truncated frame — or one from a peer predating credit — is
+ * detectable at the call site instead of silently granting nonsense.
+ */
+export declare function decodeUint32(bytes: Uint8Array): number | undefined;
+//# sourceMappingURL=uint32.d.ts.map

package/dist/uint32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uint32.d.ts","sourceRoot":"","sources":["../src/uint32.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,0EAA0E;AAC1E,eAAO,MAAM,UAAU,aAAa,CAAC;AAErC;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,CAKlD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CAGlE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statewalker/webrun-streams",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "private": false,
   "type": "module",
   "description": "Async-iterator / ReadableStream primitives: collect, text/jsonl codecs, lines, backpressure generators, serialisable errors.",
@@ -16,31 +16,38 @@
     "directory": "packages/webrun-streams"
   },
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   },
   "files": [
     "dist",
     "src"
   ],
   "devDependencies": {
-    "@types/node": "^26.2.0",
+    "@biomejs/biome": "^2.5.15",
+    "@types/node": "^26.6.4",
     "rimraf": "^6.1.3",
-    "tsdown": "^0.22.14",
+    "rolldown": "^1.2.12",
     "typescript": "^7.0.2",
-    "vitest": "^4.1.10"
+    "vitest": "^5.0.3"
   },
   "sideEffects": false,
   "publishConfig": {
     "access": "public"
   },
+  "types": "./dist/index.d.ts",
   "scripts": {
-    "build": "tsdown",
+    "build": "rimraf dist && rolldown -c && tsc --emitDeclarationOnly --declaration",
     "dev": "tsdown --watch",
     "test": "vitest run",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit",
+    "typecheck:tests": "tsc -p tsconfig.tests.json",
     "clean": "rimraf dist",
-    "lint": "biome check --write .",
+    "lint": "biome check src tests",
     "format": "biome format --write ."
   }
 }