@powerlines/core 0.15.0 → 0.15.2

package/dist/lib/streaming-channel.d.mts

@@ -0,0 +1,133 @@
+import { EventEmitter } from "devframe/types";
+
+//#region src/lib/streaming-channel.d.ts
+/**
+ * Serialized error shape sent over the wire when a stream ends with a failure.
+ * Stays JSON-safe so the strict-JSON encoder can carry it without coercion.
+ */
+interface StreamErrorPayload {
+  name: string;
+  message: string;
+}
+/**
+ * Single buffered chunk in the server-side ring buffer.
+ *
+ * Sequence numbers start at 1 and increment per write. Subscribers track
+ * `lastSeenSeq` and ask for `afterSeq` on resubscribe so the server can
+ * replay any chunks the client missed during a brief disconnect.
+ */
+interface BufferedChunk<T> {
+  seq: number;
+  chunk: T;
+}
+interface StreamSinkEvents<T> {
+  /** Fired for each `write()`. The RPC layer subscribes and broadcasts. */
+  chunk: (seq: number, chunk: T) => void;
+  /** Terminal — fired exactly once per sink lifetime. */
+  end: (error?: StreamErrorPayload) => void;
+}
+interface CreateStreamSinkOptions {
+  id?: string;
+  /**
+   * Size of the per-stream ring buffer kept for replay-on-resubscribe.
+   * `0` (default) disables replay.
+   */
+  replayWindow?: number;
+}
+/**
+ * Server-side producer handle. Two equivalent surfaces share one piece of
+ * state: the imperative `write/error/close` triple, and a `WritableStream<T>`
+ * for `pipeTo`-style consumption.
+ */
+interface StreamSink<T> {
+  /** Stable id used by clients to subscribe. */
+  readonly id: string;
+  /**
+   * Aborts when the consumer cancels (server-side) or when the transport
+   * loses every subscriber. Producers should poll `signal.aborted` and exit
+   * cleanly.
+   */
+  readonly signal: AbortSignal;
+  /** `true` after `close()` / `error()`. Further writes throw. */
+  readonly closed: boolean;
+  /** Last allocated sequence number. `0` until the first write. */
+  readonly lastSeq: number;
+  write: (chunk: T) => void;
+  error: (reason: unknown) => void;
+  close: () => void;
+  /** External-cancel path. Aborts the signal so handlers can short-circuit. */
+  abort: (reason?: unknown) => void;
+  /** `WritableStream<T>` adapter — same in-memory state as the imperative API. */
+  readonly writable: WritableStream<T>;
+  /**
+   * Internal — RPC layer subscribes to receive chunk/end notifications.
+   * Not part of the public contract; do not call directly.
+   *
+   * @internal
+   */
+  readonly events: EventEmitter<StreamSinkEvents<T>>;
+  /**
+   * Internal — replay buffer. RPC layer reads on (re)subscribe to feed
+   * missed chunks before going live.
+   *
+   * @internal
+   */
+  readonly buffer: ReadonlyArray<BufferedChunk<T>>;
+}
+interface CreateStreamReaderOptions {
+  id?: string;
+  /**
+   * Maximum number of buffered chunks held client-side while the consumer
+   * isn't draining. On overflow, the oldest chunk is dropped.
+   */
+  highWaterMark?: number;
+  /**
+   * Called when the chunk queue overflows the high-water mark. The RPC
+   * layer wires this to a coded warning; the primitive itself is
+   * RPC-agnostic.
+   */
+  onOverflow?: (dropped: number) => void;
+  /** Called when the consumer cancels — the RPC layer sends `:cancel` upstream. */
+  onCancel?: () => void;
+}
+/**
+ * Client-side consumer handle. Both an `AsyncIterable<T>` (for `for await`)
+ * and exposes `readable: ReadableStream<T>` (for `pipeTo`). Pick one — they
+ * share a single internal queue, so concurrent draining will race.
+ */
+interface StreamReader<T> extends AsyncIterable<T> {
+  readonly id: string;
+  readonly cancelled: boolean;
+  readonly done: boolean;
+  /** Highest `seq` observed. Used for replay on reconnect. */
+  readonly lastSeenSeq: number;
+  /** `ReadableStream<T>` adapter for `pipeTo`-style consumption. */
+  readonly readable: ReadableStream<T>;
+  cancel: () => void;
+  /** @internal */
+  _push: (seq: number, chunk: T) => void;
+  /** @internal */
+  _end: (error?: StreamErrorPayload) => void;
+}
+/**
+ * Build a server-side stream sink. RPC-agnostic — the RPC host wires
+ * `events.on('chunk' | 'end')` to broadcast, and reads `buffer` to replay
+ * for late or reconnecting subscribers.
+ */
+declare function createStreamSink<T>(options?: CreateStreamSinkOptions): StreamSink<T>;
+/**
+ * Build a client-side stream reader. RPC-agnostic — the RPC host calls
+ * `_push(seq, chunk)` on each incoming chunk and `_end(error?)` on the
+ * terminal frame. Consumers iterate with `for await` or pipe `readable`.
+ */
+declare function createStreamReader<T>(options?: CreateStreamReaderOptions): StreamReader<T>;
+declare type __ΩStreamErrorPayload = any[];
+declare type __ΩBufferedChunk = any[];
+declare type __ΩStreamSinkEvents = any[];
+declare type __ΩCreateStreamSinkOptions = any[];
+declare type __ΩStreamSink = any[];
+declare type __ΩCreateStreamReaderOptions = any[];
+declare type __ΩStreamReader = any[];
+//#endregion
+export { BufferedChunk, CreateStreamReaderOptions, CreateStreamSinkOptions, StreamErrorPayload, StreamReader, StreamSink, StreamSinkEvents, __ΩBufferedChunk, __ΩCreateStreamReaderOptions, __ΩCreateStreamSinkOptions, __ΩStreamErrorPayload, __ΩStreamReader, __ΩStreamSink, __ΩStreamSinkEvents, createStreamReader, createStreamSink };
+//# sourceMappingURL=streaming-channel.d.mts.map

