claude-flow 3.25.6 → 3.26.1

package/v3/@claude-flow/shared/dist/hooks/executor.js

@@ -1,267 +0,0 @@
-/**
- * V3 Hooks System - Hook Executor
- *
- * Executes hooks in priority order with timeout handling and error recovery.
- * Integrates with event bus for coordination and monitoring.
- *
- * @module v3/shared/hooks/executor
- */
-/**
- * Hook executor implementation
- */
-export class HookExecutor {
-    registry;
-    eventBus;
-    constructor(registry, eventBus) {
-        this.registry = registry;
-        this.eventBus = eventBus;
-    }
-    /**
-     * Execute all hooks for an event
-     *
-     * @param event - Hook event type
-     * @param context - Hook context
-     * @param options - Execution options
-     * @returns Aggregated results
-     */
-    async execute(event, context, options = {}) {
-        const startTime = Date.now();
-        const results = [];
-        let aborted = false;
-        let finalContext = {};
-        // Get enabled hooks for this event
-        const hooks = this.registry.getHandlers(event, false);
-        // Emit pre-execution event
-        this.eventBus?.emit('hooks:pre-execute', {
-            event,
-            hookCount: hooks.length,
-            context,
-        });
-        // Execute hooks in priority order
-        for (const hook of hooks) {
-            if (aborted) {
-                break;
-            }
-            try {
-                const result = await this.executeSingleHook(hook.handler, context, hook.timeout || options.timeout);
-                results.push(result);
-                // Record execution statistics
-                this.registry.recordExecution(result.success, result.executionTime || 0);
-                // Merge context modifications
-                if (result.data) {
-                    finalContext = { ...finalContext, ...result.data };
-                    // Update context for next hooks
-                    Object.assign(context, result.data);
-                }
-                // Check if we should abort
-                if (result.abort) {
-                    aborted = true;
-                    break;
-                }
-                // Check if we should stop the chain
-                if (result.continueChain === false) {
-                    break;
-                }
-                // Check if we should stop on error
-                if (!result.success && !options.continueOnError) {
-                    aborted = true;
-                    break;
-                }
-            }
-            catch (error) {
-                const errorResult = {
-                    success: false,
-                    error: error instanceof Error ? error : new Error(String(error)),
-                    continueChain: options.continueOnError,
-                };
-                results.push(errorResult);
-                this.registry.recordExecution(false, 0);
-                // Emit error event
-                this.eventBus?.emit('hooks:error', {
-                    event,
-                    hookId: hook.id,
-                    error,
-                });
-                if (!options.continueOnError) {
-                    aborted = true;
-                    break;
-                }
-            }
-        }
-        const totalExecutionTime = Date.now() - startTime;
-        const hooksFailed = results.filter(r => !r.success).length;
-        // Build aggregated result
-        const aggregatedResult = {
-            success: hooksFailed === 0 && !aborted,
-            results: options.collectResults ? results : [],
-            totalExecutionTime,
-            hooksExecuted: results.length,
-            hooksFailed,
-            aborted,
-            finalContext,
-        };
-        // Emit post-execution event
-        this.eventBus?.emit('hooks:post-execute', {
-            event,
-            ...aggregatedResult,
-        });
-        return aggregatedResult;
-    }
-    /**
-     * Execute hooks with timeout
-     *
-     * @param event - Hook event type
-     * @param context - Hook context
-     * @param timeout - Timeout in ms
-     * @returns Aggregated results
-     */
-    async executeWithTimeout(event, context, timeout) {
-        return this.withTimeout(this.execute(event, context, { timeout }), timeout);
-    }
-    /**
-     * Execute a single hook with timeout and error handling
-     *
-     * @param handler - Hook handler function
-     * @param context - Hook context
-     * @param timeout - Optional timeout in ms
-     * @returns Hook result
-     */
-    async executeSingleHook(handler, context, timeout) {
-        const startTime = Date.now();
-        try {
-            let resultPromise = Promise.resolve(handler(context));
-            // Apply timeout if specified
-            if (timeout && timeout > 0) {
-                resultPromise = this.withTimeout(resultPromise, timeout);
-            }
-            const result = await resultPromise;
-            const executionTime = Date.now() - startTime;
-            return {
-                ...result,
-                executionTime,
-            };
-        }
-        catch (error) {
-            const executionTime = Date.now() - startTime;
-            return {
-                success: false,
-                error: error instanceof Error ? error : new Error(String(error)),
-                executionTime,
-            };
-        }
-    }
-    /**
-     * Execute multiple hooks in parallel
-     *
-     * @param events - Array of hook events
-     * @param contexts - Array of contexts (matched by index)
-     * @param options - Execution options
-     * @returns Array of aggregated results
-     */
-    async executeParallel(events, contexts, options = {}) {
-        if (events.length !== contexts.length) {
-            throw new Error('Events and contexts arrays must have same length');
-        }
-        const maxParallel = options.maxParallel || events.length;
-        const results = [];
-        // Execute in batches
-        for (let i = 0; i < events.length; i += maxParallel) {
-            const batch = events.slice(i, i + maxParallel);
-            const batchContexts = contexts.slice(i, i + maxParallel);
-            const batchResults = await Promise.allSettled(batch.map((event, index) => this.execute(event, batchContexts[index], options)));
-            for (const result of batchResults) {
-                if (result.status === 'fulfilled') {
-                    results.push(result.value);
-                }
-                else {
-                    // Create error result for rejected promises
-                    results.push({
-                        success: false,
-                        results: [{
-                                success: false,
-                                error: result.reason instanceof Error
-                                    ? result.reason
-                                    : new Error(String(result.reason)),
-                            }],
-                        totalExecutionTime: 0,
-                        hooksExecuted: 0,
-                        hooksFailed: 1,
-                        aborted: true,
-                    });
-                }
-            }
-        }
-        return results;
-    }
-    /**
-     * Execute hooks sequentially with context chaining
-     *
-     * @param events - Array of hook events
-     * @param initialContext - Initial context
-     * @param options - Execution options
-     * @returns Final aggregated result with chained context
-     */
-    async executeSequential(events, initialContext, options = {}) {
-        const results = [];
-        let currentContext = { ...initialContext };
-        let totalExecutionTime = 0;
-        let totalHooksExecuted = 0;
-        let totalHooksFailed = 0;
-        let aborted = false;
-        for (const event of events) {
-            if (aborted) {
-                break;
-            }
-            const result = await this.execute(event, currentContext, options);
-            results.push(...result.results);
-            totalExecutionTime += result.totalExecutionTime;
-            totalHooksExecuted += result.hooksExecuted;
-            totalHooksFailed += result.hooksFailed;
-            // Merge context for next event
-            if (result.finalContext) {
-                currentContext = { ...currentContext, ...result.finalContext };
-            }
-            if (result.aborted || !result.success) {
-                aborted = true;
-                break;
-            }
-        }
-        return {
-            success: totalHooksFailed === 0 && !aborted,
-            results: options.collectResults ? results : [],
-            totalExecutionTime,
-            hooksExecuted: totalHooksExecuted,
-            hooksFailed: totalHooksFailed,
-            aborted,
-            finalContext: currentContext,
-        };
-    }
-    /**
-     * Wrap a promise with timeout
-     */
-    async withTimeout(promise, timeout) {
-        return Promise.race([
-            promise,
-            new Promise((_, reject) => setTimeout(() => reject(new Error(`Hook execution timeout after ${timeout}ms`)), timeout)),
-        ]);
-    }
-    /**
-     * Set event bus for coordination
-     */
-    setEventBus(eventBus) {
-        this.eventBus = eventBus;
-    }
-    /**
-     * Get hook registry
-     */
-    getRegistry() {
-        return this.registry;
-    }
-}
-/**
- * Create a new hook executor
- */
-export function createHookExecutor(registry, eventBus) {
-    return new HookExecutor(registry, eventBus);
-}
-//# sourceMappingURL=executor.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

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

