@ricsam/isolate-fetch 0.1.1 → 0.1.2

package/src/stream-state.test.ts

@@ -1,338 +0,0 @@
-import { test, describe } from "node:test";
-import assert from "node:assert";
-import {
-  createStreamStateRegistry,
-  HIGH_WATER_MARK,
-  MAX_QUEUE_CHUNKS,
-} from "./stream-state.ts";
-
-describe("StreamStateRegistry", () => {
-  test("create returns unique IDs", () => {
-    const registry = createStreamStateRegistry();
-    const id1 = registry.create();
-    const id2 = registry.create();
-    expect(id1).not.toBe(id2);
-  });
-
-  test("create starts from 1", () => {
-    const registry = createStreamStateRegistry();
-    const id = registry.create();
-    assert.strictEqual(id, 1);
-  });
-
-  test("get returns stream state after create", () => {
-    const registry = createStreamStateRegistry();
-    const streamId = registry.create();
-    const state = registry.get(streamId);
-
-    assert.notStrictEqual(state, undefined);
-    assert.deepStrictEqual(state?.queue, []);
-    assert.strictEqual(state?.queueSize, 0);
-    assert.strictEqual(state?.closed, false);
-    assert.strictEqual(state?.errored, false);
-    assert.strictEqual(state?.pullWaiting, false);
-  });
-
-  test("get returns undefined for non-existent stream", () => {
-    const registry = createStreamStateRegistry();
-    const state = registry.get(999);
-    assert.strictEqual(state, undefined);
-  });
-
-  test("push and pull work synchronously when data available", async () => {
-    const registry = createStreamStateRegistry();
-    const streamId = registry.create();
-
-    registry.push(streamId, new Uint8Array([1, 2, 3]));
-    const result = await registry.pull(streamId);
-
-    assert.strictEqual(result.done, false);
-    if (!result.done) {
-      assert.deepStrictEqual(result.value, new Uint8Array([1, 2, 3]));
-    }
-  });
-
-  test("push returns true on success", () => {
-    const registry = createStreamStateRegistry();
-    const streamId = registry.create();
-
-    const result = registry.push(streamId, new Uint8Array([1, 2, 3]));
-    assert.strictEqual(result, true);
-  });
-
-  test("push returns false for non-existent stream", () => {
-    const registry = createStreamStateRegistry();
-    const result = registry.push(999, new Uint8Array([1, 2, 3]));
-    assert.strictEqual(result, false);
-  });
-
-  test("push returns false for closed stream", () => {
-    const registry = createStreamStateRegistry();
-    const streamId = registry.create();
-
-    registry.close(streamId);
-    const result = registry.push(streamId, new Uint8Array([1, 2, 3]));
-    assert.strictEqual(result, false);
-  });
-
-  test("push returns false for errored stream", () => {
-    const registry = createStreamStateRegistry();
-    const streamId = registry.create();
-
-    registry.error(streamId, new Error("test error"));
-    const result = registry.push(streamId, new Uint8Array([1, 2, 3]));
-    assert.strictEqual(result, false);
-  });
-
-  test("pull waits for data when queue empty", async () => {
-    const registry = createStreamStateRegistry();
-    const streamId = registry.create();
-
-    // Start pull (will wait)
-    const pullPromise = registry.pull(streamId);
-
-    // Push after delay
-    setTimeout(() => {
-      registry.push(streamId, new Uint8Array([4, 5, 6]));
-    }, 10);
-
-    const result = await pullPromise;
-    assert.strictEqual(result.done, false);
-    if (!result.done) {
-      assert.deepStrictEqual(result.value, new Uint8Array([4, 5, 6]));
-    }
-  });
-
-  test("push delivers directly to waiting pull", async () => {
-    const registry = createStreamStateRegistry();
-    const streamId = registry.create();
-
-    // Start pull (will wait)
-    const pullPromise = registry.pull(streamId);
-
-    // Verify pull is waiting
-    const state = registry.get(streamId);
-    assert.strictEqual(state?.pullWaiting, true);
-
-    // Push should deliver directly
-    registry.push(streamId, new Uint8Array([7, 8, 9]));
-
-    // Queue should still be empty (delivered directly)
-    assert.strictEqual(state?.queue.length, 0);
-    assert.strictEqual(state?.pullWaiting, false);
-
-    const result = await pullPromise;
-    assert.strictEqual(result.done, false);
-    if (!result.done) {
-      assert.deepStrictEqual(result.value, new Uint8Array([7, 8, 9]));
-    }
-  });
-
-  test("multiple chunks can be queued and pulled in order", async () => {
-    const registry = createStreamStateRegistry();
-    const streamId = registry.create();
-
-    registry.push(streamId, new Uint8Array([1]));
-    registry.push(streamId, new Uint8Array([2]));
-    registry.push(streamId, new Uint8Array([3]));
-
-    const result1 = await registry.pull(streamId);
-    const result2 = await registry.pull(streamId);
-    const result3 = await registry.pull(streamId);
-
-    assert.strictEqual(result1.done, false);
-    assert.strictEqual(result2.done, false);
-    assert.strictEqual(result3.done, false);
-
-    if (!result1.done && !result2.done && !result3.done) {
-      assert.deepStrictEqual(result1.value, new Uint8Array([1]));
-      assert.deepStrictEqual(result2.value, new Uint8Array([2]));
-      assert.deepStrictEqual(result3.value, new Uint8Array([3]));
-    }
-  });
-
-  test("close resolves waiting pull with done", async () => {
-    const registry = createStreamStateRegistry();
-    const streamId = registry.create();
-
-    const pullPromise = registry.pull(streamId);
-    registry.close(streamId);
-
-    const result = await pullPromise;
-    assert.strictEqual(result.done, true);
-  });
-
-  test("pull returns done after close when queue empty", async () => {
-    const registry = createStreamStateRegistry();
-    const streamId = registry.create();
-
-    registry.close(streamId);
-
-    const result = await registry.pull(streamId);
-    assert.strictEqual(result.done, true);
-  });
-
-  test("pull returns queued data before done after close", async () => {
-    const registry = createStreamStateRegistry();
-    const streamId = registry.create();
-
-    registry.push(streamId, new Uint8Array([1, 2, 3]));
-    registry.close(streamId);
-
-    // First pull gets the data
-    const result1 = await registry.pull(streamId);
-    assert.strictEqual(result1.done, false);
-    if (!result1.done) {
-      assert.deepStrictEqual(result1.value, new Uint8Array([1, 2, 3]));
-    }
-
-    // Second pull gets done
-    const result2 = await registry.pull(streamId);
-    assert.strictEqual(result2.done, true);
-  });
-
-  test("error rejects waiting pull", async () => {
-    const registry = createStreamStateRegistry();
-    const streamId = registry.create();
-
-    const pullPromise = registry.pull(streamId);
-    registry.error(streamId, new Error("test error"));
-
-    await assert.rejects(pullPromise, { message: "test error" });
-  });
-
-  test("pull throws for errored stream", async () => {
-    const registry = createStreamStateRegistry();
-    const streamId = registry.create();
-
-    registry.error(streamId, new Error("test error"));
-
-    await assert.rejects(registry.pull(streamId), { message: "test error" });
-  });
-
-  test("pull returns done for non-existent stream", async () => {
-    const registry = createStreamStateRegistry();
-    const result = await registry.pull(999);
-    assert.strictEqual(result.done, true);
-  });
-
-  test("isQueueFull returns false initially", () => {
-    const registry = createStreamStateRegistry();
-    const streamId = registry.create();
-
-    assert.strictEqual(registry.isQueueFull(streamId), false);
-  });
-
-  test("isQueueFull returns true for non-existent stream", () => {
-    const registry = createStreamStateRegistry();
-    assert.strictEqual(registry.isQueueFull(999), true);
-  });
-
-  test("isQueueFull respects high water mark", () => {
-    const registry = createStreamStateRegistry();
-    const streamId = registry.create();
-
-    assert.strictEqual(registry.isQueueFull(streamId), false);
-
-    // Push chunk at high water mark
-    registry.push(streamId, new Uint8Array(HIGH_WATER_MARK));
-    assert.strictEqual(registry.isQueueFull(streamId), true);
-  });
-
-  test("isQueueFull respects max queue chunks", () => {
-    const registry = createStreamStateRegistry();
-    const streamId = registry.create();
-
-    // Push small chunks up to MAX_QUEUE_CHUNKS
-    for (let i = 0; i < MAX_QUEUE_CHUNKS; i++) {
-      registry.push(streamId, new Uint8Array([i]));
-    }
-
-    assert.strictEqual(registry.isQueueFull(streamId), true);
-  });
-
-  test("queueSize tracks total bytes correctly", () => {
-    const registry = createStreamStateRegistry();
-    const streamId = registry.create();
-
-    registry.push(streamId, new Uint8Array(100));
-    registry.push(streamId, new Uint8Array(200));
-
-    const state = registry.get(streamId);
-    assert.strictEqual(state?.queueSize, 300);
-  });
-
-  test("queueSize decreases on pull", async () => {
-    const registry = createStreamStateRegistry();
-    const streamId = registry.create();
-
-    registry.push(streamId, new Uint8Array(100));
-    registry.push(streamId, new Uint8Array(200));
-
-    await registry.pull(streamId);
-
-    const state = registry.get(streamId);
-    assert.strictEqual(state?.queueSize, 200);
-  });
-
-  test("delete removes stream state", () => {
-    const registry = createStreamStateRegistry();
-    const streamId = registry.create();
-
-    registry.delete(streamId);
-
-    const state = registry.get(streamId);
-    assert.strictEqual(state, undefined);
-  });
-
-  test("delete rejects waiting pull", async () => {
-    const registry = createStreamStateRegistry();
-    const streamId = registry.create();
-
-    const pullPromise = registry.pull(streamId);
-    registry.delete(streamId);
-
-    await assert.rejects(pullPromise, { message: "Stream deleted" });
-  });
-
-  test("clear removes all streams", () => {
-    const registry = createStreamStateRegistry();
-    const id1 = registry.create();
-    const id2 = registry.create();
-    const id3 = registry.create();
-
-    registry.clear();
-
-    assert.strictEqual(registry.get(id1), undefined);
-    assert.strictEqual(registry.get(id2), undefined);
-    assert.strictEqual(registry.get(id3), undefined);
-  });
-
-  test("clear rejects all waiting pulls", async () => {
-    const registry = createStreamStateRegistry();
-    const id1 = registry.create();
-    const id2 = registry.create();
-
-    const pull1 = registry.pull(id1);
-    const pull2 = registry.pull(id2);
-
-    registry.clear();
-
-    await assert.rejects(pull1, { message: "Stream deleted" });
-    await assert.rejects(pull2, { message: "Stream deleted" });
-  });
-});
-
-// Test that we correctly use assert.notStrictEqual to fix the first test
-function expect(value: unknown) {
-  return {
-    not: {
-      toBe(other: unknown) {
-        assert.notStrictEqual(value, other);
-      },
-    },
-    toBe(other: unknown) {
-      assert.strictEqual(value, other);
-    },
-  };
-}

