@statewalker/webrun-streams 0.1.0 → 0.2.0

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

@@ -13,7 +13,7 @@ async function collectBytes(input) {
 		chunks.push(chunk);
 		total += chunk.length;
 	}
-	if (chunks.length === 1) return chunks[0] ?? new Uint8Array(0);
+	if (chunks.length === 1) return chunks[0] ?? /* @__PURE__ */ new Uint8Array(0);
 	const result = new Uint8Array(total);
 	let offset = 0;
 	for (const chunk of chunks) {
@@ -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;
@@ -73,12 +186,15 @@ const TYPE_END = 4;
 const TYPE_ERROR = 5;
 const TYPE_CLOSE = 6;
 const DEFAULT_MAX_STREAMS = 256;
-const DEFAULT_MTU = 64 * 1024;
+const DEFAULT_MTU = 65536;
+const DEFAULT_MAX_STREAM_BUFFER = 8388608;
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();
 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;
@@ -99,13 +215,24 @@ 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);
+	};
+	/**
+	* Graceful counterpart to `teardownStream`. A stream occupies a slot in
+	* `streams` until BOTH directions finish; releasing on inbound END alone
+	* would set `closed` while our own `pumpOutbound` is still sending, and it
+	* checks that flag to decide whether to keep going.
+	*
+	* Without this, only abnormal endings (cancel, ERROR, CLOSE, transport
+	* failure) ever freed a slot, so every normally-completed call leaked one
+	* until `maxStreams` began rejecting new calls.
+	*/
+	const releaseIfComplete = (s) => {
+		if (s.closed || !s.inDone || !s.outDone) return;
+		s.closed = true;
 		streams.delete(s.id);
 	};
 	const failAll = (err) => {
@@ -124,31 +251,42 @@ function emulateMux(channel, opts = {}) {
 			}),
 			pushIn: queue.push,
 			doneIn: queue.done,
-			resolveAck: null,
-			rejectAck: null,
-			closed: false
+			outboundCredit: newCreditLedger(0),
+			grantor: newCreditGrantor(maxStreamBuffer),
+			closed: false,
+			inDone: false,
+			outDone: false,
+			queuedBytes: 0
 		};
 		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;
 				}
 			}
-			if (!s.closed && !muxClosed) sendFrame(s.id, TYPE_END);
+			if (!s.closed && !muxClosed) {
+				sendFrame(s.id, TYPE_END);
+				s.outDone = true;
+				releaseIfComplete(s);
+			}
 		} catch (err) {
 			if (!s.closed && !muxClosed) {
 				const e = err instanceof Error ? err : new Error(String(err));
@@ -168,11 +306,22 @@ function emulateMux(channel, opts = {}) {
 			return;
 		}
 		await pumpOutbound(s, outbound);
+		if (!s.inDone && !s.closed && !muxClosed) {
+			sendFrame(s.id, TYPE_CLOSE);
+			teardownStream(s);
+		}
 	};
 	const handleFrame = (frame) => {
 		if (muxClosed) return;
 		if (frame.byteLength < 2) return;
-		const { value: id, offset } = decodeVarint(frame, 0);
+		let id;
+		let offset;
+		try {
+			({value: id, offset} = decodeVarint(frame, 0));
+		} catch {
+			return;
+		}
+		if (offset >= frame.byteLength) return;
 		const type = frame[offset];
 		const payload = frame.subarray(offset + 1);
 		if (type === TYPE_OPEN) {
@@ -187,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;
 		}
@@ -194,21 +346,31 @@ function emulateMux(channel, opts = {}) {
 		if (!s) return;
 		switch (type) {
 			case TYPE_DATA: {
+				s.queuedBytes += payload.byteLength;
+				if (s.queuedBytes > maxStreamBuffer) {
+					const err = /* @__PURE__ */ new RangeError(`emulateMux: stream ${id} buffered ${s.queuedBytes} bytes past maxStreamBuffer=${maxStreamBuffer} without being drained`);
+					sendFrame(id, TYPE_ERROR, encodeError(err));
+					teardownStream(s, err);
+					return;
+				}
 				const copy = payload.byteLength === 0 ? payload : new Uint8Array(payload);
 				s.pushIn(copy).then((handled) => {
-					if (handled && !s.closed && !muxClosed) sendFrame(id, TYPE_ACK);
+					s.queuedBytes -= copy.byteLength;
+					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:
+				s.inDone = true;
 				s.doneIn();
+				releaseIfComplete(s);
 				return;
 			case TYPE_ERROR:
 				teardownStream(s, decodeError(payload));
@@ -239,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;
 	};
@@ -596,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
@@ -690,7 +885,7 @@ async function* encodeText(input) {
 }
 //#endregion
 //#region src/to-chunks.ts
-const DEFAULT_CHUNK_SIZE = 16 * 1024;
+const DEFAULT_CHUNK_SIZE = 16384;
 /**
 * Curried `Duplex`-shaped transformer that splits incoming `Uint8Array`s into
 * chunks no larger than `size` bytes. Empty input chunks are skipped; small
@@ -719,4 +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 };
+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