@@ -1,322 +0,0 @@
-/**
- * V3 Hooks System - Tests
- *
- * Comprehensive tests for hook registry and executor.
- *
- * @module v3/shared/hooks/hooks.test
- */
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { createHookRegistry } from './registry.js';
-import { createHookExecutor } from './executor.js';
-import { HookEvent, HookPriority } from './types.js';
-import { createEventBus } from '../core/event-bus.js';
-describe('HookRegistry', () => {
-    let registry;
-    beforeEach(() => {
-        registry = createHookRegistry();
-    });
-    it('should register a hook', () => {
-        const handler = vi.fn();
-        const id = registry.register(HookEvent.PreToolUse, handler);
-        expect(id).toBeDefined();
-        expect(registry.has(id)).toBe(true);
-        expect(registry.count()).toBe(1);
-    });
-    it('should unregister a hook', () => {
-        const handler = vi.fn();
-        const id = registry.register(HookEvent.PreToolUse, handler);
-        const result = registry.unregister(id);
-        expect(result).toBe(true);
-        expect(registry.has(id)).toBe(false);
-        expect(registry.count()).toBe(0);
-    });
-    it('should return false when unregistering non-existent hook', () => {
-        const result = registry.unregister('non-existent');
-        expect(result).toBe(false);
-    });
-    it('should get handlers sorted by priority', () => {
-        const handler1 = vi.fn();
-        const handler2 = vi.fn();
-        const handler3 = vi.fn();
-        registry.register(HookEvent.PreToolUse, handler1, HookPriority.Normal);
-        registry.register(HookEvent.PreToolUse, handler2, HookPriority.High);
-        registry.register(HookEvent.PreToolUse, handler3, HookPriority.Low);
-        const handlers = registry.getHandlers(HookEvent.PreToolUse);
-        expect(handlers).toHaveLength(3);
-        expect(handlers[0].handler).toBe(handler2); // High priority first
-        expect(handlers[1].handler).toBe(handler1); // Normal priority second
-        expect(handlers[2].handler).toBe(handler3); // Low priority last
-    });
-    it('should filter disabled hooks', () => {
-        const handler = vi.fn();
-        const id = registry.register(HookEvent.PreToolUse, handler, HookPriority.Normal, {
-            enabled: false,
-        });
-        const handlers = registry.getHandlers(HookEvent.PreToolUse);
-        const allHandlers = registry.getHandlers(HookEvent.PreToolUse, true);
-        expect(handlers).toHaveLength(0);
-        expect(allHandlers).toHaveLength(1);
-    });
-    it('should enable and disable hooks', () => {
-        const handler = vi.fn();
-        const id = registry.register(HookEvent.PreToolUse, handler);
-        registry.disable(id);
-        expect(registry.getHandlers(HookEvent.PreToolUse)).toHaveLength(0);
-        registry.enable(id);
-        expect(registry.getHandlers(HookEvent.PreToolUse)).toHaveLength(1);
-    });
-    it('should list hooks with filters', () => {
-        registry.register(HookEvent.PreToolUse, vi.fn(), HookPriority.High);
-        registry.register(HookEvent.PostToolUse, vi.fn(), HookPriority.Normal);
-        registry.register(HookEvent.PreEdit, vi.fn(), HookPriority.Low);
-        const allHooks = registry.listHooks();
-        expect(allHooks).toHaveLength(3);
-        const preToolHooks = registry.listHooks({ event: HookEvent.PreToolUse });
-        expect(preToolHooks).toHaveLength(1);
-        const highPriorityHooks = registry.listHooks({ minPriority: HookPriority.Normal });
-        expect(highPriorityHooks).toHaveLength(2);
-    });
-    it('should get event types', () => {
-        registry.register(HookEvent.PreToolUse, vi.fn());
-        registry.register(HookEvent.PostToolUse, vi.fn());
-        registry.register(HookEvent.PreEdit, vi.fn());
-        const eventTypes = registry.getEventTypes();
-        expect(eventTypes).toContain(HookEvent.PreToolUse);
-        expect(eventTypes).toContain(HookEvent.PostToolUse);
-        expect(eventTypes).toContain(HookEvent.PreEdit);
-    });
-    it('should track statistics', () => {
-        registry.register(HookEvent.PreToolUse, vi.fn());
-        registry.register(HookEvent.PostToolUse, vi.fn());
-        registry.recordExecution(true, 10);
-        registry.recordExecution(true, 20);
-        registry.recordExecution(false, 5);
-        const stats = registry.getStats();
-        expect(stats.totalHooks).toBe(2);
-        expect(stats.totalExecutions).toBe(3);
-        expect(stats.totalFailures).toBe(1);
-        expect(stats.avgExecutionTime).toBe((10 + 20 + 5) / 3);
-    });
-    it('should reset statistics', () => {
-        registry.recordExecution(true, 10);
-        registry.resetStats();
-        const stats = registry.getStats();
-        expect(stats.totalExecutions).toBe(0);
-        expect(stats.totalFailures).toBe(0);
-    });
-    it('should clear all hooks', () => {
-        registry.register(HookEvent.PreToolUse, vi.fn());
-        registry.register(HookEvent.PostToolUse, vi.fn());
-        registry.clear();
-        expect(registry.count()).toBe(0);
-        expect(registry.getEventTypes()).toHaveLength(0);
-    });
-});
-describe('HookExecutor', () => {
-    let registry;
-    let executor;
-    let eventBus;
-    beforeEach(() => {
-        registry = createHookRegistry();
-        eventBus = createEventBus();
-        executor = createHookExecutor(registry, eventBus);
-    });
-    it('should execute single hook successfully', async () => {
-        const handler = vi.fn(async () => ({ success: true }));
-        registry.register(HookEvent.PreToolUse, handler);
-        const context = {
-            event: HookEvent.PreToolUse,
-            timestamp: new Date(),
-            tool: { name: 'Read', parameters: { path: 'file.ts' } },
-        };
-        const result = await executor.execute(HookEvent.PreToolUse, context);
-        expect(result.success).toBe(true);
-        expect(result.hooksExecuted).toBe(1);
-        expect(result.hooksFailed).toBe(0);
-        expect(handler).toHaveBeenCalledWith(context);
-    });
-    it('should execute multiple hooks in priority order', async () => {
-        const executionOrder = [];
-        const handler1 = vi.fn(async () => {
-            executionOrder.push(1);
-            return { success: true };
-        });
-        const handler2 = vi.fn(async () => {
-            executionOrder.push(2);
-            return { success: true };
-        });
-        const handler3 = vi.fn(async () => {
-            executionOrder.push(3);
-            return { success: true };
-        });
-        registry.register(HookEvent.PreToolUse, handler1, HookPriority.Normal);
-        registry.register(HookEvent.PreToolUse, handler2, HookPriority.High);
-        registry.register(HookEvent.PreToolUse, handler3, HookPriority.Low);
-        const context = {
-            event: HookEvent.PreToolUse,
-            timestamp: new Date(),
-        };
-        await executor.execute(HookEvent.PreToolUse, context);
-        expect(executionOrder).toEqual([2, 1, 3]); // High, Normal, Low
-    });
-    it('should handle hook errors gracefully', async () => {
-        const handler1 = vi.fn(async () => ({ success: true }));
-        const handler2 = vi.fn(async () => {
-            throw new Error('Hook failed');
-        });
-        const handler3 = vi.fn(async () => ({ success: true }));
-        registry.register(HookEvent.PreToolUse, handler1, HookPriority.High);
-        registry.register(HookEvent.PreToolUse, handler2, HookPriority.Normal);
-        registry.register(HookEvent.PreToolUse, handler3, HookPriority.Low);
-        const context = {
-            event: HookEvent.PreToolUse,
-            timestamp: new Date(),
-        };
-        const result = await executor.execute(HookEvent.PreToolUse, context, {
-            continueOnError: true,
-        });
-        expect(result.hooksExecuted).toBe(3);
-        expect(result.hooksFailed).toBe(1);
-        expect(handler3).toHaveBeenCalled(); // Should continue despite error
-    });
-    it('should abort on error when continueOnError is false', async () => {
-        const handler1 = vi.fn(async () => ({ success: true }));
-        const handler2 = vi.fn(async () => {
-            throw new Error('Hook failed');
-        });
-        const handler3 = vi.fn(async () => ({ success: true }));
-        registry.register(HookEvent.PreToolUse, handler1, HookPriority.High);
-        registry.register(HookEvent.PreToolUse, handler2, HookPriority.Normal);
-        registry.register(HookEvent.PreToolUse, handler3, HookPriority.Low);
-        const context = {
-            event: HookEvent.PreToolUse,
-            timestamp: new Date(),
-        };
-        const result = await executor.execute(HookEvent.PreToolUse, context);
-        expect(result.aborted).toBe(true);
-        expect(result.hooksExecuted).toBe(2);
-        expect(handler3).not.toHaveBeenCalled(); // Should not execute after error
-    });
-    it('should abort when hook returns abort flag', async () => {
-        const handler1 = vi.fn(async () => ({ success: true }));
-        const handler2 = vi.fn(async () => ({ success: true, abort: true }));
-        const handler3 = vi.fn(async () => ({ success: true }));
-        registry.register(HookEvent.PreToolUse, handler1, HookPriority.High);
-        registry.register(HookEvent.PreToolUse, handler2, HookPriority.Normal);
-        registry.register(HookEvent.PreToolUse, handler3, HookPriority.Low);
-        const context = {
-            event: HookEvent.PreToolUse,
-            timestamp: new Date(),
-        };
-        const result = await executor.execute(HookEvent.PreToolUse, context);
-        expect(result.aborted).toBe(true);
-        expect(result.hooksExecuted).toBe(2);
-        expect(handler3).not.toHaveBeenCalled();
-    });
-    it('should merge context modifications', async () => {
-        const handler1 = vi.fn(async () => ({
-            success: true,
-            data: { metadata: { modified: true } },
-        }));
-        const handler2 = vi.fn(async (context) => {
-            expect(context.metadata?.modified).toBe(true);
-            return { success: true };
-        });
-        registry.register(HookEvent.PreToolUse, handler1, HookPriority.High);
-        registry.register(HookEvent.PreToolUse, handler2, HookPriority.Normal);
-        const context = {
-            event: HookEvent.PreToolUse,
-            timestamp: new Date(),
-        };
-        const result = await executor.execute(HookEvent.PreToolUse, context);
-        expect(result.finalContext?.metadata).toEqual({ modified: true });
-    });
-    it('should handle timeout', async () => {
-        const handler = vi.fn(async () => {
-            await new Promise(resolve => setTimeout(resolve, 200));
-            return { success: true };
-        });
-        registry.register(HookEvent.PreToolUse, handler);
-        const context = {
-            event: HookEvent.PreToolUse,
-            timestamp: new Date(),
-        };
-        const result = await executor.executeWithTimeout(HookEvent.PreToolUse, context, 100);
-        expect(result.success).toBe(false);
-        expect(result.hooksFailed).toBe(1);
-    });
-    it('should execute hooks in parallel', async () => {
-        const handler1 = vi.fn(async () => ({ success: true }));
-        const handler2 = vi.fn(async () => ({ success: true }));
-        registry.register(HookEvent.PreToolUse, handler1);
-        registry.register(HookEvent.PostToolUse, handler2);
-        const contexts = [
-            { event: HookEvent.PreToolUse, timestamp: new Date() },
-            { event: HookEvent.PostToolUse, timestamp: new Date() },
-        ];
-        const results = await executor.executeParallel([HookEvent.PreToolUse, HookEvent.PostToolUse], contexts);
-        expect(results).toHaveLength(2);
-        expect(results[0].success).toBe(true);
-        expect(results[1].success).toBe(true);
-    });
-    it('should execute hooks sequentially with context chaining', async () => {
-        const handler1 = vi.fn(async () => ({
-            success: true,
-            data: { metadata: { step: 1 } },
-        }));
-        const handler2 = vi.fn(async () => ({
-            success: true,
-            data: { metadata: { step: 2 } },
-        }));
-        registry.register(HookEvent.PreToolUse, handler1);
-        registry.register(HookEvent.PostToolUse, handler2);
-        const initialContext = {
-            event: HookEvent.PreToolUse,
-            timestamp: new Date(),
-        };
-        const result = await executor.executeSequential([HookEvent.PreToolUse, HookEvent.PostToolUse], initialContext);
-        expect(result.success).toBe(true);
-        expect(result.hooksExecuted).toBe(2);
-    });
-    it('should emit events to event bus', async () => {
-        const preExecuteHandler = vi.fn();
-        const postExecuteHandler = vi.fn();
-        eventBus.on('hooks:pre-execute', preExecuteHandler);
-        eventBus.on('hooks:post-execute', postExecuteHandler);
-        const handler = vi.fn(async () => ({ success: true }));
-        registry.register(HookEvent.PreToolUse, handler);
-        const context = {
-            event: HookEvent.PreToolUse,
-            timestamp: new Date(),
-        };
-        await executor.execute(HookEvent.PreToolUse, context);
-        expect(preExecuteHandler).toHaveBeenCalled();
-        expect(postExecuteHandler).toHaveBeenCalled();
-    });
-    it('should skip disabled hooks', async () => {
-        const handler = vi.fn(async () => ({ success: true }));
-        const id = registry.register(HookEvent.PreToolUse, handler, HookPriority.Normal, {
-            enabled: false,
-        });
-        const context = {
-            event: HookEvent.PreToolUse,
-            timestamp: new Date(),
-        };
-        const result = await executor.execute(HookEvent.PreToolUse, context);
-        expect(result.hooksExecuted).toBe(0);
-        expect(handler).not.toHaveBeenCalled();
-    });
-    it('should record execution statistics', async () => {
-        const handler = vi.fn(async () => ({ success: true }));
-        registry.register(HookEvent.PreToolUse, handler);
-        const context = {
-            event: HookEvent.PreToolUse,
-            timestamp: new Date(),
-        };
-        await executor.execute(HookEvent.PreToolUse, context);
-        const stats = registry.getStats();
-        expect(stats.totalExecutions).toBe(1);
-        expect(stats.totalFailures).toBe(0);
-    });
-});
-//# sourceMappingURL=hooks.test.js.map

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

