profclaw 2.0.0 → 2.3.0

package/dist/hooks/built-in/audit-log.js

@@ -0,0 +1,84 @@
+/**
+ * Built-in Hook: Audit Log
+ *
+ * Logs all tool executions after they complete (`afterToolCall`).
+ * Records: timestamp, sessionId, toolName, sanitized args, success/failure,
+ * and duration (if startedAt is provided via metadata).
+ */
+import { createContextualLogger } from '../../utils/logger.js';
+const log = createContextualLogger('AuditLog');
+/** Keys that should never appear in audit logs */
+const SENSITIVE_ARG_KEYS = new Set([
+    'password',
+    'token',
+    'secret',
+    'apiKey',
+    'api_key',
+    'Authorization',
+    'authorization',
+    'credential',
+    'credentials',
+    'private_key',
+    'privateKey',
+]);
+function sanitizeArgs(args) {
+    if (args === null || typeof args !== 'object')
+        return args;
+    if (Array.isArray(args)) {
+        return args.map(sanitizeArgs);
+    }
+    const record = args;
+    const sanitized = {};
+    for (const [key, value] of Object.entries(record)) {
+        sanitized[key] = SENSITIVE_ARG_KEYS.has(key) ? '[REDACTED]' : sanitizeArgs(value);
+    }
+    return sanitized;
+}
+function isSuccessResult(result) {
+    if (result === null || result === undefined)
+        return true;
+    if (typeof result !== 'object')
+        return true;
+    const r = result;
+    if (typeof r.success === 'boolean')
+        return r.success;
+    if (r.error !== undefined)
+        return false;
+    return true;
+}
+export const auditLogHook = {
+    name: 'built-in:audit-log',
+    point: 'afterToolCall',
+    priority: 200, // Run late so other hooks can modify before we record
+    handler: async (context) => {
+        const { toolName, toolArgs, toolResult, sessionId, metadata } = context;
+        const timestamp = new Date().toISOString();
+        const success = isSuccessResult(toolResult);
+        const sanitizedArgs = sanitizeArgs(toolArgs);
+        // Duration: caller may pass startedAt (epoch ms) in metadata
+        let durationMs;
+        if (typeof metadata.toolStartedAt === 'number') {
+            durationMs = Date.now() - metadata.toolStartedAt;
+        }
+        log.info('Tool executed', {
+            audit: true,
+            timestamp,
+            sessionId,
+            toolName,
+            args: sanitizedArgs,
+            success,
+            durationMs,
+        });
+        return {
+            proceed: true,
+            metadata: {
+                auditRecorded: true,
+                auditTimestamp: timestamp,
+                auditSuccess: success,
+                auditDurationMs: durationMs,
+            },
+        };
+    },
+};
+export default auditLogHook;
+//# sourceMappingURL=audit-log.js.map

package/dist/hooks/built-in/cost-warning.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Built-in Hook: Cost Warning
+ *
+ * Fires on `onBudgetWarning` at 50%, 80%, and 100% of budget usage.
+ * At 100%, sets proceed: false to stop execution.
+ */
+import type { Hook } from '../registry.js';
+export declare const costWarningHook: Hook;
+export default costWarningHook;
+//# sourceMappingURL=cost-warning.d.ts.map

package/dist/hooks/built-in/cost-warning.js

