@adtrackify/at-service-common 3.19.23 → 3.19.25

package/dist/esm/__tests__/integration/sqs-bundling-roundtrip.spec.js

@@ -1,583 +1,583 @@
-import { BundledSQSClient } from '../../clients/generic/sqs-bundled-client';
-import { CompressionAlgorithm } from '../../clients/generic/sqs-bundled-client.types';
-import { unbundleRecords } from '../../clients/generic/sqs-unbundle';
-import { compress } from '../../utils/compression';
-import { createSqsLimits, SQS_1MB } from '../../constants/sqs';
-jest.mock('../../helpers/logging-helper', () => ({
-    Logger: {
-        debug: jest.fn(),
-        info: jest.fn(),
-        warn: jest.fn(),
-        error: jest.fn(),
-    },
-}));
-function makeTestEvent(id, name = 'test', value, metadata) {
-    return { id, name, value, metadata };
-}
-function makeRealisticTrackingEvent(index) {
-    return {
-        anonymousId: `anon-${index}-${Math.random().toString(36).substring(7)}`,
-        accountId: `acc-${index % 10}`,
-        pixelId: `pixel-${index % 5}`,
-        eventType: ['track', 'identify', 'page'][index % 3] ?? 'track',
-        eventName: ['purchase', 'add_to_cart', 'page_view', 'begin_checkout'][index % 4] ?? 'track',
-        timestamp: new Date(Date.now() - index * 1000).toISOString(),
-        context: {
-            page: {
-                url: `https://example.com/product/${index}`,
-                path: `/product/${index}`,
-                title: `Product ${index} - Example Store`,
-                referrer: index % 3 === 0 ? 'https://google.com' : '',
-            },
-            userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-            ip: `192.168.${index % 256}.${(index * 7) % 256}`,
-            locale: ['en-US', 'en-GB', 'de-DE', 'fr-FR'][index % 4] ?? 'en-US',
-            timezone: 'America/New_York',
-        },
-        properties: {
-            productId: `prod-${index}`,
-            productName: `Amazing Product ${index}`,
-            price: 29.99 + (index % 100),
-            currency: 'USD',
-            quantity: (index % 5) + 1,
-            category: ['Electronics', 'Clothing', 'Home', 'Sports'][index % 4],
-            customFields: {
-                brand: `Brand${index % 20}`,
-                sku: `SKU-${index}-${Date.now()}`,
-                inStock: index % 2 === 0,
-            },
-        },
-        shopifyData: index % 3 === 0
-            ? {
-                checkoutToken: `checkout-${index}`,
-                orderId: index % 5 === 0 ? `order-${index}` : undefined,
-                customerEmail: `customer${index}@example.com`,
-                lineItems: Array.from({ length: (index % 3) + 1 }, (_, j) => ({
-                    variantId: `variant-${index}-${j}`,
-                    title: `Line Item ${j}`,
-                    price: 19.99 + j * 10,
-                    quantity: j + 1,
-                })),
-            }
-            : undefined,
-    };
-}
-function simulateSqsDelivery(envelopes) {
-    return envelopes.map((env, i) => ({
-        messageId: `msg-${i}-${Date.now()}`,
-        body: JSON.stringify({ messageBody: env }),
-    }));
-}
-describe('Full Round-Trip: Producer → Consumer', () => {
-    let mockSqsClient;
-    let capturedEnvelopes;
-    beforeEach(() => {
-        capturedEnvelopes = [];
-        mockSqsClient = {
-            buildAndSendMessagesV2: jest.fn(async (_type, envelopes) => {
-                capturedEnvelopes.push(...envelopes);
-                return {
-                    successCount: envelopes.length,
-                    failedCount: 0,
-                    batchCount: 1,
-                    failedMessages: [],
-                };
-            }),
-            queueUrl: 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue',
-            limits: createSqsLimits(SQS_1MB),
-        };
-    });
-    describe('1. Basic round-trip test (100 items)', () => {
-        it('100 items survive complete round-trip with deep equality', async () => {
-            const bundledClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-                compressionLevel: 3,
-            });
-            const originalItems = Array.from({ length: 100 }, (_, i) => ({
-                id: `event-${i}`,
-                name: 'purchase',
-                value: i * 99.99,
-                metadata: { source: 'test', index: i },
-            }));
-            await bundledClient.sendBundled('test', originalItems);
-            expect(capturedEnvelopes.length).toBeGreaterThanOrEqual(1);
-            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
-            const { items: recoveredItems, stats } = await unbundleRecords(sqsRecords);
-            expect(recoveredItems).toHaveLength(100);
-            expect(recoveredItems).toEqual(originalItems);
-            expect(stats.bundledSqsRecords).toBe(capturedEnvelopes.length);
-            expect(stats.failedRecords).toBe(0);
-        });
-        it('preserves all primitive types correctly', async () => {
-            const bundledClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-            });
-            const originalItems = [
-                { id: 'str', name: 'string-test', value: undefined },
-                { id: 'num', name: 'number-test', value: 123.456 },
-                { id: 'zero', name: 'zero-test', value: 0 },
-                { id: 'neg', name: 'negative-test', value: -999.99 },
-                { id: 'big', name: 'big-number', value: Number.MAX_SAFE_INTEGER },
-            ];
-            await bundledClient.sendBundled('test', originalItems);
-            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
-            const { items: recoveredItems } = await unbundleRecords(sqsRecords);
-            expect(recoveredItems).toEqual(originalItems);
-        });
-    });
-    describe('2. Large scale round-trip (1000 items)', () => {
-        it('1000 items survive round-trip with no data loss', async () => {
-            const bundledClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-                compressionLevel: 3,
-            });
-            const originalItems = Array.from({ length: 1000 }, (_, i) => ({
-                id: `event-${i.toString().padStart(4, '0')}`,
-                name: `type-${i % 10}`,
-                value: i * 1.5,
-                metadata: {
-                    batch: Math.floor(i / 100),
-                    position: i % 100,
-                    timestamp: Date.now() + i,
-                },
-            }));
-            await bundledClient.sendBundled('test', originalItems);
-            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
-            const { items: recoveredItems, stats } = await unbundleRecords(sqsRecords);
-            expect(recoveredItems).toHaveLength(1000);
-            expect(stats.totalItems).toBe(1000);
-            expect(stats.failedRecords).toBe(0);
-            const recoveredIds = recoveredItems.map((item) => item.id);
-            const originalIds = originalItems.map((item) => item.id);
-            expect(new Set(recoveredIds)).toEqual(new Set(originalIds));
-            expect(recoveredItems).toEqual(originalItems);
-        });
-        it('preserves order within each bundle', async () => {
-            const bundledClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-                maxItemsPerBundle: 100,
-            });
-            const originalItems = Array.from({ length: 500 }, (_, i) => makeTestEvent(`seq-${i}`, 'ordered', i));
-            await bundledClient.sendBundled('test', originalItems);
-            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
-            const { items: recoveredItems } = await unbundleRecords(sqsRecords);
-            let currentBundleStart = 0;
-            for (const envelope of capturedEnvelopes) {
-                const bundleSize = envelope.n;
-                const bundleItems = recoveredItems.slice(currentBundleStart, currentBundleStart + bundleSize);
-                for (let j = 1; j < bundleItems.length; j++) {
-                    const prevValue = bundleItems[j - 1]?.value ?? 0;
-                    const currValue = bundleItems[j]?.value ?? 0;
-                    expect(currValue).toBeGreaterThan(prevValue);
-                }
-                currentBundleStart += bundleSize;
-            }
-        });
-    });
-    describe('3. Compression round-trip verification', () => {
-        it('ZSTD compressed data decompresses to byte-exact JSON', async () => {
-            const bundledClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-                compressionLevel: 5,
-            });
-            const originalItems = Array.from({ length: 50 }, (_, i) => ({
-                id: `compress-test-${i}`,
-                name: 'compression-verification',
-                value: i * 123.456789,
-                metadata: {
-                    unicode: '日本語テスト',
-                    emoji: '🚀✨🎉',
-                    special: 'line\nbreak\ttab\r\nwindows',
-                    quotes: '"double" and \'single\'',
-                },
-            }));
-            const originalJson = JSON.stringify(originalItems);
-            await bundledClient.sendBundled('test', originalItems);
-            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
-            const { items: recoveredItems } = await unbundleRecords(sqsRecords);
-            const recoveredJson = JSON.stringify(recoveredItems);
-            expect(recoveredJson).toBe(originalJson);
-            expect(recoveredItems).toEqual(originalItems);
-        });
-        it('verifies actual compression occurred', async () => {
-            const bundledClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-                compressionLevel: 3,
-            });
-            const originalItems = Array.from({ length: 200 }, (_, i) => ({
-                id: `item-${i}`,
-                name: 'repetitive-data-for-compression',
-                value: i,
-                metadata: {
-                    commonField1: 'this is repeated many times',
-                    commonField2: 'another repeated value',
-                },
-            }));
-            const originalSizeBytes = Buffer.byteLength(JSON.stringify(originalItems), 'utf8');
-            await bundledClient.sendBundled('test', originalItems);
-            for (const envelope of capturedEnvelopes) {
-                expect(envelope.c).toBe(CompressionAlgorithm.ZSTD);
-                expect(typeof envelope.p).toBe('string');
-                const compressedSizeBytes = Buffer.byteLength(envelope.p, 'utf8');
-                expect(compressedSizeBytes).toBeLessThan(originalSizeBytes);
-            }
-        });
-    });
-    describe('4. Mixed message types round-trip', () => {
-        it('handles mix of NONE and ZSTD compression in same batch', async () => {
-            const zstdClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-            });
-            const noneClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.NONE,
-            });
-            const zstdItems = [
-                makeTestEvent('zstd-1', 'compressed', 100),
-                makeTestEvent('zstd-2', 'compressed', 200),
-            ];
-            const noneItems = [
-                makeTestEvent('none-1', 'uncompressed', 300),
-                makeTestEvent('none-2', 'uncompressed', 400),
-            ];
-            await zstdClient.sendBundled('test', zstdItems);
-            const zstdEnvelopes = [...capturedEnvelopes];
-            capturedEnvelopes = [];
-            await noneClient.sendBundled('test', noneItems);
-            const noneEnvelopes = [...capturedEnvelopes];
-            const allEnvelopes = [...zstdEnvelopes, ...noneEnvelopes];
-            const sqsRecords = simulateSqsDelivery(allEnvelopes);
-            const { items: recoveredItems, stats } = await unbundleRecords(sqsRecords);
-            expect(recoveredItems).toHaveLength(4);
-            expect(stats.bundledSqsRecords).toBe(2);
-            expect(stats.failedRecords).toBe(0);
-            const zstdRecovered = recoveredItems.filter((item) => item.name === 'compressed');
-            const noneRecovered = recoveredItems.filter((item) => item.name === 'uncompressed');
-            expect(zstdRecovered).toHaveLength(2);
-            expect(noneRecovered).toHaveLength(2);
-            expect(zstdRecovered).toEqual(zstdItems);
-            expect(noneRecovered).toEqual(noneItems);
-        });
-        it('handles mixed bundled and legacy messages', async () => {
-            const bundledClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-            });
-            const bundledItems = [
-                makeTestEvent('bundled-1', 'bundled', 100),
-                makeTestEvent('bundled-2', 'bundled', 200),
-            ];
-            await bundledClient.sendBundled('test', bundledItems);
-            const legacyRecord = {
-                messageId: 'legacy-msg-1',
-                body: JSON.stringify(makeTestEvent('legacy-1', 'legacy', 999)),
-            };
-            const wrappedLegacyRecord = {
-                messageId: 'legacy-msg-2',
-                body: JSON.stringify({ messageBody: makeTestEvent('legacy-2', 'wrapped-legacy', 888) }),
-            };
-            const bundledRecords = simulateSqsDelivery(capturedEnvelopes);
-            const allRecords = [...bundledRecords, legacyRecord, wrappedLegacyRecord];
-            const { items: recoveredItems, stats } = await unbundleRecords(allRecords);
-            expect(recoveredItems).toHaveLength(4);
-            expect(stats.bundledSqsRecords).toBe(1);
-            expect(stats.legacySqsRecords).toBe(2);
-            expect(stats.failedRecords).toBe(0);
-        });
-    });
-    describe('5. Error injection round-trip', () => {
-        it('recovers valid bundles while reporting corrupted bundle in failedMessageIds', async () => {
-            const bundledClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-            });
-            const validItems1 = [makeTestEvent('valid-1', 'first-batch', 100)];
-            const validItems2 = [makeTestEvent('valid-2', 'second-batch', 200)];
-            await bundledClient.sendBundled('test', validItems1);
-            const envelope1 = { ...capturedEnvelopes[0] };
-            capturedEnvelopes = [];
-            await bundledClient.sendBundled('test', validItems2);
-            const envelope2 = { ...capturedEnvelopes[0] };
-            const corruptedEnvelope = {
-                v: 1,
-                c: CompressionAlgorithm.ZSTD,
-                n: 10,
-                s: 1000,
-                p: 'dGhpcyBpcyBub3QgdmFsaWQgenN0ZA==',
-            };
-            const records = [
-                { messageId: 'valid-1', body: JSON.stringify({ messageBody: envelope1 }) },
-                { messageId: 'corrupted', body: JSON.stringify({ messageBody: corruptedEnvelope }) },
-                { messageId: 'valid-2', body: JSON.stringify({ messageBody: envelope2 }) },
-            ];
-            const { items: recoveredItems, failedMessageIds, stats } = await unbundleRecords(records);
-            expect(recoveredItems).toHaveLength(2);
-            expect(recoveredItems[0]?.id).toBe('valid-1');
-            expect(recoveredItems[1]?.id).toBe('valid-2');
-            expect(failedMessageIds).toContain('corrupted');
-            expect(failedMessageIds).toHaveLength(1);
-            expect(stats.bundledSqsRecords).toBe(2);
-            expect(stats.failedRecords).toBe(1);
-            expect(stats.totalItems).toBe(2);
-        });
-        it('handles invalid JSON gracefully', async () => {
-            const bundledClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-            });
-            const validItems = [makeTestEvent('valid', 'test', 100)];
-            await bundledClient.sendBundled('test', validItems);
-            const records = [
-                ...simulateSqsDelivery(capturedEnvelopes),
-                { messageId: 'invalid-json-1', body: 'not-valid-json{{{' },
-                { messageId: 'invalid-json-2', body: '{"incomplete":' },
-                { messageId: 'empty', body: '' },
-            ];
-            const { items: recoveredItems, failedMessageIds, stats } = await unbundleRecords(records);
-            expect(recoveredItems).toHaveLength(1);
-            expect(recoveredItems[0]?.id).toBe('valid');
-            expect(failedMessageIds).toContain('invalid-json-1');
-            expect(failedMessageIds).toContain('invalid-json-2');
-            expect(failedMessageIds).toContain('empty');
-            expect(failedMessageIds).toHaveLength(3);
-            expect(stats.failedRecords).toBe(3);
-        });
-        it('handles decompression bomb protection', async () => {
-            const largeItems = Array.from({ length: 1000 }, (_, i) => ({
-                id: `item-${i}`,
-                data: 'x'.repeat(1000),
-            }));
-            const json = JSON.stringify(largeItems);
-            const compressed = await compress(Buffer.from(json, 'utf8'), CompressionAlgorithm.ZSTD, 3);
-            const base64 = compressed.toString('base64');
-            const bigEnvelope = {
-                v: 1,
-                c: CompressionAlgorithm.ZSTD,
-                n: 1000,
-                s: json.length,
-                p: base64,
-            };
-            const records = [{ messageId: 'too-large', body: JSON.stringify({ messageBody: bigEnvelope }) }];
-            const { failedMessageIds, stats } = await unbundleRecords(records, {
-                maxDecompressedSizeBytes: 100 * 1024,
-            });
-            expect(failedMessageIds).toContain('too-large');
-            expect(stats.failedRecords).toBe(1);
-        });
-    });
-    describe('6. Realistic event types round-trip', () => {
-        it('TrackingEvent-like structures survive round-trip exactly', async () => {
-            const realisticMockSqs = {
-                buildAndSendMessagesV2: jest.fn(async (_type, envelopes) => {
-                    capturedEnvelopes = [];
-                    capturedEnvelopes.push(...envelopes);
-                    return {
-                        successCount: envelopes.length,
-                        failedCount: 0,
-                        batchCount: 1,
-                        failedMessages: [],
-                    };
-                }),
-                queueUrl: 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue',
-                limits: createSqsLimits(SQS_1MB),
-            };
-            const bundledClient = new BundledSQSClient(realisticMockSqs, {
-                compression: CompressionAlgorithm.ZSTD,
-                compressionLevel: 3,
-            });
-            const originalEvents = Array.from({ length: 100 }, (_, i) => makeRealisticTrackingEvent(i));
-            await bundledClient.sendBundled('tracking-events', originalEvents);
-            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
-            const { items: recoveredEvents, stats } = await unbundleRecords(sqsRecords);
-            expect(recoveredEvents).toHaveLength(100);
-            expect(stats.failedRecords).toBe(0);
-            expect(recoveredEvents).toEqual(originalEvents);
-            for (let i = 0; i < originalEvents.length; i++) {
-                const original = originalEvents[i];
-                const recovered = recoveredEvents[i];
-                expect(recovered?.anonymousId).toBe(original?.anonymousId);
-                expect(recovered?.context.page.url).toBe(original?.context.page.url);
-                expect(recovered?.properties.price).toBe(original?.properties.price);
-                if (original?.shopifyData) {
-                    expect(recovered?.shopifyData).toEqual(original.shopifyData);
-                }
-            }
-        });
-        it('preserves nested object structures exactly', async () => {
-            const bundledClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-            });
-            const deeplyNestedItems = [
-                {
-                    id: 'nested-1',
-                    name: 'deep-nesting',
-                    nested: {
-                        level1: {
-                            level2: {
-                                deep: 'very deep value',
-                            },
-                        },
-                    },
-                },
-                {
-                    id: 'nested-2',
-                    name: 'with-arrays',
-                    tags: ['tag1', 'tag2', 'tag3'],
-                    metadata: {
-                        array: [1, 2, 3],
-                        object: { a: 1, b: 2 },
-                        mixed: [{ key: 'value' }, [1, 2, 3]],
-                    },
-                },
-            ];
-            await bundledClient.sendBundled('test', deeplyNestedItems);
-            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
-            const { items: recoveredItems } = await unbundleRecords(sqsRecords);
-            expect(recoveredItems).toEqual(deeplyNestedItems);
-            expect(recoveredItems[0]?.nested?.level1.level2.deep).toBe('very deep value');
-            expect(recoveredItems[1]?.tags).toEqual(['tag1', 'tag2', 'tag3']);
-        });
-    });
-    describe('7. High compression ratio round-trip', () => {
-        it('highly repetitive data compresses and decompresses correctly', async () => {
-            const bundledClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-                compressionLevel: 3,
-            });
-            const repetitiveString = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA';
-            const originalItems = Array.from({ length: 200 }, (_, i) => ({
-                id: `repetitive-${i}`,
-                name: repetitiveString,
-                value: 42,
-                metadata: {
-                    field1: repetitiveString,
-                    field2: repetitiveString,
-                    field3: repetitiveString,
-                    field4: repetitiveString,
-                    field5: repetitiveString,
-                },
-            }));
-            const originalSizeBytes = Buffer.byteLength(JSON.stringify(originalItems), 'utf8');
-            await bundledClient.sendBundled('test', originalItems);
-            let totalCompressedSize = 0;
-            for (const envelope of capturedEnvelopes) {
-                expect(typeof envelope.p).toBe('string');
-                totalCompressedSize += Buffer.byteLength(envelope.p, 'utf8');
-            }
-            const compressionRatio = originalSizeBytes / totalCompressedSize;
-            expect(compressionRatio).toBeGreaterThan(5);
-            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
-            const { items: recoveredItems, stats } = await unbundleRecords(sqsRecords);
-            expect(recoveredItems).toHaveLength(200);
-            expect(recoveredItems).toEqual(originalItems);
-            expect(stats.failedRecords).toBe(0);
-            for (const item of recoveredItems) {
-                expect(item.name).toBe(repetitiveString);
-                expect(item.value).toBe(42);
-                expect(item.metadata?.field1).toBe(repetitiveString);
-            }
-        });
-        it('varying compression levels all round-trip correctly', async () => {
-            const items = Array.from({ length: 50 }, (_, i) => makeTestEvent(`level-test-${i}`, 'compression-level', i));
-            for (const level of [1, 3, 9, 15]) {
-                capturedEnvelopes = [];
-                const bundledClient = new BundledSQSClient(mockSqsClient, {
-                    compression: CompressionAlgorithm.ZSTD,
-                    compressionLevel: level,
-                });
-                await bundledClient.sendBundled('test', items);
-                const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
-                const { items: recoveredItems, stats } = await unbundleRecords(sqsRecords);
-                expect(recoveredItems).toEqual(items);
-                expect(stats.failedRecords).toBe(0);
-            }
-        });
-    });
-    describe('8. Edge cases', () => {
-        it('empty arrays survive round-trip', async () => {
-            const bundledClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-            });
-            const result = await bundledClient.sendBundled('test', []);
-            expect(result.totalItems).toBe(0);
-            expect(capturedEnvelopes).toHaveLength(0);
-        });
-        it('single item survives round-trip', async () => {
-            const bundledClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-            });
-            const singleItem = [makeTestEvent('single', 'lone-wolf', 999)];
-            await bundledClient.sendBundled('test', singleItem);
-            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
-            const { items: recoveredItems } = await unbundleRecords(sqsRecords);
-            expect(recoveredItems).toHaveLength(1);
-            expect(recoveredItems).toEqual(singleItem);
-        });
-        it('special characters survive round-trip', async () => {
-            const bundledClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-            });
-            const specialCharsItems = [
-                {
-                    id: 'unicode-日本語',
-                    name: '中文测试',
-                    metadata: {
-                        emoji: '🎉🚀✨💯',
-                        rtl: 'مرحبا بالعالم',
-                        escape: '\\n\\t\\r',
-                        quotes: '"double" \'single\' `backtick`',
-                        angle: '<script>alert("xss")</script>',
-                        null_char: 'before\x00after',
-                    },
-                },
-            ];
-            await bundledClient.sendBundled('test', specialCharsItems);
-            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
-            const { items: recoveredItems } = await unbundleRecords(sqsRecords);
-            expect(recoveredItems).toEqual(specialCharsItems);
-        });
-        it('null and undefined values are handled correctly', async () => {
-            const bundledClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-            });
-            const itemsWithNulls = [
-                { id: 'null-test', name: 'test', value: undefined },
-                {
-                    id: 'explicit-null',
-                    name: 'test',
-                    metadata: { key: null },
-                },
-            ];
-            await bundledClient.sendBundled('test', itemsWithNulls);
-            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
-            const { items: recoveredItems } = await unbundleRecords(sqsRecords);
-            expect(recoveredItems[0]?.value).toBeUndefined();
-            expect(recoveredItems[1]?.metadata?.key).toBeNull();
-        });
-        it('recordMap correctly tracks items back to SQS messages', async () => {
-            const bundledClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-                maxItemsPerBundle: 3,
-            });
-            const items = Array.from({ length: 10 }, (_, i) => makeTestEvent(`item-${i}`, 'tracking', i));
-            await bundledClient.sendBundled('test', items);
-            const sqsRecords = capturedEnvelopes.map((env, i) => ({
-                messageId: `bundle-${i}`,
-                body: JSON.stringify({ messageBody: env }),
-            }));
-            const { items: recoveredItems, recordMap, stats } = await unbundleRecords(sqsRecords);
-            expect(recoveredItems).toHaveLength(10);
-            const messageIdCounts = new Map();
-            for (const item of recoveredItems) {
-                const messageId = recordMap.get(item);
-                expect(messageId).toBeDefined();
-                if (messageId) {
-                    messageIdCounts.set(messageId, (messageIdCounts.get(messageId) ?? 0) + 1);
-                }
-            }
-            expect(messageIdCounts.size).toBe(capturedEnvelopes.length);
-            for (const [messageId, count] of messageIdCounts) {
-                expect(count).toBeLessThanOrEqual(3);
-                expect(messageId).toMatch(/^bundle-\d+$/);
-            }
-            expect(stats.bundledSqsRecords).toBe(capturedEnvelopes.length);
-        });
-    });
-});
+import { BundledSQSClient } from '../../clients/generic/sqs-bundled-client';
+import { CompressionAlgorithm } from '../../clients/generic/sqs-bundled-client.types';
+import { unbundleRecords } from '../../clients/generic/sqs-unbundle';
+import { compress } from '../../utils/compression';
+import { createSqsLimits, SQS_1MB } from '../../constants/sqs';
+jest.mock('../../helpers/logging-helper', () => ({
+    Logger: {
+        debug: jest.fn(),
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+    },
+}));
+function makeTestEvent(id, name = 'test', value, metadata) {
+    return { id, name, value, metadata };
+}
+function makeRealisticTrackingEvent(index) {
+    return {
+        anonymousId: `anon-${index}-${Math.random().toString(36).substring(7)}`,
+        accountId: `acc-${index % 10}`,
+        pixelId: `pixel-${index % 5}`,
+        eventType: ['track', 'identify', 'page'][index % 3] ?? 'track',
+        eventName: ['purchase', 'add_to_cart', 'page_view', 'begin_checkout'][index % 4] ?? 'track',
+        timestamp: new Date(Date.now() - index * 1000).toISOString(),
+        context: {
+            page: {
+                url: `https://example.com/product/${index}`,
+                path: `/product/${index}`,
+                title: `Product ${index} - Example Store`,
+                referrer: index % 3 === 0 ? 'https://google.com' : '',
+            },
+            userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            ip: `192.168.${index % 256}.${(index * 7) % 256}`,
+            locale: ['en-US', 'en-GB', 'de-DE', 'fr-FR'][index % 4] ?? 'en-US',
+            timezone: 'America/New_York',
+        },
+        properties: {
+            productId: `prod-${index}`,
+            productName: `Amazing Product ${index}`,
+            price: 29.99 + (index % 100),
+            currency: 'USD',
+            quantity: (index % 5) + 1,
+            category: ['Electronics', 'Clothing', 'Home', 'Sports'][index % 4],
+            customFields: {
+                brand: `Brand${index % 20}`,
+                sku: `SKU-${index}-${Date.now()}`,
+                inStock: index % 2 === 0,
+            },
+        },
+        shopifyData: index % 3 === 0
+            ? {
+                checkoutToken: `checkout-${index}`,
+                orderId: index % 5 === 0 ? `order-${index}` : undefined,
+                customerEmail: `customer${index}@example.com`,
+                lineItems: Array.from({ length: (index % 3) + 1 }, (_, j) => ({
+                    variantId: `variant-${index}-${j}`,
+                    title: `Line Item ${j}`,
+                    price: 19.99 + j * 10,
+                    quantity: j + 1,
+                })),
+            }
+            : undefined,
+    };
+}
+function simulateSqsDelivery(envelopes) {
+    return envelopes.map((env, i) => ({
+        messageId: `msg-${i}-${Date.now()}`,
+        body: JSON.stringify({ messageBody: env }),
+    }));
+}
+describe('Full Round-Trip: Producer → Consumer', () => {
+    let mockSqsClient;
+    let capturedEnvelopes;
+    beforeEach(() => {
+        capturedEnvelopes = [];
+        mockSqsClient = {
+            buildAndSendMessagesV2: jest.fn(async (_type, envelopes) => {
+                capturedEnvelopes.push(...envelopes);
+                return {
+                    successCount: envelopes.length,
+                    failedCount: 0,
+                    batchCount: 1,
+                    failedMessages: [],
+                };
+            }),
+            queueUrl: 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue',
+            limits: createSqsLimits(SQS_1MB),
+        };
+    });
+    describe('1. Basic round-trip test (100 items)', () => {
+        it('100 items survive complete round-trip with deep equality', async () => {
+            const bundledClient = new BundledSQSClient(mockSqsClient, {
+                compression: CompressionAlgorithm.ZSTD,
+                compressionLevel: 3,
+            });
+            const originalItems = Array.from({ length: 100 }, (_, i) => ({
+                id: `event-${i}`,
+                name: 'purchase',
+                value: i * 99.99,
+                metadata: { source: 'test', index: i },
+            }));
+            await bundledClient.sendBundled('test', originalItems);
+            expect(capturedEnvelopes.length).toBeGreaterThanOrEqual(1);
+            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
+            const { items: recoveredItems, stats } = await unbundleRecords(sqsRecords);
+            expect(recoveredItems).toHaveLength(100);
+            expect(recoveredItems).toEqual(originalItems);
+            expect(stats.bundledSqsRecords).toBe(capturedEnvelopes.length);
+            expect(stats.failedRecords).toBe(0);
+        });
+        it('preserves all primitive types correctly', async () => {
+            const bundledClient = new BundledSQSClient(mockSqsClient, {
+                compression: CompressionAlgorithm.ZSTD,
+            });
+            const originalItems = [
+                { id: 'str', name: 'string-test', value: undefined },
+                { id: 'num', name: 'number-test', value: 123.456 },
+                { id: 'zero', name: 'zero-test', value: 0 },
+                { id: 'neg', name: 'negative-test', value: -999.99 },
+                { id: 'big', name: 'big-number', value: Number.MAX_SAFE_INTEGER },
+            ];
+            await bundledClient.sendBundled('test', originalItems);
+            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
+            const { items: recoveredItems } = await unbundleRecords(sqsRecords);
+            expect(recoveredItems).toEqual(originalItems);
+        });
+    });
+    describe('2. Large scale round-trip (1000 items)', () => {
+        it('1000 items survive round-trip with no data loss', async () => {
+            const bundledClient = new BundledSQSClient(mockSqsClient, {
+                compression: CompressionAlgorithm.ZSTD,
+                compressionLevel: 3,
+            });
+            const originalItems = Array.from({ length: 1000 }, (_, i) => ({
+                id: `event-${i.toString().padStart(4, '0')}`,
+                name: `type-${i % 10}`,
+                value: i * 1.5,
+                metadata: {
+                    batch: Math.floor(i / 100),
+                    position: i % 100,
+                    timestamp: Date.now() + i,
+                },
+            }));
+            await bundledClient.sendBundled('test', originalItems);
+            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
+            const { items: recoveredItems, stats } = await unbundleRecords(sqsRecords);
+            expect(recoveredItems).toHaveLength(1000);
+            expect(stats.totalItems).toBe(1000);
+            expect(stats.failedRecords).toBe(0);
+            const recoveredIds = recoveredItems.map((item) => item.id);
+            const originalIds = originalItems.map((item) => item.id);
+            expect(new Set(recoveredIds)).toEqual(new Set(originalIds));
+            expect(recoveredItems).toEqual(originalItems);
+        });
+        it('preserves order within each bundle', async () => {
+            const bundledClient = new BundledSQSClient(mockSqsClient, {
+                compression: CompressionAlgorithm.ZSTD,
+                maxItemsPerBundle: 100,
+            });
+            const originalItems = Array.from({ length: 500 }, (_, i) => makeTestEvent(`seq-${i}`, 'ordered', i));
+            await bundledClient.sendBundled('test', originalItems);
+            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
+            const { items: recoveredItems } = await unbundleRecords(sqsRecords);
+            let currentBundleStart = 0;
+            for (const envelope of capturedEnvelopes) {
+                const bundleSize = envelope.n;
+                const bundleItems = recoveredItems.slice(currentBundleStart, currentBundleStart + bundleSize);
+                for (let j = 1; j < bundleItems.length; j++) {
+                    const prevValue = bundleItems[j - 1]?.value ?? 0;
+                    const currValue = bundleItems[j]?.value ?? 0;
+                    expect(currValue).toBeGreaterThan(prevValue);
+                }
+                currentBundleStart += bundleSize;
+            }
+        });
+    });
+    describe('3. Compression round-trip verification', () => {
+        it('ZSTD compressed data decompresses to byte-exact JSON', async () => {
+            const bundledClient = new BundledSQSClient(mockSqsClient, {
+                compression: CompressionAlgorithm.ZSTD,
+                compressionLevel: 5,
+            });
+            const originalItems = Array.from({ length: 50 }, (_, i) => ({
+                id: `compress-test-${i}`,
+                name: 'compression-verification',
+                value: i * 123.456789,
+                metadata: {
+                    unicode: '日本語テスト',
+                    emoji: '🚀✨🎉',
+                    special: 'line\nbreak\ttab\r\nwindows',
+                    quotes: '"double" and \'single\'',
+                },
+            }));
+            const originalJson = JSON.stringify(originalItems);
+            await bundledClient.sendBundled('test', originalItems);
+            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
+            const { items: recoveredItems } = await unbundleRecords(sqsRecords);
+            const recoveredJson = JSON.stringify(recoveredItems);
+            expect(recoveredJson).toBe(originalJson);
+            expect(recoveredItems).toEqual(originalItems);
+        });
+        it('verifies actual compression occurred', async () => {
+            const bundledClient = new BundledSQSClient(mockSqsClient, {
+                compression: CompressionAlgorithm.ZSTD,
+                compressionLevel: 3,
+            });
+            const originalItems = Array.from({ length: 200 }, (_, i) => ({
+                id: `item-${i}`,
+                name: 'repetitive-data-for-compression',
+                value: i,
+                metadata: {
+                    commonField1: 'this is repeated many times',
+                    commonField2: 'another repeated value',
+                },
+            }));
+            const originalSizeBytes = Buffer.byteLength(JSON.stringify(originalItems), 'utf8');
+            await bundledClient.sendBundled('test', originalItems);
+            for (const envelope of capturedEnvelopes) {
+                expect(envelope.c).toBe(CompressionAlgorithm.ZSTD);
+                expect(typeof envelope.p).toBe('string');
+                const compressedSizeBytes = Buffer.byteLength(envelope.p, 'utf8');
+                expect(compressedSizeBytes).toBeLessThan(originalSizeBytes);
+            }
+        });
+    });
+    describe('4. Mixed message types round-trip', () => {
+        it('handles mix of NONE and ZSTD compression in same batch', async () => {
+            const zstdClient = new BundledSQSClient(mockSqsClient, {
+                compression: CompressionAlgorithm.ZSTD,
+            });
+            const noneClient = new BundledSQSClient(mockSqsClient, {
+                compression: CompressionAlgorithm.NONE,
+            });
+            const zstdItems = [
+                makeTestEvent('zstd-1', 'compressed', 100),
+                makeTestEvent('zstd-2', 'compressed', 200),
+            ];
+            const noneItems = [
+                makeTestEvent('none-1', 'uncompressed', 300),
+                makeTestEvent('none-2', 'uncompressed', 400),
+            ];
+            await zstdClient.sendBundled('test', zstdItems);
+            const zstdEnvelopes = [...capturedEnvelopes];
+            capturedEnvelopes = [];
+            await noneClient.sendBundled('test', noneItems);
+            const noneEnvelopes = [...capturedEnvelopes];
+            const allEnvelopes = [...zstdEnvelopes, ...noneEnvelopes];
+            const sqsRecords = simulateSqsDelivery(allEnvelopes);
+            const { items: recoveredItems, stats } = await unbundleRecords(sqsRecords);
+            expect(recoveredItems).toHaveLength(4);
+            expect(stats.bundledSqsRecords).toBe(2);
+            expect(stats.failedRecords).toBe(0);
+            const zstdRecovered = recoveredItems.filter((item) => item.name === 'compressed');
+            const noneRecovered = recoveredItems.filter((item) => item.name === 'uncompressed');
+            expect(zstdRecovered).toHaveLength(2);
+            expect(noneRecovered).toHaveLength(2);
+            expect(zstdRecovered).toEqual(zstdItems);
+            expect(noneRecovered).toEqual(noneItems);
+        });
+        it('handles mixed bundled and legacy messages', async () => {
+            const bundledClient = new BundledSQSClient(mockSqsClient, {
+                compression: CompressionAlgorithm.ZSTD,
+            });
+            const bundledItems = [
+                makeTestEvent('bundled-1', 'bundled', 100),
+                makeTestEvent('bundled-2', 'bundled', 200),
+            ];
+            await bundledClient.sendBundled('test', bundledItems);
+            const legacyRecord = {
+                messageId: 'legacy-msg-1',
+                body: JSON.stringify(makeTestEvent('legacy-1', 'legacy', 999)),
+            };
+            const wrappedLegacyRecord = {
+                messageId: 'legacy-msg-2',
+                body: JSON.stringify({ messageBody: makeTestEvent('legacy-2', 'wrapped-legacy', 888) }),
+            };
+            const bundledRecords = simulateSqsDelivery(capturedEnvelopes);
+            const allRecords = [...bundledRecords, legacyRecord, wrappedLegacyRecord];
+            const { items: recoveredItems, stats } = await unbundleRecords(allRecords);
+            expect(recoveredItems).toHaveLength(4);
+            expect(stats.bundledSqsRecords).toBe(1);
+            expect(stats.legacySqsRecords).toBe(2);
+            expect(stats.failedRecords).toBe(0);
+        });
+    });
+    describe('5. Error injection round-trip', () => {
+        it('recovers valid bundles while reporting corrupted bundle in failedMessageIds', async () => {
+            const bundledClient = new BundledSQSClient(mockSqsClient, {
+                compression: CompressionAlgorithm.ZSTD,
+            });
+            const validItems1 = [makeTestEvent('valid-1', 'first-batch', 100)];
+            const validItems2 = [makeTestEvent('valid-2', 'second-batch', 200)];
+            await bundledClient.sendBundled('test', validItems1);
+            const envelope1 = { ...capturedEnvelopes[0] };
+            capturedEnvelopes = [];
+            await bundledClient.sendBundled('test', validItems2);
+            const envelope2 = { ...capturedEnvelopes[0] };
+            const corruptedEnvelope = {
+                v: 1,
+                c: CompressionAlgorithm.ZSTD,
+                n: 10,
+                s: 1000,
+                p: 'dGhpcyBpcyBub3QgdmFsaWQgenN0ZA==',
+            };
+            const records = [
+                { messageId: 'valid-1', body: JSON.stringify({ messageBody: envelope1 }) },
+                { messageId: 'corrupted', body: JSON.stringify({ messageBody: corruptedEnvelope }) },
+                { messageId: 'valid-2', body: JSON.stringify({ messageBody: envelope2 }) },
+            ];
+            const { items: recoveredItems, failedMessageIds, stats } = await unbundleRecords(records);
+            expect(recoveredItems).toHaveLength(2);
+            expect(recoveredItems[0]?.id).toBe('valid-1');
+            expect(recoveredItems[1]?.id).toBe('valid-2');
+            expect(failedMessageIds).toContain('corrupted');
+            expect(failedMessageIds).toHaveLength(1);
+            expect(stats.bundledSqsRecords).toBe(2);
+            expect(stats.failedRecords).toBe(1);
+            expect(stats.totalItems).toBe(2);
+        });
+        it('handles invalid JSON gracefully', async () => {
+            const bundledClient = new BundledSQSClient(mockSqsClient, {
+                compression: CompressionAlgorithm.ZSTD,
+            });
+            const validItems = [makeTestEvent('valid', 'test', 100)];
+            await bundledClient.sendBundled('test', validItems);
+            const records = [
+                ...simulateSqsDelivery(capturedEnvelopes),
+                { messageId: 'invalid-json-1', body: 'not-valid-json{{{' },
+                { messageId: 'invalid-json-2', body: '{"incomplete":' },
+                { messageId: 'empty', body: '' },
+            ];
+            const { items: recoveredItems, failedMessageIds, stats } = await unbundleRecords(records);
+            expect(recoveredItems).toHaveLength(1);
+            expect(recoveredItems[0]?.id).toBe('valid');
+            expect(failedMessageIds).toContain('invalid-json-1');
+            expect(failedMessageIds).toContain('invalid-json-2');
+            expect(failedMessageIds).toContain('empty');
+            expect(failedMessageIds).toHaveLength(3);
+            expect(stats.failedRecords).toBe(3);
+        });
+        it('handles decompression bomb protection', async () => {
+            const largeItems = Array.from({ length: 1000 }, (_, i) => ({
+                id: `item-${i}`,
+                data: 'x'.repeat(1000),
+            }));
+            const json = JSON.stringify(largeItems);
+            const compressed = await compress(Buffer.from(json, 'utf8'), CompressionAlgorithm.ZSTD, 3);
+            const base64 = compressed.toString('base64');
+            const bigEnvelope = {
+                v: 1,
+                c: CompressionAlgorithm.ZSTD,
+                n: 1000,
+                s: json.length,
+                p: base64,
+            };
+            const records = [{ messageId: 'too-large', body: JSON.stringify({ messageBody: bigEnvelope }) }];
+            const { failedMessageIds, stats } = await unbundleRecords(records, {
+                maxDecompressedSizeBytes: 100 * 1024,
+            });
+            expect(failedMessageIds).toContain('too-large');
+            expect(stats.failedRecords).toBe(1);
+        });
+    });
+    describe('6. Realistic event types round-trip', () => {
+        it('TrackingEvent-like structures survive round-trip exactly', async () => {
+            const realisticMockSqs = {
+                buildAndSendMessagesV2: jest.fn(async (_type, envelopes) => {
+                    capturedEnvelopes = [];
+                    capturedEnvelopes.push(...envelopes);
+                    return {
+                        successCount: envelopes.length,
+                        failedCount: 0,
+                        batchCount: 1,
+                        failedMessages: [],
+                    };
+                }),
+                queueUrl: 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue',
+                limits: createSqsLimits(SQS_1MB),
+            };
+            const bundledClient = new BundledSQSClient(realisticMockSqs, {
+                compression: CompressionAlgorithm.ZSTD,
+                compressionLevel: 3,
+            });
+            const originalEvents = Array.from({ length: 100 }, (_, i) => makeRealisticTrackingEvent(i));
+            await bundledClient.sendBundled('tracking-events', originalEvents);
+            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
+            const { items: recoveredEvents, stats } = await unbundleRecords(sqsRecords);
+            expect(recoveredEvents).toHaveLength(100);
+            expect(stats.failedRecords).toBe(0);
+            expect(recoveredEvents).toEqual(originalEvents);
+            for (let i = 0; i < originalEvents.length; i++) {
+                const original = originalEvents[i];
+                const recovered = recoveredEvents[i];
+                expect(recovered?.anonymousId).toBe(original?.anonymousId);
+                expect(recovered?.context.page.url).toBe(original?.context.page.url);
+                expect(recovered?.properties.price).toBe(original?.properties.price);
+                if (original?.shopifyData) {
+                    expect(recovered?.shopifyData).toEqual(original.shopifyData);
+                }
+            }
+        });
+        it('preserves nested object structures exactly', async () => {
+            const bundledClient = new BundledSQSClient(mockSqsClient, {
+                compression: CompressionAlgorithm.ZSTD,
+            });
+            const deeplyNestedItems = [
+                {
+                    id: 'nested-1',
+                    name: 'deep-nesting',
+                    nested: {
+                        level1: {
+                            level2: {
+                                deep: 'very deep value',
+                            },
+                        },
+                    },
+                },
+                {
+                    id: 'nested-2',
+                    name: 'with-arrays',
+                    tags: ['tag1', 'tag2', 'tag3'],
+                    metadata: {
+                        array: [1, 2, 3],
+                        object: { a: 1, b: 2 },
+                        mixed: [{ key: 'value' }, [1, 2, 3]],
+                    },
+                },
+            ];
+            await bundledClient.sendBundled('test', deeplyNestedItems);
+            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
+            const { items: recoveredItems } = await unbundleRecords(sqsRecords);
+            expect(recoveredItems).toEqual(deeplyNestedItems);
+            expect(recoveredItems[0]?.nested?.level1.level2.deep).toBe('very deep value');
+            expect(recoveredItems[1]?.tags).toEqual(['tag1', 'tag2', 'tag3']);
+        });
+    });
+    describe('7. High compression ratio round-trip', () => {
+        it('highly repetitive data compresses and decompresses correctly', async () => {
+            const bundledClient = new BundledSQSClient(mockSqsClient, {
+                compression: CompressionAlgorithm.ZSTD,
+                compressionLevel: 3,
+            });
+            const repetitiveString = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA';
+            const originalItems = Array.from({ length: 200 }, (_, i) => ({
+                id: `repetitive-${i}`,
+                name: repetitiveString,
+                value: 42,
+                metadata: {
+                    field1: repetitiveString,
+                    field2: repetitiveString,
+                    field3: repetitiveString,
+                    field4: repetitiveString,
+                    field5: repetitiveString,
+                },
+            }));
+            const originalSizeBytes = Buffer.byteLength(JSON.stringify(originalItems), 'utf8');
+            await bundledClient.sendBundled('test', originalItems);
+            let totalCompressedSize = 0;
+            for (const envelope of capturedEnvelopes) {
+                expect(typeof envelope.p).toBe('string');
+                totalCompressedSize += Buffer.byteLength(envelope.p, 'utf8');
+            }
+            const compressionRatio = originalSizeBytes / totalCompressedSize;
+            expect(compressionRatio).toBeGreaterThan(5);
+            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
+            const { items: recoveredItems, stats } = await unbundleRecords(sqsRecords);
+            expect(recoveredItems).toHaveLength(200);
+            expect(recoveredItems).toEqual(originalItems);
+            expect(stats.failedRecords).toBe(0);
+            for (const item of recoveredItems) {
+                expect(item.name).toBe(repetitiveString);
+                expect(item.value).toBe(42);
+                expect(item.metadata?.field1).toBe(repetitiveString);
+            }
+        });
+        it('varying compression levels all round-trip correctly', async () => {
+            const items = Array.from({ length: 50 }, (_, i) => makeTestEvent(`level-test-${i}`, 'compression-level', i));
+            for (const level of [1, 3, 9, 15]) {
+                capturedEnvelopes = [];
+                const bundledClient = new BundledSQSClient(mockSqsClient, {
+                    compression: CompressionAlgorithm.ZSTD,
+                    compressionLevel: level,
+                });
+                await bundledClient.sendBundled('test', items);
+                const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
+                const { items: recoveredItems, stats } = await unbundleRecords(sqsRecords);
+                expect(recoveredItems).toEqual(items);
+                expect(stats.failedRecords).toBe(0);
+            }
+        });
+    });
+    describe('8. Edge cases', () => {
+        it('empty arrays survive round-trip', async () => {
+            const bundledClient = new BundledSQSClient(mockSqsClient, {
+                compression: CompressionAlgorithm.ZSTD,
+            });
+            const result = await bundledClient.sendBundled('test', []);
+            expect(result.totalItems).toBe(0);
+            expect(capturedEnvelopes).toHaveLength(0);
+        });
+        it('single item survives round-trip', async () => {
+            const bundledClient = new BundledSQSClient(mockSqsClient, {
+                compression: CompressionAlgorithm.ZSTD,
+            });
+            const singleItem = [makeTestEvent('single', 'lone-wolf', 999)];
+            await bundledClient.sendBundled('test', singleItem);
+            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
+            const { items: recoveredItems } = await unbundleRecords(sqsRecords);
+            expect(recoveredItems).toHaveLength(1);
+            expect(recoveredItems).toEqual(singleItem);
+        });
+        it('special characters survive round-trip', async () => {
+            const bundledClient = new BundledSQSClient(mockSqsClient, {
+                compression: CompressionAlgorithm.ZSTD,
+            });
+            const specialCharsItems = [
+                {
+                    id: 'unicode-日本語',
+                    name: '中文测试',
+                    metadata: {
+                        emoji: '🎉🚀✨💯',
+                        rtl: 'مرحبا بالعالم',
+                        escape: '\\n\\t\\r',
+                        quotes: '"double" \'single\' `backtick`',
+                        angle: '<script>alert("xss")</script>',
+                        null_char: 'before\x00after',
+                    },
+                },
+            ];
+            await bundledClient.sendBundled('test', specialCharsItems);
+            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
+            const { items: recoveredItems } = await unbundleRecords(sqsRecords);
+            expect(recoveredItems).toEqual(specialCharsItems);
+        });
+        it('null and undefined values are handled correctly', async () => {
+            const bundledClient = new BundledSQSClient(mockSqsClient, {
+                compression: CompressionAlgorithm.ZSTD,
+            });
+            const itemsWithNulls = [
+                { id: 'null-test', name: 'test', value: undefined },
+                {
+                    id: 'explicit-null',
+                    name: 'test',
+                    metadata: { key: null },
+                },
+            ];
+            await bundledClient.sendBundled('test', itemsWithNulls);
+            const sqsRecords = simulateSqsDelivery(capturedEnvelopes);
+            const { items: recoveredItems } = await unbundleRecords(sqsRecords);
+            expect(recoveredItems[0]?.value).toBeUndefined();
+            expect(recoveredItems[1]?.metadata?.key).toBeNull();
+        });
+        it('recordMap correctly tracks items back to SQS messages', async () => {
+            const bundledClient = new BundledSQSClient(mockSqsClient, {
+                compression: CompressionAlgorithm.ZSTD,
+                maxItemsPerBundle: 3,
+            });
+            const items = Array.from({ length: 10 }, (_, i) => makeTestEvent(`item-${i}`, 'tracking', i));
+            await bundledClient.sendBundled('test', items);
+            const sqsRecords = capturedEnvelopes.map((env, i) => ({
+                messageId: `bundle-${i}`,
+                body: JSON.stringify({ messageBody: env }),
+            }));
+            const { items: recoveredItems, recordMap, stats } = await unbundleRecords(sqsRecords);
+            expect(recoveredItems).toHaveLength(10);
+            const messageIdCounts = new Map();
+            for (const item of recoveredItems) {
+                const messageId = recordMap.get(item);
+                expect(messageId).toBeDefined();
+                if (messageId) {
+                    messageIdCounts.set(messageId, (messageIdCounts.get(messageId) ?? 0) + 1);
+                }
+            }
+            expect(messageIdCounts.size).toBe(capturedEnvelopes.length);
+            for (const [messageId, count] of messageIdCounts) {
+                expect(count).toBeLessThanOrEqual(3);
+                expect(messageId).toMatch(/^bundle-\d+$/);
+            }
+            expect(stats.bundledSqsRecords).toBe(capturedEnvelopes.length);
+        });
+    });
+});
 //# sourceMappingURL=sqs-bundling-roundtrip.spec.js.map