@@ -1,52 +0,0 @@
-/**
- * V3 Hooks System - Main Export
- *
- * Provides extensible hook points for tool execution, file operations,
- * and session lifecycle events. Integrates with event bus for coordination.
- *
- * Example usage:
- *
- * ```typescript
- * import { createHookRegistry, createHookExecutor, HookEvent, HookPriority } from '@claude-flow/shared/hooks';
- *
- * const registry = createHookRegistry();
- * const executor = createHookExecutor(registry, eventBus);
- *
- * // Register a hook
- * const hookId = registry.register(
- *   HookEvent.PreToolUse,
- *   async (context) => {
- *     console.log('Before tool use:', context.tool?.name);
- *     return { success: true };
- *   },
- *   HookPriority.High
- * );
- *
- * // Execute hooks
- * const result = await executor.execute(
- *   HookEvent.PreToolUse,
- *   {
- *     event: HookEvent.PreToolUse,
- *     timestamp: new Date(),
- *     tool: { name: 'Read', parameters: { path: 'file.ts' } }
- *   }
- * );
- *
- * // Unregister hook
- * registry.unregister(hookId);
- * ```
- *
- * @module v3/shared/hooks
- */
-export type { HookContext, HookResult, HookHandler, HookDefinition, HookStats, HookExecutionOptions, ToolInfo, CommandInfo, FileOperationInfo, SessionInfo, AgentInfo, TaskInfo, MemoryInfo, ErrorInfo, } from './types.js';
-export { HookEvent, HookPriority, } from './types.js';
-export { HookRegistry, createHookRegistry, } from './registry.js';
-export type { AggregatedHookResult, } from './executor.js';
-export { HookExecutor, createHookExecutor, } from './executor.js';
-export { TaskHooksManager, createTaskHooksManager, } from './task-hooks.js';
-export type { PreTaskHookResult, PostTaskHookResult, AgentSuggestion, TaskPattern, TaskOutcome, LearningUpdate, } from './task-hooks.js';
-export { SessionHooksManager, createSessionHooksManager, InMemorySessionStorage, } from './session-hooks.js';
-export type { SessionState, SessionEndHookResult, SessionRestoreHookResult, SessionSummary, SessionStorage, } from './session-hooks.js';
-export { BashSafetyHook, createBashSafetyHook, FileOrganizationHook, createFileOrganizationHook, GitCommitHook, createGitCommitHook, } from './safety/index.js';
-export type { BashSafetyResult, CommandRisk, FileOrganizationResult, FormatterRecommendation, LinterRecommendation, OrganizationIssue, GitCommitResult, CommitType, CommitValidationIssue, } from './safety/index.js';
-//# sourceMappingURL=index.d.ts.map