@@ -0,0 +1,59 @@
+/**
+ * Built-in Hook: Cost Warning
+ *
+ * Fires on `onBudgetWarning` at 50%, 80%, and 100% of budget usage.
+ * At 100%, sets proceed: false to stop execution.
+ */
+import { createContextualLogger } from '../../utils/logger.js';
+const log = createContextualLogger('CostWarningHook');
+const WARNING_THRESHOLDS = [0.5, 0.8, 1.0];
+function getThresholdLabel(t) {
+    return `${Math.round(t * 100)}%`;
+}
+function crossedThreshold(previousRatio, currentRatio, threshold) {
+    return previousRatio < threshold && currentRatio >= threshold;
+}
+export const costWarningHook = {
+    name: 'built-in:cost-warning',
+    point: 'onBudgetWarning',
+    priority: 10,
+    handler: async (context) => {
+        const { budgetUsed, budgetMax, metadata } = context;
+        if (budgetUsed === undefined || budgetMax === undefined || budgetMax <= 0) {
+            return { proceed: true };
+        }
+        const currentRatio = budgetUsed / budgetMax;
+        const previousRatio = typeof metadata.previousBudgetRatio === 'number' ? metadata.previousBudgetRatio : 0;
+        // Hard stop at 100%
+        if (currentRatio >= 1.0) {
+            log.warn('Budget exhausted — stopping execution', {
+                budgetUsed,
+                budgetMax,
+                percentUsed: '100%',
+                sessionId: context.sessionId,
+            });
+            return {
+                proceed: false,
+                metadata: { previousBudgetRatio: currentRatio, budgetExhausted: true },
+            };
+        }
+        // Warn at soft thresholds (50%, 80%)
+        for (const threshold of WARNING_THRESHOLDS) {
+            if (crossedThreshold(previousRatio, currentRatio, threshold)) {
+                log.warn(`Budget warning: ${getThresholdLabel(threshold)} of limit used`, {
+                    budgetUsed,
+                    budgetMax,
+                    threshold: getThresholdLabel(threshold),
+                    sessionId: context.sessionId,
+                });
+                break;
+            }
+        }
+        return {
+            proceed: true,
+            metadata: { previousBudgetRatio: currentRatio },
+        };
+    },
+};
+export default costWarningHook;
+//# sourceMappingURL=cost-warning.js.map

package/dist/hooks/built-in/dangerous-tool.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Built-in Hook: Dangerous Tool Guard
+ *
+ * Intercepts `beforeToolCall` and delegates to a PermissionManager instance.
+ * If the manager denies the operation the hook returns `proceed: false`,
+ * halting the hook chain before the tool runs.
+ *
+ * In non-interactive mode (no prompt callback registered on the manager) all
+ * tools are allowed and the call is flagged with `metadata.requiresApproval`.
+ */
+import { PermissionManager } from '../../agents/permissions.js';
+import type { Hook } from '../registry.js';
+/**
+ * Tools that are considered dangerous and should require human approval
+ * before execution in interactive sessions.
+ *
+ * Exported for backwards-compatibility and convenience checks.
+ */
+export declare const DANGEROUS_TOOLS: Set<string>;
+/**
+ * Retrieve (or lazily create) the PermissionManager used by this hook.
+ * Use this to register a `setPromptCallback` in interactive sessions.
+ */
+export declare function getPermissionManager(): PermissionManager;
+/**
+ * Replace the PermissionManager used by this hook.
+ * Primarily useful in tests where you want full control over the manager.
+ */
+export declare function setPermissionManager(manager: PermissionManager): void;
+export declare const dangerousToolHook: Hook;
+export default dangerousToolHook;
+//# sourceMappingURL=dangerous-tool.d.ts.map

package/dist/hooks/built-in/dangerous-tool.js

