thatcher 1.0.6 → 1.0.33

package/src/lib/error-handler.js

@@ -1,7 +1,6 @@
-/**
- * Error Handling - Centralized error types and utilities
- */
+import { createLogger } from './logger.js';
 
+// AppError stays a real class (base error type; `instanceof AppError` works).
 export class AppError extends Error {
   constructor(message, code = 'APP_ERROR', status = 500, details = null) {
     super(message);
@@ -9,98 +8,46 @@ export class AppError extends Error {
     this.code = code;
     this.status = status;
     this.details = details;
-    if (Error.captureStackTrace) Error.captureStackTrace(this, AppError);
+    if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
   }
 }
 
-export class UnauthorizedError extends AppError {
-  constructor(message = 'Authentication required') {
-    super(message, 'UNAUTHORIZED', 401);
-    this.name = 'UnauthorizedError';
-  }
+// The specific error types are exported as FACTORY FUNCTIONS, not classes, so
+// both `throw UnauthorizedError(x)` (the style moonlanding and ~17 callsites in
+// this repo use) and a plain call work. A derived `class X extends AppError`
+// cannot be invoked without `new` at all (the engine throws before the body, so
+// a new.target guard does not help) — a factory is the portable fix. Each
+// returns an AppError instance, so `instanceof AppError` still holds in catch.
+export function UnauthorizedError(message = 'Authentication required') {
+  const e = new AppError(message, 'UNAUTHORIZED', 401); e.name = 'UnauthorizedError'; return e;
 }
-
-export class PermissionError extends AppError {
-  constructor(message = 'Permission denied') {
-    super(message, 'PERMISSION_DENIED', 403);
-    this.name = 'PermissionError';
-  }
+export function PermissionError(message = 'Permission denied') {
+  const e = new AppError(message, 'PERMISSION_DENIED', 403); e.name = 'PermissionError'; return e;
 }
-
-export class NotFoundError extends AppError {
-  constructor(entity = 'Resource', id = null) {
-    const msg = id ? `${entity} with id ${id} not found` : `${entity} not found`;
-    super(msg, 'NOT_FOUND', 404);
-    this.name = 'NotFoundError';
-    this.entity = entity;
-    this.id = id;
-  }
+export function NotFoundError(entity = 'Resource', id = null) {
+  const msg = id ? `${entity} with id ${id} not found` : `${entity} not found`;
+  const e = new AppError(msg, 'NOT_FOUND', 404); e.name = 'NotFoundError'; e.entity = entity; e.id = id; return e;
 }
-
-export class ValidationError extends AppError {
-  constructor(message = 'Validation failed', errors = {}) {
-    super(message, 'VALIDATION_ERROR', 422);
-    this.name = 'ValidationError';
-    this.errors = errors;
-  }
+export function ValidationError(message = 'Validation failed', errors = {}) {
+  const e = new AppError(message, 'VALIDATION_ERROR', 422); e.name = 'ValidationError'; e.errors = errors; return e;
 }
-
-export class DatabaseError extends AppError {
-  constructor(operation = 'Database operation', originalError = null) {
-    super(`Database ${operation} failed: ${originalError?.message || 'unknown error'}`, 'DATABASE_ERROR', 500);
-    this.name = 'DatabaseError';
-    this.originalError = originalError;
-  }
+export function DatabaseError(operation = 'Database operation', originalError = null) {
+  const e = new AppError(`Database ${operation} failed: ${originalError?.message || 'unknown error'}`, 'DATABASE_ERROR', 500);
+  e.name = 'DatabaseError'; e.originalError = originalError; return e;
 }
-
-export class ConflictError extends AppError {
-  constructor(message = 'Resource already exists') {
-    super(message, 'CONFLICT', 409);
-    this.name = 'ConflictError';
-  }
+export function ConflictError(message = 'Resource already exists') {
+  const e = new AppError(message, 'CONFLICT', 409); e.name = 'ConflictError'; return e;
 }
-
-export class BadRequestError extends AppError {
-  constructor(message = 'Invalid request') {
-    super(message, 'BAD_REQUEST', 400);
-    this.name = 'BadRequestError';
-  }
+export function BadRequestError(message = 'Invalid request') {
+  const e = new AppError(message, 'BAD_REQUEST', 400); e.name = 'BadRequestError'; return e;
 }
 
-/**
- * Create an error logger
- * @param {string} context
- * @returns {object}
- */
 export function createErrorLogger(context = '') {
-  return {
-    error: (msg, meta = {}) => {
-      console.error(`[${context}] ${msg}`, meta);
-    },
-    warn: (msg, meta = {}) => {
-      console.warn(`[${context}] ${msg}`, meta);
-    },
-    info: (_msg, _meta = {}) => {},
-    debug: (msg, meta = {}) => {
-      if (process.env.DEBUG) {
-        console.debug(`[${context}] Debug:`, msg, meta);
-      }
-    },
-  };
+  const log = createLogger(`[${context}]`);
+  return { error: log.error, warn: log.warn, info: (_msg, _meta = {}) => {}, debug: log.debug };
 }
 
-/**
- * Normalize an arbitrary thrown value into one of thatcher's AppError-class
- * instances. AppError instances (and anything already shaped like one — a
- * numeric `status` + a `code`) pass through untouched; common low-level
- * errors are mapped to the appropriate thatcher error class.
- *
- * (Ported from moonlanding, adapted to thatcher's class-based hierarchy and
- * its `status`/`code`/`details` shape. Kept import-free so the module stays
- * loadable under the plain-node test runner.)
- * @param {unknown} error
- * @returns {AppError}
- */
+// Ported from moonlanding; kept import-free so this module loads under the plain-node test runner.
 export function normalizeError(error) {
   if (error instanceof AppError) {
     return error;
@@ -135,13 +82,7 @@ export function normalizeError(error) {
   });
 }
 
-/**
- * Build a JSON-serializable error response body from any thrown value.
- * (Ported from moonlanding, adapted to thatcher's error shape.)
- * @param {unknown} error
- * @param {boolean} [includeStack=false]
- * @returns {object}
- */
+// Ported from moonlanding.
 export function formatErrorResponse(error, includeStack = false) {
   const normalized = normalizeError(error);
   const response = {

package/src/lib/error-recovery.js

@@ -1,5 +1,8 @@
-import { retryWithBackoff, withCircuitBreaker, checkpoint, restoreCheckpoint, logRecovery, normalizeError } from '@/lib/error-handler';
-import { AppError } from '@/lib/errors';
+import { createLogger } from './logger.js';
+import { retryWithBackoff, withCircuitBreaker, checkpoint, restoreCheckpoint, logRecovery } from '@/lib/error-resilience';
+
+const log = createLogger('[Recovery]');
+import { normalizeError, AppError } from '@/lib/error-handler';
 import { HTTP } from '@/config/constants';
 
 const recoveryState = { supervisors: new Map(), lastHealthCheck: null };
@@ -37,7 +40,7 @@ export async function supervise(name, fn, options = {}) {
     );
     supervisor.state = 'failed';
     supervisor.lastError = error;
-    console.error(`[SUPERVISOR] ${name} failed permanently after ${supervisor.restarts.length} restarts`);
+    log.error(`${name} failed permanently after ${supervisor.restarts.length} restarts`);
     throw error;
   }
 
@@ -58,7 +61,7 @@ export async function supervise(name, fn, options = {}) {
 
     if (supervisor.restarts.length < supervisor.maxRestarts) {
       const delay = Math.min(1000 * Math.pow(2, supervisor.restarts.length - 1), 30000);
-      console.warn(`[SUPERVISOR] ${name} restarting in ${delay}ms (attempt ${supervisor.restarts.length})`);
+      log.warn(`${name} restarting in ${delay}ms (attempt ${supervisor.restarts.length})`);
       await new Promise(resolve => setTimeout(resolve, delay));
       return supervise(name, fn, options);
     }
@@ -79,7 +82,7 @@ export async function degradedMode(fn, fallback, options = {}) {
     ]);
     return { mode: 'normal', result };
   } catch (error) {
-    console.warn('[DEGRADED] Falling back to degraded mode', { error: error.message });
+    log.warn('falling back to degraded mode', { error: error.message });
     const result = await fallback();
     return { mode: 'degraded', result };
   }
@@ -115,7 +118,7 @@ export function isolateFailure(fn, defaultValue = null) {
     try {
       return await fn(...args);
     } catch (error) {
-      console.error('[ISOLATE] Failure contained', {
+      log.error('failure contained', {
         function: fn.name,
         error: String(error.message || error)
       });
@@ -163,7 +166,7 @@ export async function withRecovery(fn, options = {}) {
     return result;
   } catch (error) {
     if (fallback) {
-      console.warn('[RECOVERY] Using fallback after error', { error: error.message });
+      log.warn('using fallback after error', { error: error.message });
       return fallback();
     }
     throw error;

package/src/lib/error-resilience.js

@@ -1,6 +1,8 @@
+import { createLogger } from './logger.js';
 import { HTTP } from '@/config/constants';
-import { AppError } from '@/lib/errors';
-import { normalizeError } from '@/lib/error-handler';
+
+const log = createLogger('[Resilience]');
+import { AppError, normalizeError } from '@/lib/error-handler';
 
 const errorState = { errors: [], circuitBreakers: new Map(), checkpoints: new Map() };
 
@@ -13,12 +15,12 @@ export async function retryWithBackoff(fn, options = {}) {
     } catch (error) {
       if (attempt === maxAttempts) {
         const normalized = normalizeError(error);
-        console.error(`[RETRY] Final attempt failed:`, { ...context, attempt, error: normalized.toJSON() });
+        log.error('final attempt failed:', { ...context, attempt, error: normalized.toJSON() });
         throw normalized;
       }
 
       const waitTime = delay * Math.pow(backoff, attempt - 1);
-      console.warn(`[RETRY] Attempt ${attempt} failed, retrying in ${waitTime}ms`, context);
+      log.warn(`attempt ${attempt} failed, retrying in ${waitTime}ms`, context);
       await new Promise(resolve => setTimeout(resolve, waitTime));
     }
   }
@@ -66,7 +68,7 @@ export async function withCircuitBreaker(name, fn, options = {}) {
     if (breaker.failures >= breaker.threshold) {
       breaker.state = 'open';
       breaker.nextAttempt = Date.now() + breaker.resetTimeout;
-      console.error(`[CIRCUIT] ${name} opened after ${breaker.failures} failures`);
+      log.error(`circuit ${name} opened after ${breaker.failures} failures`);
     }
 
     throw error;

package/src/lib/events-engine.js

@@ -1,4 +1,7 @@
+import { createLogger } from './logger.js';
 import { hookEngine } from '@/lib/hook-engine.js';
+
+const log = createLogger('[EventsEngine]');
 import { list, get, update, create, remove } from '@/engine.js';
 import { queueEmail } from '@/engine/notification-engine';
 import { safeJsonParse } from '@/lib/safe-json.js';
@@ -31,7 +34,7 @@ const activateWorkflowsForStage = async (engagementId, stage, user) => {
       hookEngine.execute(`feature:activated:${feature}`, { engagementId, stage, feature, user });
     }
   } catch (error) {
-    console.error(`[ACTIVATION] Error activating workflows for stage ${stage}:`, error.message);
+    log.error(`error activating workflows for stage ${stage}:`, { message: error.message });
   }
 };
 
@@ -47,7 +50,7 @@ export const registerEntityHandlers = () => {
       create('activity_log', { entity_type: 'engagement', entity_id: context.id, action: 'stage_transition',
         message: `Stage transitioned: ${prev.stage} -> ${data.stage}`,
         details: JSON.stringify({ from: prev.stage, to: data.stage, user_role: user?.role }), user_email: user?.email }, user);
-    } catch (e) { console.error('[events-engine] Failed to log stage change:', e.message); }
+    } catch (e) { log.error('failed to log stage change:', { message: e.message }); }
     return context;
   }, { priority: 100, name: 'workflow-stage-validator' });
 
@@ -70,7 +73,7 @@ export const registerEntityHandlers = () => {
 
   hookEngine.on('engagement:afterUpdate', async (engagement, changes, prev, user) => {
     if (changes.stage && changes.stage !== prev.stage) {
-      logActivity('engagement', engagement.id, 'stage_change', `Stage: ${prev.stage} → ${changes.stage}`, user, { from: prev.stage, to: changes.stage });
+      logActivity('engagement', engagement.id, 'stage_change', `Stage: ${prev.stage} -> ${changes.stage}`, user, { from: prev.stage, to: changes.stage });
       const stageActions = {
         commencement: () => queueEmail('engagement_commencement', { engagement, recipients: 'client_users' }),
         finalization: async () => {
@@ -85,7 +88,7 @@ export const registerEntityHandlers = () => {
       await stageActions[changes.stage]?.();
     }
     if (changes.status && changes.status !== prev.status) {
-      logActivity('engagement', engagement.id, 'status_change', `Status: ${prev.status} → ${changes.status}`, user);
+      logActivity('engagement', engagement.id, 'status_change', `Status: ${prev.status} -> ${changes.status}`, user);
     }
     if (changes.commencement_date && changes.commencement_date !== prev.commencement_date) {
       await queueEmail('engagement_date_change', { engagement, field: 'commencement_date', recipients: 'team_members' });
@@ -118,7 +121,7 @@ export const registerEntityHandlers = () => {
       if (changes.client_status && changes.client_status !== prev.client_status) {
         await queueEmail('rfi_status_change', { rfi, from: prev.client_status, to: changes.client_status, recipients: 'assigned_users' });
       }
-      logActivity('rfi', rfi.id, 'status_change', `Status: ${prev.status} → ${changes.status}`, user);
+      logActivity('rfi', rfi.id, 'status_change', `Status: ${prev.status} -> ${changes.status}`, user);
     }
     if (changes.deadline && changes.deadline !== prev.deadline) {
       await queueEmail('rfi_deadline_change', { rfi, newDeadline: changes.deadline, recipients: 'assigned_users' });
@@ -160,7 +163,7 @@ export const registerEntityHandlers = () => {
   hookEngine.on('review:afterUpdate', async (review, changes, prev, user) => {
     if (changes.status && changes.status !== prev.status) {
       await queueEmail('review_status_change', { review, from: prev.status, to: changes.status, recipients: 'team_members' });
-      logActivity('review', review.id, 'status_change', `Status: ${prev.status} → ${changes.status}`, user);
+      logActivity('review', review.id, 'status_change', `Status: ${prev.status} -> ${changes.status}`, user);
     }
     if (changes.collaborators && changes.collaborators !== prev.collaborators) {
       const added = safeJsonParse(changes.collaborators, []).filter(c => !safeJsonParse(prev.collaborators, []).find(p => p.id === c.id));

package/src/lib/export-sink.js

@@ -1,8 +1,3 @@
-/**
- * Observability Export Sink - Streams traces and metrics to external systems
- * Supports file, HTTP (OTLP), and stdout targets with batching and retry
- */
-
 import fs from 'fs';
 import path from 'path';
 import { createLogger } from './logger.js';

package/src/lib/field-iterator.js

@@ -1,13 +1,9 @@
-/**
- * Field Iterator - Iterate over all fields (including nested/computed) in a spec
- */
-
-/**
- * Iterate over all fields in an entity spec
- * @param {object} spec - Entity specification
- * @param {Function} callback - (key, fieldDef) => void
- * @param {object} options - { includeComputed, includeHidden }
- */
+/* ------------------------------------------------------------------ *
+ * Predicate-based field query helpers (ported from moonlanding).
+ * Additive: these do not change thatcher's existing forEachField /
+ * getEditableFields / getFieldNames / getFieldsByType signatures.
+ * ------------------------------------------------------------------ */
+
 export function forEachField(spec, callback, options = {}) {
   const { includeComputed = false, includeHidden = false } = options;
 
@@ -18,50 +14,21 @@ export function forEachField(spec, callback, options = {}) {
   }
 }
 
-/**
- * Get all field names
- * @param {object} spec
- * @returns {string[]}
- */
 export function getFieldNames(spec) {
   return Object.keys(spec.fields || {});
 }
 
-/**
- * Get only editable fields
- * @param {object} spec
- * @returns {string[]}
- */
 export function getEditableFields(spec) {
   return Object.entries(spec.fields || {})
     .filter(([key, field]) => !field.readonly && !field.auto && !field.auto_generate)
     .map(([key]) => key);
 }
 
-/**
- * Get field by type
- * @param {object} spec
- * @param {string} type
- * @returns {Array<{key: string, field: object}>}
- */
 export function getFieldsByType(spec, type) {
   return Object.entries(spec.fields || {})
     .filter(([key, field]) => field.type === type);
 }
 
-/* ------------------------------------------------------------------ *
- * Predicate-based field query helpers (ported from moonlanding).
- * Additive: these do not change thatcher's existing forEachField /
- * getEditableFields / getFieldNames / getFieldsByType signatures.
- * ------------------------------------------------------------------ */
-
-/**
- * Query the fields of a spec with one or more predicates.
- * @param {object} spec
- * @param {Function|Function[]} predicates - (field, key) => boolean
- * @param {object} [options] - { keysOnly }
- * @returns {Array<string|object>} keys when keysOnly, else { key, ...field }
- */
 export function fieldQuery(spec, predicates, options = {}) {
   const preds = Array.isArray(predicates) ? predicates : [predicates];
   const results = [];
@@ -73,9 +40,6 @@ export function fieldQuery(spec, predicates, options = {}) {
   return results;
 }
 
-/**
- * Reusable field predicates for fieldQuery.
- */
 export const is = {
   notId: f => f.type !== 'id',
   notHidden: f => !f.hidden,
@@ -90,85 +54,52 @@ export const is = {
   hasProperty: prop => f => f[prop] !== undefined,
 };
 
-/**
- * Editable fields as full { key, ...field } objects (form rendering).
- * Distinct from thatcher's getEditableFields (which returns names only).
- */
+// Returns { key, ...field } objects, unlike getEditableFields() which returns names only.
 export function getFormFields(spec) {
   if (spec.system_entity) return [];
   return fieldQuery(spec, is.editable);
 }
 
-/**
- * Listable fields as full { key, ...field } objects.
- */
 export function getListFields(spec) {
   return fieldQuery(spec, is.listable);
 }
 
-/**
- * Displayable fields as full { key, ...field } objects.
- */
 export function getDisplayFields(spec) {
   return fieldQuery(spec, is.displayable);
 }
 
-/**
- * Required field names.
- */
 export function getRequiredFields(spec) {
   return fieldQuery(spec, is.required, { keysOnly: true });
 }
 
-/**
- * Searchable field names.
- */
 export function getSearchFields(spec) {
   return fieldQuery(spec, is.searchable, { keysOnly: true });
 }
 
-/**
- * Filterable fields, resolved from list.filters config.
- */
 export function getFilterableFields(spec) {
   return (spec.list?.filters || [])
     .map(filterKey => spec.fields?.[filterKey])
     .filter(Boolean);
 }
 
-/**
- * Reference (ref) fields as full { key, ...field } objects.
- */
 export function getRefFields(spec) {
   return fieldQuery(spec, is.ref);
 }
 
-/**
- * Get a single field definition by key.
- */
 export function getField(spec, fieldKey) {
   return spec.fields?.[fieldKey];
 }
 
-/**
- * Get a single field's type by key.
- */
 export function getFieldType(spec, fieldKey) {
   return spec.fields?.[fieldKey]?.type;
 }
 
-/**
- * Iterate editable fields on create. callback = (key, field) => void
- */
 export function iterateCreateFields(spec, callback) {
   for (const { key, ...field } of fieldQuery(spec, is.editable)) {
     callback(key, field);
   }
 }
 
-/**
- * Iterate editable fields on update. callback = (key, field) => void
- */
 export function iterateUpdateFields(spec, callback) {
   for (const { key, ...field } of fieldQuery(spec, is.editable)) {
     callback(key, field);

package/src/lib/field-registry.js

@@ -1,13 +1,3 @@
-/**
- * Field Registry - Type coercion and field utilities
- */
-
-/**
- * Coerce value to field type
- * @param {any} value
- * @param {string} type
- * @returns {any}
- */
 export function coerceFieldValue(value, type) {
   if (value === null || value === undefined) return value;
 
@@ -31,22 +21,10 @@ export function coerceFieldValue(value, type) {
   }
 }
 
-/**
- * Serialize field value for database
- * @param {any} value
- * @param {string} type
- * @returns {any}
- */
 export function serializeField(value, type) {
   return coerceFieldValue(value, type);
 }
 
-/**
- * Deserialize field value from database
- * @param {any} value
- * @param {string} type
- * @returns {any}
- */
 export function deserializeField(value, type) {
   if (value === null) return null;
 

package/src/lib/generic-crud-handler.js

@@ -1,26 +1,10 @@
-/**
- * Generic CRUD Handler - Catch-all API handler for any entity
- * This provides out-of-the-box CRUD for all entities defined in config
- * Users can override by creating their own route files
- */
-
 import { createCrudHandlers } from '../lib/crud-factory.js';
 import { getConfigEngineSync } from '../lib/config-generator-engine.js';
 
-/**
- * Get handler for an entity
- * @param {string} entityName
- * @returns {object} {GET, POST, PUT, DELETE}
- */
 export function getEntityHandlers(entityName) {
   return createCrudHandlers(entityName);
 }
 
-/**
- * Check if entity exists and is accessible
- * @param {string} entityName
- * @returns {boolean}
- */
 export function hasEntity(entityName) {
   try {
     const engine = getConfigEngineSync();

package/src/lib/hook-engine.js

@@ -1,19 +1,12 @@
-/**
- * Hook Engine - Event system for plugins and lifecycle hooks
- * Fires events like 'create:entity:after', 'update:entity:before', etc.
- */
+import { createLogger } from './logger.js';
+
+const log = createLogger('[HookEngine]');
 
 export class HookEngine {
   constructor() {
     this.hooks = new Map();
   }
 
-  /**
-   * Register a hook handler
-   * @param {string} name - Event name
-   * @param {Function} callback - Handler function
-   * @param {object} options - { priority, once }
-   */
   register(name, callback, options = {}) {
     const { priority = 0, once = false } = options;
     if (!this.hooks.has(name)) this.hooks.set(name, []);
@@ -23,16 +16,10 @@ export class HookEngine {
     return this;
   }
 
-  /**
-   * Alias for register
-   */
   on(name, callback, options = {}) {
     return this.register(name, callback, options);
   }
 
-  /**
-   * Unregister a hook handler
-   */
   off(name, callback) {
     const list = this.hooks.get(name);
     if (!list) return this;
@@ -42,13 +29,6 @@ export class HookEngine {
     return this;
   }
 
-  /**
-   * Execute all handlers for an event (fire-and-forget style)
-   * @param {string} name
-   * @param {object} data
-   * @param {object} options - { fallthrough: true to continue on error }
-   * @returns {Promise<{success: boolean, data, errors}>}
-   */
   async execute(name, data = {}, options = {}) {
     const { fallthrough = true } = options;
     const hooks = this.hooks.get(name);
@@ -60,7 +40,7 @@ export class HookEngine {
         await hook.callback(data);
         if (hook.once) this.off(name, hook.callback);
       } catch (error) {
-        console.error(`[HookEngine] Hook "${name}" error:`, error.message);
+        log.error(`hook "${name}" error:`, { message: error.message });
         errors.push(error);
         if (!fallthrough) throw error;
       }
@@ -69,12 +49,6 @@ export class HookEngine {
     return { success: errors.length === 0, data, errors };
   }
 
-  /**
-   * Pipe data through transformation hooks
-   * @param {string} name
-   * @param {any} data
-   * @returns {Promise<any>}
-   */
   async pipe(name, data = {}) {
     const hooks = this.hooks.get(name);
     if (!hooks || hooks.length === 0) return data;
@@ -86,25 +60,16 @@ export class HookEngine {
         if (result !== undefined) current = result;
         if (hook.once) this.off(name, hook.callback);
       } catch (error) {
-        console.error(`[HookEngine] Pipe hook "${name}" error:`, error.message);
+        log.error(`pipe hook "${name}" error:`, { message: error.message });
       }
     }
     return current;
   }
 
-  /**
-   * Get all listeners for an event
-   * @param {string} name
-   * @returns {Array}
-   */
   listeners(name) {
     return this.hooks.has(name) ? Array.from(this.hooks.get(name)) : [];
   }
 
-  /**
-   * Get statistics
-   * @returns {object} Map of event -> count
-   */
   stats() {
     const result = {};
     for (const [name, list] of this.hooks.entries()) {
@@ -113,34 +78,21 @@ export class HookEngine {
     return result;
   }
 
-  /**
-   * Clear all hooks
-   */
   clear() {
     this.hooks.clear();
   }
 }
 
-// Global singleton
 export const hookEngine = new HookEngine();
 
-/**
- * Execute hook (convenience function)
- */
 export async function executeHook(name, data = {}, options = {}) {
   return hookEngine.execute(name, data, options);
 }
 
-/**
- * Pipe through hooks
- */
 export async function pipeHook(name, data = {}) {
   return hookEngine.pipe(name, data);
 }
 
-/**
- * Register hook debug exposure
- */
 function registerHookDebug() {
   if (globalThis.__debug__) {
     globalThis.__debug__.expose('hooks', {