claude-flow 3.56.6 → 3.56.8

package/v3/@claude-flow/shared/dist/events/rvf-event-log.js

@@ -15,7 +15,7 @@
  * @module v3/shared/events/rvf-event-log
  */
 import { EventEmitter } from 'node:events';
-import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync, renameSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync, renameSync, truncateSync } from 'node:fs';
 import { dirname } from 'node:path';
 /** Validate a file path is safe */
 function validatePath(p) {
@@ -26,6 +26,7 @@ const DEFAULT_CONFIG = {
     logPath: 'events.rvf',
     verbose: false,
     snapshotThreshold: 100,
+    repairOversizedTail: false,
 };
 // =============================================================================
 // Constants
@@ -34,12 +35,17 @@ const DEFAULT_CONFIG = {
 const MAGIC = Buffer.from('RVFL');
 const MAGIC_LENGTH = 4;
 const LENGTH_PREFIX_BYTES = 4;
+/** Largest record replayFile() will read; appendRecord() refuses anything bigger so no accepted append is unreadable. */
+const MAX_PAYLOAD_SIZE = 100 * 1024 * 1024; // 100MB safety limit
 // =============================================================================
 // RvfEventLog Implementation
 // =============================================================================
 export class RvfEventLog extends EventEmitter {
     config;
     initialized = false;
+    /** Files whose incomplete tails could not be repaired because they are read-only. */
+    /** Files that hold bytes we could not repair; appends to them are refused (value: why). */
+    readOnlyFiles = new Map();
     /**
      * All events kept in insertion order.
      * Rebuilt from the file on initialize().
@@ -115,6 +121,7 @@ export class RvfEventLog extends EventEmitter {
         this.aggregateIndex.clear();
         this.aggregateVersions.clear();
         this.snapshots.clear();
+        this.readOnlyFiles.clear();
         this.initialized = false;
         this.emit('shutdown');
     }
@@ -273,22 +280,24 @@ export class RvfEventLog extends EventEmitter {
             throw new Error(`[RvfEventLog] Invalid file header in ${filePath}`);
         }
         let offset = MAGIC_LENGTH;
-        const MAX_PAYLOAD_SIZE = 100 * 1024 * 1024; // 100MB safety limit
+        let oversizedAt = -1;
         while (offset + LENGTH_PREFIX_BYTES <= buf.length) {
             const payloadLength = buf.readUInt32BE(offset);
             offset += LENGTH_PREFIX_BYTES;
             if (payloadLength > MAX_PAYLOAD_SIZE) {
+                oversizedAt = offset - LENGTH_PREFIX_BYTES;
                 if (this.config.verbose) {
                     console.warn(`[RvfEventLog] Payload size ${payloadLength} exceeds safety limit`);
                 }
                 break;
             }
             if (offset + payloadLength > buf.length) {
-                // Truncated record — stop reading (crash recovery).
+                // Remove only the incomplete record before accepting future appends.
                 if (this.config.verbose) {
                     console.warn(`[RvfEventLog] Truncated record at offset ${offset - LENGTH_PREFIX_BYTES} — ` +
                         `expected ${payloadLength} bytes, have ${buf.length - offset}`);
                 }
+                offset -= LENGTH_PREFIX_BYTES;
                 break;
             }
             const json = buf.subarray(offset, offset + payloadLength).toString('utf8');
@@ -303,12 +312,44 @@ export class RvfEventLog extends EventEmitter {
                 }
             }
         }
+        // An oversized length prefix is not a torn write: keep the bytes unless the caller opted in to repair.
+        let keepUntil = offset;
+        if (oversizedAt >= 0) {
+            if (!this.config.repairOversizedTail) {
+                this.readOnlyFiles.set(filePath, 'a record length prefix exceeds the safety limit');
+                return;
+            }
+            keepUntil = oversizedAt;
+        }
+        if (keepUntil < buf.length) {
+            try {
+                truncateSync(filePath, keepUntil);
+            }
+            catch (error) {
+                const code = error.code;
+                if (code !== 'EACCES' && code !== 'EROFS' && code !== 'EPERM')
+                    throw error;
+                // Preserve readable history but never append behind an unreadable tail.
+                this.readOnlyFiles.set(filePath, 'the file is not writable, so its damaged tail could not be repaired');
+                if (this.config.verbose) {
+                    console.warn(`[RvfEventLog] Read-only log has an unrepaired tail: ${filePath}`);
+                }
+            }
+        }
     }
     /** Append a single record to an RVF file. */
     appendRecord(filePath, record) {
+        const refused = this.readOnlyFiles.get(filePath);
+        if (refused !== undefined) {
+            throw new Error(`[RvfEventLog] Read-only until repaired: unrepaired tail (${refused}); append refused: ${filePath}`);
+        }
         const json = JSON.stringify(record);
         const persisted = JSON.parse(json);
         const payload = Buffer.from(json, 'utf8');
+        if (payload.length > MAX_PAYLOAD_SIZE) {
+            // replayFile() refuses records this large, so writing one would be an append that can never be read back.
+            throw new Error(`[RvfEventLog] Record of ${payload.length} bytes exceeds the ${MAX_PAYLOAD_SIZE} byte limit; append refused`);
+        }
         const lengthBuf = Buffer.allocUnsafe(LENGTH_PREFIX_BYTES);
         lengthBuf.writeUInt32BE(payload.length, 0);
         appendFileSync(filePath, Buffer.concat([lengthBuf, payload]));

package/v3/@claude-flow/shared/dist/mcp/transport/http.js

@@ -270,6 +270,15 @@ export class HttpTransport extends EventEmitter {
         });
         // Error handler
         this.app.use((err, req, res, next) => {
+            // body-parser marks a malformed JSON body: that is the client's JSON-RPC parse error, not ours.
+            if (err.type === 'entity.parse.failed') {
+                res.status(400).json({
+                    jsonrpc: '2.0',
+                    id: null,
+                    error: { code: -32700, message: 'Parse error' },
+                });
+                return;
+            }
             this.logger.error('Express error', { error: err });
             this.errors++;
             res.status(500).json({
@@ -335,7 +344,8 @@ export class HttpTransport extends EventEmitter {
             // No auth configured but auth is required - warn and continue (development mode)
             this.logger.warn('No authentication configured - running in development mode');
         }
-        const message = req.body;
+        // Express 5 leaves req.body undefined when no JSON body was parsed (Express 4 gave {}).
+        const message = req.body ?? {};
         // Validate JSON-RPC format
         if (message.jsonrpc !== '2.0') {
             res.status(400).json({

package/v3/@claude-flow/shared/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/shared",
-  "version": "3.0.3",
+  "version": "3.0.4",
   "type": "module",
   "description": "Shared module - common types, events, utilities, core interfaces",
   "main": "dist/index.js",
@@ -18,6 +18,9 @@
   },
   "files": [
     "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*",
+    "!dist/**/__tests__",
     "README.md"
   ],
   "scripts": {
@@ -25,20 +28,20 @@
     "build": "tsc"
   },
   "dependencies": {
-    "sql.js": "^1.10.3"
+    "@types/ws": "^8.5.10",
+    "cors": "^2.8.5",
+    "express": "^4.22.2 || ^5.0.0",
+    "helmet": "^7.2.0",
+    "sql.js": "^1.10.3",
+    "ws": "^8.21.0",
+    "zod": "^3.22.4"
   },
   "devDependencies": {
     "@types/cors": "^2.8.17",
     "@types/express": "^4.17.21",
     "@types/node": "^20.0.0",
     "@types/sql.js": "^1.4.9",
-    "@types/ws": "^8.5.10",
-    "cors": "^2.8.5",
-    "express": "^4.21.0",
-    "helmet": "^7.1.0",
-    "vitest": "^4.1.0",
-    "ws": "^8.16.0",
-    "zod": "^3.22.4"
+    "vitest": "^4.1.0"
   },
   "publishConfig": {
     "access": "public"

package/v3/@claude-flow/shared/dist/events/event-store-pagination.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=event-store-pagination.test.d.ts.map

package/v3/@claude-flow/shared/dist/events/event-store-pagination.test.js

@@ -1,32 +0,0 @@
-import { beforeEach, afterEach, describe, it, expect } from 'vitest';
-import { EventStore } from './event-store.js';
-import { createAgentSpawnedEvent } from './domain-events.js';
-describe('SQLite event query pagination', () => {
-    let store;
-    beforeEach(async () => {
-        store = new EventStore({
-            databasePath: ':memory:',
-            autoPersistInterval: 0,
-        });
-        await store.initialize();
-        for (let i = 0; i < 3; i++) {
-            const event = createAgentSpawnedEvent(`agent-${i}`, 'coder', 'core', []);
-            event.timestamp = 100 + i;
-            await store.append(event);
-        }
-    });
-    afterEach(async () => {
-        await store.shutdown();
-    });
-    it('supports offsets without a caller-specified limit', async () => {
-        expect((await store.query({ offset: 1 })).map((event) => event.aggregateId)).toEqual(['agent-1', 'agent-2']);
-    });
-    it('returns no rows for an explicit zero limit', async () => {
-        expect(await store.query({ limit: 0 })).toEqual([]);
-        expect(await store.query({ limit: 0, offset: 1 })).toEqual([]);
-    });
-    it('retains bounded page ordering', async () => {
-        expect((await store.query({ limit: 1, offset: 1 })).map((event) => event.aggregateId)).toEqual(['agent-1']);
-    });
-});
-//# sourceMappingURL=event-store-pagination.test.js.map

package/v3/@claude-flow/shared/dist/events/event-store.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * Event Store Tests
- *
- * Comprehensive tests for the event sourcing implementation.
- * Tests event storage, retrieval, filtering, snapshots, and projections.
- */
-export {};
-//# sourceMappingURL=event-store.test.d.ts.map

package/v3/@claude-flow/shared/dist/events/event-store.test.js

@@ -1,313 +0,0 @@
-/**
- * Event Store Tests
- *
- * Comprehensive tests for the event sourcing implementation.
- * Tests event storage, retrieval, filtering, snapshots, and projections.
- */
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { EventStore } from './event-store.js';
-import { StateReconstructor, TaskAggregate } from './state-reconstructor.js';
-import { AgentStateProjection, TaskHistoryProjection, MemoryIndexProjection } from './projections.js';
-import { createAgentSpawnedEvent, createAgentStartedEvent, createAgentTaskAssignedEvent, createAgentTaskCompletedEvent, createTaskCreatedEvent, createTaskStartedEvent, createTaskCompletedEvent, createMemoryStoredEvent, createMemoryRetrievedEvent, createMemoryDeletedEvent, } from './domain-events.js';
-describe('EventStore', () => {
-    let eventStore;
-    beforeEach(async () => {
-        eventStore = new EventStore({ databasePath: ':memory:', verbose: false });
-        await eventStore.initialize();
-    });
-    afterEach(async () => {
-        await eventStore.shutdown();
-    });
-    describe('Event Appending', () => {
-        it('should append events to the store', async () => {
-            const event = createAgentSpawnedEvent('agent-1', 'coder', 'core', ['coding', 'testing']);
-            await eventStore.append(event);
-            const events = await eventStore.getEvents('agent-1');
-            expect(events).toHaveLength(1);
-            expect(events[0].type).toBe('agent:spawned');
-            expect(events[0].version).toBe(1);
-        });
-        it('should increment version for each event', async () => {
-            const event1 = createAgentSpawnedEvent('agent-1', 'coder', 'core', []);
-            const event2 = createAgentStartedEvent('agent-1');
-            await eventStore.append(event1);
-            await eventStore.append(event2);
-            const events = await eventStore.getEvents('agent-1');
-            expect(events[0].version).toBe(1);
-            expect(events[1].version).toBe(2);
-        });
-        it('should maintain version per aggregate', async () => {
-            const agent1Event = createAgentSpawnedEvent('agent-1', 'coder', 'core', []);
-            const agent2Event = createAgentSpawnedEvent('agent-2', 'tester', 'quality', []);
-            await eventStore.append(agent1Event);
-            await eventStore.append(agent2Event);
-            const agent1Events = await eventStore.getEvents('agent-1');
-            const agent2Events = await eventStore.getEvents('agent-2');
-            expect(agent1Events[0].version).toBe(1);
-            expect(agent2Events[0].version).toBe(1);
-        });
-    });
-    describe('Event Retrieval', () => {
-        beforeEach(async () => {
-            // Setup: Create multiple events
-            await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
-            await eventStore.append(createAgentStartedEvent('agent-1'));
-            await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Build feature', 'Description', 'high', []));
-            await eventStore.append(createTaskStartedEvent('task-1', 'agent-1'));
-        });
-        it('should retrieve events by aggregate ID', async () => {
-            const events = await eventStore.getEvents('agent-1');
-            expect(events).toHaveLength(2);
-            expect(events[0].type).toBe('agent:spawned');
-            expect(events[1].type).toBe('agent:started');
-        });
-        it('should retrieve events from specific version', async () => {
-            const events = await eventStore.getEvents('agent-1', 2);
-            expect(events).toHaveLength(1);
-            expect(events[0].type).toBe('agent:started');
-        });
-        it('should retrieve events by type', async () => {
-            const events = await eventStore.getEventsByType('task:created');
-            expect(events).toHaveLength(1);
-            expect(events[0].aggregateId).toBe('task-1');
-        });
-    });
-    describe('Event Filtering', () => {
-        beforeEach(async () => {
-            await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
-            await eventStore.append(createAgentSpawnedEvent('agent-2', 'tester', 'quality', []));
-            await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Task 1', 'Desc', 'high', []));
-            await eventStore.append(createMemoryStoredEvent('mem-1', 'default', 'key1', 'semantic', 1024));
-        });
-        it('should filter by aggregate types', async () => {
-            const events = await eventStore.query({ aggregateTypes: ['agent'] });
-            expect(events).toHaveLength(2);
-            expect(events.every((e) => e.aggregateType === 'agent')).toBe(true);
-        });
-        it('should filter by event types', async () => {
-            const events = await eventStore.query({ eventTypes: ['agent:spawned'] });
-            expect(events).toHaveLength(2);
-            expect(events.every((e) => e.type === 'agent:spawned')).toBe(true);
-        });
-        it('should filter by aggregate IDs', async () => {
-            const events = await eventStore.query({ aggregateIds: ['agent-1', 'task-1'] });
-            expect(events).toHaveLength(2);
-        });
-        it('should support pagination', async () => {
-            const page1 = await eventStore.query({ limit: 2, offset: 0 });
-            const page2 = await eventStore.query({ limit: 2, offset: 2 });
-            expect(page1).toHaveLength(2);
-            expect(page2).toHaveLength(2);
-            expect(page1[0].id).not.toBe(page2[0].id);
-        });
-    });
-    describe('Event Replay', () => {
-        it('should replay all events', async () => {
-            await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
-            await eventStore.append(createAgentStartedEvent('agent-1'));
-            await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Task', 'Desc', 'high', []));
-            const events = [];
-            for await (const event of eventStore.replay()) {
-                events.push(event);
-            }
-            expect(events).toHaveLength(3);
-        });
-        it('should replay from specific version', async () => {
-            await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
-            await eventStore.append(createAgentStartedEvent('agent-1'));
-            await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Task', 'Desc', 'high', []));
-            const events = [];
-            for await (const event of eventStore.replay(2)) {
-                events.push(event);
-            }
-            expect(events.length).toBeGreaterThanOrEqual(2);
-        });
-    });
-    describe('Snapshots', () => {
-        it('should save snapshots', async () => {
-            const snapshot = {
-                aggregateId: 'agent-1',
-                aggregateType: 'agent',
-                version: 5,
-                state: { status: 'active', tasks: ['task-1'] },
-                timestamp: Date.now(),
-            };
-            await eventStore.saveSnapshot(snapshot);
-            const retrieved = await eventStore.getSnapshot('agent-1');
-            expect(retrieved).not.toBeNull();
-            expect(retrieved?.version).toBe(5);
-            expect(retrieved?.state).toEqual({ status: 'active', tasks: ['task-1'] });
-        });
-        it('should return latest snapshot', async () => {
-            const snapshot1 = {
-                aggregateId: 'agent-1',
-                aggregateType: 'agent',
-                version: 5,
-                state: { status: 'active' },
-                timestamp: Date.now(),
-            };
-            const snapshot2 = {
-                aggregateId: 'agent-1',
-                aggregateType: 'agent',
-                version: 10,
-                state: { status: 'completed' },
-                timestamp: Date.now(),
-            };
-            await eventStore.saveSnapshot(snapshot1);
-            await eventStore.saveSnapshot(snapshot2);
-            const retrieved = await eventStore.getSnapshot('agent-1');
-            expect(retrieved?.version).toBe(10);
-        });
-        it('should return null when no snapshot exists for the aggregate', async () => {
-            await expect(eventStore.getSnapshot('missing')).resolves.toBeNull();
-        });
-        it('should return null for an unknown aggregate when other snapshots exist', async () => {
-            await eventStore.saveSnapshot({
-                aggregateId: 'agent-1',
-                aggregateType: 'agent',
-                version: 1,
-                state: {},
-                timestamp: Date.now(),
-            });
-            await expect(eventStore.getSnapshot('other')).resolves.toBeNull();
-        });
-        it('should reconstruct from the event log when no snapshot exists', async () => {
-            await eventStore.append(createTaskCreatedEvent('task-1', 'impl', 'Write code', 'desc', 'normal', []));
-            const reconstructor = new StateReconstructor(eventStore);
-            const task = await reconstructor.reconstruct('task-1', (id) => new TaskAggregate(id));
-            expect(task.version).toBe(1);
-        });
-    });
-    describe('Statistics', () => {
-        it('should provide event store statistics', async () => {
-            await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
-            await eventStore.append(createAgentSpawnedEvent('agent-2', 'tester', 'quality', []));
-            await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Task', 'Desc', 'high', []));
-            const stats = await eventStore.getStats();
-            expect(stats.totalEvents).toBe(3);
-            expect(stats.eventsByType['agent:spawned']).toBe(2);
-            expect(stats.eventsByType['task:created']).toBe(1);
-            expect(stats.eventsByAggregate['agent-1']).toBe(1);
-            expect(stats.eventsByAggregate['agent-2']).toBe(1);
-        });
-    });
-});
-describe('AgentStateProjection', () => {
-    let eventStore;
-    let projection;
-    beforeEach(async () => {
-        eventStore = new EventStore({ databasePath: ':memory:' });
-        await eventStore.initialize();
-        projection = new AgentStateProjection(eventStore);
-    });
-    afterEach(async () => {
-        await eventStore.shutdown();
-    });
-    it('should build agent state from events', async () => {
-        await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', ['coding']));
-        await eventStore.append(createAgentStartedEvent('agent-1'));
-        await projection.initialize();
-        const agent = projection.getAgent('agent-1');
-        expect(agent).not.toBeNull();
-        expect(agent?.role).toBe('coder');
-        expect(agent?.status).toBe('active');
-    });
-    it('should track task assignments', async () => {
-        await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
-        await eventStore.append(createAgentTaskAssignedEvent('agent-1', 'task-1', Date.now()));
-        await projection.initialize();
-        const agent = projection.getAgent('agent-1');
-        expect(agent?.currentTask).toBe('task-1');
-    });
-    it('should track completed tasks', async () => {
-        await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
-        await eventStore.append(createAgentTaskCompletedEvent('agent-1', 'task-1', { success: true }, Date.now(), 5000));
-        await projection.initialize();
-        const agent = projection.getAgent('agent-1');
-        expect(agent?.completedTasks).toContain('task-1');
-        expect(agent?.taskCount).toBe(1);
-    });
-    it('should filter agents by status', async () => {
-        await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
-        await eventStore.append(createAgentSpawnedEvent('agent-2', 'tester', 'quality', []));
-        await eventStore.append(createAgentStartedEvent('agent-1'));
-        await projection.initialize();
-        const activeAgents = projection.getAgentsByStatus('active');
-        const idleAgents = projection.getAgentsByStatus('idle');
-        expect(activeAgents).toHaveLength(1);
-        expect(idleAgents).toHaveLength(1);
-    });
-});
-describe('TaskHistoryProjection', () => {
-    let eventStore;
-    let projection;
-    beforeEach(async () => {
-        eventStore = new EventStore({ databasePath: ':memory:' });
-        await eventStore.initialize();
-        projection = new TaskHistoryProjection(eventStore);
-    });
-    afterEach(async () => {
-        await eventStore.shutdown();
-    });
-    it('should build task history from events', async () => {
-        await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Build Feature', 'Description', 'high', []));
-        await eventStore.append(createTaskStartedEvent('task-1', 'agent-1'));
-        await eventStore.append(createTaskCompletedEvent('task-1', { success: true }, 5000));
-        await projection.initialize();
-        const task = projection.getTask('task-1');
-        expect(task).not.toBeNull();
-        expect(task?.title).toBe('Build Feature');
-        expect(task?.status).toBe('completed');
-        expect(task?.assignedAgent).toBe('agent-1');
-    });
-    it('should calculate average task duration', async () => {
-        await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Task 1', 'Desc', 'high', []));
-        await eventStore.append(createTaskCompletedEvent('task-1', { success: true }, 5000));
-        await eventStore.append(createTaskCreatedEvent('task-2', 'implementation', 'Task 2', 'Desc', 'high', []));
-        await eventStore.append(createTaskCompletedEvent('task-2', { success: true }, 3000));
-        await projection.initialize();
-        const avgDuration = projection.getAverageTaskDuration();
-        expect(avgDuration).toBe(4000);
-    });
-});
-describe('MemoryIndexProjection', () => {
-    let eventStore;
-    let projection;
-    beforeEach(async () => {
-        eventStore = new EventStore({ databasePath: ':memory:' });
-        await eventStore.initialize();
-        projection = new MemoryIndexProjection(eventStore);
-    });
-    afterEach(async () => {
-        await eventStore.shutdown();
-    });
-    it('should build memory index from events', async () => {
-        await eventStore.append(createMemoryStoredEvent('mem-1', 'default', 'key1', 'semantic', 1024));
-        await eventStore.append(createMemoryRetrievedEvent('mem-1', 'default', 'key1', 1));
-        await projection.initialize();
-        const memory = projection.getMemory('mem-1');
-        expect(memory).not.toBeNull();
-        expect(memory?.namespace).toBe('default');
-        expect(memory?.accessCount).toBe(1);
-    });
-    it('should track memory deletions', async () => {
-        await eventStore.append(createMemoryStoredEvent('mem-1', 'default', 'key1', 'semantic', 1024));
-        await eventStore.append(createMemoryDeletedEvent('mem-1', 'default', 'key1'));
-        await projection.initialize();
-        const memory = projection.getMemory('mem-1');
-        expect(memory?.isDeleted).toBe(true);
-        const activeMemories = projection.getActiveMemories();
-        expect(activeMemories).toHaveLength(0);
-    });
-    it('should calculate total size by namespace', async () => {
-        await eventStore.append(createMemoryStoredEvent('mem-1', 'ns1', 'key1', 'semantic', 1024));
-        await eventStore.append(createMemoryStoredEvent('mem-2', 'ns1', 'key2', 'semantic', 2048));
-        await eventStore.append(createMemoryStoredEvent('mem-3', 'ns2', 'key3', 'semantic', 512));
-        await projection.initialize();
-        const ns1Size = projection.getTotalSizeByNamespace('ns1');
-        const ns2Size = projection.getTotalSizeByNamespace('ns2');
-        expect(ns1Size).toBe(3072);
-        expect(ns2Size).toBe(512);
-    });
-});
-//# sourceMappingURL=event-store.test.js.map

package/v3/@claude-flow/shared/dist/hooks/hooks.test.d.ts

@@ -1,9 +0,0 @@
-/**
- * V3 Hooks System - Tests
- *
- * Comprehensive tests for hook registry and executor.
- *
- * @module v3/shared/hooks/hooks.test
- */
-export {};
-//# sourceMappingURL=hooks.test.d.ts.map