@storacha/encrypt-upload-client 1.1.56 → 1.1.58

package/dist/test/lit-crypto-adapter.spec.d.ts

@@ -1,2 +1,2 @@
-export {};
-//# sourceMappingURL=lit-crypto-adapter.spec.d.ts.map
+export {}
+//# sourceMappingURL=lit-crypto-adapter.spec.d.ts.map

package/dist/test/lit-crypto-adapter.spec.js

@@ -1,120 +1,208 @@
-import './setup.js';
-import { test, describe } from 'node:test';
-import assert from 'node:assert';
-import { GenericAesCtrStreamingCrypto } from '../src/crypto/symmetric/generic-aes-ctr-streaming-crypto.js';
-import { NodeAesCbcCrypto } from '../src/crypto/symmetric/node-aes-cbc-crypto.js';
-import { LitCryptoAdapter } from '../src/crypto/adapters/lit-crypto-adapter.js';
-import { stringToUint8Array, streamToUint8Array, uint8ArrayToString, } from './helpers/test-file-utils.js';
+import './setup.js'
+import { test, describe } from 'node:test'
+import assert from 'node:assert'
+import { GenericAesCtrStreamingCrypto } from '../src/crypto/symmetric/generic-aes-ctr-streaming-crypto.js'
+import { NodeAesCbcCrypto } from '../src/crypto/symmetric/node-aes-cbc-crypto.js'
+import { LitCryptoAdapter } from '../src/crypto/adapters/lit-crypto-adapter.js'
+import {
+  stringToUint8Array,
+  streamToUint8Array,
+  uint8ArrayToString,
+} from './helpers/test-file-utils.js'
 // Mock Lit client - cast to any for testing
