observability-toolkit 1.8.4 → 1.8.5

package/dist/test-helpers/memfs-utils.js

@@ -0,0 +1,292 @@
+/**
+ * In-memory file system utilities for tests
+ *
+ * Uses memfs to provide a virtual file system that avoids disk I/O.
+ * Tests can use createMemFs() to get an isolated fs instance and directory.
+ *
+ * @example
+ * ```ts
+ * import { createMemFs, writeJsonlMem } from '../test-helpers/memfs-utils.js';
+ *
+ * describe('MyTest', () => {
+ *   let mfs: MemFsInstance;
+ *
+ *   beforeEach(() => {
+ *     mfs = createMemFs();
+ *   });
+ *
+ *   it('should work', async () => {
+ *     writeJsonlMem(mfs, 'traces-2026-01-31.jsonl', [{ traceId: 't1' }]);
+ *     // mfs.dir contains the path prefix to use
+ *     const backend = new LocalJsonlBackend(mfs.dir, { fs: mfs.fs });
+ *   });
+ * });
+ * ```
+ */
+import { createFsFromVolume, Volume } from 'memfs';
+import * as path from 'path';
+/** Counter for unique directory names */
+let memFsCounter = 0;
+/**
+ * Create a new in-memory file system instance
+ *
+ * Each call creates an isolated volume with its own directory.
+ * The returned fs object is compatible with node:fs operations.
+ *
+ * @param prefix - Optional prefix for the directory name
+ * @returns MemFsInstance with fs, vol, dir, and reset function
+ */
+export function createMemFs(prefix = 'test') {
+    const vol = new Volume();
+    const fs = createFsFromVolume(vol);
+    const dir = `/memfs-${prefix}-${++memFsCounter}`;
+    // Create the base directory
+    vol.mkdirSync(dir, { recursive: true });
+    return {
+        fs: fs,
+        vol,
+        dir,
+        reset: () => {
+            // Clear volume and recreate base directory
+            vol.reset();
+            vol.mkdirSync(dir, { recursive: true });
+        },
+    };
+}
+/**
+ * Write JSONL data to an in-memory file
+ *
+ * @param mfs - MemFsInstance from createMemFs()
+ * @param filename - Filename (not full path) to write
+ * @param data - Array of objects to write as JSONL
+ */
+export function writeJsonlMem(mfs, filename, data) {
+    const content = data.map(item => JSON.stringify(item)).join('\n');
+    const filePath = path.join(mfs.dir, filename);
+    mfs.vol.writeFileSync(filePath, content, { encoding: 'utf-8' });
+}
+/**
+ * Write raw content to an in-memory file
+ *
+ * @param mfs - MemFsInstance from createMemFs()
+ * @param filename - Filename (not full path) to write
+ * @param content - Content to write (string or Buffer)
+ */
+export function writeFileMem(mfs, filename, content) {
+    const filePath = path.join(mfs.dir, filename);
+    mfs.vol.writeFileSync(filePath, content);
+}
+/**
+ * Read file content from in-memory file system
+ *
+ * @param mfs - MemFsInstance from createMemFs()
+ * @param filename - Filename (not full path) to read
+ * @returns File content as string
+ */
+export function readFileMem(mfs, filename) {
+    const filePath = path.join(mfs.dir, filename);
+    return mfs.vol.readFileSync(filePath, 'utf-8');
+}
+/**
+ * Check if a file exists in the in-memory file system
+ *
+ * @param mfs - MemFsInstance from createMemFs()
+ * @param filename - Filename (not full path) to check
+ * @returns true if file exists
+ */
+export function existsMem(mfs, filename) {
+    const filePath = path.join(mfs.dir, filename);
+    return mfs.vol.existsSync(filePath);
+}
+/**
+ * Create a subdirectory in the in-memory file system
+ *
+ * @param mfs - MemFsInstance from createMemFs()
+ * @param dirname - Directory name to create (relative to mfs.dir)
+ */
+export function mkdirMem(mfs, dirname) {
+    const dirPath = path.join(mfs.dir, dirname);
+    mfs.vol.mkdirSync(dirPath, { recursive: true });
+}
+/**
+ * List files in a directory in the in-memory file system
+ *
+ * @param mfs - MemFsInstance from createMemFs()
+ * @param dirname - Optional subdirectory (defaults to mfs.dir)
+ * @returns Array of filenames
+ */
+export function readdirMem(mfs, dirname = '') {
+    const dirPath = dirname ? path.join(mfs.dir, dirname) : mfs.dir;
+    return mfs.vol.readdirSync(dirPath);
+}
+/**
+ * Get today's date in YYYY-MM-DD format
+ * @returns Today's date string
+ */
+export function getTestDateMem() {
+    return new Date().toISOString().split('T')[0];
+}
+/**
+ * Shared memfs instances for test suites
+ * Use getSharedMemFs() to get/create a shared instance by ID
+ */
+const sharedMemFsInstances = new Map();
+/**
+ * Get or create a shared memfs instance for a test suite
+ *
+ * Use this when multiple tests in a suite can share the same in-memory fs.
+ * Call resetSharedMemFs() in beforeEach to clear files between tests.
+ *
+ * @param suiteId - Unique identifier for the test suite
+ * @returns Shared MemFsInstance
+ */
+export function getSharedMemFs(suiteId) {
+    let mfs = sharedMemFsInstances.get(suiteId);
+    if (!mfs) {
+        mfs = createMemFs(suiteId);
+        sharedMemFsInstances.set(suiteId, mfs);
+    }
+    return mfs;
+}
+/**
+ * Reset (clear) a shared memfs instance
+ *
+ * Call this in beforeEach to ensure clean state between tests.
+ *
+ * @param suiteId - Unique identifier for the test suite
+ */
+export function resetSharedMemFs(suiteId) {
+    const mfs = sharedMemFsInstances.get(suiteId);
+    if (mfs) {
+        mfs.reset();
+    }
+}
+/**
+ * Remove a shared memfs instance
+ *
+ * Call this in after() to clean up suite-level resources.
+ *
+ * @param suiteId - Unique identifier for the test suite
+ */
+export function removeSharedMemFs(suiteId) {
+    sharedMemFsInstances.delete(suiteId);
+}
+/**
+ * Clean up all shared memfs instances
+ *
+ * Useful for global test teardown.
+ */
+export function cleanupAllSharedMemFs() {
+    sharedMemFsInstances.clear();
+}
+/**
+ * Read JSONL content from in-memory file and parse to objects
+ *
+ * @param mfs - MemFsInstance from createMemFs()
+ * @param filename - Filename (not full path) to read
+ * @returns Array of parsed objects (skips invalid lines)
+ */
+export function readJsonlMem(mfs, filename) {
+    const content = readFileMem(mfs, filename);
+    const results = [];
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            results.push(JSON.parse(trimmed));
+        }
+        catch {
+            // Skip invalid JSON lines
+        }
+    }
+    return results;
+}
+/**
+ * Read JSONL content with stats (mirrors readJsonlSyncWithStats)
+ *
+ * @param mfs - MemFsInstance from createMemFs()
+ * @param filename - Filename (not full path) to read
+ * @returns Object with data array and stats
+ */
+export function readJsonlMemWithStats(mfs, filename) {
+    const content = readFileMem(mfs, filename);
+    const data = [];
+    let totalLines = 0;
+    let skippedLines = 0;
+    let emptyLines = 0;
+    for (const line of content.split('\n')) {
+        totalLines++;
+        const trimmed = line.trim();
+        if (!trimmed) {
+            emptyLines++;
+            continue;
+        }
+        try {
+            data.push(JSON.parse(trimmed));
+        }
+        catch {
+            skippedLines++;
+        }
+    }
+    return { data, stats: { totalLines, skippedLines, emptyLines } };
+}
+/**
+ * Async generator for streaming JSONL from memfs (mirrors streamJsonl)
+ *
+ * @param mfs - MemFsInstance from createMemFs()
+ * @param filename - Filename (not full path) to read
+ * @yields Parsed objects from each line
+ */
+export async function* streamJsonlMem(mfs, filename) {
+    const content = readFileMem(mfs, filename);
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            yield JSON.parse(trimmed);
+        }
+        catch {
+            // Skip invalid JSON lines
+        }
+    }
+}
+/**
+ * List files matching a pattern prefix in the memfs directory
+ *
+ * @param mfs - MemFsInstance from createMemFs()
+ * @param prefix - Filename prefix to match (e.g., 'traces-')
+ * @returns Array of matching filenames
+ */
+export function listFilesMem(mfs, prefix) {
+    const files = readdirMem(mfs);
+    return files.filter(f => f.startsWith(prefix)).sort();
+}
+/**
+ * List files matching a date range pattern
+ *
+ * @param mfs - MemFsInstance from createMemFs()
+ * @param type - Telemetry type prefix (e.g., 'traces', 'logs')
+ * @param startDate - Optional start date (YYYY-MM-DD)
+ * @param endDate - Optional end date (YYYY-MM-DD)
+ * @returns Array of matching full paths
+ */
+export function listFilesInRangeMem(mfs, type, startDate, endDate) {
+    const allFiles = listFilesMem(mfs, `${type}-`);
+    const result = [];
+    for (const filename of allFiles) {
+        // Extract date from filename (e.g., traces-2026-01-31.jsonl -> 2026-01-31)
+        const match = filename.match(/\d{4}-\d{2}-\d{2}/);
+        if (!match)
+            continue;
+        const fileDate = match[0];
+        if (startDate && fileDate < startDate)
+            continue;
+        if (endDate && fileDate > endDate)
+            continue;
+        result.push(path.join(mfs.dir, filename));
+    }
+    return result;
+}
+//# sourceMappingURL=memfs-utils.js.map