package/dist/lib/streaming-channel.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-channel.d.mts","names":[],"sources":["../../src/lib/streaming-channel.ts"],"mappings":";;;;;AA0BA;;UAAiB,kBAAA;EACf,IAAA;EACA,OAAA;AAAA;;;;;;;;UAUe,aAAA;EACf,GAAA;EACA,KAAA,EAAO,CAAA;AAAA;AAAA,UAGQ,gBAAA;EAIiB;EAFhC,KAAA,GAAQ,GAAA,UAAa,KAAA,EAAO,CAAA;EAA5B;EAEA,GAAA,GAAM,KAAA,GAAQ,kBAAA;AAAA;AAAA,UAGC,uBAAA;EACf,EAAA;EAJc;;;;EASd,YAAA;AAAA;;;;AAQF;;UAAiB,UAAA;EAQE;EAAA,SANR,EAAA;EAmByB;;;;;EAAA,SAbzB,MAAA,EAAQ,WAAA;EA6Bc;EAAA,SA3BtB,MAAA;EA2BqB;EAAA,SAzBrB,OAAA;EAET,KAAA,GAAQ,KAAA,EAAO,CAAA;EACf,KAAA,GAAQ,MAAA;EACR,KAAA;EARiB;EAUjB,KAAA,GAAQ,MAAA;EANC;EAAA,SASA,QAAA,EAAU,cAAA,CAAe,CAAA;EAPnB;;;;;;EAAA,SAeN,MAAA,EAAQ,YAAA,CAAa,gBAAA,CAAiB,CAAA;EARtC;;;;;;EAAA,SAgBA,MAAA,EAAQ,aAAA,CAAc,aAAA,CAAc,CAAA;AAAA;AAAA,UAG9B,yBAAA;EACf,EAAA;EAJ6C;;;AAG/C;EAME,aAAA;;;;;;EAMA,UAAA,IAAc,OAAA;EAEd;EAAA,QAAA;AAAA;AAQF;;;;;AAAA,UAAiB,YAAA,YAAwB,aAAA,CAAc,CAAA;EAAA,SAC5C,EAAA;EAAA,SACA,SAAA;EAAA,SACA,IAAA;EAH2C;EAAA,SAK3C,WAAA;EALmB;EAAA,SAOnB,QAAA,EAAU,cAAA,CAAe,CAAA;EAElC,MAAA;EARS;EAWT,KAAA,GAAQ,GAAA,UAAa,KAAA,EAAO,CAAA;EATnB;EAWT,IAAA,GAAO,KAAA,GAAQ,kBAAA;AAAA;;;;;;iBAcD,gBAAA,GAAA,CACd,OAAA,GAAS,uBAAA,GACR,UAAA,CAAW,CAAA;;;;;;iBA+EE,kBAAA,GAAA,CACd,OAAA,GAAS,yBAAA,GACR,YAAA,CAAa,CAAA;AAAA"}

package/dist/lib/streaming-channel.mjs