-const mockLitClient = /** @type {any} */ ({
-// Add mock methods as needed
-});
+const mockLitClient = /** @type {any} */ (
+  {
+    // Add mock methods as needed
+  }
+)
 await describe('LitCryptoAdapter', async () => {
-    await describe('Generic AES-CTR Crypto Implementation', async () => {
-        await test('should delegate symmetric crypto operations to the generic implementation', async () => {
-            const symmetricCrypto = new GenericAesCtrStreamingCrypto();
-            const adapter = new LitCryptoAdapter(symmetricCrypto, mockLitClient);
-            const originalText = 'Op, this is a test for strategy-based encryption!';
-            const blob = new Blob([stringToUint8Array(originalText)]);
-            // Test that it delegates to the symmetric crypto implementation
-            const { key, iv, encryptedStream } = await adapter.encryptStream(blob);
-            assert(key instanceof Uint8Array, 'Key should be a Uint8Array');
-            assert(iv instanceof Uint8Array, 'IV should be a Uint8Array');
-            assert(encryptedStream instanceof ReadableStream, 'Encrypted stream should be a ReadableStream');
-            // Test decryption delegation
-            const decryptedStream = await adapter.decryptStream(encryptedStream, key, iv);
-            const decryptedBytes = await streamToUint8Array(decryptedStream);
-            const decryptedText = uint8ArrayToString(decryptedBytes);
-            assert.strictEqual(decryptedText, originalText, 'Decrypted text should match original');
-        });
-        await test('should initialize Generic Lit adapter with correct configuration', async () => {
-            const symmetricCrypto = new GenericAesCtrStreamingCrypto();
-            const adapter = new LitCryptoAdapter(symmetricCrypto, mockLitClient);
-            // Test that the adapter has the required methods
-            assert(typeof adapter.encryptSymmetricKey === 'function', 'encryptSymmetricKey should be a function');
-            assert(typeof adapter.decryptSymmetricKey === 'function', 'decryptSymmetricKey should be a function');
-            // Verify adapter has the lit client
-            assert.strictEqual(adapter.litClient, mockLitClient, 'Adapter should store the Lit client');
-            // Verify it uses the correct crypto implementation
-            assert(adapter.symmetricCrypto instanceof GenericAesCtrStreamingCrypto, 'Should use GenericAesCtrStreamingCrypto');
-        });
-    });
-    await describe('Node.js AES-CBC Crypto Implementation (Legacy)', async () => {
-        await test('should delegate symmetric crypto operations to the Node.js implementation', async () => {
-            const symmetricCrypto = new NodeAesCbcCrypto();
-            const adapter = new LitCryptoAdapter(symmetricCrypto, mockLitClient);
-            const originalText = 'Op, this is a test for legacy Node.js encryption!';
-            const blob = new Blob([stringToUint8Array(originalText)]);
-            // Test that it delegates to the symmetric crypto implementation
-            const { key, iv, encryptedStream } = await adapter.encryptStream(blob);
-            assert(key instanceof Uint8Array, 'Key should be a Uint8Array');
-            assert(iv instanceof Uint8Array, 'IV should be a Uint8Array');
-            assert(encryptedStream instanceof ReadableStream, 'Encrypted stream should be a ReadableStream');
-            // Test decryption delegation
-            const decryptedStream = await adapter.decryptStream(encryptedStream, key, iv);
-            const decryptedBytes = await streamToUint8Array(decryptedStream);
-            const decryptedText = uint8ArrayToString(decryptedBytes);
-            assert.strictEqual(decryptedText, originalText, 'Decrypted text should match original');
-        });
-        await test('should initialize Node.js Lit adapter with correct configuration', async () => {
-            const symmetricCrypto = new NodeAesCbcCrypto();
-            const adapter = new LitCryptoAdapter(symmetricCrypto, mockLitClient);
-            // Test that the adapter has the required methods
-            assert(typeof adapter.encryptSymmetricKey === 'function', 'encryptSymmetricKey should be a function');
-            assert(typeof adapter.decryptSymmetricKey === 'function', 'decryptSymmetricKey should be a function');
-            // Verify adapter has the lit client
-            assert.strictEqual(adapter.litClient, mockLitClient, 'Adapter should store the Lit client');
-            // Verify it uses the correct crypto implementation
-            assert(adapter.symmetricCrypto instanceof NodeAesCbcCrypto, 'Should use NodeAesCbcCrypto');
-        });
-    });
-    await describe('Cross-Implementation Compatibility', async () => {
-        await test('should demonstrate algorithm differences between implementations', async () => {
-            const genericCrypto = new GenericAesCtrStreamingCrypto();
-            const nodeCrypto = new NodeAesCbcCrypto();
-            const genericAdapter = new LitCryptoAdapter(genericCrypto, mockLitClient);
-            const nodeAdapter = new LitCryptoAdapter(nodeCrypto, mockLitClient);
-            const originalText = 'Test data for algorithm comparison';
-            const blob = new Blob([stringToUint8Array(originalText)]);
-            // Encrypt with both adapters
-            const genericResult = await genericAdapter.encryptStream(blob);
-            const nodeResult = await nodeAdapter.encryptStream(blob);
-            // Convert streams to bytes
-            const genericEncrypted = await streamToUint8Array(genericResult.encryptedStream);
-            const nodeEncrypted = await streamToUint8Array(nodeResult.encryptedStream);
-            // Verify they produce different results (different algorithms)
-            assert.notDeepEqual(genericEncrypted, nodeEncrypted, 'AES-CTR and AES-CBC should produce different encrypted outputs');
-            // Verify both can decrypt their own data
-            const genericDecryptStream = new ReadableStream({
-                start(controller) {
-                    controller.enqueue(genericEncrypted);
-                    controller.close();
-                },
-            });
-            const nodeDecryptStream = new ReadableStream({
-                start(controller) {
-                    controller.enqueue(nodeEncrypted);
-                    controller.close();
-                },
-            });
-            const genericDecrypted = await genericAdapter.decryptStream(genericDecryptStream, genericResult.key, genericResult.iv);
-            const nodeDecrypted = await nodeAdapter.decryptStream(nodeDecryptStream, nodeResult.key, nodeResult.iv);
-            const genericDecryptedBytes = await streamToUint8Array(genericDecrypted);
-            const nodeDecryptedBytes = await streamToUint8Array(nodeDecrypted);
-            // Both should decrypt to the same original text
-            assert.strictEqual(uint8ArrayToString(genericDecryptedBytes), originalText, 'Generic adapter should decrypt correctly');
-            assert.strictEqual(uint8ArrayToString(nodeDecryptedBytes), originalText, 'Node adapter should decrypt correctly');
-            console.log('Both crypto implementations work with Lit adapter but produce different encrypted outputs');
-        });
-        await test('should verify factory function behavior', async () => {
-            const { createGenericLitAdapter, createNodeLitAdapter } = await import('../src/crypto/factories.node.js');
-            const genericAdapter = createGenericLitAdapter(mockLitClient);
-            const nodeAdapter = createNodeLitAdapter(mockLitClient);
-            // Verify factory functions create adapters with correct crypto implementations
-            assert(genericAdapter.symmetricCrypto instanceof GenericAesCtrStreamingCrypto, 'Generic factory should create adapter with GenericAesCtrStreamingCrypto');
-            assert(nodeAdapter.symmetricCrypto instanceof NodeAesCbcCrypto, 'Node factory should create adapter with NodeAesCbcCrypto');
-            console.log('Factory functions create adapters with correct crypto implementations');
-        });
-    });
-});
-//# sourceMappingURL=lit-crypto-adapter.spec.js.map
+  await describe('Generic AES-CTR Crypto Implementation', async () => {
+    await test('should delegate symmetric crypto operations to the generic implementation', async () => {
+      const symmetricCrypto = new GenericAesCtrStreamingCrypto()
+      const adapter = new LitCryptoAdapter(symmetricCrypto, mockLitClient)
+      const originalText = 'Op, this is a test for strategy-based encryption!'
+      const blob = new Blob([stringToUint8Array(originalText)])
+      // Test that it delegates to the symmetric crypto implementation
+      const { key, iv, encryptedStream } = await adapter.encryptStream(blob)
+      assert(key instanceof Uint8Array, 'Key should be a Uint8Array')
+      assert(iv instanceof Uint8Array, 'IV should be a Uint8Array')
+      assert(
+        encryptedStream instanceof ReadableStream,
+        'Encrypted stream should be a ReadableStream'
+      )
+      // Test decryption delegation
+      const decryptedStream = await adapter.decryptStream(
+        encryptedStream,
+        key,
+        iv
+      )
+      const decryptedBytes = await streamToUint8Array(decryptedStream)
+      const decryptedText = uint8ArrayToString(decryptedBytes)
+      assert.strictEqual(
+        decryptedText,
+        originalText,
+        'Decrypted text should match original'
+      )
+    })
+    await test('should initialize Generic Lit adapter with correct configuration', async () => {
+      const symmetricCrypto = new GenericAesCtrStreamingCrypto()
+      const adapter = new LitCryptoAdapter(symmetricCrypto, mockLitClient)
+      // Test that the adapter has the required methods
+      assert(
+        typeof adapter.encryptSymmetricKey === 'function',
+        'encryptSymmetricKey should be a function'
+      )
+      assert(
+        typeof adapter.decryptSymmetricKey === 'function',
+        'decryptSymmetricKey should be a function'
+      )
+      // Verify adapter has the lit client
+      assert.strictEqual(
+        adapter.litClient,
+        mockLitClient,
+        'Adapter should store the Lit client'
+      )
+      // Verify it uses the correct crypto implementation
+      assert(
+        adapter.symmetricCrypto instanceof GenericAesCtrStreamingCrypto,
+        'Should use GenericAesCtrStreamingCrypto'
+      )
+    })
+  })
+  await describe('Node.js AES-CBC Crypto Implementation (Legacy)', async () => {
+    await test('should delegate symmetric crypto operations to the Node.js implementation', async () => {
+      const symmetricCrypto = new NodeAesCbcCrypto()
+      const adapter = new LitCryptoAdapter(symmetricCrypto, mockLitClient)
+      const originalText = 'Op, this is a test for legacy Node.js encryption!'
+      const blob = new Blob([stringToUint8Array(originalText)])
+      // Test that it delegates to the symmetric crypto implementation
+      const { key, iv, encryptedStream } = await adapter.encryptStream(blob)
+      assert(key instanceof Uint8Array, 'Key should be a Uint8Array')
+      assert(iv instanceof Uint8Array, 'IV should be a Uint8Array')
+      assert(
+        encryptedStream instanceof ReadableStream,
+        'Encrypted stream should be a ReadableStream'
+      )
+      // Test decryption delegation
+      const decryptedStream = await adapter.decryptStream(
+        encryptedStream,
+        key,
+        iv
+      )
+      const decryptedBytes = await streamToUint8Array(decryptedStream)
+      const decryptedText = uint8ArrayToString(decryptedBytes)
+      assert.strictEqual(
+        decryptedText,
+        originalText,
+        'Decrypted text should match original'
+      )
+    })
+    await test('should initialize Node.js Lit adapter with correct configuration', async () => {
+      const symmetricCrypto = new NodeAesCbcCrypto()
+      const adapter = new LitCryptoAdapter(symmetricCrypto, mockLitClient)
+      // Test that the adapter has the required methods
+      assert(
+        typeof adapter.encryptSymmetricKey === 'function',
+        'encryptSymmetricKey should be a function'
+      )
+      assert(
+        typeof adapter.decryptSymmetricKey === 'function',
+        'decryptSymmetricKey should be a function'
+      )
+      // Verify adapter has the lit client
+      assert.strictEqual(
+        adapter.litClient,
+        mockLitClient,
+        'Adapter should store the Lit client'
+      )
+      // Verify it uses the correct crypto implementation
+      assert(
+        adapter.symmetricCrypto instanceof NodeAesCbcCrypto,
+        'Should use NodeAesCbcCrypto'
+      )
+    })
+  })
+  await describe('Cross-Implementation Compatibility', async () => {
+    await test('should demonstrate algorithm differences between implementations', async () => {
+      const genericCrypto = new GenericAesCtrStreamingCrypto()
+      const nodeCrypto = new NodeAesCbcCrypto()
+      const genericAdapter = new LitCryptoAdapter(genericCrypto, mockLitClient)
+      const nodeAdapter = new LitCryptoAdapter(nodeCrypto, mockLitClient)
+      const originalText = 'Test data for algorithm comparison'
+      const blob = new Blob([stringToUint8Array(originalText)])
+      // Encrypt with both adapters
+      const genericResult = await genericAdapter.encryptStream(blob)
+      const nodeResult = await nodeAdapter.encryptStream(blob)
+      // Convert streams to bytes
+      const genericEncrypted = await streamToUint8Array(
+        genericResult.encryptedStream
+      )
+      const nodeEncrypted = await streamToUint8Array(nodeResult.encryptedStream)
+      // Verify they produce different results (different algorithms)
+      assert.notDeepEqual(
+        genericEncrypted,
+        nodeEncrypted,
+        'AES-CTR and AES-CBC should produce different encrypted outputs'
+      )
+      // Verify both can decrypt their own data
+      const genericDecryptStream = new ReadableStream({
+        start(controller) {
+          controller.enqueue(genericEncrypted)
+          controller.close()
+        },
+      })
+      const nodeDecryptStream = new ReadableStream({
+        start(controller) {
+          controller.enqueue(nodeEncrypted)
+          controller.close()
+        },
+      })
+      const genericDecrypted = await genericAdapter.decryptStream(
+        genericDecryptStream,
+        genericResult.key,
+        genericResult.iv
+      )
+      const nodeDecrypted = await nodeAdapter.decryptStream(
+        nodeDecryptStream,
+        nodeResult.key,
+        nodeResult.iv
+      )
+      const genericDecryptedBytes = await streamToUint8Array(genericDecrypted)
+      const nodeDecryptedBytes = await streamToUint8Array(nodeDecrypted)
+      // Both should decrypt to the same original text
+      assert.strictEqual(
+        uint8ArrayToString(genericDecryptedBytes),
+        originalText,
+        'Generic adapter should decrypt correctly'
+      )
+      assert.strictEqual(
+        uint8ArrayToString(nodeDecryptedBytes),
+        originalText,
+        'Node adapter should decrypt correctly'
+      )
+      console.log(
+        'Both crypto implementations work with Lit adapter but produce different encrypted outputs'
+      )
+    })
+    await test('should verify factory function behavior', async () => {
+      const { createGenericLitAdapter, createNodeLitAdapter } = await import(
+        '../src/crypto/factories.node.js'
+      )
+      const genericAdapter = createGenericLitAdapter(mockLitClient)
+      const nodeAdapter = createNodeLitAdapter(mockLitClient)
+      // Verify factory functions create adapters with correct crypto implementations
+      assert(
+        genericAdapter.symmetricCrypto instanceof GenericAesCtrStreamingCrypto,
+        'Generic factory should create adapter with GenericAesCtrStreamingCrypto'
+      )
+      assert(
+        nodeAdapter.symmetricCrypto instanceof NodeAesCbcCrypto,
+        'Node factory should create adapter with NodeAesCbcCrypto'
+      )
+      console.log(
+        'Factory functions create adapters with correct crypto implementations'
+      )
+    })
+  })
+})
+//# sourceMappingURL=lit-crypto-adapter.spec.js.map