@@ -0,0 +1,80 @@
+/**
+ * Built-in Hook: Dangerous Tool Guard
+ *
+ * Intercepts `beforeToolCall` and delegates to a PermissionManager instance.
+ * If the manager denies the operation the hook returns `proceed: false`,
+ * halting the hook chain before the tool runs.
+ *
+ * In non-interactive mode (no prompt callback registered on the manager) all
+ * tools are allowed and the call is flagged with `metadata.requiresApproval`.
+ */
+import { createContextualLogger } from '../../utils/logger.js';
+import { PermissionManager, DEFAULT_PERMISSION_RULES } from '../../agents/permissions.js';
+const log = createContextualLogger('DangerousToolHook');
+/**
+ * Tools that are considered dangerous and should require human approval
+ * before execution in interactive sessions.
+ *
+ * Exported for backwards-compatibility and convenience checks.
+ */
+export const DANGEROUS_TOOLS = new Set(DEFAULT_PERMISSION_RULES.filter((r) => r.level === 'dangerous').map((r) => r.toolName));
+/**
+ * Module-level PermissionManager shared by the hook.
+ * Callers can obtain a reference via `getPermissionManager()` to attach a
+ * prompt callback before the hook fires.
+ */
+let sharedManager = new PermissionManager();
+/**
+ * Retrieve (or lazily create) the PermissionManager used by this hook.
+ * Use this to register a `setPromptCallback` in interactive sessions.
+ */
+export function getPermissionManager() {
+    return sharedManager;
+}
+/**
+ * Replace the PermissionManager used by this hook.
+ * Primarily useful in tests where you want full control over the manager.
+ */
+export function setPermissionManager(manager) {
+    sharedManager = manager;
+}
+export const dangerousToolHook = {
+    name: 'built-in:dangerous-tool',
+    point: 'beforeToolCall',
+    priority: 20,
+    handler: async (context) => {
+        const { toolName, toolArgs, sessionId } = context;
+        if (!toolName) {
+            return { proceed: true };
+        }
+        const level = sharedManager.getLevel(toolName);
+        // Safe tools (or unknown tools with no rule) are always allowed without prompting
+        if (level === 'safe') {
+            return { proceed: true };
+        }
+        log.debug('Checking permission for tool', { tool: toolName, level, sessionId });
+        const result = await sharedManager.check(toolName, toolArgs);
+        if (!result.allowed) {
+            log.warn('Tool call denied by permission manager', {
+                tool: toolName,
+                reason: result.reason,
+                sessionId,
+            });
+            return {
+                proceed: false,
+                metadata: {
+                    permissionDenied: true,
+                    deniedTool: toolName,
+                    reason: result.reason,
+                },
+            };
+        }
+        // Allowed — flag with requiresApproval so callers remain aware
+        return {
+            proceed: true,
+            metadata: { requiresApproval: true, dangerousTool: toolName },
+        };
+    },
+};
+export default dangerousToolHook;
+//# sourceMappingURL=dangerous-tool.js.map

package/dist/hooks/built-in/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Built-in Hooks
+ *
+ * Export all built-in hooks and a helper to register them all at once.
+ */
+export { costWarningHook } from './cost-warning.js';
+export { dangerousToolHook, DANGEROUS_TOOLS } from './dangerous-tool.js';
+export { auditLogHook } from './audit-log.js';
+import type { HookRegistry } from '../registry.js';
+/**
+ * Register all built-in hooks on a registry.
+ */
+export declare function registerBuiltInHooks(registry: HookRegistry): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/built-in/index.js

@@ -0,0 +1,20 @@
+/**
+ * Built-in Hooks
+ *
+ * Export all built-in hooks and a helper to register them all at once.
+ */
+export { costWarningHook } from './cost-warning.js';
+export { dangerousToolHook, DANGEROUS_TOOLS } from './dangerous-tool.js';
+export { auditLogHook } from './audit-log.js';
+import { costWarningHook } from './cost-warning.js';
+import { dangerousToolHook } from './dangerous-tool.js';
+import { auditLogHook } from './audit-log.js';
+/**
+ * Register all built-in hooks on a registry.
+ */
+export function registerBuiltInHooks(registry) {
+    registry.register(costWarningHook);
+    registry.register(dangerousToolHook);
+    registry.register(auditLogHook);
+}
+//# sourceMappingURL=index.js.map

package/dist/hooks/index.d.ts