@@ -0,0 +1,258 @@
+import { createEventEmitter } from "./events.mjs";
+import { nanoid } from "@stryke/unique-id/nanoid-client";
+
+//#region src/lib/streaming-channel.ts
+const DEFAULT_HIGH_WATER_MARK = 256;
+var StreamClosedError = class extends Error {
+	name = "StreamClosedError";
+};
+/**
+* Build a server-side stream sink. RPC-agnostic — the RPC host wires
+* `events.on('chunk' | 'end')` to broadcast, and reads `buffer` to replay
+* for late or reconnecting subscribers.
+*/
+function createStreamSink(options = {}) {
+	const id = options.id ?? nanoid();
+	const replayWindow = Math.max(0, options.replayWindow ?? 0);
+	const events = createEventEmitter();
+	const controller = new AbortController();
+	const buffer = [];
+	let closed = false;
+	let lastSeq = 0;
+	function write(chunk) {
+		if (closed) throw new StreamClosedError(`Cannot write to a closed stream "${id}"`);
+		lastSeq += 1;
+		if (replayWindow > 0) {
+			buffer.push({
+				seq: lastSeq,
+				chunk
+			});
+			if (buffer.length > replayWindow) buffer.splice(0, buffer.length - replayWindow);
+		}
+		events.emit("chunk", lastSeq, chunk);
+	}
+	function error(reason) {
+		if (closed) return;
+		closed = true;
+		const payload = toErrorPayload(reason);
+		controller.abort(reason);
+		events.emit("end", payload);
+	}
+	function close() {
+		if (closed) return;
+		closed = true;
+		if (!controller.signal.aborted) controller.abort("stream closed");
+		events.emit("end", void 0);
+	}
+	function abort(reason) {
+		if (closed) return;
+		if (!controller.signal.aborted) controller.abort(reason ?? "aborted");
+	}
+	const writable = new WritableStream({
+		write(chunk) {
+			write(chunk);
+		},
+		close() {
+			close();
+		},
+		abort(reason) {
+			error(reason);
+		}
+	});
+	return {
+		id,
+		signal: controller.signal,
+		get closed() {
+			return closed;
+		},
+		get lastSeq() {
+			return lastSeq;
+		},
+		write,
+		error,
+		close,
+		abort,
+		writable,
+		events,
+		buffer
+	};
+}
+/**
+* Build a client-side stream reader. RPC-agnostic — the RPC host calls
+* `_push(seq, chunk)` on each incoming chunk and `_end(error?)` on the
+* terminal frame. Consumers iterate with `for await` or pipe `readable`.
+*/
+function createStreamReader(options = {}) {
+	const id = options.id ?? nanoid();
+	const highWaterMark = Math.max(1, options.highWaterMark ?? DEFAULT_HIGH_WATER_MARK);
+	const queue = [];
+	let lastSeenSeq = 0;
+	let done = false;
+	let cancelled = false;
+	let endError;
+	let pending;
+	let pullController;
+	let readableInstance;
+	function drainNext() {
+		if (!pending) return;
+		if (queue.length > 0) {
+			const value = queue.shift();
+			const r = pending;
+			pending = void 0;
+			r.resolve({
+				value,
+				done: false
+			});
+			return;
+		}
+		if (done) {
+			const r = pending;
+			pending = void 0;
+			if (endError) {
+				const err = new Error(endError.message);
+				err.name = endError.name;
+				r.reject(err);
+			} else r.resolve({
+				value: void 0,
+				done: true
+			});
+		}
+	}
+	function feedReadable() {
+		if (!pullController) return;
+		while (queue.length > 0) {
+			const v = queue.shift();
+			try {
+				pullController.enqueue(v);
+			} catch {
+				break;
+			}
+		}
+		if (done && pullController) {
+			try {
+				if (endError) {
+					const err = new Error(endError.message);
+					err.name = endError.name;
+					pullController.error(err);
+				} else pullController.close();
+			} catch {}
+			pullController = void 0;
+		}
+	}
+	function push(seq, chunk) {
+		if (done || cancelled) return;
+		if (seq <= lastSeenSeq) return;
+		lastSeenSeq = seq;
+		queue.push(chunk);
+		if (queue.length > highWaterMark) {
+			const overflow = queue.length - highWaterMark;
+			queue.splice(0, overflow);
+			options.onOverflow?.(overflow);
+		}
+		drainNext();
+		if (readableInstance) feedReadable();
+	}
+	function end(error) {
+		if (done) return;
+		done = true;
+		endError = error;
+		drainNext();
+		if (readableInstance) feedReadable();
+	}
+	function cancel() {
+		if (cancelled || done) return;
+		cancelled = true;
+		options.onCancel?.();
+		end(void 0);
+	}
+	function getReadable() {
+		if (readableInstance) return readableInstance;
+		readableInstance = new ReadableStream({
+			start(controller) {
+				pullController = controller;
+				feedReadable();
+			},
+			cancel() {
+				cancel();
+			}
+		});
+		return readableInstance;
+	}
+	return {
+		id,
+		get cancelled() {
+			return cancelled;
+		},
+		get done() {
+			return done;
+		},
+		get lastSeenSeq() {
+			return lastSeenSeq;
+		},
+		get readable() {
+			return getReadable();
+		},
+		cancel,
+		_push: push,
+		_end: end,
+		[Symbol.asyncIterator]() {
+			return {
+				async next() {
+					if (queue.length > 0) return Promise.resolve({
+						value: queue.shift(),
+						done: false
+					});
+					if (done) {
+						if (endError) {
+							const err = new Error(endError.message);
+							err.name = endError.name;
+							return Promise.reject(err);
+						}
+						return Promise.resolve({
+							value: void 0,
+							done: true
+						});
+					}
+					return new Promise((resolve, reject) => {
+						pending = {
+							resolve,
+							reject
+						};
+					});
+				},
+				async return() {
+					cancel();
+					return Promise.resolve({
+						value: void 0,
+						done: true
+					});
+				}
+			};
+		}
+	};
+}
+function toErrorPayload(reason) {
+	if (reason instanceof Error) return {
+		name: reason.name || "Error",
+		message: reason.message
+	};
+	if (typeof reason === "string") return {
+		name: "Error",
+		message: reason
+	};
+	try {
+		return {
+			name: "Error",
+			message: JSON.stringify(reason)
+		};
+	} catch {
+		return {
+			name: "Error",
+			message: String(reason)
+		};
+	}
+}
+
+//#endregion
+export { createStreamReader, createStreamSink };
+//# sourceMappingURL=streaming-channel.mjs.map