package/dist/test/memory-efficiency.spec.d.ts

@@ -1,2 +1,2 @@
-export {};
-//# sourceMappingURL=memory-efficiency.spec.d.ts.map
+export {}
+//# sourceMappingURL=memory-efficiency.spec.d.ts.map

package/dist/test/memory-efficiency.spec.js

@@ -1,93 +1,106 @@
-import './setup.js';
-import { test, describe } from 'node:test';
-import assert from 'node:assert';
-import { GenericAesCtrStreamingCrypto } from '../src/crypto/symmetric/generic-aes-ctr-streaming-crypto.js';
-import { createTestFile } from './helpers/test-file-utils.js';
+import './setup.js'
+import { test, describe } from 'node:test'
+import assert from 'node:assert'
+import { GenericAesCtrStreamingCrypto } from '../src/crypto/symmetric/generic-aes-ctr-streaming-crypto.js'
+import { createTestFile } from './helpers/test-file-utils.js'
 /**
  * These tests demonstrate why streaming is necessary for large files.
  * They show that buffered approaches fail with memory errors while streaming succeeds.
  */
 await describe('Memory Efficiency - Why Streaming Matters', async () => {
-    await test('should show streaming handles progressively larger files', async () => {
-        const streamingCrypto = new GenericAesCtrStreamingCrypto();
-        // Test with multiple sizes to show streaming scales linearly
-        const testSizes = [5, 10, 15, 20, 50, 100, 500, 1000]; // MB - sizes that would challenge buffered approaches
-        for (const sizeMB of testSizes) {
-            console.log(`Processing ${sizeMB}MB file...`);
-            const testFile = createTestFile(sizeMB);
-            const startTime = Date.now();
-            const { encryptedStream } = await streamingCrypto.encryptStream(testFile);
-            let processedBytes = 0;
-            let chunkCount = 0;
-            const reader = encryptedStream.getReader();
-            try {
-                // eslint-disable-next-line no-constant-condition
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done)
-                        break;
-                    processedBytes += value.length;
-                    chunkCount++;
-                }
-            }
-            finally {
-                reader.releaseLock();
-            }
-            const processingTime = Date.now() - startTime;
-            const throughput = processedBytes / 1024 / 1024 / (processingTime / 1000); // MB/s
-            assert.strictEqual(processedBytes, testFile.size, `Should process entire ${sizeMB}MB file`);
-            console.log(`✓ ${sizeMB}MB: ${chunkCount} chunks, ${throughput.toFixed(1)} MB/s`);
+  await test('should show streaming handles progressively larger files', async () => {
+    const streamingCrypto = new GenericAesCtrStreamingCrypto()
+    // Test with multiple sizes to show streaming scales linearly
+    const testSizes = [5, 10, 15, 20, 50, 100, 500, 1000] // MB - sizes that would challenge buffered approaches
+    for (const sizeMB of testSizes) {
+      console.log(`Processing ${sizeMB}MB file...`)
+      const testFile = createTestFile(sizeMB)
+      const startTime = Date.now()
+      const { encryptedStream } = await streamingCrypto.encryptStream(testFile)
+      let processedBytes = 0
+      let chunkCount = 0
+      const reader = encryptedStream.getReader()
+      try {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+          const { done, value } = await reader.read()
+          if (done) break
+          processedBytes += value.length
+          chunkCount++
         }
-        console.log('DEMONSTRATED: Streaming handles large files with consistent performance');
-    });
-    await test('should project memory behavior for realistic file sizes', async () => {
-        const streamingCrypto = new GenericAesCtrStreamingCrypto();
-        // Test with a size we can actually handle to project larger files
-        const testFile = createTestFile(5); // 5MB
-        const getMemoryUsage = () => {
-            if (globalThis.gc)
-                globalThis.gc();
-            return process.memoryUsage ? process.memoryUsage().heapUsed : 0;
-        };
-        const baseMemory = getMemoryUsage();
-        const { encryptedStream } = await streamingCrypto.encryptStream(testFile);
-        let peakMemoryDelta = 0;
-        let processedBytes = 0;
-        const reader = encryptedStream.getReader();
-        try {
-            // eslint-disable-next-line no-constant-condition
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                processedBytes += value.length;
-                // Sample memory usage
-                const currentMemory = getMemoryUsage();
-                const memoryDelta = currentMemory - baseMemory;
-                peakMemoryDelta = Math.max(peakMemoryDelta, memoryDelta);
-            }
-        }
-        finally {
-            reader.releaseLock();
-        }
-        const peakMemoryMB = peakMemoryDelta / 1024 / 1024;
-        const fileSize = testFile.size / 1024 / 1024;
-        const memoryEfficiency = (peakMemoryDelta / testFile.size) * 100;
-        console.log(`File size: ${fileSize.toFixed(1)}MB`);
-        console.log(`Peak memory delta: ${peakMemoryMB.toFixed(2)}MB`);
-        console.log(`Memory efficiency: ${memoryEfficiency.toFixed(1)}% of file size`);
-        // Project to larger file sizes
-        console.log('\nProjected memory usage:');
-        const projectedSizes = [100, 1000, 5000]; // MB = 100MB, 1GB, 5GB
-        for (const sizeMB of projectedSizes) {
-            const projectedMemory = (memoryEfficiency / 100) * sizeMB;
-            const sizeLabel = sizeMB >= 1000 ? `${sizeMB / 1000}GB` : `${sizeMB}MB`;
-            console.log(`  ${sizeLabel}: ~${projectedMemory.toFixed(1)}MB memory`);
-        }
-        // Memory should be bounded (much less than file size)
-        assert(peakMemoryMB < fileSize, 'Streaming should use less memory than file size');
-        assert(memoryEfficiency < 50, 'Memory usage should be less than 50% of file size');
-        console.log('DEMONSTRATED: Streaming memory usage scales sub-linearly with file size');
-    });
-});
-//# sourceMappingURL=memory-efficiency.spec.js.map
+      } finally {
+        reader.releaseLock()
+      }
+      const processingTime = Date.now() - startTime
+      const throughput = processedBytes / 1024 / 1024 / (processingTime / 1000) // MB/s
+      assert.strictEqual(
+        processedBytes,
+        testFile.size,
+        `Should process entire ${sizeMB}MB file`
+      )
+      console.log(
+        `✓ ${sizeMB}MB: ${chunkCount} chunks, ${throughput.toFixed(1)} MB/s`
+      )
+    }
+    console.log(
+      'DEMONSTRATED: Streaming handles large files with consistent performance'
+    )
+  })
+  await test('should project memory behavior for realistic file sizes', async () => {
+    const streamingCrypto = new GenericAesCtrStreamingCrypto()
+    // Test with a size we can actually handle to project larger files
+    const testFile = createTestFile(5) // 5MB
+    const getMemoryUsage = () => {
+      if (globalThis.gc) globalThis.gc()
+      return process.memoryUsage ? process.memoryUsage().heapUsed : 0
+    }
+    const baseMemory = getMemoryUsage()
+    const { encryptedStream } = await streamingCrypto.encryptStream(testFile)
+    let peakMemoryDelta = 0
+    let processedBytes = 0
+    const reader = encryptedStream.getReader()
+    try {
+      // eslint-disable-next-line no-constant-condition
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+        processedBytes += value.length
+        // Sample memory usage
+        const currentMemory = getMemoryUsage()
+        const memoryDelta = currentMemory - baseMemory
+        peakMemoryDelta = Math.max(peakMemoryDelta, memoryDelta)
+      }
+    } finally {
+      reader.releaseLock()
+    }
+    const peakMemoryMB = peakMemoryDelta / 1024 / 1024
+    const fileSize = testFile.size / 1024 / 1024
+    const memoryEfficiency = (peakMemoryDelta / testFile.size) * 100
+    console.log(`File size: ${fileSize.toFixed(1)}MB`)
+    console.log(`Peak memory delta: ${peakMemoryMB.toFixed(2)}MB`)
+    console.log(
+      `Memory efficiency: ${memoryEfficiency.toFixed(1)}% of file size`
+    )
+    // Project to larger file sizes
+    console.log('\nProjected memory usage:')
+    const projectedSizes = [100, 1000, 5000] // MB = 100MB, 1GB, 5GB
+    for (const sizeMB of projectedSizes) {
+      const projectedMemory = (memoryEfficiency / 100) * sizeMB
+      const sizeLabel = sizeMB >= 1000 ? `${sizeMB / 1000}GB` : `${sizeMB}MB`
+      console.log(`  ${sizeLabel}: ~${projectedMemory.toFixed(1)}MB memory`)
+    }
+    // Memory should be bounded (much less than file size)
+    assert(
+      peakMemoryMB < fileSize,
+      'Streaming should use less memory than file size'
+    )
+    assert(
+      memoryEfficiency < 50,
+      'Memory usage should be less than 50% of file size'
+    )
+    console.log(
+      'DEMONSTRATED: Streaming memory usage scales sub-linearly with file size'
+    )
+  })
+})
+//# sourceMappingURL=memory-efficiency.spec.js.map