package/dist/test-helpers/memfs-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memfs-utils.js","sourceRoot":"","sources":["../../src/test-helpers/memfs-utils.ts"],"names":[],"mappings":"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"}

package/dist/test-helpers/memfs-utils.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for in-memory file system utilities
+ */
+export {};
+//# sourceMappingURL=memfs-utils.test.d.ts.map

package/dist/test-helpers/memfs-utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memfs-utils.test.d.ts","sourceRoot":"","sources":["../../src/test-helpers/memfs-utils.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/test-helpers/memfs-utils.test.js

@@ -0,0 +1,338 @@
+/**
+ * Tests for in-memory file system utilities
+ */
+import { describe, it, after, beforeEach } from 'node:test';
+import * as assert from 'node:assert';
+import { createMemFs, writeJsonlMem, writeFileMem, readFileMem, readJsonlMem, readJsonlMemWithStats, streamJsonlMem, existsMem, mkdirMem, readdirMem, listFilesMem, listFilesInRangeMem, getTestDateMem, getSharedMemFs, resetSharedMemFs, removeSharedMemFs, cleanupAllSharedMemFs, } from './memfs-utils.js';
+describe('memfs-utils', () => {
+    describe('createMemFs', () => {
+        it('should create isolated memfs instance', () => {
+            const mfs1 = createMemFs();
+            const mfs2 = createMemFs();
+            assert.ok(mfs1.dir !== mfs2.dir, 'Each instance should have unique directory');
+            assert.ok(mfs1.fs !== mfs2.fs, 'Each instance should have unique fs');
+        });
+        it('should create base directory on initialization', () => {
+            const mfs = createMemFs();
+            assert.ok(mfs.vol.existsSync(mfs.dir), 'Base directory should exist');
+        });
+        it('should support custom prefix', () => {
+            const mfs = createMemFs('custom');
+            assert.ok(mfs.dir.includes('custom'), 'Directory should include prefix');
+        });
+    });
+    describe('writeJsonlMem and readJsonlMem', () => {
+        let mfs;
+        beforeEach(() => {
+            mfs = createMemFs('jsonl');
+        });
+        it('should write and read JSONL data', () => {
+            const data = [
+                { id: 1, name: 'first' },
+                { id: 2, name: 'second' },
+            ];
+            writeJsonlMem(mfs, 'test.jsonl', data);
+            const result = readJsonlMem(mfs, 'test.jsonl');
+            assert.strictEqual(result.length, 2);
+            assert.deepStrictEqual(result[0], { id: 1, name: 'first' });
+            assert.deepStrictEqual(result[1], { id: 2, name: 'second' });
+        });
+        it('should handle empty array', () => {
+            writeJsonlMem(mfs, 'empty.jsonl', []);
+            const result = readJsonlMem(mfs, 'empty.jsonl');
+            assert.strictEqual(result.length, 0);
+        });
+        it('should skip invalid JSON lines', () => {
+            writeFileMem(mfs, 'mixed.jsonl', '{"id":1}\ninvalid json\n{"id":2}');
+            const result = readJsonlMem(mfs, 'mixed.jsonl');
+            assert.strictEqual(result.length, 2);
+            assert.strictEqual(result[0].id, 1);
+            assert.strictEqual(result[1].id, 2);
+        });
+    });
+    describe('readJsonlMemWithStats', () => {
+        let mfs;
+        beforeEach(() => {
+            mfs = createMemFs('stats');
+        });
+        it('should track line statistics', () => {
+            writeFileMem(mfs, 'test.jsonl', '{"id":1}\n\ninvalid\n{"id":2}');
+            const { data, stats } = readJsonlMemWithStats(mfs, 'test.jsonl');
+            assert.strictEqual(data.length, 2);
+            assert.strictEqual(stats.totalLines, 4);
+            assert.strictEqual(stats.emptyLines, 1);
+            assert.strictEqual(stats.skippedLines, 1);
+        });
+    });
+    describe('streamJsonlMem', () => {
+        let mfs;
+        beforeEach(() => {
+            mfs = createMemFs('stream');
+        });
+        it('should stream JSONL data', async () => {
+            const data = [
+                { id: 1, value: 'a' },
+                { id: 2, value: 'b' },
+                { id: 3, value: 'c' },
+            ];
+            writeJsonlMem(mfs, 'stream.jsonl', data);
+            const results = [];
+            for await (const item of streamJsonlMem(mfs, 'stream.jsonl')) {
+                results.push(item);
+            }
+            assert.strictEqual(results.length, 3);
+            assert.deepStrictEqual(results, data);
+        });
+        it('should skip invalid lines when streaming', async () => {
+            writeFileMem(mfs, 'mixed.jsonl', '{"id":1}\nbad line\n{"id":2}');
+            const results = [];
+            for await (const item of streamJsonlMem(mfs, 'mixed.jsonl')) {
+                results.push(item);
+            }
+            assert.strictEqual(results.length, 2);
+        });
+    });
+    describe('file operations', () => {
+        let mfs;
+        beforeEach(() => {
+            mfs = createMemFs('fileops');
+        });
+        it('should check file existence', () => {
+            assert.strictEqual(existsMem(mfs, 'nonexistent.txt'), false);
+            writeFileMem(mfs, 'exists.txt', 'content');
+            assert.strictEqual(existsMem(mfs, 'exists.txt'), true);
+        });
+        it('should create subdirectories', () => {
+            mkdirMem(mfs, 'subdir/nested');
+            writeFileMem(mfs, 'subdir/nested/file.txt', 'nested content');
+            const content = readFileMem(mfs, 'subdir/nested/file.txt');
+            assert.strictEqual(content, 'nested content');
+        });
+        it('should list directory contents', () => {
+            writeFileMem(mfs, 'file1.txt', 'a');
+            writeFileMem(mfs, 'file2.txt', 'b');
+            mkdirMem(mfs, 'subdir');
+            const files = readdirMem(mfs);
+            assert.ok(files.includes('file1.txt'));
+            assert.ok(files.includes('file2.txt'));
+            assert.ok(files.includes('subdir'));
+        });
+    });
+    describe('listFilesMem', () => {
+        let mfs;
+        beforeEach(() => {
+            mfs = createMemFs('listfiles');
+        });
+        it('should list files matching prefix', () => {
+            writeFileMem(mfs, 'traces-2026-01-28.jsonl', '{}');
+            writeFileMem(mfs, 'traces-2026-01-29.jsonl', '{}');
+            writeFileMem(mfs, 'logs-2026-01-28.jsonl', '{}');
+            const traces = listFilesMem(mfs, 'traces-');
+            assert.strictEqual(traces.length, 2);
+            assert.ok(traces.includes('traces-2026-01-28.jsonl'));
+            assert.ok(traces.includes('traces-2026-01-29.jsonl'));
+            const logs = listFilesMem(mfs, 'logs-');
+            assert.strictEqual(logs.length, 1);
+        });
+        it('should return sorted files', () => {
+            writeFileMem(mfs, 'traces-2026-01-31.jsonl', '{}');
+            writeFileMem(mfs, 'traces-2026-01-28.jsonl', '{}');
+            writeFileMem(mfs, 'traces-2026-01-30.jsonl', '{}');
+            const traces = listFilesMem(mfs, 'traces-');
+            assert.deepStrictEqual(traces, [
+                'traces-2026-01-28.jsonl',
+                'traces-2026-01-30.jsonl',
+                'traces-2026-01-31.jsonl',
+            ]);
+        });
+    });
+    describe('listFilesInRangeMem', () => {
+        let mfs;
+        beforeEach(() => {
+            mfs = createMemFs('daterange');
+            writeFileMem(mfs, 'traces-2026-01-28.jsonl', '{}');
+            writeFileMem(mfs, 'traces-2026-01-29.jsonl', '{}');
+            writeFileMem(mfs, 'traces-2026-01-30.jsonl', '{}');
+            writeFileMem(mfs, 'traces-2026-01-31.jsonl', '{}');
+        });
+        it('should filter by date range', () => {
+            const files = listFilesInRangeMem(mfs, 'traces', '2026-01-29', '2026-01-30');
+            assert.strictEqual(files.length, 2);
+            assert.ok(files[0].includes('2026-01-29'));
+            assert.ok(files[1].includes('2026-01-30'));
+        });
+        it('should return all files when no date range', () => {
+            const files = listFilesInRangeMem(mfs, 'traces');
+            assert.strictEqual(files.length, 4);
+        });
+        it('should filter by start date only', () => {
+            const files = listFilesInRangeMem(mfs, 'traces', '2026-01-30');
+            assert.strictEqual(files.length, 2);
+        });
+        it('should filter by end date only', () => {
+            const files = listFilesInRangeMem(mfs, 'traces', undefined, '2026-01-29');
+            assert.strictEqual(files.length, 2);
+        });
+    });
+    describe('reset', () => {
+        it('should clear all files on reset', () => {
+            const mfs = createMemFs('reset');
+            writeFileMem(mfs, 'file1.txt', 'a');
+            writeFileMem(mfs, 'file2.txt', 'b');
+            assert.strictEqual(readdirMem(mfs).length, 2);
+            mfs.reset();
+            assert.strictEqual(readdirMem(mfs).length, 0);
+            assert.ok(mfs.vol.existsSync(mfs.dir), 'Base directory should still exist');
+        });
+    });
+    describe('shared memfs instances', () => {
+        const SUITE_ID = 'test-shared-suite';
+        after(() => {
+            removeSharedMemFs(SUITE_ID);
+        });
+        it('should return same instance for same suite ID', () => {
+            const mfs1 = getSharedMemFs(SUITE_ID);
+            const mfs2 = getSharedMemFs(SUITE_ID);
+            assert.strictEqual(mfs1, mfs2);
+        });
+        it('should reset shared instance files', () => {
+            const mfs = getSharedMemFs(SUITE_ID);
+            writeFileMem(mfs, 'shared.txt', 'content');
+            assert.ok(existsMem(mfs, 'shared.txt'));
+            resetSharedMemFs(SUITE_ID);
+            assert.strictEqual(existsMem(mfs, 'shared.txt'), false);
+        });
+    });
+    describe('getTestDateMem', () => {
+        it('should return date in YYYY-MM-DD format', () => {
+            const date = getTestDateMem();
+            assert.match(date, /^\d{4}-\d{2}-\d{2}$/);
+        });
+    });
+    describe('cleanupAllSharedMemFs', () => {
+        it('should clear all shared instances', () => {
+            getSharedMemFs('suite1');
+            getSharedMemFs('suite2');
+            cleanupAllSharedMemFs();
+            // After cleanup, getting same IDs should create new instances
+            const newMfs = getSharedMemFs('suite1');
+            assert.ok(newMfs, 'Should be able to create new instance after cleanup');
+        });
+    });
+});
+describe('memfs-utils: realistic test patterns', () => {
+    describe('trace data pattern', () => {
+        let mfs;
+        beforeEach(() => {
+            mfs = createMemFs('traces');
+        });
+        it('should handle trace span data', () => {
+            const today = getTestDateMem();
+            const spans = [
+                {
+                    traceId: 'trace1',
+                    spanId: 'span1',
+                    name: 'http-request',
+                    startTime: [1700000000, 0],
+                    attributes: { 'http.method': 'GET' },
+                },
+                {
+                    traceId: 'trace1',
+                    spanId: 'span2',
+                    name: 'db-query',
+                    startTime: [1700000001, 0],
+                    attributes: { 'db.system': 'postgres' },
+                },
+            ];
+            writeJsonlMem(mfs, `traces-${today}.jsonl`, spans);
+            const loaded = readJsonlMem(mfs, `traces-${today}.jsonl`);
+            assert.strictEqual(loaded.length, 2);
+            assert.strictEqual(loaded[0].traceId, 'trace1');
+            assert.strictEqual(loaded[1].name, 'db-query');
+        });
+        it('should handle trace data filtering pattern', async () => {
+            const spans = Array.from({ length: 100 }, (_, i) => ({
+                traceId: `trace-${i % 10}`,
+                spanId: `span-${i}`,
+                name: i % 2 === 0 ? 'http-request' : 'db-query',
+                startTime: [1700000000 + i, 0],
+            }));
+            writeJsonlMem(mfs, 'traces-2026-01-31.jsonl', spans);
+            // Simulate filtering by traceId using streaming
+            const filteredSpans = [];
+            for await (const span of streamJsonlMem(mfs, 'traces-2026-01-31.jsonl')) {
+                if (span.traceId === 'trace-5') {
+                    filteredSpans.push(span);
+                }
+            }
+            assert.strictEqual(filteredSpans.length, 10);
+            assert.ok(filteredSpans.every(s => s.traceId === 'trace-5'));
+        });
+    });
+    describe('log data pattern', () => {
+        let mfs;
+        beforeEach(() => {
+            mfs = createMemFs('logs');
+        });
+        it('should handle log record data', () => {
+            const logs = [
+                { timestamp: '2026-01-31T10:00:00Z', severityText: 'INFO', body: 'Application started' },
+                { timestamp: '2026-01-31T10:00:01Z', severityText: 'ERROR', body: 'Connection failed' },
+            ];
+            writeJsonlMem(mfs, 'logs-2026-01-31.jsonl', logs);
+            const loaded = readJsonlMem(mfs, 'logs-2026-01-31.jsonl');
+            assert.strictEqual(loaded.length, 2);
+            assert.strictEqual(loaded[1].severityText, 'ERROR');
+        });
+    });
+    describe('index data pattern', () => {
+        let mfs;
+        beforeEach(() => {
+            mfs = createMemFs('index');
+        });
+        it('should handle index file storage', () => {
+            // Simulate index structure
+            const index = {
+                version: 1,
+                sourceFile: '/path/to/traces.jsonl',
+                sourceMtime: Date.now(),
+                entries: [
+                    { lineNumber: 1, timestamp: 1700000000000, traceId: 'trace1', spanName: 'op1' },
+                    { lineNumber: 2, timestamp: 1700000001000, traceId: 'trace2', spanName: 'op2' },
+                ],
+            };
+            writeFileMem(mfs, 'traces.jsonl.idx', JSON.stringify(index));
+            const loaded = JSON.parse(readFileMem(mfs, 'traces.jsonl.idx'));
+            assert.strictEqual(loaded.version, 1);
+            assert.strictEqual(loaded.entries.length, 2);
+        });
+    });
+    describe('multi-file query pattern', () => {
+        let mfs;
+        beforeEach(() => {
+            mfs = createMemFs('multifile');
+            // Create files for multiple dates
+            for (let day = 28; day <= 31; day++) {
+                const date = `2026-01-${day}`;
+                const spans = [{ traceId: `trace-${day}`, spanId: 's1', name: 'op', startTime: [1700000000, 0] }];
+                writeJsonlMem(mfs, `traces-${date}.jsonl`, spans);
+            }
+        });
+        it('should query across date range', async () => {
+            const files = listFilesInRangeMem(mfs, 'traces', '2026-01-29', '2026-01-30');
+            assert.strictEqual(files.length, 2);
+            // Aggregate results from all files
+            const allSpans = [];
+            for (const file of files) {
+                const filename = file.split('/').pop();
+                for await (const span of streamJsonlMem(mfs, filename)) {
+                    allSpans.push(span);
+                }
+            }
+            assert.strictEqual(allSpans.length, 2);
+            assert.ok(allSpans.some(s => s.traceId === 'trace-29'));
+            assert.ok(allSpans.some(s => s.traceId === 'trace-30'));
+        });
+    });
+});
+//# sourceMappingURL=memfs-utils.test.js.map