package/dist/lib/streaming-channel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-channel.mjs","names":[],"sources":["../../src/lib/streaming-channel.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport { nanoid } from \"@stryke/unique-id/nanoid-client\";\nimport type { EventEmitter } from \"devframe/types\";\nimport { createEventEmitter } from \"./events\";\n\n/**\n * Serialized error shape sent over the wire when a stream ends with a failure.\n * Stays JSON-safe so the strict-JSON encoder can carry it without coercion.\n */\nexport interface StreamErrorPayload {\n  name: string;\n  message: string;\n}\n\n/**\n * Single buffered chunk in the server-side ring buffer.\n *\n * Sequence numbers start at 1 and increment per write. Subscribers track\n * `lastSeenSeq` and ask for `afterSeq` on resubscribe so the server can\n * replay any chunks the client missed during a brief disconnect.\n */\nexport interface BufferedChunk<T> {\n  seq: number;\n  chunk: T;\n}\n\nexport interface StreamSinkEvents<T> {\n  /** Fired for each `write()`. The RPC layer subscribes and broadcasts. */\n  chunk: (seq: number, chunk: T) => void;\n  /** Terminal — fired exactly once per sink lifetime. */\n  end: (error?: StreamErrorPayload) => void;\n}\n\nexport interface CreateStreamSinkOptions {\n  id?: string;\n  /**\n   * Size of the per-stream ring buffer kept for replay-on-resubscribe.\n   * `0` (default) disables replay.\n   */\n  replayWindow?: number;\n}\n\n/**\n * Server-side producer handle. Two equivalent surfaces share one piece of\n * state: the imperative `write/error/close` triple, and a `WritableStream<T>`\n * for `pipeTo`-style consumption.\n */\nexport interface StreamSink<T> {\n  /** Stable id used by clients to subscribe. */\n  readonly id: string;\n  /**\n   * Aborts when the consumer cancels (server-side) or when the transport\n   * loses every subscriber. Producers should poll `signal.aborted` and exit\n   * cleanly.\n   */\n  readonly signal: AbortSignal;\n  /** `true` after `close()` / `error()`. Further writes throw. */\n  readonly closed: boolean;\n  /** Last allocated sequence number. `0` until the first write. */\n  readonly lastSeq: number;\n\n  write: (chunk: T) => void;\n  error: (reason: unknown) => void;\n  close: () => void;\n  /** External-cancel path. Aborts the signal so handlers can short-circuit. */\n  abort: (reason?: unknown) => void;\n\n  /** `WritableStream<T>` adapter — same in-memory state as the imperative API. */\n  readonly writable: WritableStream<T>;\n\n  /**\n   * Internal — RPC layer subscribes to receive chunk/end notifications.\n   * Not part of the public contract; do not call directly.\n   *\n   * @internal\n   */\n  readonly events: EventEmitter<StreamSinkEvents<T>>;\n\n  /**\n   * Internal — replay buffer. RPC layer reads on (re)subscribe to feed\n   * missed chunks before going live.\n   *\n   * @internal\n   */\n  readonly buffer: ReadonlyArray<BufferedChunk<T>>;\n}\n\nexport interface CreateStreamReaderOptions {\n  id?: string;\n  /**\n   * Maximum number of buffered chunks held client-side while the consumer\n   * isn't draining. On overflow, the oldest chunk is dropped.\n   */\n  highWaterMark?: number;\n  /**\n   * Called when the chunk queue overflows the high-water mark. The RPC\n   * layer wires this to a coded warning; the primitive itself is\n   * RPC-agnostic.\n   */\n  onOverflow?: (dropped: number) => void;\n  /** Called when the consumer cancels — the RPC layer sends `:cancel` upstream. */\n  onCancel?: () => void;\n}\n\n/**\n * Client-side consumer handle. Both an `AsyncIterable<T>` (for `for await`)\n * and exposes `readable: ReadableStream<T>` (for `pipeTo`). Pick one — they\n * share a single internal queue, so concurrent draining will race.\n */\nexport interface StreamReader<T> extends AsyncIterable<T> {\n  readonly id: string;\n  readonly cancelled: boolean;\n  readonly done: boolean;\n  /** Highest `seq` observed. Used for replay on reconnect. */\n  readonly lastSeenSeq: number;\n  /** `ReadableStream<T>` adapter for `pipeTo`-style consumption. */\n  readonly readable: ReadableStream<T>;\n\n  cancel: () => void;\n\n  /** @internal */\n  _push: (seq: number, chunk: T) => void;\n  /** @internal */\n  _end: (error?: StreamErrorPayload) => void;\n}\n\nconst DEFAULT_HIGH_WATER_MARK = 256;\n\nclass StreamClosedError extends Error {\n  override name = \"StreamClosedError\";\n}\n\n/**\n * Build a server-side stream sink. RPC-agnostic — the RPC host wires\n * `events.on('chunk' | 'end')` to broadcast, and reads `buffer` to replay\n * for late or reconnecting subscribers.\n */\nexport function createStreamSink<T>(\n  options: CreateStreamSinkOptions = {}\n): StreamSink<T> {\n  const id = options.id ?? nanoid();\n  const replayWindow = Math.max(0, options.replayWindow ?? 0);\n  const events = createEventEmitter<StreamSinkEvents<T>>();\n  const controller = new AbortController();\n  const buffer: BufferedChunk<T>[] = [];\n\n  let closed = false;\n  let lastSeq = 0;\n\n  function write(chunk: T): void {\n    if (closed) {\n      throw new StreamClosedError(`Cannot write to a closed stream \"${id}\"`);\n    }\n    lastSeq += 1;\n    if (replayWindow > 0) {\n      buffer.push({ seq: lastSeq, chunk });\n      if (buffer.length > replayWindow)\n        buffer.splice(0, buffer.length - replayWindow);\n    }\n    events.emit(\"chunk\", lastSeq, chunk);\n  }\n\n  function error(reason: unknown): void {\n    if (closed) return;\n    closed = true;\n    const payload = toErrorPayload(reason);\n    controller.abort(reason);\n    events.emit(\"end\", payload);\n  }\n\n  function close(): void {\n    if (closed) return;\n    closed = true;\n    if (!controller.signal.aborted) controller.abort(\"stream closed\");\n    events.emit(\"end\", undefined);\n  }\n\n  function abort(reason?: unknown): void {\n    if (closed) return;\n    if (!controller.signal.aborted) controller.abort(reason ?? \"aborted\");\n  }\n\n  const writable = new WritableStream<T>({\n    write(chunk) {\n      write(chunk);\n    },\n    close() {\n      close();\n    },\n    abort(reason) {\n      error(reason);\n    }\n  });\n\n  return {\n    id,\n    signal: controller.signal,\n    get closed() {\n      return closed;\n    },\n    get lastSeq() {\n      return lastSeq;\n    },\n    write,\n    error,\n    close,\n    abort,\n    writable,\n    events,\n    buffer\n  };\n}\n\n/**\n * Build a client-side stream reader. RPC-agnostic — the RPC host calls\n * `_push(seq, chunk)` on each incoming chunk and `_end(error?)` on the\n * terminal frame. Consumers iterate with `for await` or pipe `readable`.\n */\nexport function createStreamReader<T>(\n  options: CreateStreamReaderOptions = {}\n): StreamReader<T> {\n  const id = options.id ?? nanoid();\n  const highWaterMark = Math.max(\n    1,\n    options.highWaterMark ?? DEFAULT_HIGH_WATER_MARK\n  );\n\n  const queue: T[] = [];\n  let lastSeenSeq = 0;\n  let done = false;\n  let cancelled = false;\n  let endError: StreamErrorPayload | undefined;\n  let pending:\n    | {\n        resolve: (r: IteratorResult<T>) => void;\n        reject: (err: unknown) => void;\n      }\n    | undefined;\n  // Lazily created — accessing `reader.readable` claims the queue for\n  // `pipeTo` consumption. While inactive, `_push` only feeds the\n  // AsyncIterator path. Mixing the two surfaces is undefined behavior.\n  let pullController: ReadableStreamDefaultController<T> | undefined;\n  let readableInstance: ReadableStream<T> | undefined;\n\n  function drainNext(): void {\n    if (!pending) return;\n    if (queue.length > 0) {\n      const value = queue.shift()!;\n      const r = pending;\n      pending = undefined;\n      r.resolve({ value, done: false });\n      return;\n    }\n    if (done) {\n      const r = pending;\n      pending = undefined;\n      if (endError) {\n        const err = new Error(endError.message);\n        err.name = endError.name;\n        r.reject(err);\n      } else {\n        r.resolve({ value: undefined, done: true });\n      }\n    }\n  }\n\n  function feedReadable(): void {\n    if (!pullController) return;\n    while (queue.length > 0) {\n      const v = queue.shift()!;\n      try {\n        pullController.enqueue(v);\n      } catch {\n        // controller closed/errored under us — drop silently; the\n        // ReadableStream consumer is gone and we can't push further.\n        break;\n      }\n    }\n    if (done && pullController) {\n      try {\n        if (endError) {\n          const err = new Error(endError.message);\n          err.name = endError.name;\n          pullController.error(err);\n        } else {\n          pullController.close();\n        }\n      } catch {\n        // already closed\n      }\n      pullController = undefined;\n    }\n  }\n\n  function push(seq: number, chunk: T): void {\n    if (done || cancelled) return;\n    if (seq <= lastSeenSeq) return; // dedupe replays we've already seen\n    lastSeenSeq = seq;\n    queue.push(chunk);\n    if (queue.length > highWaterMark) {\n      const overflow = queue.length - highWaterMark;\n      queue.splice(0, overflow);\n      options.onOverflow?.(overflow);\n    }\n    drainNext();\n    if (readableInstance) feedReadable();\n  }\n\n  function end(error?: StreamErrorPayload): void {\n    if (done) return;\n    done = true;\n    endError = error;\n    drainNext();\n    if (readableInstance) feedReadable();\n  }\n\n  function cancel(): void {\n    if (cancelled || done) return;\n    cancelled = true;\n    options.onCancel?.();\n    end(undefined);\n  }\n\n  function getReadable(): ReadableStream<T> {\n    if (readableInstance) return readableInstance;\n    readableInstance = new ReadableStream<T>({\n      start(controller) {\n        pullController = controller;\n        feedReadable();\n      },\n      cancel() {\n        cancel();\n      }\n    });\n    return readableInstance;\n  }\n\n  const reader: StreamReader<T> = {\n    id,\n    get cancelled() {\n      return cancelled;\n    },\n    get done() {\n      return done;\n    },\n    get lastSeenSeq() {\n      return lastSeenSeq;\n    },\n    get readable() {\n      return getReadable();\n    },\n    cancel,\n    _push: push,\n    _end: end,\n    [Symbol.asyncIterator](): AsyncIterator<T> {\n      return {\n        async next(): Promise<IteratorResult<T>> {\n          if (queue.length > 0) {\n            return Promise.resolve({ value: queue.shift()!, done: false });\n          }\n          if (done) {\n            if (endError) {\n              const err = new Error(endError.message);\n              err.name = endError.name;\n              return Promise.reject(err);\n            }\n            return Promise.resolve({\n              value: undefined as unknown as T,\n              done: true\n            });\n          }\n          return new Promise<IteratorResult<T>>((resolve, reject) => {\n            pending = { resolve, reject };\n          });\n        },\n        async return(): Promise<IteratorResult<T>> {\n          cancel();\n          return Promise.resolve({\n            value: undefined as unknown as T,\n            done: true\n          });\n        }\n      };\n    }\n  };\n\n  return reader;\n}\n\nfunction toErrorPayload(reason: unknown): StreamErrorPayload {\n  if (reason instanceof Error) {\n    return { name: reason.name || \"Error\", message: reason.message };\n  }\n  if (typeof reason === \"string\") {\n    return { name: \"Error\", message: reason };\n  }\n  try {\n    return { name: \"Error\", message: JSON.stringify(reason) };\n  } catch {\n    return { name: \"Error\", message: String(reason) };\n  }\n}\n"],"mappings":"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"}

