@adtrackify/at-service-common 5.1.2 → 5.1.4

package/dist/cjs/__tests__/clients/sqs-bundled-client.spec.js

@@ -15,58 +15,40 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
 const sqs_bundled_client_1 = require("../../clients/generic/sqs-bundled-client");
 const sqs_bundled_client_types_1 = require("../../clients/generic/sqs-bundled-client.types");
 const sqs_1 = require("../../constants/sqs");
-vitest_1.vi.mock('../../helpers/logging-helper', () => ({
+jest.mock('../../helpers/logging-helper', () => ({
     Logger: {
-        debug: vitest_1.vi.fn(),
-        info: vitest_1.vi.fn(),
-        warn: vitest_1.vi.fn(),
-        error: vitest_1.vi.fn(),
+        debug: jest.fn(),
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
     },
 }));
-const mockSizeInBytes = vitest_1.vi.hoisted(() => vitest_1.vi.fn());
-vitest_1.vi.mock('../../utils/size', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        sizeInBytes: (obj) => mockSizeInBytes(obj),
-    };
-});
-let actualSizeModule;
-(0, vitest_1.beforeAll)(async () => {
-    actualSizeModule = await vitest_1.vi.importActual('../../utils/size');
-    mockSizeInBytes.mockImplementation(actualSizeModule.sizeInBytes);
-});
+const actualSizeModule = jest.requireActual('../../utils/size');
+const mockSizeInBytes = jest.fn(actualSizeModule.sizeInBytes);
+jest.mock('../../utils/size', () => ({
+    ...jest.requireActual('../../utils/size'),
+    sizeInBytes: (obj) => mockSizeInBytes(obj),
+}));
 function makeTestEvent(id, name = 'test', value) {
     return { id, name, value };
 }
-(0, vitest_1.describe)('BundledSQSClient', () => {
+describe('BundledSQSClient', () => {
     let mockSqsClient;
     let bundledClient;
-    (0, vitest_1.beforeEach)(() => {
+    beforeEach(() => {
         mockSqsClient = {
-            buildAndSendMessagesV2: vitest_1.vi.fn().mockResolvedValue({
+            buildAndSendMessagesV2: jest.fn().mockResolvedValue({
                 successCount: 1,
                 failedCount: 0,
                 batchCount: 1,
@@ -80,48 +62,48 @@ function makeTestEvent(id, name = 'test', value) {
             compressionLevel: 3,
         });
     });
-    (0, vitest_1.describe)('sendBundled', () => {
-        (0, vitest_1.it)('returns empty result for empty items array', async () => {
+    describe('sendBundled', () => {
+        it('returns empty result for empty items array', async () => {
             const result = await bundledClient.sendBundled('test-message', []);
-            (0, vitest_1.expect)(result.totalItems).toBe(0);
-            (0, vitest_1.expect)(result.bundleCount).toBe(0);
-            (0, vitest_1.expect)(result.messageCount).toBe(0);
-            (0, vitest_1.expect)(mockSqsClient.buildAndSendMessagesV2).not.toHaveBeenCalled();
+            expect(result.totalItems).toBe(0);
+            expect(result.bundleCount).toBe(0);
+            expect(result.messageCount).toBe(0);
+            expect(mockSqsClient.buildAndSendMessagesV2).not.toHaveBeenCalled();
         });
-        (0, vitest_1.it)('passes delaySeconds through to the underlying send', async () => {
+        it('passes delaySeconds through to the underlying send', async () => {
             const items = [makeTestEvent('1'), makeTestEvent('2')];
             await bundledClient.sendBundled('test-message', items, 480);
-            (0, vitest_1.expect)(mockSqsClient.buildAndSendMessagesV2).toHaveBeenCalledWith('test-message', vitest_1.expect.any(Array), 480);
+            expect(mockSqsClient.buildAndSendMessagesV2).toHaveBeenCalledWith('test-message', expect.any(Array), 480);
         });
-        (0, vitest_1.it)('defaults delaySeconds to 0 when omitted', async () => {
+        it('defaults delaySeconds to 0 when omitted', async () => {
             const items = [makeTestEvent('1')];
             await bundledClient.sendBundled('test-message', items);
-            (0, vitest_1.expect)(mockSqsClient.buildAndSendMessagesV2).toHaveBeenCalledWith('test-message', vitest_1.expect.any(Array), 0);
+            expect(mockSqsClient.buildAndSendMessagesV2).toHaveBeenCalledWith('test-message', expect.any(Array), 0);
         });
-        (0, vitest_1.it)('bundles and sends small items', async () => {
+        it('bundles and sends small items', async () => {
             const items = [makeTestEvent('1'), makeTestEvent('2'), makeTestEvent('3')];
             const result = await bundledClient.sendBundled('test-message', items);
-            (0, vitest_1.expect)(result.totalItems).toBe(3);
-            (0, vitest_1.expect)(result.bundleCount).toBeGreaterThanOrEqual(1);
-            (0, vitest_1.expect)(mockSqsClient.buildAndSendMessagesV2).toHaveBeenCalledTimes(1);
+            expect(result.totalItems).toBe(3);
+            expect(result.bundleCount).toBeGreaterThanOrEqual(1);
+            expect(mockSqsClient.buildAndSendMessagesV2).toHaveBeenCalledTimes(1);
             const sentEnvelopes = mockSqsClient.buildAndSendMessagesV2.mock
                 .calls[0][1];
-            (0, vitest_1.expect)(sentEnvelopes.length).toBeGreaterThanOrEqual(1);
+            expect(sentEnvelopes.length).toBeGreaterThanOrEqual(1);
             const envelope = sentEnvelopes[0];
-            (0, vitest_1.expect)(envelope.v).toBe(1);
-            (0, vitest_1.expect)(envelope.c).toBe(sqs_bundled_client_types_1.CompressionAlgorithm.ZSTD);
-            (0, vitest_1.expect)(envelope.n).toBe(3);
-            (0, vitest_1.expect)(typeof envelope.p).toBe('string');
+            expect(envelope.v).toBe(1);
+            expect(envelope.c).toBe(sqs_bundled_client_types_1.CompressionAlgorithm.ZSTD);
+            expect(envelope.n).toBe(3);
+            expect(typeof envelope.p).toBe('string');
         });
-        (0, vitest_1.it)('tracks compression metrics', async () => {
+        it('tracks compression metrics', async () => {
             const items = Array.from({ length: 100 }, (_, i) => makeTestEvent(`event-${i}`, `name-${i}`, i * 100));
             const result = await bundledClient.sendBundled('test-message', items);
-            (0, vitest_1.expect)(result.metrics.originalSizeBytes).toBeGreaterThan(0);
-            (0, vitest_1.expect)(result.metrics.finalSizeBytes).toBeGreaterThan(0);
-            (0, vitest_1.expect)(result.metrics.compressionRatio).toBeGreaterThan(1);
-            (0, vitest_1.expect)(result.metrics.compressionTimeMs).toBeGreaterThanOrEqual(0);
+            expect(result.metrics.originalSizeBytes).toBeGreaterThan(0);
+            expect(result.metrics.finalSizeBytes).toBeGreaterThan(0);
+            expect(result.metrics.compressionRatio).toBeGreaterThan(1);
+            expect(result.metrics.compressionTimeMs).toBeGreaterThanOrEqual(0);
         });
-        (0, vitest_1.it)('sends items without compression when NONE specified', async () => {
+        it('sends items without compression when NONE specified', async () => {
             const noCompressionClient = new sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
                 compression: sqs_bundled_client_types_1.CompressionAlgorithm.NONE,
             });
@@ -130,10 +112,10 @@ function makeTestEvent(id, name = 'test', value) {
             const sentEnvelopes = mockSqsClient.buildAndSendMessagesV2.mock
                 .calls[0][1];
             const envelope = sentEnvelopes[0];
-            (0, vitest_1.expect)(envelope.c).toBe(sqs_bundled_client_types_1.CompressionAlgorithm.NONE);
-            (0, vitest_1.expect)(Array.isArray(envelope.p)).toBe(true);
+            expect(envelope.c).toBe(sqs_bundled_client_types_1.CompressionAlgorithm.NONE);
+            expect(Array.isArray(envelope.p)).toBe(true);
         });
-        (0, vitest_1.it)('respects maxItemsPerBundle config', async () => {
+        it('respects maxItemsPerBundle config', async () => {
             const client = new sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
                 compression: sqs_bundled_client_types_1.CompressionAlgorithm.ZSTD,
                 maxItemsPerBundle: 10,
@@ -146,22 +128,22 @@ function makeTestEvent(id, name = 'test', value) {
                 failedMessages: [],
             });
             const result = await client.sendBundled('test-message', items);
-            (0, vitest_1.expect)(result.totalItems).toBe(25);
-            (0, vitest_1.expect)(result.bundleCount).toBeGreaterThanOrEqual(2);
+            expect(result.totalItems).toBe(25);
+            expect(result.bundleCount).toBeGreaterThanOrEqual(2);
             const sentEnvelopes = mockSqsClient.buildAndSendMessagesV2.mock
                 .calls[0][1];
             for (const envelope of sentEnvelopes) {
-                (0, vitest_1.expect)(envelope.n).toBeLessThanOrEqual(10);
+                expect(envelope.n).toBeLessThanOrEqual(10);
             }
         });
-        (0, vitest_1.it)('calculates billable requests based on size', async () => {
+        it('calculates billable requests based on size', async () => {
             const items = Array.from({ length: 50 }, (_, i) => makeTestEvent(`${i}`, 'name', i * 10));
             const result = await bundledClient.sendBundled('test-message', items);
-            (0, vitest_1.expect)(result.billableRequests).toBeGreaterThanOrEqual(1);
+            expect(result.billableRequests).toBeGreaterThanOrEqual(1);
         });
     });
-    (0, vitest_1.describe)('retry behavior', () => {
-        (0, vitest_1.it)('retries failed messages', async () => {
+    describe('retry behavior', () => {
+        it('retries failed messages', async () => {
             mockSqsClient.buildAndSendMessagesV2
                 .mockResolvedValueOnce({
                 successCount: 0,
@@ -177,10 +159,10 @@ function makeTestEvent(id, name = 'test', value) {
             });
             const items = [makeTestEvent('1')];
             const result = await bundledClient.sendBundled('test-message', items);
-            (0, vitest_1.expect)(mockSqsClient.buildAndSendMessagesV2).toHaveBeenCalledTimes(2);
-            (0, vitest_1.expect)(result.failedBundles).toBe(0);
+            expect(mockSqsClient.buildAndSendMessagesV2).toHaveBeenCalledTimes(2);
+            expect(result.failedBundles).toBe(0);
         });
-        (0, vitest_1.it)('stops retrying after max retries', async () => {
+        it('stops retrying after max retries', async () => {
             mockSqsClient.buildAndSendMessagesV2.mockResolvedValue({
                 successCount: 0,
                 failedCount: 1,
@@ -189,34 +171,34 @@ function makeTestEvent(id, name = 'test', value) {
             });
             const items = [makeTestEvent('1')];
             const result = await bundledClient.sendBundled('test-message', items);
-            (0, vitest_1.expect)(mockSqsClient.buildAndSendMessagesV2).toHaveBeenCalledTimes(3);
-            (0, vitest_1.expect)(result.failedBundles).toBeGreaterThan(0);
+            expect(mockSqsClient.buildAndSendMessagesV2).toHaveBeenCalledTimes(3);
+            expect(result.failedBundles).toBeGreaterThan(0);
         });
     });
-    (0, vitest_1.describe)('auto-resize', () => {
-        (0, vitest_1.it)('is enabled by default', () => {
+    describe('auto-resize', () => {
+        it('is enabled by default', () => {
             const client = new sqs_bundled_client_1.BundledSQSClient(mockSqsClient);
-            (0, vitest_1.expect)(client.config.autoResize).toBe(true);
+            expect(client.config.autoResize).toBe(true);
         });
-        (0, vitest_1.it)('can be configured to be disabled', () => {
+        it('can be configured to be disabled', () => {
             const client = new sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
                 autoResize: false,
             });
-            (0, vitest_1.expect)(client.config.autoResize).toBe(false);
+            expect(client.config.autoResize).toBe(false);
         });
     });
-    (0, vitest_1.describe)('skippedItems behavior', () => {
-        (0, vitest_1.afterEach)(() => {
+    describe('skippedItems behavior', () => {
+        afterEach(() => {
             mockSizeInBytes.mockImplementation(actualSizeModule.sizeInBytes);
         });
-        (0, vitest_1.it)('reports skippedItems as 0 when all items sent successfully', async () => {
+        it('reports skippedItems as 0 when all items sent successfully', async () => {
             const items = [makeTestEvent('1'), makeTestEvent('2')];
             const result = await bundledClient.sendBundled('test-message', items);
-            (0, vitest_1.expect)(result.skippedItems).toBe(0);
-            (0, vitest_1.expect)(result.totalItems).toBe(2);
-            (0, vitest_1.expect)(result.failedBundles).toBe(0);
+            expect(result.skippedItems).toBe(0);
+            expect(result.totalItems).toBe(2);
+            expect(result.failedBundles).toBe(0);
         });
-        (0, vitest_1.it)('tracks skippedItems when autoResize disabled and bundle exceeds limit', async () => {
+        it('tracks skippedItems when autoResize disabled and bundle exceeds limit', async () => {
             const noResizeClient = new sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
                 compression: sqs_bundled_client_types_1.CompressionAlgorithm.ZSTD,
                 autoResize: false,
@@ -224,16 +206,16 @@ function makeTestEvent(id, name = 'test', value) {
             const items = [makeTestEvent('1'), makeTestEvent('2'), makeTestEvent('3')];
             mockSizeInBytes.mockImplementation((obj) => {
                 if (typeof obj === 'object' && obj !== null && 'v' in obj) {
-                    return 2_000_000;
+                    return 2000000;
                 }
                 return 100;
             });
             const result = await noResizeClient.sendBundled('test-message', items);
-            (0, vitest_1.expect)(result.skippedItems).toBe(3);
-            (0, vitest_1.expect)(result.totalItems).toBe(3);
-            (0, vitest_1.expect)(mockSqsClient.buildAndSendMessagesV2).not.toHaveBeenCalled();
+            expect(result.skippedItems).toBe(3);
+            expect(result.totalItems).toBe(3);
+            expect(mockSqsClient.buildAndSendMessagesV2).not.toHaveBeenCalled();
         });
-        (0, vitest_1.it)('tracks skippedItems when single item cannot fit (splitAndRetry terminates)', async () => {
+        it('tracks skippedItems when single item cannot fit (splitAndRetry terminates)', async () => {
             const client = new sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
                 compression: sqs_bundled_client_types_1.CompressionAlgorithm.ZSTD,
                 autoResize: true,
@@ -241,15 +223,15 @@ function makeTestEvent(id, name = 'test', value) {
             const items = [makeTestEvent('oversized-item')];
             mockSizeInBytes.mockImplementation((obj) => {
                 if (typeof obj === 'object' && obj !== null && 'v' in obj) {
-                    return 2_000_000;
+                    return 2000000;
                 }
                 return 100;
             });
             const result = await client.sendBundled('test-message', items);
-            (0, vitest_1.expect)(result.skippedItems).toBe(1);
-            (0, vitest_1.expect)(result.totalItems).toBe(1);
+            expect(result.skippedItems).toBe(1);
+            expect(result.totalItems).toBe(1);
         });
-        (0, vitest_1.it)('reports partial skippedItems when some items are too large', async () => {
+        it('reports partial skippedItems when some items are too large', async () => {
             const client = new sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
                 compression: sqs_bundled_client_types_1.CompressionAlgorithm.ZSTD,
                 autoResize: true,
@@ -261,25 +243,25 @@ function makeTestEvent(id, name = 'test', value) {
                 if (typeof obj === 'object' && obj !== null && 'v' in obj) {
                     envelopeValidationCount++;
                     if (envelopeValidationCount === 2) {
-                        return 2_000_000;
+                        return 2000000;
                     }
                     return 500;
                 }
                 return 100;
             });
             const result = await client.sendBundled('test-message', items);
-            (0, vitest_1.expect)(result.skippedItems).toBe(1);
-            (0, vitest_1.expect)(result.totalItems).toBe(3);
-            (0, vitest_1.expect)(mockSqsClient.buildAndSendMessagesV2).toHaveBeenCalled();
+            expect(result.skippedItems).toBe(1);
+            expect(result.totalItems).toBe(3);
+            expect(mockSqsClient.buildAndSendMessagesV2).toHaveBeenCalled();
         });
-        (0, vitest_1.it)('emptyResult returns skippedItems as 0', async () => {
+        it('emptyResult returns skippedItems as 0', async () => {
             const result = await bundledClient.sendBundled('test-message', []);
-            (0, vitest_1.expect)(result.skippedItems).toBe(0);
-            (0, vitest_1.expect)(result.totalItems).toBe(0);
+            expect(result.skippedItems).toBe(0);
+            expect(result.totalItems).toBe(0);
         });
     });
-    (0, vitest_1.describe)('integration: end-to-end bundle flow', () => {
-        (0, vitest_1.it)('produces envelopes that unbundleRecords can process', async () => {
+    describe('integration: end-to-end bundle flow', () => {
+        it('produces envelopes that unbundleRecords can process', async () => {
             const { unbundleRecords } = await Promise.resolve().then(() => __importStar(require('../../clients/generic/sqs-unbundle')));
             const items = [
                 makeTestEvent('event-1', 'purchase', 99.99),
@@ -289,38 +271,38 @@ function makeTestEvent(id, name = 'test', value) {
             let capturedEnvelope = null;
             mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_type, envelopes) => {
                 capturedEnvelope = envelopes[0];
-                return await Promise.resolve({
+                return {
                     successCount: envelopes.length,
                     failedCount: 0,
                     batchCount: 1,
                     failedMessages: [],
-                });
+                };
             });
             await bundledClient.sendBundled('test-message', items);
-            (0, vitest_1.expect)(capturedEnvelope).not.toBeNull();
+            expect(capturedEnvelope).not.toBeNull();
             const sqsRecord = {
                 messageId: 'msg-1',
                 body: JSON.stringify({ messageBody: capturedEnvelope }),
             };
             const { items: unbundledItems, stats } = await unbundleRecords([sqsRecord]);
-            (0, vitest_1.expect)(unbundledItems).toHaveLength(3);
-            (0, vitest_1.expect)(unbundledItems[0]).toEqual({ id: 'event-1', name: 'purchase', value: 99.99 });
-            (0, vitest_1.expect)(unbundledItems[1]).toEqual({ id: 'event-2', name: 'add_to_cart', value: 29.99 });
-            (0, vitest_1.expect)(unbundledItems[2]).toEqual({ id: 'event-3', name: 'page_view' });
-            (0, vitest_1.expect)(stats.bundledSqsRecords).toBe(1);
+            expect(unbundledItems).toHaveLength(3);
+            expect(unbundledItems[0]).toEqual({ id: 'event-1', name: 'purchase', value: 99.99 });
+            expect(unbundledItems[1]).toEqual({ id: 'event-2', name: 'add_to_cart', value: 29.99 });
+            expect(unbundledItems[2]).toEqual({ id: 'event-3', name: 'page_view' });
+            expect(stats.bundledSqsRecords).toBe(1);
         });
-        (0, vitest_1.it)('maintains compatibility with large bundles', async () => {
+        it('maintains compatibility with large bundles', async () => {
             const { unbundleRecords } = await Promise.resolve().then(() => __importStar(require('../../clients/generic/sqs-unbundle')));
             const items = Array.from({ length: 200 }, (_, i) => makeTestEvent(`event-${i}`, `type-${i % 5}`, i * 1.5));
             let capturedEnvelopes = [];
             mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_type, envelopes) => {
                 capturedEnvelopes = envelopes;
-                return await Promise.resolve({
+                return {
                     successCount: envelopes.length,
                     failedCount: 0,
                     batchCount: 1,
                     failedMessages: [],
-                });
+                };
             });
             await bundledClient.sendBundled('test-message', items);
             const sqsRecords = capturedEnvelopes.map((env, i) => ({
@@ -328,13 +310,13 @@ function makeTestEvent(id, name = 'test', value) {
                 body: JSON.stringify({ messageBody: env }),
             }));
             const { items: unbundledItems } = await unbundleRecords(sqsRecords);
-            (0, vitest_1.expect)(unbundledItems).toHaveLength(200);
-            (0, vitest_1.expect)(unbundledItems[0].id).toBe('event-0');
-            (0, vitest_1.expect)(unbundledItems[199].id).toBe('event-199');
+            expect(unbundledItems).toHaveLength(200);
+            expect(unbundledItems[0].id).toBe('event-0');
+            expect(unbundledItems[199].id).toBe('event-199');
         });
     });
-    (0, vitest_1.describe)('producer edge cases - real sequences', () => {
-        (0, vitest_1.it)('handles 1000 items with real bundling and verifies envelope structure', async () => {
+    describe('producer edge cases - real sequences', () => {
+        it('handles 1000 items with real bundling and verifies envelope structure', async () => {
             const { unbundleRecords } = await Promise.resolve().then(() => __importStar(require('../../clients/generic/sqs-unbundle')));
             const items = Array.from({ length: 1000 }, (_, i) => ({
                 id: `item-${i}`,
@@ -345,36 +327,36 @@ function makeTestEvent(id, name = 'test', value) {
             const capturedEnvelopes = [];
             mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
                 capturedEnvelopes.push(...envelopes);
-                return await Promise.resolve({
+                return {
                     successCount: envelopes.length,
                     failedCount: 0,
                     batchCount: 1,
                     failedMessages: [],
-                });
+                };
             });
             const result = await bundledClient.sendBundled('test', items);
-            (0, vitest_1.expect)(result.totalItems).toBe(1000);
-            (0, vitest_1.expect)(capturedEnvelopes.length).toBeGreaterThan(0);
+            expect(result.totalItems).toBe(1000);
+            expect(capturedEnvelopes.length).toBeGreaterThan(0);
             let totalItemsInEnvelopes = 0;
             for (const env of capturedEnvelopes) {
-                (0, vitest_1.expect)(env.v).toBe(1);
-                (0, vitest_1.expect)(env.c).toBe(sqs_bundled_client_types_1.CompressionAlgorithm.ZSTD);
-                (0, vitest_1.expect)(typeof env.p).toBe('string');
-                (0, vitest_1.expect)(typeof env.n).toBe('number');
-                (0, vitest_1.expect)(env.n).toBeGreaterThan(0);
+                expect(env.v).toBe(1);
+                expect(env.c).toBe(sqs_bundled_client_types_1.CompressionAlgorithm.ZSTD);
+                expect(typeof env.p).toBe('string');
+                expect(typeof env.n).toBe('number');
+                expect(env.n).toBeGreaterThan(0);
                 totalItemsInEnvelopes += env.n;
             }
-            (0, vitest_1.expect)(totalItemsInEnvelopes).toBe(1000);
+            expect(totalItemsInEnvelopes).toBe(1000);
             const sqsRecords = capturedEnvelopes.map((env, i) => ({
                 messageId: `msg-${i}`,
                 body: JSON.stringify({ messageBody: env }),
             }));
             const { items: unbundledItems } = await unbundleRecords(sqsRecords);
-            (0, vitest_1.expect)(unbundledItems).toHaveLength(1000);
-            (0, vitest_1.expect)(unbundledItems[0]).toEqual({ id: 'item-0', name: 'payload-0', value: 0, data: 'extra-data-0' });
-            (0, vitest_1.expect)(unbundledItems[999]).toEqual({ id: 'item-999', name: 'payload-999', value: 9990, data: 'extra-data-999' });
+            expect(unbundledItems).toHaveLength(1000);
+            expect(unbundledItems[0]).toEqual({ id: 'item-0', name: 'payload-0', value: 0, data: 'extra-data-0' });
+            expect(unbundledItems[999]).toEqual({ id: 'item-999', name: 'payload-999', value: 9990, data: 'extra-data-999' });
         });
-        (0, vitest_1.it)('achieves compression effectiveness with repetitive data', async () => {
+        it('achieves compression effectiveness with repetitive data', async () => {
             const { unbundleRecords } = await Promise.resolve().then(() => __importStar(require('../../clients/generic/sqs-unbundle')));
             const repetitiveText = 'AAAAAAAAAA'.repeat(100);
             const items = Array.from({ length: 100 }, (_, i) => ({
@@ -386,31 +368,31 @@ function makeTestEvent(id, name = 'test', value) {
             const capturedEnvelopes = [];
             mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
                 capturedEnvelopes.push(envelopes[0]);
-                return await Promise.resolve({
+                return {
                     successCount: envelopes.length,
                     failedCount: 0,
                     batchCount: 1,
                     failedMessages: [],
-                });
+                };
             });
             const result = await bundledClient.sendBundled('test', items);
-            (0, vitest_1.expect)(result.metrics.compressionRatio).toBeGreaterThan(1);
-            (0, vitest_1.expect)(result.metrics.finalSizeBytes).toBeLessThan(result.metrics.originalSizeBytes);
-            (0, vitest_1.expect)(result.metrics.compressionRatio).toBeGreaterThan(5);
-            (0, vitest_1.expect)(capturedEnvelopes).toHaveLength(1);
+            expect(result.metrics.compressionRatio).toBeGreaterThan(1);
+            expect(result.metrics.finalSizeBytes).toBeLessThan(result.metrics.originalSizeBytes);
+            expect(result.metrics.compressionRatio).toBeGreaterThan(5);
+            expect(capturedEnvelopes).toHaveLength(1);
             const envelope = capturedEnvelopes[0];
-            (0, vitest_1.expect)(typeof envelope.p).toBe('string');
+            expect(typeof envelope.p).toBe('string');
             const { items: unbundledItems } = await unbundleRecords([
                 {
                     messageId: 'msg-1',
                     body: JSON.stringify({ messageBody: envelope }),
                 },
             ]);
-            (0, vitest_1.expect)(unbundledItems).toHaveLength(100);
-            (0, vitest_1.expect)(unbundledItems[0].data).toBe(repetitiveText);
-            (0, vitest_1.expect)(unbundledItems[99].data).toBe(repetitiveText);
+            expect(unbundledItems).toHaveLength(100);
+            expect(unbundledItems[0].data).toBe(repetitiveText);
+            expect(unbundledItems[99].data).toBe(repetitiveText);
         });
-        (0, vitest_1.it)('handles various item sizes correctly', async () => {
+        it('handles various item sizes correctly', async () => {
             const { unbundleRecords } = await Promise.resolve().then(() => __importStar(require('../../clients/generic/sqs-unbundle')));
             const tinyItems = Array.from({ length: 10 }, (_, i) => ({
                 id: `tiny-${i}`,
@@ -426,50 +408,50 @@ function makeTestEvent(id, name = 'test', value) {
                 id: `medium-${i}`,
                 name: 'medium-item',
                 value: i,
-                data: 'y'.repeat(10_000),
+                data: 'y'.repeat(10000),
             }));
             const largerItems = Array.from({ length: 5 }, (_, i) => ({
                 id: `larger-${i}`,
                 name: 'larger-item',
                 value: i,
-                data: 'z'.repeat(100_000),
+                data: 'z'.repeat(100000),
             }));
             const allItems = [...tinyItems, ...smallItems, ...mediumItems, ...largerItems];
             const totalExpectedItems = allItems.length;
             const capturedEnvelopes = [];
             mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
                 capturedEnvelopes.push(...envelopes);
-                return await Promise.resolve({
+                return {
                     successCount: envelopes.length,
                     failedCount: 0,
                     batchCount: 1,
                     failedMessages: [],
-                });
+                };
             });
             const result = await bundledClient.sendBundled('test', allItems);
-            (0, vitest_1.expect)(result.totalItems).toBe(totalExpectedItems);
-            (0, vitest_1.expect)(result.skippedItems).toBe(0);
+            expect(result.totalItems).toBe(totalExpectedItems);
+            expect(result.skippedItems).toBe(0);
             const totalInEnvelopes = capturedEnvelopes.reduce((sum, env) => sum + env.n, 0);
-            (0, vitest_1.expect)(totalInEnvelopes).toBe(totalExpectedItems);
+            expect(totalInEnvelopes).toBe(totalExpectedItems);
             const sqsRecords = capturedEnvelopes.map((env, i) => ({
                 messageId: `msg-${i}`,
                 body: JSON.stringify({ messageBody: env }),
             }));
             const { items: unbundledItems } = await unbundleRecords(sqsRecords);
-            (0, vitest_1.expect)(unbundledItems).toHaveLength(totalExpectedItems);
+            expect(unbundledItems).toHaveLength(totalExpectedItems);
             const unbundledTiny = unbundledItems.filter((item) => item.id.startsWith('tiny-'));
             const unbundledSmall = unbundledItems.filter((item) => item.id.startsWith('small-'));
             const unbundledMedium = unbundledItems.filter((item) => item.id.startsWith('medium-'));
             const unbundledLarger = unbundledItems.filter((item) => item.id.startsWith('larger-'));
-            (0, vitest_1.expect)(unbundledTiny).toHaveLength(10);
-            (0, vitest_1.expect)(unbundledSmall).toHaveLength(10);
-            (0, vitest_1.expect)(unbundledMedium).toHaveLength(10);
-            (0, vitest_1.expect)(unbundledLarger).toHaveLength(5);
-            (0, vitest_1.expect)(unbundledSmall[0].data).toBe('x'.repeat(100));
-            (0, vitest_1.expect)(unbundledMedium[0].data).toBe('y'.repeat(10_000));
-            (0, vitest_1.expect)(unbundledLarger[0].data).toBe('z'.repeat(100_000));
-        });
-        (0, vitest_1.it)('preserves unicode and special characters through compression', async () => {
+            expect(unbundledTiny).toHaveLength(10);
+            expect(unbundledSmall).toHaveLength(10);
+            expect(unbundledMedium).toHaveLength(10);
+            expect(unbundledLarger).toHaveLength(5);
+            expect(unbundledSmall[0].data).toBe('x'.repeat(100));
+            expect(unbundledMedium[0].data).toBe('y'.repeat(10000));
+            expect(unbundledLarger[0].data).toBe('z'.repeat(100000));
+        });
+        it('preserves unicode and special characters through compression', async () => {
             const { unbundleRecords } = await Promise.resolve().then(() => __importStar(require('../../clients/generic/sqs-unbundle')));
             const unicodeItems = [
                 {
@@ -526,35 +508,35 @@ function makeTestEvent(id, name = 'test', value) {
             let capturedEnvelope = null;
             mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
                 capturedEnvelope = envelopes[0];
-                return await Promise.resolve({
+                return {
                     successCount: envelopes.length,
                     failedCount: 0,
                     batchCount: 1,
                     failedMessages: [],
-                });
+                };
             });
             const result = await bundledClient.sendBundled('test', unicodeItems);
-            (0, vitest_1.expect)(result.totalItems).toBe(unicodeItems.length);
-            (0, vitest_1.expect)(result.skippedItems).toBe(0);
-            (0, vitest_1.expect)(capturedEnvelope).not.toBeNull();
+            expect(result.totalItems).toBe(unicodeItems.length);
+            expect(result.skippedItems).toBe(0);
+            expect(capturedEnvelope).not.toBeNull();
             const { items: unbundledItems } = await unbundleRecords([
                 {
                     messageId: 'msg-1',
                     body: JSON.stringify({ messageBody: capturedEnvelope }),
                 },
             ]);
-            (0, vitest_1.expect)(unbundledItems).toHaveLength(unicodeItems.length);
+            expect(unbundledItems).toHaveLength(unicodeItems.length);
             for (let i = 0; i < unicodeItems.length; i++) {
-                (0, vitest_1.expect)(unbundledItems[i]).toEqual(unicodeItems[i]);
+                expect(unbundledItems[i]).toEqual(unicodeItems[i]);
             }
             const emojiItem = unbundledItems.find((item) => item.id === 'emoji');
-            (0, vitest_1.expect)(emojiItem?.name).toBe('🎉🚀💯🔥✨');
+            expect(emojiItem?.name).toBe('🎉🚀💯🔥✨');
             const chineseItem = unbundledItems.find((item) => item.id === 'chinese');
-            (0, vitest_1.expect)(chineseItem?.name).toBe('你好世界');
+            expect(chineseItem?.name).toBe('你好世界');
             const arabicItem = unbundledItems.find((item) => item.id === 'arabic');
-            (0, vitest_1.expect)(arabicItem?.name).toBe('مرحبا بالعالم');
+            expect(arabicItem?.name).toBe('مرحبا بالعالم');
         });
-        (0, vitest_1.it)('preserves deeply nested object structures', async () => {
+        it('preserves deeply nested object structures', async () => {
             const { unbundleRecords } = await Promise.resolve().then(() => __importStar(require('../../clients/generic/sqs-unbundle')));
             const nestedItems = [
                 {
@@ -631,79 +613,79 @@ function makeTestEvent(id, name = 'test', value) {
             let capturedEnvelope = null;
             mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
                 capturedEnvelope = envelopes[0];
-                return await Promise.resolve({
+                return {
                     successCount: envelopes.length,
                     failedCount: 0,
                     batchCount: 1,
                     failedMessages: [],
-                });
+                };
             });
             const genericClient = new sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
                 compression: sqs_bundled_client_types_1.CompressionAlgorithm.ZSTD,
             });
             const result = await genericClient.sendBundled('test', nestedItems);
-            (0, vitest_1.expect)(result.totalItems).toBe(nestedItems.length);
-            (0, vitest_1.expect)(result.skippedItems).toBe(0);
+            expect(result.totalItems).toBe(nestedItems.length);
+            expect(result.skippedItems).toBe(0);
             const { items: unbundledItems } = await unbundleRecords([
                 {
                     messageId: 'msg-1',
                     body: JSON.stringify({ messageBody: capturedEnvelope }),
                 },
             ]);
-            (0, vitest_1.expect)(unbundledItems).toHaveLength(nestedItems.length);
+            expect(unbundledItems).toHaveLength(nestedItems.length);
             const deepItem = unbundledItems.find((item) => item.id === 'deep-nested');
-            (0, vitest_1.expect)(deepItem?.nested?.level1?.level2?.level3?.level4?.level5?.level6?.value).toBe('deep-value');
-            (0, vitest_1.expect)(deepItem?.nested?.level1?.level2?.level3?.level4?.level5?.level6?.number).toBe(12345);
-            (0, vitest_1.expect)(deepItem?.nested?.level1?.level2?.level3?.level4?.level5?.level6?.boolean).toBe(true);
+            expect(deepItem?.nested?.level1?.level2?.level3?.level4?.level5?.level6?.value).toBe('deep-value');
+            expect(deepItem?.nested?.level1?.level2?.level3?.level4?.level5?.level6?.number).toBe(12345);
+            expect(deepItem?.nested?.level1?.level2?.level3?.level4?.level5?.level6?.boolean).toBe(true);
             const arrayItem = unbundledItems.find((item) => item.id === 'array-of-objects');
-            (0, vitest_1.expect)(arrayItem?.items?.length).toBe(3);
-            (0, vitest_1.expect)(arrayItem?.items?.[0]?.data?.nested?.value).toBe('a');
-            (0, vitest_1.expect)(arrayItem?.items?.[2]?.data?.nested?.value).toBe('c');
+            expect(arrayItem?.items?.length).toBe(3);
+            expect(arrayItem?.items?.[0]?.data?.nested?.value).toBe('a');
+            expect(arrayItem?.items?.[2]?.data?.nested?.value).toBe('c');
             const mixedItem = unbundledItems.find((item) => item.id === 'mixed-structures');
-            (0, vitest_1.expect)(mixedItem?.config?.settings?.features).toEqual(['feature-1', 'feature-2', 'feature-3']);
-            (0, vitest_1.expect)(mixedItem?.config?.settings?.metadata?.tags?.secondary?.group2).toEqual(['tag-e', 'tag-f']);
+            expect(mixedItem?.config?.settings?.features).toEqual(['feature-1', 'feature-2', 'feature-3']);
+            expect(mixedItem?.config?.settings?.metadata?.tags?.secondary?.group2).toEqual(['tag-e', 'tag-f']);
             const nullItem = unbundledItems.find((item) => item.id === 'null-undefined-handling');
-            (0, vitest_1.expect)(nullItem?.value).toBeNull();
-            (0, vitest_1.expect)(nullItem?.nested?.nullField).toBeNull();
-            (0, vitest_1.expect)(nullItem?.nested?.emptyObject).toEqual({});
-            (0, vitest_1.expect)(nullItem?.nested?.emptyArray).toEqual([]);
-            (0, vitest_1.expect)(nullItem?.nested?.zeroValue).toBe(0);
-            (0, vitest_1.expect)(nullItem?.nested?.falseValue).toBe(false);
-            (0, vitest_1.expect)(nullItem?.nested?.emptyString).toBe('');
+            expect(nullItem?.value).toBeNull();
+            expect(nullItem?.nested?.nullField).toBeNull();
+            expect(nullItem?.nested?.emptyObject).toEqual({});
+            expect(nullItem?.nested?.emptyArray).toEqual([]);
+            expect(nullItem?.nested?.zeroValue).toBe(0);
+            expect(nullItem?.nested?.falseValue).toBe(false);
+            expect(nullItem?.nested?.emptyString).toBe('');
             const largeArrayItem = unbundledItems.find((item) => item.id === 'large-array');
-            (0, vitest_1.expect)(largeArrayItem?.items).toHaveLength(100);
-            (0, vitest_1.expect)(largeArrayItem?.items?.[0]).toEqual({ index: 0, data: 'item-0', nested: { level: 1, value: 0 } });
-            (0, vitest_1.expect)(largeArrayItem?.items?.[99]).toEqual({ index: 99, data: 'item-99', nested: { level: 1, value: 198 } });
+            expect(largeArrayItem?.items).toHaveLength(100);
+            expect(largeArrayItem?.items?.[0]).toEqual({ index: 0, data: 'item-0', nested: { level: 1, value: 0 } });
+            expect(largeArrayItem?.items?.[99]).toEqual({ index: 99, data: 'item-99', nested: { level: 1, value: 198 } });
         });
-        (0, vitest_1.it)('handles exactly 1 item', async () => {
+        it('handles exactly 1 item', async () => {
             const { unbundleRecords } = await Promise.resolve().then(() => __importStar(require('../../clients/generic/sqs-unbundle')));
             const items = [{ id: 'single', name: 'only-one', value: 42 }];
             const capturedEnvelopes = [];
             mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
                 capturedEnvelopes.push(envelopes[0]);
-                return await Promise.resolve({
+                return {
                     successCount: envelopes.length,
                     failedCount: 0,
                     batchCount: 1,
                     failedMessages: [],
-                });
+                };
             });
             const result = await bundledClient.sendBundled('test', items);
-            (0, vitest_1.expect)(result.totalItems).toBe(1);
-            (0, vitest_1.expect)(result.bundleCount).toBe(1);
-            (0, vitest_1.expect)(result.messageCount).toBe(1);
-            (0, vitest_1.expect)(capturedEnvelopes).toHaveLength(1);
-            (0, vitest_1.expect)(capturedEnvelopes[0].n).toBe(1);
+            expect(result.totalItems).toBe(1);
+            expect(result.bundleCount).toBe(1);
+            expect(result.messageCount).toBe(1);
+            expect(capturedEnvelopes).toHaveLength(1);
+            expect(capturedEnvelopes[0].n).toBe(1);
             const { items: unbundledItems } = await unbundleRecords([
                 {
                     messageId: 'msg-1',
                     body: JSON.stringify({ messageBody: capturedEnvelopes[0] }),
                 },
             ]);
-            (0, vitest_1.expect)(unbundledItems).toHaveLength(1);
-            (0, vitest_1.expect)(unbundledItems[0]).toEqual(items[0]);
+            expect(unbundledItems).toHaveLength(1);
+            expect(unbundledItems[0]).toEqual(items[0]);
         });
-        (0, vitest_1.it)('handles exactly maxItemsPerBundle items', async () => {
+        it('handles exactly maxItemsPerBundle items', async () => {
             const { unbundleRecords } = await Promise.resolve().then(() => __importStar(require('../../clients/generic/sqs-unbundle')));
             const maxItems = 50;
             const client = new sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
@@ -718,25 +700,25 @@ function makeTestEvent(id, name = 'test', value) {
             const capturedEnvelopes = [];
             mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
                 capturedEnvelopes.push(...envelopes);
-                return await Promise.resolve({
+                return {
                     successCount: envelopes.length,
                     failedCount: 0,
                     batchCount: 1,
                     failedMessages: [],
-                });
+                };
             });
             const result = await client.sendBundled('test', items);
-            (0, vitest_1.expect)(result.totalItems).toBe(maxItems);
-            (0, vitest_1.expect)(capturedEnvelopes).toHaveLength(1);
-            (0, vitest_1.expect)(capturedEnvelopes[0].n).toBe(maxItems);
+            expect(result.totalItems).toBe(maxItems);
+            expect(capturedEnvelopes).toHaveLength(1);
+            expect(capturedEnvelopes[0].n).toBe(maxItems);
             const sqsRecords = capturedEnvelopes.map((env, i) => ({
                 messageId: `msg-${i}`,
                 body: JSON.stringify({ messageBody: env }),
             }));
             const { items: unbundledItems } = await unbundleRecords(sqsRecords);
-            (0, vitest_1.expect)(unbundledItems).toHaveLength(maxItems);
+            expect(unbundledItems).toHaveLength(maxItems);
         });
-        (0, vitest_1.it)('handles maxItemsPerBundle + 1 items (splits correctly)', async () => {
+        it('handles maxItemsPerBundle + 1 items (splits correctly)', async () => {
             const { unbundleRecords } = await Promise.resolve().then(() => __importStar(require('../../clients/generic/sqs-unbundle')));
             const maxItems = 50;
             const client = new sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
@@ -751,26 +733,26 @@ function makeTestEvent(id, name = 'test', value) {
             const capturedEnvelopes = [];
             mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
                 capturedEnvelopes.push(...envelopes);
-                return await Promise.resolve({
+                return {
                     successCount: envelopes.length,
                     failedCount: 0,
                     batchCount: 1,
                     failedMessages: [],
-                });
+                };
             });
             const result = await client.sendBundled('test', items);
-            (0, vitest_1.expect)(result.totalItems).toBe(maxItems + 1);
-            (0, vitest_1.expect)(capturedEnvelopes).toHaveLength(2);
-            (0, vitest_1.expect)(capturedEnvelopes[0].n).toBe(maxItems);
-            (0, vitest_1.expect)(capturedEnvelopes[1].n).toBe(1);
+            expect(result.totalItems).toBe(maxItems + 1);
+            expect(capturedEnvelopes).toHaveLength(2);
+            expect(capturedEnvelopes[0].n).toBe(maxItems);
+            expect(capturedEnvelopes[1].n).toBe(1);
             const sqsRecords = capturedEnvelopes.map((env, i) => ({
                 messageId: `msg-${i}`,
                 body: JSON.stringify({ messageBody: env }),
             }));
             const { items: unbundledItems } = await unbundleRecords(sqsRecords);
-            (0, vitest_1.expect)(unbundledItems).toHaveLength(maxItems + 1);
+            expect(unbundledItems).toHaveLength(maxItems + 1);
         });
-        (0, vitest_1.it)('handles uncompressed mode (NONE) with various data', async () => {
+        it('handles uncompressed mode (NONE) with various data', async () => {
             const { unbundleRecords } = await Promise.resolve().then(() => __importStar(require('../../clients/generic/sqs-unbundle')));
             const noCompressionClient = new sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
                 compression: sqs_bundled_client_types_1.CompressionAlgorithm.NONE,
@@ -784,32 +766,32 @@ function makeTestEvent(id, name = 'test', value) {
             const capturedEnvelopes = [];
             mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
                 capturedEnvelopes.push(envelopes[0]);
-                return await Promise.resolve({
+                return {
                     successCount: envelopes.length,
                     failedCount: 0,
                     batchCount: 1,
                     failedMessages: [],
-                });
+                };
             });
             const result = await noCompressionClient.sendBundled('test', items);
-            (0, vitest_1.expect)(result.totalItems).toBe(50);
-            (0, vitest_1.expect)(capturedEnvelopes).toHaveLength(1);
+            expect(result.totalItems).toBe(50);
+            expect(capturedEnvelopes).toHaveLength(1);
             const envelope = capturedEnvelopes[0];
-            (0, vitest_1.expect)(envelope.c).toBe(sqs_bundled_client_types_1.CompressionAlgorithm.NONE);
-            (0, vitest_1.expect)(Array.isArray(envelope.p)).toBe(true);
-            (0, vitest_1.expect)(envelope.p.length).toBe(50);
-            (0, vitest_1.expect)(result.metrics.compressionRatio).toBeCloseTo(1, 0);
+            expect(envelope.c).toBe(sqs_bundled_client_types_1.CompressionAlgorithm.NONE);
+            expect(Array.isArray(envelope.p)).toBe(true);
+            expect(envelope.p.length).toBe(50);
+            expect(result.metrics.compressionRatio).toBeCloseTo(1, 0);
             const { items: unbundledItems } = await unbundleRecords([
                 {
                     messageId: 'msg-1',
                     body: JSON.stringify({ messageBody: envelope }),
                 },
             ]);
-            (0, vitest_1.expect)(unbundledItems).toHaveLength(50);
-            (0, vitest_1.expect)(unbundledItems[0]).toEqual(items[0]);
-            (0, vitest_1.expect)(unbundledItems[49]).toEqual(items[49]);
+            expect(unbundledItems).toHaveLength(50);
+            expect(unbundledItems[0]).toEqual(items[0]);
+            expect(unbundledItems[49]).toEqual(items[49]);
         });
-        (0, vitest_1.it)('produces correct metrics for a large mixed batch', async () => {
+        it('produces correct metrics for a large mixed batch', async () => {
             const items = Array.from({ length: 500 }, (_, i) => ({
                 id: `metric-test-${i}`,
                 name: `item-${i % 10}`,
@@ -819,25 +801,25 @@ function makeTestEvent(id, name = 'test', value) {
             const capturedEnvelopes = [];
             mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
                 capturedEnvelopes.push(...envelopes);
-                return await Promise.resolve({
+                return {
                     successCount: envelopes.length,
                     failedCount: 0,
                     batchCount: 1,
                     failedMessages: [],
-                });
+                };
             });
             const result = await bundledClient.sendBundled('test', items);
-            (0, vitest_1.expect)(result.totalItems).toBe(500);
-            (0, vitest_1.expect)(result.metrics.originalSizeBytes).toBeGreaterThan(0);
-            (0, vitest_1.expect)(result.metrics.finalSizeBytes).toBeGreaterThan(0);
-            (0, vitest_1.expect)(result.metrics.compressionRatio).toBeGreaterThan(1);
-            (0, vitest_1.expect)(result.metrics.compressionTimeMs).toBeGreaterThanOrEqual(0);
-            (0, vitest_1.expect)(result.metrics.avgItemsPerBundle).toBeGreaterThan(0);
+            expect(result.totalItems).toBe(500);
+            expect(result.metrics.originalSizeBytes).toBeGreaterThan(0);
+            expect(result.metrics.finalSizeBytes).toBeGreaterThan(0);
+            expect(result.metrics.compressionRatio).toBeGreaterThan(1);
+            expect(result.metrics.compressionTimeMs).toBeGreaterThanOrEqual(0);
+            expect(result.metrics.avgItemsPerBundle).toBeGreaterThan(0);
             const expectedAvg = items.length / capturedEnvelopes.length;
-            (0, vitest_1.expect)(result.metrics.avgItemsPerBundle).toBeCloseTo(expectedAvg, 1);
-            (0, vitest_1.expect)(result.billableRequests).toBeGreaterThanOrEqual(1);
+            expect(result.metrics.avgItemsPerBundle).toBeCloseTo(expectedAvg, 1);
+            expect(result.billableRequests).toBeGreaterThanOrEqual(1);
         });
-        (0, vitest_1.it)('handles items with special JSON edge cases', async () => {
+        it('handles items with special JSON edge cases', async () => {
             const { unbundleRecords } = await Promise.resolve().then(() => __importStar(require('../../clients/generic/sqs-unbundle')));
             const edgeCaseItems = [
                 {
@@ -876,40 +858,40 @@ function makeTestEvent(id, name = 'test', value) {
             let capturedEnvelope = null;
             mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
                 capturedEnvelope = envelopes[0];
-                return await Promise.resolve({
+                return {
                     successCount: envelopes.length,
                     failedCount: 0,
                     batchCount: 1,
                     failedMessages: [],
-                });
+                };
             });
             const genericClient = new sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
                 compression: sqs_bundled_client_types_1.CompressionAlgorithm.ZSTD,
             });
             const result = await genericClient.sendBundled('test', edgeCaseItems);
-            (0, vitest_1.expect)(result.totalItems).toBe(edgeCaseItems.length);
-            (0, vitest_1.expect)(result.skippedItems).toBe(0);
+            expect(result.totalItems).toBe(edgeCaseItems.length);
+            expect(result.skippedItems).toBe(0);
             const { items: unbundledItems } = await unbundleRecords([
                 {
                     messageId: 'msg-1',
                     body: JSON.stringify({ messageBody: capturedEnvelope }),
                 },
             ]);
-            (0, vitest_1.expect)(unbundledItems).toHaveLength(edgeCaseItems.length);
+            expect(unbundledItems).toHaveLength(edgeCaseItems.length);
             const numbersItem = unbundledItems.find((item) => item.id === 'large-numbers');
-            (0, vitest_1.expect)(numbersItem?.bigInt).toBe(9007199254740991);
-            (0, vitest_1.expect)(numbersItem?.scientific).toBe(1.23e10);
-            (0, vitest_1.expect)(numbersItem?.negative).toBe(-999999);
-            (0, vitest_1.expect)(numbersItem?.zero).toBe(0);
+            expect(numbersItem?.bigInt).toBe(9007199254740991);
+            expect(numbersItem?.scientific).toBe(1.23e10);
+            expect(numbersItem?.negative).toBe(-999999);
+            expect(numbersItem?.zero).toBe(0);
             const stringsItem = unbundledItems.find((item) => item.id === 'special-strings');
-            (0, vitest_1.expect)(stringsItem?.data).toBe(JSON.stringify({ nested: 'json' }));
-            (0, vitest_1.expect)(stringsItem?.withQuotes).toBe('He said "hello"');
-            (0, vitest_1.expect)(stringsItem?.withBackslash).toBe('path\\to\\file');
+            expect(stringsItem?.data).toBe(JSON.stringify({ nested: 'json' }));
+            expect(stringsItem?.withQuotes).toBe('He said "hello"');
+            expect(stringsItem?.withBackslash).toBe('path\\to\\file');
             const booleansItem = unbundledItems.find((item) => item.id === 'boolean-variants');
-            (0, vitest_1.expect)(booleansItem?.trueVal).toBe(true);
-            (0, vitest_1.expect)(booleansItem?.falseVal).toBe(false);
+            expect(booleansItem?.trueVal).toBe(true);
+            expect(booleansItem?.falseVal).toBe(false);
         });
-        (0, vitest_1.it)('handles concurrent sends without interference', async () => {
+        it('handles concurrent sends without interference', async () => {
             const batch1 = Array.from({ length: 100 }, (_, i) => ({
                 id: `batch1-${i}`,
                 name: 'batch-one',
@@ -926,24 +908,24 @@ function makeTestEvent(id, name = 'test', value) {
                 value: i * 3,
             }));
             mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
-                return await Promise.resolve({
+                return {
                     successCount: envelopes.length,
                     failedCount: 0,
                     batchCount: 1,
                     failedMessages: [],
-                });
+                };
             });
             const [result1, result2, result3] = await Promise.all([
                 bundledClient.sendBundled('test', batch1),
                 bundledClient.sendBundled('test', batch2),
                 bundledClient.sendBundled('test', batch3),
             ]);
-            (0, vitest_1.expect)(result1.totalItems).toBe(100);
-            (0, vitest_1.expect)(result2.totalItems).toBe(100);
-            (0, vitest_1.expect)(result3.totalItems).toBe(100);
-            (0, vitest_1.expect)(result1.skippedItems).toBe(0);
-            (0, vitest_1.expect)(result2.skippedItems).toBe(0);
-            (0, vitest_1.expect)(result3.skippedItems).toBe(0);
+            expect(result1.totalItems).toBe(100);
+            expect(result2.totalItems).toBe(100);
+            expect(result3.totalItems).toBe(100);
+            expect(result1.skippedItems).toBe(0);
+            expect(result2.skippedItems).toBe(0);
+            expect(result3.skippedItems).toBe(0);
         });
     });
 });