package/src/stream-state.ts

@@ -1,337 +0,0 @@
-import ivm from "isolated-vm";
-
-// ============================================================================
-// Types
-// ============================================================================
-
-export interface StreamState {
-  /** Buffered chunks waiting to be read */
-  queue: Uint8Array[];
-
-  /** Total bytes in queue (for backpressure) */
-  queueSize: number;
-
-  /** Stream has been closed (no more data) */
-  closed: boolean;
-
-  /** Stream encountered an error */
-  errored: boolean;
-
-  /** The error value if errored */
-  errorValue: unknown;
-
-  /** A pull is waiting for data */
-  pullWaiting: boolean;
-
-  /** Resolve function for waiting pull */
-  pullResolve: ((chunk: Uint8Array | null) => void) | null;
-
-  /** Reject function for waiting pull */
-  pullReject: ((error: unknown) => void) | null;
-}
-
-export interface StreamStateRegistry {
-  /** Create a new stream and return its ID */
-  create(): number;
-
-  /** Get stream state by ID */
-  get(streamId: number): StreamState | undefined;
-
-  /** Push a chunk to the stream's queue */
-  push(streamId: number, chunk: Uint8Array): boolean;
-
-  /** Pull a chunk from the stream (returns Promise that resolves when data available) */
-  pull(
-    streamId: number
-  ): Promise<{ value: Uint8Array; done: false } | { done: true }>;
-
-  /** Close the stream (no more data) */
-  close(streamId: number): void;
-
-  /** Error the stream */
-  error(streamId: number, errorValue: unknown): void;
-
-  /** Check if stream queue is above high-water mark */
-  isQueueFull(streamId: number): boolean;
-
-  /** Delete stream state (cleanup) */
-  delete(streamId: number): void;
-
-  /** Clear all streams (context cleanup) */
-  clear(): void;
-}
-
-// ============================================================================
-// Constants
-// ============================================================================
-
-/** Maximum bytes to buffer before backpressure kicks in */
-export const HIGH_WATER_MARK = 64 * 1024; // 64KB
-
-/** Maximum number of chunks in queue */
-export const MAX_QUEUE_CHUNKS = 16;
-
-// ============================================================================
-// Implementation
-// ============================================================================
-
-export function createStreamStateRegistry(): StreamStateRegistry {
-  const streams = new Map<number, StreamState>();
-  let nextStreamId = 1;
-
-  return {
-    create(): number {
-      const streamId = nextStreamId++;
-      streams.set(streamId, {
-        queue: [],
-        queueSize: 0,
-        closed: false,
-        errored: false,
-        errorValue: undefined,
-        pullWaiting: false,
-        pullResolve: null,
-        pullReject: null,
-      });
-      return streamId;
-    },
-
-    get(streamId: number): StreamState | undefined {
-      return streams.get(streamId);
-    },
-
-    push(streamId: number, chunk: Uint8Array): boolean {
-      const state = streams.get(streamId);
-      if (!state) return false;
-      if (state.closed || state.errored) return false;
-
-      // If a pull is waiting, deliver directly
-      if (state.pullWaiting && state.pullResolve) {
-        state.pullWaiting = false;
-        const resolve = state.pullResolve;
-        state.pullResolve = null;
-        state.pullReject = null;
-        resolve(chunk);
-        return true;
-      }
-
-      // Otherwise queue the chunk
-      state.queue.push(chunk);
-      state.queueSize += chunk.length;
-      return true;
-    },
-
-    async pull(
-      streamId: number
-    ): Promise<{ value: Uint8Array; done: false } | { done: true }> {
-      const state = streams.get(streamId);
-      if (!state) {
-        return { done: true };
-      }
-
-      // If queue has data, return it first (even if stream is errored)
-      if (state.queue.length > 0) {
-        const chunk = state.queue.shift()!;
-        state.queueSize -= chunk.length;
-        return { value: chunk, done: false };
-      }
-
-      // If errored (and queue is empty), throw
-      if (state.errored) {
-        throw state.errorValue;
-      }
-
-      // If closed and queue empty, we're done
-      if (state.closed) {
-        return { done: true };
-      }
-
-      // Wait for data
-      return new Promise((resolve, reject) => {
-        state.pullWaiting = true;
-        state.pullResolve = (chunk) => {
-          if (chunk === null) {
-            resolve({ done: true });
-          } else {
-            resolve({ value: chunk, done: false });
-          }
-        };
-        state.pullReject = reject;
-      });
-    },
-
-    close(streamId: number): void {
-      const state = streams.get(streamId);
-      if (!state) return;
-
-      state.closed = true;
-
-      // If a pull is waiting, resolve with done
-      if (state.pullWaiting && state.pullResolve) {
-        state.pullWaiting = false;
-        const resolve = state.pullResolve;
-        state.pullResolve = null;
-        state.pullReject = null;
-        resolve(null);
-      }
-    },
-
-    error(streamId: number, errorValue: unknown): void {
-      const state = streams.get(streamId);
-      if (!state) return;
-
-      state.errored = true;
-      state.errorValue = errorValue;
-
-      // If a pull is waiting, reject it
-      if (state.pullWaiting && state.pullReject) {
-        state.pullWaiting = false;
-        const reject = state.pullReject;
-        state.pullResolve = null;
-        state.pullReject = null;
-        reject(errorValue);
-      }
-    },
-
-    isQueueFull(streamId: number): boolean {
-      const state = streams.get(streamId);
-      if (!state) return true;
-      return (
-        state.queueSize >= HIGH_WATER_MARK ||
-        state.queue.length >= MAX_QUEUE_CHUNKS
-      );
-    },
-
-    delete(streamId: number): void {
-      const state = streams.get(streamId);
-      if (state && state.pullWaiting && state.pullReject) {
-        state.pullReject(new Error("Stream deleted"));
-      }
-      streams.delete(streamId);
-    },
-
-    clear(): void {
-      for (const [streamId] of streams) {
-        this.delete(streamId);
-      }
-    },
-  };
-}
-
-// ============================================================================
-// Context-Scoped Registry
-// ============================================================================
-
-const contextRegistries = new WeakMap<ivm.Context, StreamStateRegistry>();
-
-export function getStreamRegistryForContext(
-  context: ivm.Context
-): StreamStateRegistry {
-  let registry = contextRegistries.get(context);
-  if (!registry) {
-    registry = createStreamStateRegistry();
-    contextRegistries.set(context, registry);
-  }
-  return registry;
-}
-
-export function clearStreamRegistryForContext(context: ivm.Context): void {
-  const registry = contextRegistries.get(context);
-  if (registry) {
-    registry.clear();
-    contextRegistries.delete(context);
-  }
-}
-
-// ============================================================================
-// Native Stream Reader
-// ============================================================================
-
-/**
- * Start reading from a native ReadableStream and push to host queue.
- * Respects backpressure by pausing when queue is full.
- *
- * @param nativeStream The native ReadableStream to read from
- * @param streamId The stream ID in the registry
- * @param registry The stream state registry
- * @returns Async cleanup function to cancel the reader
- */
-export function startNativeStreamReader(
-  nativeStream: ReadableStream<Uint8Array>,
-  streamId: number,
-  registry: StreamStateRegistry
-): () => Promise<void> {
-  let cancelled = false;
-  let reader: ReadableStreamDefaultReader<Uint8Array> | null = null;
-  let readLoopPromise: Promise<void> | null = null;
-
-  const CHUNK_SIZE = 64 * 1024; // 64KB max chunk size
-
-  async function readLoop() {
-    try {
-      reader = nativeStream.getReader();
-
-      while (!cancelled) {
-        // Respect backpressure - wait if queue is full
-        while (registry.isQueueFull(streamId) && !cancelled) {
-          await new Promise((resolve) => setTimeout(resolve, 1));
-        }
-        if (cancelled) break;
-
-        const { done, value } = await reader.read();
-
-        if (done) {
-          registry.close(streamId);
-          break;
-        }
-
-        if (value) {
-          // Split large chunks to maintain granularity
-          if (value.length > CHUNK_SIZE) {
-            for (let offset = 0; offset < value.length; offset += CHUNK_SIZE) {
-              const chunk = value.slice(
-                offset,
-                Math.min(offset + CHUNK_SIZE, value.length)
-              );
-              registry.push(streamId, chunk);
-            }
-          } else {
-            registry.push(streamId, value);
-          }
-        }
-      }
-    } catch (error) {
-      registry.error(streamId, error);
-    } finally {
-      if (reader) {
-        try {
-          reader.releaseLock();
-        } catch {
-          // Ignore release errors
-        }
-      }
-    }
-  }
-
-  // Start the read loop and save the promise
-  readLoopPromise = readLoop();
-
-  // Return async cleanup function
-  return async () => {
-    cancelled = true;
-    if (reader) {
-      try {
-        await reader.cancel();
-      } catch {
-        // Ignore cancel errors
-      }
-    }
-    // Wait for read loop to finish
-    if (readLoopPromise) {
-      try {
-        await readLoopPromise;
-      } catch {
-        // Ignore read loop errors during cleanup
-      }
-    }
-  };
-}