package/dist/lib/typescript/index.cjs

@@ -0,0 +1,16 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_lib_typescript_ts_morph = require('./ts-morph.cjs');
+const require_lib_typescript_tsconfig = require('./tsconfig.cjs');
+
+exports.VirtualFileSystemHost = require_lib_typescript_ts_morph.VirtualFileSystemHost;
+exports.createProgram = require_lib_typescript_ts_morph.createProgram;
+exports.findIncludeMatch = require_lib_typescript_tsconfig.findIncludeMatch;
+exports.findMatch = require_lib_typescript_tsconfig.findMatch;
+exports.getParsedTypeScriptConfig = require_lib_typescript_tsconfig.getParsedTypeScriptConfig;
+exports.getTsconfigDtsPath = require_lib_typescript_tsconfig.getTsconfigDtsPath;
+exports.getTsconfigFilePath = require_lib_typescript_tsconfig.getTsconfigFilePath;
+exports.initializeTsconfig = require_lib_typescript_tsconfig.initializeTsconfig;
+exports.isIncludeMatchFound = require_lib_typescript_tsconfig.isIncludeMatchFound;
+exports.isMatchFound = require_lib_typescript_tsconfig.isMatchFound;
+exports.resolveTsconfig = require_lib_typescript_tsconfig.resolveTsconfig;
+exports.tryTsconfigFilePath = require_lib_typescript_tsconfig.tryTsconfigFilePath;

