@cloudflare/sandbox 0.0.0-7fd1847 → 0.0.0-80fd0f2

package/tests/sse-parser.test.ts

@@ -1,5 +1,9 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { asyncIterableToSSEStream, parseSSEStream, responseToAsyncIterable } from '../src/sse-parser';
+import {
+  asyncIterableToSSEStream,
+  parseSSEStream,
+  responseToAsyncIterable
+} from '../src/sse-parser';
 
 function createMockSSEStream(events: string[]): ReadableStream<Uint8Array> {
   return new ReadableStream({
@@ -25,7 +29,6 @@ describe('SSE Parser', () => {
   });
 
   describe('parseSSEStream', () => {
-
     it('should parse valid SSE events', async () => {
       const stream = createMockSSEStream([
         'data: {"type":"start","command":"echo test"}\n\n',
@@ -134,9 +137,7 @@ describe('SSE Parser', () => {
     });
 
     it('should handle remaining buffer data after stream ends', async () => {
-      const stream = createMockSSEStream([
-        'data: {"type":"complete"}'
-      ]);
+      const stream = createMockSSEStream(['data: {"type":"complete"}']);
 
       const events: any[] = [];
       for await (const event of parseSSEStream(stream)) {
@@ -153,7 +154,8 @@ describe('SSE Parser', () => {
       controller.abort();
 
       await expect(async () => {
-        for await (const event of parseSSEStream(stream, controller.signal)) {}
+        for await (const event of parseSSEStream(stream, controller.signal)) {
+        }
       }).rejects.toThrow('Operation was aborted');
     });
 
@@ -236,10 +238,10 @@ describe('SSE Parser', () => {
       const stream = asyncIterableToSSEStream(mockEvents());
       const reader = stream.getReader();
       const decoder = new TextDecoder();
-      
+
       const chunks: string[] = [];
       let done = false;
-      
+
       while (!done) {
         const { value, done: readerDone } = await reader.read();
         done = readerDone;
@@ -251,9 +253,9 @@ describe('SSE Parser', () => {
       const fullOutput = chunks.join('');
       expect(fullOutput).toBe(
         'data: {"type":"start","command":"test"}\n\n' +
-        'data: {"type":"stdout","data":"output"}\n\n' +
-        'data: {"type":"complete","exitCode":0}\n\n' +
-        'data: [DONE]\n\n'
+          'data: {"type":"stdout","data":"output"}\n\n' +
+          'data: {"type":"complete","exitCode":0}\n\n' +
+          'data: [DONE]\n\n'
       );
     });
 
@@ -262,10 +264,9 @@ describe('SSE Parser', () => {
         yield { name: 'test', value: 123 };
       }
 
-      const stream = asyncIterableToSSEStream(
-        mockEvents(),
-        { serialize: (event) => `custom:${event.name}=${event.value}` }
-      );
+      const stream = asyncIterableToSSEStream(mockEvents(), {
+        serialize: (event) => `custom:${event.name}=${event.value}`
+      });
 
       const reader = stream.getReader();
       const decoder = new TextDecoder();
@@ -287,4 +288,4 @@ describe('SSE Parser', () => {
       await expect(reader.read()).rejects.toThrow('Async iterable error');
     });
   });
-});
+});

package/tests/utility-client.test.ts

@@ -1,15 +1,16 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import type {
   CommandsResponse,
-  PingResponse
+  PingResponse,
+  VersionResponse
 } from '../src/clients';
 import { UtilityClient } from '../src/clients/utility-client';
-import {
-  SandboxError
-} from '../src/errors';
+import { SandboxError } from '../src/errors';
 
 // Mock data factory for creating test responses
-const mockPingResponse = (overrides: Partial<PingResponse> = {}): PingResponse => ({
+const mockPingResponse = (
+  overrides: Partial<PingResponse> = {}
+): PingResponse => ({
   success: true,
   message: 'pong',
   uptime: 12345,
@@ -17,7 +18,10 @@ const mockPingResponse = (overrides: Partial<PingResponse> = {}): PingResponse =
   ...overrides
 });
 
-const mockCommandsResponse = (commands: string[], overrides: Partial<CommandsResponse> = {}): CommandsResponse => ({
+const mockCommandsResponse = (
+  commands: string[],
+  overrides: Partial<CommandsResponse> = {}
+): CommandsResponse => ({
   success: true,
   availableCommands: commands,
   count: commands.length,
@@ -25,6 +29,16 @@ const mockCommandsResponse = (commands: string[], overrides: Partial<CommandsRes
   ...overrides
 });
 
+const mockVersionResponse = (
+  version: string = '0.4.5',
+  overrides: Partial<VersionResponse> = {}
+): VersionResponse => ({
+  success: true,
+  version,
+  timestamp: '2023-01-01T00:00:00Z',
+  ...overrides
+});
+
 describe('UtilityClient', () => {
   let client: UtilityClient;
   let mockFetch: ReturnType<typeof vi.fn>;
@@ -37,7 +51,7 @@ describe('UtilityClient', () => {
 
     client = new UtilityClient({
       baseUrl: 'http://test.com',
-      port: 3000,
+      port: 3000
     });
   });
 
@@ -47,10 +61,9 @@ describe('UtilityClient', () => {
 
   describe('health checking', () => {
     it('should check sandbox health successfully', async () => {
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(mockPingResponse()),
-        { status: 200 }
-      ));
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(mockPingResponse()), { status: 200 })
+      );
 
       const result = await client.ping();
 
@@ -61,10 +74,11 @@ describe('UtilityClient', () => {
       const messages = ['pong', 'alive', 'ok'];
 
       for (const message of messages) {
-        mockFetch.mockResolvedValueOnce(new Response(
-          JSON.stringify(mockPingResponse({ message })),
-          { status: 200 }
-        ));
+        mockFetch.mockResolvedValueOnce(
+          new Response(JSON.stringify(mockPingResponse({ message })), {
+            status: 200
+          })
+        );
 
         const result = await client.ping();
         expect(result).toBe(message);
@@ -79,11 +93,11 @@ describe('UtilityClient', () => {
       const healthChecks = await Promise.all([
         client.ping(),
         client.ping(),
-        client.ping(),
+        client.ping()
       ]);
 
       expect(healthChecks).toHaveLength(3);
-      healthChecks.forEach(result => {
+      healthChecks.forEach((result) => {
         expect(result).toBe('pong');
       });
 
@@ -96,10 +110,9 @@ describe('UtilityClient', () => {
         code: 'HEALTH_CHECK_FAILED'
       };
 
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(errorResponse),
-        { status: 503 }
-      ));
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(errorResponse), { status: 503 })
+      );
 
       await expect(client.ping()).rejects.toThrow();
     });
@@ -115,10 +128,11 @@ describe('UtilityClient', () => {
     it('should discover available system commands', async () => {
       const systemCommands = ['ls', 'cat', 'echo', 'grep', 'find'];
 
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(mockCommandsResponse(systemCommands)),
-        { status: 200 }
-      ));
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(mockCommandsResponse(systemCommands)), {
+          status: 200
+        })
+      );
 
       const result = await client.getCommands();
 
@@ -131,10 +145,11 @@ describe('UtilityClient', () => {
     it('should handle minimal command environments', async () => {
       const minimalCommands = ['sh', 'echo', 'cat'];
 
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(mockCommandsResponse(minimalCommands)),
-        { status: 200 }
-      ));
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(mockCommandsResponse(minimalCommands)), {
+          status: 200
+        })
+      );
 
       const result = await client.getCommands();
 
@@ -145,10 +160,11 @@ describe('UtilityClient', () => {
     it('should handle large command environments', async () => {
       const richCommands = Array.from({ length: 150 }, (_, i) => `cmd_${i}`);
 
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(mockCommandsResponse(richCommands)),
-        { status: 200 }
-      ));
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(mockCommandsResponse(richCommands)), {
+          status: 200
+        })
+      );
 
       const result = await client.getCommands();
 
@@ -157,10 +173,9 @@ describe('UtilityClient', () => {
     });
 
     it('should handle empty command environments', async () => {
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(mockCommandsResponse([])),
-        { status: 200 }
-      ));
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(mockCommandsResponse([])), { status: 200 })
+      );
 
       const result = await client.getCommands();
 
@@ -174,10 +189,9 @@ describe('UtilityClient', () => {
         code: 'PERMISSION_DENIED'
       };
 
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(errorResponse),
-        { status: 403 }
-      ));
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(errorResponse), { status: 403 })
+      );
 
       await expect(client.getCommands()).rejects.toThrow();
     });
@@ -185,10 +199,9 @@ describe('UtilityClient', () => {
 
   describe('error handling and resilience', () => {
     it('should handle malformed server responses gracefully', async () => {
-      mockFetch.mockResolvedValue(new Response(
-        'invalid json {',
-        { status: 200 }
-      ));
+      mockFetch.mockResolvedValue(
+        new Response('invalid json {', { status: 200 })
+      );
 
       await expect(client.ping()).rejects.toThrow(SandboxError);
     });
@@ -202,10 +215,9 @@ describe('UtilityClient', () => {
 
     it('should handle partial service failures', async () => {
       // First call (ping) succeeds
-      mockFetch.mockResolvedValueOnce(new Response(
-        JSON.stringify(mockPingResponse()),
-        { status: 200 }
-      ));
+      mockFetch.mockResolvedValueOnce(
+        new Response(JSON.stringify(mockPingResponse()), { status: 200 })
+      );
 
       // Second call (getCommands) fails
       const errorResponse = {
@@ -213,10 +225,9 @@ describe('UtilityClient', () => {
         code: 'SERVICE_UNAVAILABLE'
       };
 
-      mockFetch.mockResolvedValueOnce(new Response(
-        JSON.stringify(errorResponse),
-        { status: 503 }
-      ));
+      mockFetch.mockResolvedValueOnce(
+        new Response(JSON.stringify(errorResponse), { status: 503 })
+      );
 
       const pingResult = await client.ping();
       expect(pingResult).toBe('pong');
@@ -231,7 +242,9 @@ describe('UtilityClient', () => {
         if (callCount % 2 === 0) {
           return Promise.reject(new Error('Intermittent failure'));
         } else {
-          return Promise.resolve(new Response(JSON.stringify(mockPingResponse())));
+          return Promise.resolve(
+            new Response(JSON.stringify(mockPingResponse()))
+          );
         }
       });
 
@@ -239,7 +252,7 @@ describe('UtilityClient', () => {
         client.ping(), // Should succeed (call 1)
         client.ping(), // Should fail (call 2)
         client.ping(), // Should succeed (call 3)
-        client.ping(), // Should fail (call 4)
+        client.ping() // Should fail (call 4)
       ]);
 
       expect(results[0].status).toBe('fulfilled');
@@ -249,6 +262,66 @@ describe('UtilityClient', () => {
     });
   });
 
+  describe('version checking', () => {
+    it('should get container version successfully', async () => {
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(mockVersionResponse('0.4.5')), {
+          status: 200
+        })
+      );
+
+      const result = await client.getVersion();
+
+      expect(result).toBe('0.4.5');
+    });
+
+    it('should handle different version formats', async () => {
+      const versions = ['1.0.0', '2.5.3-beta', '0.0.1', '10.20.30'];
+
+      for (const version of versions) {
+        mockFetch.mockResolvedValueOnce(
+          new Response(JSON.stringify(mockVersionResponse(version)), {
+            status: 200
+          })
+        );
+
+        const result = await client.getVersion();
+        expect(result).toBe(version);
+      }
+    });
+
+    it('should return "unknown" when version endpoint does not exist (backward compatibility)', async () => {
+      // Simulate 404 or other error for old containers
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify({ error: 'Not Found' }), { status: 404 })
+      );
+
+      const result = await client.getVersion();
+
+      expect(result).toBe('unknown');
+    });
+
+    it('should return "unknown" on network failure (backward compatibility)', async () => {
+      mockFetch.mockRejectedValue(new Error('Network connection failed'));
+
+      const result = await client.getVersion();
+
+      expect(result).toBe('unknown');
+    });
+
+    it('should handle version response with unknown value', async () => {
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(mockVersionResponse('unknown')), {
+          status: 200
+        })
+      );
+
+      const result = await client.getVersion();
+
+      expect(result).toBe('unknown');
+    });
+  });
+
   describe('constructor options', () => {
     it('should initialize with minimal options', () => {
       const minimalClient = new UtilityClient();
@@ -258,7 +331,7 @@ describe('UtilityClient', () => {
     it('should initialize with full options', () => {
       const fullOptionsClient = new UtilityClient({
         baseUrl: 'http://custom.com',
-        port: 8080,
+        port: 8080
       });
       expect(fullOptionsClient).toBeInstanceOf(UtilityClient);
     });

package/tests/version.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from 'vitest';
+import packageJson from '../package.json';
+import { SDK_VERSION } from '../src/version';
+
+describe('Version Sync', () => {
+  test('SDK_VERSION matches package.json version', () => {
+    // Verify versions match
+    expect(SDK_VERSION).toBe(packageJson.version);
+  });
+
+  test('SDK_VERSION is a valid semver version', () => {
+    // Check if version matches semver pattern (major.minor.patch)
+    const semverPattern = /^\d+\.\d+\.\d+(-[\w.]+)?$/;
+    expect(SDK_VERSION).toMatch(semverPattern);
+  });
+});

package/tsdown.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from 'tsdown';
+
+export default defineConfig({
+  entry: 'src/index.ts',
+  outDir: 'dist',
+  dts: {
+    sourcemap: true,
+    resolve: ['@repo/shared']
+  },
+  sourcemap: true,
+  format: 'esm'
+});

package/vitest.config.ts

@@ -18,14 +18,14 @@ export default defineWorkersConfig({
     poolOptions: {
       workers: {
         wrangler: {
-          configPath: './tests/wrangler.jsonc',
+          configPath: './tests/wrangler.jsonc'
         },
         singleWorker: true,
-        isolatedStorage: false,
-      },
-    },
+        isolatedStorage: false
+      }
+    }
   },
   esbuild: {
-    target: 'esnext',
-  },
+    target: 'esnext'
+  }
 });

package/dist/chunk-BFVUNTP4.js

@@ -1,104 +0,0 @@
-// src/file-stream.ts
-async function* parseSSE(stream) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        break;
-      }
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        if (line.startsWith("data: ")) {
-          const data = line.slice(6);
-          try {
-            const event = JSON.parse(data);
-            yield event;
-          } catch {
-          }
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
-async function* streamFile(stream) {
-  let metadata = null;
-  for await (const event of parseSSE(stream)) {
-    switch (event.type) {
-      case "metadata":
-        metadata = {
-          mimeType: event.mimeType,
-          size: event.size,
-          isBinary: event.isBinary,
-          encoding: event.encoding
-        };
-        break;
-      case "chunk":
-        if (!metadata) {
-          throw new Error("Received chunk before metadata");
-        }
-        if (metadata.isBinary && metadata.encoding === "base64") {
-          const binaryString = atob(event.data);
-          const bytes = new Uint8Array(binaryString.length);
-          for (let i = 0; i < binaryString.length; i++) {
-            bytes[i] = binaryString.charCodeAt(i);
-          }
-          yield bytes;
-        } else {
-          yield event.data;
-        }
-        break;
-      case "complete":
-        if (!metadata) {
-          throw new Error("Stream completed without metadata");
-        }
-        return metadata;
-      case "error":
-        throw new Error(`File streaming error: ${event.error}`);
-    }
-  }
-  throw new Error("Stream ended unexpectedly");
-}
-async function collectFile(stream) {
-  const chunks = [];
-  const generator = streamFile(stream);
-  let result = await generator.next();
-  while (!result.done) {
-    chunks.push(result.value);
-    result = await generator.next();
-  }
-  const metadata = result.value;
-  if (!metadata) {
-    throw new Error("Failed to get file metadata");
-  }
-  if (metadata.isBinary) {
-    const totalLength = chunks.reduce(
-      (sum, chunk) => sum + (chunk instanceof Uint8Array ? chunk.length : 0),
-      0
-    );
-    const combined = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const chunk of chunks) {
-      if (chunk instanceof Uint8Array) {
-        combined.set(chunk, offset);
-        offset += chunk.length;
-      }
-    }
-    return { content: combined, metadata };
-  } else {
-    const combined = chunks.filter((c) => typeof c === "string").join("");
-    return { content: combined, metadata };
-  }
-}
-
-export {
-  streamFile,
-  collectFile
-};
-//# sourceMappingURL=chunk-BFVUNTP4.js.map

package/dist/chunk-BFVUNTP4.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/file-stream.ts"],"sourcesContent":["import type { FileChunk, FileMetadata, FileStreamEvent } from '@repo/shared';\n\n/**\n * Parse SSE (Server-Sent Events) lines from a stream\n */\nasync function* parseSSE(stream: ReadableStream<Uint8Array>): AsyncGenerator<FileStreamEvent> {\n  const reader = stream.getReader();\n  const decoder = new TextDecoder();\n  let buffer = '';\n\n  try {\n    while (true) {\n      const { done, value } = await reader.read();\n\n      if (done) {\n        break;\n      }\n\n      buffer += decoder.decode(value, { stream: true });\n      const lines = buffer.split('\\n');\n\n      // Keep the last incomplete line in the buffer\n      buffer = lines.pop() || '';\n\n      for (const line of lines) {\n        if (line.startsWith('data: ')) {\n          const data = line.slice(6); // Remove 'data: ' prefix\n          try {\n            const event = JSON.parse(data) as FileStreamEvent;\n            yield event;\n          } catch {\n            // Skip invalid JSON events and continue processing\n          }\n        }\n      }\n    }\n  } finally {\n    reader.releaseLock();\n  }\n}\n\n/**\n * Stream a file from the sandbox with automatic base64 decoding for binary files\n *\n * @param stream - The ReadableStream from readFileStream()\n * @returns AsyncGenerator that yields FileChunk (string for text, Uint8Array for binary)\n *\n * @example\n * ```ts\n * const stream = await sandbox.readFileStream('/path/to/file.png');\n * for await (const chunk of streamFile(stream)) {\n *   if (chunk instanceof Uint8Array) {\n *     // Binary chunk\n *     console.log('Binary chunk:', chunk.length, 'bytes');\n *   } else {\n *     // Text chunk\n *     console.log('Text chunk:', chunk);\n *   }\n * }\n * ```\n */\nexport async function* streamFile(stream: ReadableStream<Uint8Array>): AsyncGenerator<FileChunk, FileMetadata> {\n  let metadata: FileMetadata | null = null;\n\n  for await (const event of parseSSE(stream)) {\n    switch (event.type) {\n      case 'metadata':\n        metadata = {\n          mimeType: event.mimeType,\n          size: event.size,\n          isBinary: event.isBinary,\n          encoding: event.encoding,\n        };\n        break;\n\n      case 'chunk':\n        if (!metadata) {\n          throw new Error('Received chunk before metadata');\n        }\n\n        if (metadata.isBinary && metadata.encoding === 'base64') {\n          // Decode base64 to Uint8Array for binary files\n          const binaryString = atob(event.data);\n          const bytes = new Uint8Array(binaryString.length);\n          for (let i = 0; i < binaryString.length; i++) {\n            bytes[i] = binaryString.charCodeAt(i);\n          }\n          yield bytes;\n        } else {\n          // Text files - yield as-is\n          yield event.data;\n        }\n        break;\n\n      case 'complete':\n        if (!metadata) {\n          throw new Error('Stream completed without metadata');\n        }\n        return metadata;\n\n      case 'error':\n        throw new Error(`File streaming error: ${event.error}`);\n    }\n  }\n\n  throw new Error('Stream ended unexpectedly');\n}\n\n/**\n * Collect an entire file into memory from a stream\n *\n * @param stream - The ReadableStream from readFileStream()\n * @returns Object containing the file content and metadata\n *\n * @example\n * ```ts\n * const stream = await sandbox.readFileStream('/path/to/file.txt');\n * const { content, metadata } = await collectFile(stream);\n * console.log('Content:', content);\n * console.log('MIME type:', metadata.mimeType);\n * ```\n */\nexport async function collectFile(stream: ReadableStream<Uint8Array>): Promise<{\n  content: string | Uint8Array;\n  metadata: FileMetadata;\n}> {\n  const chunks: Array<string | Uint8Array> = [];\n\n  // Iterate through the generator and get the return value (metadata)\n  const generator = streamFile(stream);\n  let result = await generator.next();\n\n  while (!result.done) {\n    chunks.push(result.value);\n    result = await generator.next();\n  }\n\n  const metadata = result.value;\n\n  if (!metadata) {\n    throw new Error('Failed to get file metadata');\n  }\n\n  // Combine chunks based on type\n  if (metadata.isBinary) {\n    // Binary file - combine Uint8Arrays\n    const totalLength = chunks.reduce((sum, chunk) =>\n      sum + (chunk instanceof Uint8Array ? chunk.length : 0), 0\n    );\n    const combined = new Uint8Array(totalLength);\n    let offset = 0;\n    for (const chunk of chunks) {\n      if (chunk instanceof Uint8Array) {\n        combined.set(chunk, offset);\n        offset += chunk.length;\n      }\n    }\n    return { content: combined, metadata };\n  } else {\n    // Text file - combine strings\n    const combined = chunks.filter(c => typeof c === 'string').join('');\n    return { content: combined, metadata };\n  }\n}\n"],"mappings":";AAKA,gBAAgB,SAAS,QAAqE;AAC5F,QAAM,SAAS,OAAO,UAAU;AAChC,QAAM,UAAU,IAAI,YAAY;AAChC,MAAI,SAAS;AAEb,MAAI;AACF,WAAO,MAAM;AACX,YAAM,EAAE,MAAM,MAAM,IAAI,MAAM,OAAO,KAAK;AAE1C,UAAI,MAAM;AACR;AAAA,MACF;AAEA,gBAAU,QAAQ,OAAO,OAAO,EAAE,QAAQ,KAAK,CAAC;AAChD,YAAM,QAAQ,OAAO,MAAM,IAAI;AAG/B,eAAS,MAAM,IAAI,KAAK;AAExB,iBAAW,QAAQ,OAAO;AACxB,YAAI,KAAK,WAAW,QAAQ,GAAG;AAC7B,gBAAM,OAAO,KAAK,MAAM,CAAC;AACzB,cAAI;AACF,kBAAM,QAAQ,KAAK,MAAM,IAAI;AAC7B,kBAAM;AAAA,UACR,QAAQ;AAAA,UAER;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF,UAAE;AACA,WAAO,YAAY;AAAA,EACrB;AACF;AAsBA,gBAAuB,WAAW,QAA6E;AAC7G,MAAI,WAAgC;AAEpC,mBAAiB,SAAS,SAAS,MAAM,GAAG;AAC1C,YAAQ,MAAM,MAAM;AAAA,MAClB,KAAK;AACH,mBAAW;AAAA,UACT,UAAU,MAAM;AAAA,UAChB,MAAM,MAAM;AAAA,UACZ,UAAU,MAAM;AAAA,UAChB,UAAU,MAAM;AAAA,QAClB;AACA;AAAA,MAEF,KAAK;AACH,YAAI,CAAC,UAAU;AACb,gBAAM,IAAI,MAAM,gCAAgC;AAAA,QAClD;AAEA,YAAI,SAAS,YAAY,SAAS,aAAa,UAAU;AAEvD,gBAAM,eAAe,KAAK,MAAM,IAAI;AACpC,gBAAM,QAAQ,IAAI,WAAW,aAAa,MAAM;AAChD,mBAAS,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;AAC5C,kBAAM,CAAC,IAAI,aAAa,WAAW,CAAC;AAAA,UACtC;AACA,gBAAM;AAAA,QACR,OAAO;AAEL,gBAAM,MAAM;AAAA,QACd;AACA;AAAA,MAEF,KAAK;AACH,YAAI,CAAC,UAAU;AACb,gBAAM,IAAI,MAAM,mCAAmC;AAAA,QACrD;AACA,eAAO;AAAA,MAET,KAAK;AACH,cAAM,IAAI,MAAM,yBAAyB,MAAM,KAAK,EAAE;AAAA,IAC1D;AAAA,EACF;AAEA,QAAM,IAAI,MAAM,2BAA2B;AAC7C;AAgBA,eAAsB,YAAY,QAG/B;AACD,QAAM,SAAqC,CAAC;AAG5C,QAAM,YAAY,WAAW,MAAM;AACnC,MAAI,SAAS,MAAM,UAAU,KAAK;AAElC,SAAO,CAAC,OAAO,MAAM;AACnB,WAAO,KAAK,OAAO,KAAK;AACxB,aAAS,MAAM,UAAU,KAAK;AAAA,EAChC;AAEA,QAAM,WAAW,OAAO;AAExB,MAAI,CAAC,UAAU;AACb,UAAM,IAAI,MAAM,6BAA6B;AAAA,EAC/C;AAGA,MAAI,SAAS,UAAU;AAErB,UAAM,cAAc,OAAO;AAAA,MAAO,CAAC,KAAK,UACtC,OAAO,iBAAiB,aAAa,MAAM,SAAS;AAAA,MAAI;AAAA,IAC1D;AACA,UAAM,WAAW,IAAI,WAAW,WAAW;AAC3C,QAAI,SAAS;AACb,eAAW,SAAS,QAAQ;AAC1B,UAAI,iBAAiB,YAAY;AAC/B,iBAAS,IAAI,OAAO,MAAM;AAC1B,kBAAU,MAAM;AAAA,MAClB;AAAA,IACF;AACA,WAAO,EAAE,SAAS,UAAU,SAAS;AAAA,EACvC,OAAO;AAEL,UAAM,WAAW,OAAO,OAAO,OAAK,OAAO,MAAM,QAAQ,EAAE,KAAK,EAAE;AAClE,WAAO,EAAE,SAAS,UAAU,SAAS;AAAA,EACvC;AACF;","names":[]}

package/dist/chunk-EKSWCBCA.js

@@ -1,86 +0,0 @@
-// src/sse-parser.ts
-async function* parseSSEStream(stream, signal) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  try {
-    while (true) {
-      if (signal?.aborted) {
-        throw new Error("Operation was aborted");
-      }
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        if (line.trim() === "") continue;
-        if (line.startsWith("data: ")) {
-          const data = line.substring(6);
-          if (data === "[DONE]" || data.trim() === "") continue;
-          try {
-            const event = JSON.parse(data);
-            yield event;
-          } catch {
-          }
-        }
-      }
-    }
-    if (buffer.trim() && buffer.startsWith("data: ")) {
-      const data = buffer.substring(6);
-      if (data !== "[DONE]" && data.trim()) {
-        try {
-          const event = JSON.parse(data);
-          yield event;
-        } catch {
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
-async function* responseToAsyncIterable(response, signal) {
-  if (!response.ok) {
-    throw new Error(`Response not ok: ${response.status} ${response.statusText}`);
-  }
-  if (!response.body) {
-    throw new Error("No response body");
-  }
-  yield* parseSSEStream(response.body, signal);
-}
-function asyncIterableToSSEStream(events, options) {
-  const encoder = new TextEncoder();
-  const serialize = options?.serialize || JSON.stringify;
-  return new ReadableStream({
-    async start(controller) {
-      try {
-        for await (const event of events) {
-          if (options?.signal?.aborted) {
-            controller.error(new Error("Operation was aborted"));
-            break;
-          }
-          const data = serialize(event);
-          const sseEvent = `data: ${data}
-
-`;
-          controller.enqueue(encoder.encode(sseEvent));
-        }
-        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-      } catch (error) {
-        controller.error(error);
-      } finally {
-        controller.close();
-      }
-    },
-    cancel() {
-    }
-  });
-}
-
-export {
-  parseSSEStream,
-  responseToAsyncIterable,
-  asyncIterableToSSEStream
-};
-//# sourceMappingURL=chunk-EKSWCBCA.js.map

package/dist/chunk-EKSWCBCA.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/sse-parser.ts"],"sourcesContent":["/**\n * Server-Sent Events (SSE) parser for streaming responses\n * Converts ReadableStream<Uint8Array> to typed AsyncIterable<T>\n */\n\n/**\n * Parse a ReadableStream of SSE events into typed AsyncIterable\n * @param stream - The ReadableStream from fetch response\n * @param signal - Optional AbortSignal for cancellation\n */\nexport async function* parseSSEStream<T>(\n  stream: ReadableStream<Uint8Array>,\n  signal?: AbortSignal\n): AsyncIterable<T> {\n  const reader = stream.getReader();\n  const decoder = new TextDecoder();\n  let buffer = '';\n\n  try {\n    while (true) {\n      // Check for cancellation\n      if (signal?.aborted) {\n        throw new Error('Operation was aborted');\n      }\n\n      const { done, value } = await reader.read();\n      if (done) break;\n\n      // Decode chunk and add to buffer\n      buffer += decoder.decode(value, { stream: true });\n\n      // Process complete SSE events in buffer\n      const lines = buffer.split('\\n');\n\n      // Keep the last incomplete line in buffer\n      buffer = lines.pop() || '';\n\n      for (const line of lines) {\n        // Skip empty lines\n        if (line.trim() === '') continue;\n\n        // Process SSE data lines\n        if (line.startsWith('data: ')) {\n          const data = line.substring(6);\n\n          // Skip [DONE] markers or empty data\n          if (data === '[DONE]' || data.trim() === '') continue;\n\n          try {\n            const event = JSON.parse(data) as T;\n            yield event;\n          } catch {\n            // Skip invalid JSON events and continue processing\n          }\n        }\n        // Handle other SSE fields if needed (event:, id:, retry:)\n        // For now, we only care about data: lines\n      }\n    }\n\n    // Process any remaining data in buffer\n    if (buffer.trim() && buffer.startsWith('data: ')) {\n      const data = buffer.substring(6);\n      if (data !== '[DONE]' && data.trim()) {\n        try {\n          const event = JSON.parse(data) as T;\n          yield event;\n        } catch {\n          // Skip invalid JSON in final event\n        }\n      }\n    }\n  } finally {\n    // Clean up resources\n    reader.releaseLock();\n  }\n}\n\n\n/**\n * Helper to convert a Response with SSE stream directly to AsyncIterable\n * @param response - Response object with SSE stream\n * @param signal - Optional AbortSignal for cancellation\n */\nexport async function* responseToAsyncIterable<T>(\n  response: Response,\n  signal?: AbortSignal\n): AsyncIterable<T> {\n  if (!response.ok) {\n    throw new Error(`Response not ok: ${response.status} ${response.statusText}`);\n  }\n\n  if (!response.body) {\n    throw new Error('No response body');\n  }\n\n  yield* parseSSEStream<T>(response.body, signal);\n}\n\n/**\n * Create an SSE-formatted ReadableStream from an AsyncIterable\n * (Useful for Worker endpoints that need to forward AsyncIterable as SSE)\n * @param events - AsyncIterable of events\n * @param options - Stream options\n */\nexport function asyncIterableToSSEStream<T>(\n  events: AsyncIterable<T>,\n  options?: {\n    signal?: AbortSignal;\n    serialize?: (event: T) => string;\n  }\n): ReadableStream<Uint8Array> {\n  const encoder = new TextEncoder();\n  const serialize = options?.serialize || JSON.stringify;\n\n  return new ReadableStream({\n    async start(controller) {\n      try {\n        for await (const event of events) {\n          if (options?.signal?.aborted) {\n            controller.error(new Error('Operation was aborted'));\n            break;\n          }\n\n          const data = serialize(event);\n          const sseEvent = `data: ${data}\\n\\n`;\n          controller.enqueue(encoder.encode(sseEvent));\n        }\n\n        // Send completion marker\n        controller.enqueue(encoder.encode('data: [DONE]\\n\\n'));\n      } catch (error) {\n        controller.error(error);\n      } finally {\n        controller.close();\n      }\n    },\n\n    cancel() {\n      // Handle stream cancellation\n    }\n  });\n}"],"mappings":";AAUA,gBAAuB,eACrB,QACA,QACkB;AAClB,QAAM,SAAS,OAAO,UAAU;AAChC,QAAM,UAAU,IAAI,YAAY;AAChC,MAAI,SAAS;AAEb,MAAI;AACF,WAAO,MAAM;AAEX,UAAI,QAAQ,SAAS;AACnB,cAAM,IAAI,MAAM,uBAAuB;AAAA,MACzC;AAEA,YAAM,EAAE,MAAM,MAAM,IAAI,MAAM,OAAO,KAAK;AAC1C,UAAI,KAAM;AAGV,gBAAU,QAAQ,OAAO,OAAO,EAAE,QAAQ,KAAK,CAAC;AAGhD,YAAM,QAAQ,OAAO,MAAM,IAAI;AAG/B,eAAS,MAAM,IAAI,KAAK;AAExB,iBAAW,QAAQ,OAAO;AAExB,YAAI,KAAK,KAAK,MAAM,GAAI;AAGxB,YAAI,KAAK,WAAW,QAAQ,GAAG;AAC7B,gBAAM,OAAO,KAAK,UAAU,CAAC;AAG7B,cAAI,SAAS,YAAY,KAAK,KAAK,MAAM,GAAI;AAE7C,cAAI;AACF,kBAAM,QAAQ,KAAK,MAAM,IAAI;AAC7B,kBAAM;AAAA,UACR,QAAQ;AAAA,UAER;AAAA,QACF;AAAA,MAGF;AAAA,IACF;AAGA,QAAI,OAAO,KAAK,KAAK,OAAO,WAAW,QAAQ,GAAG;AAChD,YAAM,OAAO,OAAO,UAAU,CAAC;AAC/B,UAAI,SAAS,YAAY,KAAK,KAAK,GAAG;AACpC,YAAI;AACF,gBAAM,QAAQ,KAAK,MAAM,IAAI;AAC7B,gBAAM;AAAA,QACR,QAAQ;AAAA,QAER;AAAA,MACF;AAAA,IACF;AAAA,EACF,UAAE;AAEA,WAAO,YAAY;AAAA,EACrB;AACF;AAQA,gBAAuB,wBACrB,UACA,QACkB;AAClB,MAAI,CAAC,SAAS,IAAI;AAChB,UAAM,IAAI,MAAM,oBAAoB,SAAS,MAAM,IAAI,SAAS,UAAU,EAAE;AAAA,EAC9E;AAEA,MAAI,CAAC,SAAS,MAAM;AAClB,UAAM,IAAI,MAAM,kBAAkB;AAAA,EACpC;AAEA,SAAO,eAAkB,SAAS,MAAM,MAAM;AAChD;AAQO,SAAS,yBACd,QACA,SAI4B;AAC5B,QAAM,UAAU,IAAI,YAAY;AAChC,QAAM,YAAY,SAAS,aAAa,KAAK;AAE7C,SAAO,IAAI,eAAe;AAAA,IACxB,MAAM,MAAM,YAAY;AACtB,UAAI;AACF,yBAAiB,SAAS,QAAQ;AAChC,cAAI,SAAS,QAAQ,SAAS;AAC5B,uBAAW,MAAM,IAAI,MAAM,uBAAuB,CAAC;AACnD;AAAA,UACF;AAEA,gBAAM,OAAO,UAAU,KAAK;AAC5B,gBAAM,WAAW,SAAS,IAAI;AAAA;AAAA;AAC9B,qBAAW,QAAQ,QAAQ,OAAO,QAAQ,CAAC;AAAA,QAC7C;AAGA,mBAAW,QAAQ,QAAQ,OAAO,kBAAkB,CAAC;AAAA,MACvD,SAAS,OAAO;AACd,mBAAW,MAAM,KAAK;AAAA,MACxB,UAAE;AACA,mBAAW,MAAM;AAAA,MACnB;AAAA,IACF;AAAA,IAEA,SAAS;AAAA,IAET;AAAA,EACF,CAAC;AACH;","names":[]}