@@ -10,4 +10,7 @@ export { handlePostToolUse, getSessionEvents, getEvent, getSessionSummary, clear
 export { handleSessionEnd, getSessionAggregate, getAllSessionAggregates, getRecentSessions, } from './session-end.js';
 export { handlePromptSubmit, getSessionPrompts, getInitialPrompt, clearSessionPrompts, } from './prompt-submit.js';
 export { handleOpenClawWebhook, handleGenericAgentWebhook, getAgentReport, getTaskReports, getRecentReports, getReportsByAgent, AgentCompletionSchema, OpenClawCompletionSchema, type AgentCompletion, type OpenClawCompletion, } from './agent-webhook.js';
+export { HookRegistry, getHookRegistry, type HookPoint, type HookContext, type HookResult, type Hook, } from './registry.js';
+export { loadHooks } from './loader.js';
+export { costWarningHook, dangerousToolHook, auditLogHook, registerBuiltInHooks, DANGEROUS_TOOLS, } from './built-in/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.js

@@ -12,4 +12,10 @@ export { handleSessionEnd, getSessionAggregate, getAllSessionAggregates, getRece
 export { handlePromptSubmit, getSessionPrompts, getInitialPrompt, clearSessionPrompts, } from './prompt-submit.js';
 // Agent webhook exports
 export { handleOpenClawWebhook, handleGenericAgentWebhook, getAgentReport, getTaskReports, getRecentReports, getReportsByAgent, AgentCompletionSchema, OpenClawCompletionSchema, } from './agent-webhook.js';
+// Hook Registry (WS-4.1)
+export { HookRegistry, getHookRegistry, } from './registry.js';
+// Hook Loader (WS-4.1)
+export { loadHooks } from './loader.js';
+// Built-in Hooks (WS-4.2)
+export { costWarningHook, dangerousToolHook, auditLogHook, registerBuiltInHooks, DANGEROUS_TOOLS, } from './built-in/index.js';
 //# sourceMappingURL=index.js.map

package/dist/hooks/loader.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Hook Loader
+ *
+ * Dynamically loads hooks from a YAML config file or a hooks/ directory.
+ * Each hook file should export a `Hook` or `Hook[]` as its default export.
+ */
+import type { Hook } from './registry.js';
+/**
+ * Load hooks from a YAML config file or hooks/ directory.
+ *
+ * Resolution order:
+ * 1. `configPath` if provided
+ * 2. `profclaw.hooks.yml` in the current working directory
+ * 3. `hooks/` directory in the current working directory
+ */
+export declare function loadHooks(configPath?: string): Promise<Hook[]>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/hooks/loader.js

@@ -0,0 +1,142 @@
+/**
+ * Hook Loader
+ *
+ * Dynamically loads hooks from a YAML config file or a hooks/ directory.
+ * Each hook file should export a `Hook` or `Hook[]` as its default export.
+ */
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { resolve, join, extname } from 'node:path';
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('HookLoader');
+function parseSimpleYaml(content) {
+    const result = {};
+    const lines = content.split('\n');
+    let inHooks = false;
+    const hookEntries = [];
+    for (const rawLine of lines) {
+        const line = rawLine.trimEnd();
+        if (line.startsWith('hooksDir:')) {
+            result.hooksDir = line.replace('hooksDir:', '').trim().replace(/^['"]|['"]$/g, '');
+            inHooks = false;
+            continue;
+        }
+        if (line.startsWith('hooks:')) {
+            inHooks = true;
+            continue;
+        }
+        if (inHooks && line.match(/^\s+-\s+path:/)) {
+            const path = line.replace(/^\s+-\s+path:\s*/, '').replace(/^['"]|['"]$/g, '');
+            hookEntries.push({ path, enabled: true });
+            continue;
+        }
+        if (inHooks && line.match(/^\s+enabled:/)) {
+            const last = hookEntries[hookEntries.length - 1];
+            if (last) {
+                last.enabled = line.includes('true');
+            }
+            continue;
+        }
+        if (line && !line.startsWith(' ') && !line.startsWith('\t') && !line.startsWith('#')) {
+            inHooks = false;
+        }
+    }
+    if (hookEntries.length > 0) {
+        result.hooks = hookEntries;
+    }
+    return result;
+}
+async function loadHookFromPath(filePath) {
+    try {
+        const mod = await import(filePath);
+        const exported = mod.default ?? mod;
+        if (Array.isArray(exported)) {
+            return exported;
+        }
+        if (exported && typeof exported.handler === 'function') {
+            return [exported];
+        }
+        log.warn('Hook file did not export a Hook or Hook[]', { path: filePath });
+        return [];
+    }
+    catch (error) {
+        log.error('[HookLoader] Failed to load hook file', {
+            path: filePath,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return [];
+    }
+}
+/**
+ * Load hooks from a YAML config file or hooks/ directory.
+ *
+ * Resolution order:
+ * 1. `configPath` if provided
+ * 2. `profclaw.hooks.yml` in the current working directory
+ * 3. `hooks/` directory in the current working directory
+ */
+export async function loadHooks(configPath) {
+    const cwd = process.cwd();
+    const loaded = [];
+    // Resolve config path
+    const yamlPath = configPath ?? resolve(cwd, 'profclaw.hooks.yml');
+    if (existsSync(yamlPath)) {
+        log.info('Loading hooks from YAML config', { path: yamlPath });
+        try {
+            const content = readFileSync(yamlPath, 'utf-8');
+            const config = parseSimpleYaml(content);
+            // Load explicitly listed hook files
+            if (config.hooks) {
+                for (const entry of config.hooks) {
+                    if (entry.enabled === false)
+                        continue;
+                    const absPath = resolve(cwd, entry.path);
+                    const hooks = await loadHookFromPath(absPath);
+                    loaded.push(...hooks);
+                }
+            }
+            // Load from hooksDir if specified
+            if (config.hooksDir) {
+                const dir = resolve(cwd, config.hooksDir);
+                const dirHooks = await loadHooksFromDirectory(dir);
+                loaded.push(...dirHooks);
+            }
+        }
+        catch (error) {
+            log.error('[HookLoader] Failed to parse hooks YAML', {
+                path: yamlPath,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    else {
+        // Fallback: scan hooks/ directory
+        const hooksDir = resolve(cwd, 'hooks');
+        if (existsSync(hooksDir)) {
+            log.info('Loading hooks from directory', { dir: hooksDir });
+            const dirHooks = await loadHooksFromDirectory(hooksDir);
+            loaded.push(...dirHooks);
+        }
+    }
+    log.info('Hooks loaded', { count: loaded.length });
+    return loaded;
+}
+async function loadHooksFromDirectory(dir) {
+    const result = [];
+    if (!existsSync(dir))
+        return result;
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        const ext = extname(entry.name);
+        if (ext !== '.ts' && ext !== '.js' && ext !== '.mjs')
+            continue;
+        if (entry.name.endsWith('.test.ts') || entry.name.endsWith('.test.js'))
+            continue;
+        const filePath = join(dir, entry.name);
+        const hooks = await loadHookFromPath(filePath);
+        result.push(...hooks);
+    }
+    return result;
+}
+//# sourceMappingURL=loader.js.map

package/dist/hooks/registry.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Hook Registry
+ *
+ * Manages lifecycle hooks for the profClaw agent execution pipeline.
+ * Hooks run in priority order and can abort or modify the operation.
+ */
+export type HookPoint = 'beforeToolCall' | 'afterToolCall' | 'beforeApiCall' | 'afterResponse' | 'onSessionStart' | 'onSessionEnd' | 'onError' | 'onBudgetWarning';
+export interface HookContext {
+    hookPoint: HookPoint;
+    sessionId?: string;
+    toolName?: string;
+    toolArgs?: unknown;
+    toolResult?: unknown;
+    error?: Error;
+    budgetUsed?: number;
+    budgetMax?: number;
+    metadata: Record<string, unknown>;
+}
+export interface HookResult {
+    /** false = abort the operation */
+    proceed: boolean;
+    /** Override args/result if provided */
+    modified?: unknown;
+    metadata?: Record<string, unknown>;
+}
+export interface Hook {
+    name: string;
+    point: HookPoint;
+    /** Lower runs first, default 100 */
+    priority: number;
+    handler: (context: HookContext) => Promise<HookResult>;
+}
+export declare class HookRegistry {
+    private hooks;
+    constructor();
+    /**
+     * Register a hook. If a hook with the same name already exists it is replaced.
+     */
+    register(hook: Hook): void;
+    /**
+     * Unregister a hook by name (searches all hook points).
+     */
+    unregister(name: string): void;
+    /**
+     * Run all hooks for a given point in priority order.
+     *
+     * - If any hook returns `proceed: false`, the chain stops immediately.
+     * - If a hook returns `modified`, that value is forwarded to the next hook.
+     * - Returns `{ proceed: true }` when no hooks are registered for the point.
+     */
+    run(point: HookPoint, context: HookContext): Promise<HookResult>;
+    /**
+     * Return a flat list of all registered hooks across all points.
+     */
+    getRegistered(): Hook[];
+    /**
+     * Remove all registered hooks.
+     */
+    clear(): void;
+}
+export declare function getHookRegistry(): HookRegistry;
+//# sourceMappingURL=registry.d.ts.map

package/dist/hooks/registry.js

@@ -0,0 +1,127 @@
+/**
+ * Hook Registry
+ *
+ * Manages lifecycle hooks for the profClaw agent execution pipeline.
+ * Hooks run in priority order and can abort or modify the operation.
+ */
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('HookRegistry');
+export class HookRegistry {
+    hooks;
+    constructor() {
+        this.hooks = new Map();
+    }
+    /**
+     * Register a hook. If a hook with the same name already exists it is replaced.
+     */
+    register(hook) {
+        if (!this.hooks.has(hook.point)) {
+            this.hooks.set(hook.point, []);
+        }
+        const list = this.hooks.get(hook.point);
+        // Remove existing hook with same name (idempotent registration)
+        const existingIdx = list.findIndex((h) => h.name === hook.name);
+        if (existingIdx !== -1) {
+            list.splice(existingIdx, 1);
+        }
+        list.push(hook);
+        // Keep sorted by priority ascending — lower number runs first
+        list.sort((a, b) => a.priority - b.priority);
+        log.debug('Hook registered', { name: hook.name, point: hook.point, priority: hook.priority });
+    }
+    /**
+     * Unregister a hook by name (searches all hook points).
+     */
+    unregister(name) {
+        for (const [point, list] of this.hooks) {
+            const idx = list.findIndex((h) => h.name === name);
+            if (idx !== -1) {
+                list.splice(idx, 1);
+                log.debug('Hook unregistered', { name, point });
+            }
+        }
+    }
+    /**
+     * Run all hooks for a given point in priority order.
+     *
+     * - If any hook returns `proceed: false`, the chain stops immediately.
+     * - If a hook returns `modified`, that value is forwarded to the next hook.
+     * - Returns `{ proceed: true }` when no hooks are registered for the point.
+     */
+    async run(point, context) {
+        const list = this.hooks.get(point);
+        if (!list || list.length === 0) {
+            return { proceed: true };
+        }
+        let currentContext = { ...context };
+        let aggregatedMetadata = { ...context.metadata };
+        for (const hook of list) {
+            try {
+                const result = await hook.handler(currentContext);
+                if (result.metadata) {
+                    aggregatedMetadata = { ...aggregatedMetadata, ...result.metadata };
+                }
+                if (!result.proceed) {
+                    log.info('Hook chain aborted', { hook: hook.name, point });
+                    return {
+                        proceed: false,
+                        modified: result.modified,
+                        metadata: aggregatedMetadata,
+                    };
+                }
+                // Forward modified value to the next hook
+                if (result.modified !== undefined) {
+                    currentContext = {
+                        ...currentContext,
+                        toolArgs: result.modified,
+                        toolResult: result.modified,
+                        metadata: aggregatedMetadata,
+                    };
+                }
+                else {
+                    currentContext = { ...currentContext, metadata: aggregatedMetadata };
+                }
+            }
+            catch (error) {
+                log.error('[HookRegistry] Hook threw an error', {
+                    hook: hook.name,
+                    point,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                // Non-fatal: log and continue the chain
+            }
+        }
+        const finalModified = currentContext.toolArgs !== context.toolArgs ? currentContext.toolArgs : undefined;
+        return {
+            proceed: true,
+            modified: finalModified,
+            metadata: aggregatedMetadata,
+        };
+    }
+    /**
+     * Return a flat list of all registered hooks across all points.
+     */
+    getRegistered() {
+        const all = [];
+        for (const list of this.hooks.values()) {
+            all.push(...list);
+        }
+        return all;
+    }
+    /**
+     * Remove all registered hooks.
+     */
+    clear() {
+        this.hooks.clear();
+        log.debug('Hook registry cleared');
+    }
+}
+/** Module-level singleton registry */
+let defaultRegistry = null;
+export function getHookRegistry() {
+    if (!defaultRegistry) {
+        defaultRegistry = new HookRegistry();
+    }
+    return defaultRegistry;
+}
+//# sourceMappingURL=registry.js.map