package/dist/lib/typescript/index.d.cts

@@ -0,0 +1,3 @@
+import { VirtualFileSystemHost, createProgram } from "./ts-morph.cjs";
+import { findIncludeMatch, findMatch, getParsedTypeScriptConfig, getTsconfigDtsPath, getTsconfigFilePath, initializeTsconfig, isIncludeMatchFound, isMatchFound, resolveTsconfig, tryTsconfigFilePath } from "./tsconfig.cjs";
+export { VirtualFileSystemHost, createProgram, findIncludeMatch, findMatch, getParsedTypeScriptConfig, getTsconfigDtsPath, getTsconfigFilePath, initializeTsconfig, isIncludeMatchFound, isMatchFound, resolveTsconfig, tryTsconfigFilePath };

package/dist/lib/typescript/index.d.mts

@@ -0,0 +1,3 @@
+import { VirtualFileSystemHost, createProgram } from "./ts-morph.mjs";
+import { findIncludeMatch, findMatch, getParsedTypeScriptConfig, getTsconfigDtsPath, getTsconfigFilePath, initializeTsconfig, isIncludeMatchFound, isMatchFound, resolveTsconfig, tryTsconfigFilePath } from "./tsconfig.mjs";
+export { VirtualFileSystemHost, createProgram, findIncludeMatch, findMatch, getParsedTypeScriptConfig, getTsconfigDtsPath, getTsconfigFilePath, initializeTsconfig, isIncludeMatchFound, isMatchFound, resolveTsconfig, tryTsconfigFilePath };

package/dist/lib/typescript/index.mjs

@@ -0,0 +1,4 @@
+import { VirtualFileSystemHost, createProgram } from "./ts-morph.mjs";
+import { findIncludeMatch, findMatch, getParsedTypeScriptConfig, getTsconfigDtsPath, getTsconfigFilePath, initializeTsconfig, isIncludeMatchFound, isMatchFound, resolveTsconfig, tryTsconfigFilePath } from "./tsconfig.mjs";
+
+export { VirtualFileSystemHost, createProgram, findIncludeMatch, findMatch, getParsedTypeScriptConfig, getTsconfigDtsPath, getTsconfigFilePath, initializeTsconfig, isIncludeMatchFound, isMatchFound, resolveTsconfig, tryTsconfigFilePath };

package/dist/lib/typescript/ts-morph.cjs

@@ -0,0 +1,105 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
+let defu = require("defu");
+defu = require_runtime.__toESM(defu, 1);
+let ts_morph = require("ts-morph");
+
+//#region src/lib/typescript/ts-morph.ts
+var VirtualFileSystemHost = class extends ts_morph.InMemoryFileSystemHost {
+	#context;
+	constructor(context) {
+		super();
+		this.#context = context;
+	}
+	deleteSync(path) {
+		this.#context.fs.removeSync(path);
+	}
+	readDirSync(dirPath) {
+		if (!this.#context.fs.isDirectorySync(dirPath)) return [];
+		return this.#context.fs.listSync(dirPath).reduce((ret, entry) => {
+			const fullPath = this.#context.fs.resolveSync(entry);
+			if (fullPath) ret.push({
+				name: entry,
+				isDirectory: this.#context.fs.isDirectorySync(fullPath),
+				isFile: this.#context.fs.isFileSync(fullPath),
+				isSymlink: false
+			});
+			return ret;
+		}, []);
+	}
+	async readFile(filePath) {
+		if (!this.#context.fs.isFileSync(filePath)) return "";
+		return await this.#context.fs.read(filePath);
+	}
+	readFileSync(filePath) {
+		if (!this.#context.fs.isFileSync(filePath)) return "";
+		return this.#context.fs.readSync(filePath);
+	}
+	async writeFile(filePath, fileText) {
+		return this.#context.fs.write(filePath, fileText);
+	}
+	writeFileSync(filePath, fileText) {
+		this.#context.fs.writeSync(filePath, fileText);
+	}
+	async mkdir(dirPath) {
+		await this.#context.fs.mkdir(dirPath);
+	}
+	mkdirSync(dirPath) {
+		this.#context.fs.mkdirSync(dirPath);
+	}
+	async move(srcPath, destPath) {
+		await this.#context.fs.move(srcPath, destPath);
+	}
+	moveSync(srcPath, destPath) {
+		this.#context.fs.moveSync(srcPath, destPath);
+	}
+	async copy(srcPath, destPath) {
+		await this.#context.fs.copy(srcPath, destPath);
+	}
+	copySync(srcPath, destPath) {
+		this.#context.fs.copySync(srcPath, destPath);
+	}
+	async fileExists(filePath) {
+		return this.#context.fs.isFile(filePath);
+	}
+	fileExistsSync(filePath) {
+		return this.#context.fs.isFileSync(filePath);
+	}
+	async directoryExists(dirPath) {
+		return this.#context.fs.isDirectory(dirPath);
+	}
+	directoryExistsSync(dirPath) {
+		return this.#context.fs.isDirectorySync(dirPath);
+	}
+	realpathSync(path) {
+		return this.#context.fs.resolveSync(path) || path;
+	}
+	getCurrentDirectory() {
+		return this.#context.config.cwd;
+	}
+	async glob(patterns) {
+		return this.#context.fs.glob(patterns);
+	}
+	globSync(patterns) {
+		return this.#context.fs.globSync(patterns);
+	}
+};
+/**
+* Create a ts-morph {@link Project} instance used for type reflection and module manipulation during processing
+*
+* @param context - The Powerlines context
+* @returns A ts-morph {@link Project} instance
+*/
+function createProgram(context, override) {
+	context.debug(`Creating ts-morph Project instance with configuration from: ${context.tsconfig.tsconfigFilePath}.`);
+	return new ts_morph.Project((0, defu.default)(override ?? {}, {
+		skipAddingFilesFromTsConfig: false,
+		tsConfigFilePath: context.tsconfig.tsconfigFilePath,
+		fileSystem: new VirtualFileSystemHost(context),
+		compilerOptions: (0, defu.default)(context.tsconfig.options ?? {}, { lib: ["lib.esnext.full.d.ts"] })
+	}));
+}
+
+//#endregion
+exports.VirtualFileSystemHost = VirtualFileSystemHost;
+exports.createProgram = createProgram;

package/dist/lib/typescript/ts-morph.d.cts

@@ -0,0 +1,38 @@
+import { Context } from "../../types/context.cjs";
+import { FileSystemHost, InMemoryFileSystemHost, Project, ProjectOptions, RuntimeDirEntry } from "ts-morph";
+
+//#region src/lib/typescript/ts-morph.d.ts
+declare class VirtualFileSystemHost extends InMemoryFileSystemHost implements FileSystemHost {
+  #private;
+  constructor(context: Context);
+  deleteSync(path: string): void;
+  readDirSync(dirPath: string): RuntimeDirEntry[];
+  readFile(filePath: string): Promise<string>;
+  readFileSync(filePath: string): string;
+  writeFile(filePath: string, fileText: string): Promise<void>;
+  writeFileSync(filePath: string, fileText: string): void;
+  mkdir(dirPath: string): Promise<void>;
+  mkdirSync(dirPath: string): void;
+  move(srcPath: string, destPath: string): Promise<void>;
+  moveSync(srcPath: string, destPath: string): void;
+  copy(srcPath: string, destPath: string): Promise<void>;
+  copySync(srcPath: string, destPath: string): void;
+  fileExists(filePath: string): Promise<boolean>;
+  fileExistsSync(filePath: string): boolean;
+  directoryExists(dirPath: string): Promise<boolean>;
+  directoryExistsSync(dirPath: string): boolean;
+  realpathSync(path: string): string;
+  getCurrentDirectory(): string;
+  glob(patterns: ReadonlyArray<string>): Promise<string[]>;
+  globSync(patterns: ReadonlyArray<string>): string[];
+}
+/**
+ * Create a ts-morph {@link Project} instance used for type reflection and module manipulation during processing
+ *
+ * @param context - The Powerlines context
+ * @returns A ts-morph {@link Project} instance
+ */
+declare function createProgram(context: Context, override: Partial<ProjectOptions>): Project;
+//#endregion
+export { VirtualFileSystemHost, createProgram };
+//# sourceMappingURL=ts-morph.d.cts.map

package/dist/lib/typescript/ts-morph.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-morph.d.cts","names":[],"sources":["../../../src/lib/typescript/ts-morph.ts"],"mappings":";;;;cA6Ba,qBAAA,SACH,sBAAA,YACG,cAAA;EAAA;cAIQ,OAAA,EAAS,OAAA;EAMZ,UAAA,CAAW,IAAA;EAIX,WAAA,CAAY,OAAA,WAAkB,eAAA;EAoBxB,QAAA,CAAS,QAAA,WAAgB,OAAA;EAQ/B,YAAA,CAAa,QAAA;EAQP,SAAA,CAAU,QAAA,UAAkB,QAAA,WAAgB,OAAA;EAIlD,aAAA,CAAc,QAAA,UAAkB,QAAA;EAI1B,KAAA,CAAM,OAAA,WAAe,OAAA;EAI3B,SAAA,CAAU,OAAA;EAIJ,IAAA,CAAK,OAAA,UAAiB,QAAA,WAAgB,OAAA;EAI5C,QAAA,CAAS,OAAA,UAAiB,QAAA;EAIpB,IAAA,CAAK,OAAA,UAAiB,QAAA,WAAgB,OAAA;EAI5C,QAAA,CAAS,OAAA,UAAiB,QAAA;EAIpB,UAAA,CAAW,QAAA,WAAgB,OAAA;EAIjC,cAAA,CAAe,QAAA;EAIT,eAAA,CAAgB,OAAA,WAAe,OAAA;EAIrC,mBAAA,CAAoB,OAAA;EAIpB,YAAA,CAAa,IAAA;EAIb,mBAAA,CAAA;EAIM,IAAA,CACpB,QAAA,EAAU,aAAA,WACT,OAAA;EAIa,QAAA,CAAS,QAAA,EAAU,aAAA;AAAA;;;;;;;iBAWrB,aAAA,CACd,OAAA,EAAS,OAAA,EACT,QAAA,EAAU,OAAA,CAAQ,cAAA,IACjB,OAAA"}

package/dist/lib/typescript/ts-morph.d.mts

@@ -0,0 +1,38 @@
+import { Context } from "../../types/context.mjs";
+import { FileSystemHost, InMemoryFileSystemHost, Project, ProjectOptions, RuntimeDirEntry } from "ts-morph";
+
+//#region src/lib/typescript/ts-morph.d.ts
+declare class VirtualFileSystemHost extends InMemoryFileSystemHost implements FileSystemHost {
+  #private;
+  constructor(context: Context);
+  deleteSync(path: string): void;
+  readDirSync(dirPath: string): RuntimeDirEntry[];
+  readFile(filePath: string): Promise<string>;
+  readFileSync(filePath: string): string;
+  writeFile(filePath: string, fileText: string): Promise<void>;
+  writeFileSync(filePath: string, fileText: string): void;
+  mkdir(dirPath: string): Promise<void>;
+  mkdirSync(dirPath: string): void;
+  move(srcPath: string, destPath: string): Promise<void>;
+  moveSync(srcPath: string, destPath: string): void;
+  copy(srcPath: string, destPath: string): Promise<void>;
+  copySync(srcPath: string, destPath: string): void;
+  fileExists(filePath: string): Promise<boolean>;
+  fileExistsSync(filePath: string): boolean;
+  directoryExists(dirPath: string): Promise<boolean>;
+  directoryExistsSync(dirPath: string): boolean;
+  realpathSync(path: string): string;
+  getCurrentDirectory(): string;
+  glob(patterns: ReadonlyArray<string>): Promise<string[]>;
+  globSync(patterns: ReadonlyArray<string>): string[];
+}
+/**
+ * Create a ts-morph {@link Project} instance used for type reflection and module manipulation during processing
+ *
+ * @param context - The Powerlines context
+ * @returns A ts-morph {@link Project} instance
+ */
+declare function createProgram(context: Context, override: Partial<ProjectOptions>): Project;
+//#endregion
+export { VirtualFileSystemHost, createProgram };
+//# sourceMappingURL=ts-morph.d.mts.map

package/dist/lib/typescript/ts-morph.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-morph.d.mts","names":[],"sources":["../../../src/lib/typescript/ts-morph.ts"],"mappings":";;;;cA6Ba,qBAAA,SACH,sBAAA,YACG,cAAA;EAAA;cAIQ,OAAA,EAAS,OAAA;EAMZ,UAAA,CAAW,IAAA;EAIX,WAAA,CAAY,OAAA,WAAkB,eAAA;EAoBxB,QAAA,CAAS,QAAA,WAAgB,OAAA;EAQ/B,YAAA,CAAa,QAAA;EAQP,SAAA,CAAU,QAAA,UAAkB,QAAA,WAAgB,OAAA;EAIlD,aAAA,CAAc,QAAA,UAAkB,QAAA;EAI1B,KAAA,CAAM,OAAA,WAAe,OAAA;EAI3B,SAAA,CAAU,OAAA;EAIJ,IAAA,CAAK,OAAA,UAAiB,QAAA,WAAgB,OAAA;EAI5C,QAAA,CAAS,OAAA,UAAiB,QAAA;EAIpB,IAAA,CAAK,OAAA,UAAiB,QAAA,WAAgB,OAAA;EAI5C,QAAA,CAAS,OAAA,UAAiB,QAAA;EAIpB,UAAA,CAAW,QAAA,WAAgB,OAAA;EAIjC,cAAA,CAAe,QAAA;EAIT,eAAA,CAAgB,OAAA,WAAe,OAAA;EAIrC,mBAAA,CAAoB,OAAA;EAIpB,YAAA,CAAa,IAAA;EAIb,mBAAA,CAAA;EAIM,IAAA,CACpB,QAAA,EAAU,aAAA,WACT,OAAA;EAIa,QAAA,CAAS,QAAA,EAAU,aAAA;AAAA;;;;;;;iBAWrB,aAAA,CACd,OAAA,EAAS,OAAA,EACT,QAAA,EAAU,OAAA,CAAQ,cAAA,IACjB,OAAA"}