@specverse/engines 4.1.13 → 4.1.15

package/libs/instance-factories/cli/templates/commander/command-generator.ts

@@ -44,7 +44,7 @@ export default function generateCommand(context: TemplateContext): string {
     const alias = flag.alias ? `${flag.alias}, ` : '';
     const flagType = flag.type?.toLowerCase();
     const valuePart = flagType === 'boolean' ? '' : ` <${flagName.replace(/^--/, '')}>`;
-    const defaultVal = flag.default !== undefined ? `, ${JSON.stringify(flag.default)}` : '';
+    const defaultVal = flag.default !== undefined ? `, ${commanderDefault(flag.default, flagType)}` : '';
     const desc = flag.description || `${flagName} option`;
     return `    .option('${alias}${flagName}${valuePart}', '${desc}'${defaultVal})`;
   });
@@ -96,7 +96,18 @@ export default function generateCommand(context: TemplateContext): string {
       if (ENGINE_HANDLERS[key]?.imports) allImportSets.push(ENGINE_HANDLERS[key].imports);
     }
   }
-  const engineImports = deduplicateImports(allImportSets);
+  // Generate the body first so we can filter imports to only those actually used
+  const registerBody = hasSubcommands
+    ? generateCommandWithSubcommands(name, description, subcommands, optionDefs)
+    : generateLeafCommand(name, description, commandStr, optionDefs, actionParams, serviceRef, exitCodes);
+
+  const bodyForUsage = `${serviceImport}\n${registerBody}\n${subcommandRegistrations}`;
+  const commandOptionsUsed = new RegExp('\\bCommandOptions\\b').test(bodyForUsage);
+  const engineImports = deduplicateImports(allImportSets, bodyForUsage);
+
+  const commandOptionsDecl = commandOptionsUsed
+    ? `interface CommandOptions {\n${optionTypes.length > 0 ? optionTypes.join('\n') : '  [key: string]: any;'}\n}\n`
+    : '';
 
   return `/**
  * ${name} command
@@ -108,17 +119,14 @@ import { Command } from 'commander';
 ${serviceImport}
 ${engineImports}
 
-interface CommandOptions {
-${optionTypes.length > 0 ? optionTypes.join('\n') : '  [key: string]: any;'}
-}
-
+${commandOptionsDecl}
 ${exitCodeComments ? `/**\n * Exit codes:\n${exitCodeComments}\n */` : ''}
 
 /**
  * Register the ${name} command on the program.
  */
 export function register${capitalize(name)}Command(program: Command): void {
-  ${hasSubcommands ? generateCommandWithSubcommands(name, description, subcommands, optionDefs) : generateLeafCommand(name, description, commandStr, optionDefs, actionParams, serviceRef, exitCodes)}
+  ${registerBody}
 }
 ${subcommandRegistrations}
 `;
@@ -280,6 +288,44 @@ import type { ParserEngine, InferenceEngine, RealizeEngine } from '@specverse/ty
           }
         }
 
+        // Merge custom actions from original spec controllers into inferred controllers
+        // Inference generates standard CURED; custom actions (openPoll, castVote) come from the spec
+        const origControllers = Array.isArray((origComponent as any).controllers)
+          ? (origComponent as any).controllers
+          : Object.values((origComponent as any).controllers || {});
+        const inferredControllers = componentData.controllers || {};
+        for (const origCtrl of origControllers) {
+          const ctrlName = (origCtrl as any).name;
+          if (ctrlName && (origCtrl as any).actions) {
+            const inferredCtrl = inferredControllers[ctrlName];
+            if (inferredCtrl) {
+              inferredCtrl.actions = { ...(inferredCtrl.actions || {}), ...(origCtrl as any).actions };
+            }
+          }
+        }
+
+        // Merge service operation steps from original spec into inferred services
+        // Inference generates service shells with preconditions/returns but drops
+        // the declarative steps arrays — we restore them from the parsed AST.
+        const origServices = Array.isArray((origComponent as any).services)
+          ? (origComponent as any).services
+          : Object.values((origComponent as any).services || {});
+        const inferredServices = componentData.services || {};
+        for (const origSvc of origServices) {
+          const svcName = (origSvc as any).name;
+          if (!svcName) continue;
+          const inferredSvc = inferredServices[svcName];
+          if (!inferredSvc) continue;
+
+          const origOps = (origSvc as any).operations || {};
+          const inferredOps = inferredSvc.operations || {};
+          for (const [opName, origOp] of Object.entries(origOps) as [string, any][]) {
+            if (inferredOps[opName] && origOp.steps) {
+              inferredOps[opName].steps = origOp.steps;
+            }
+          }
+        }
+
         // Inject key as name into entity maps, and expand convention-format attributes
         // Iterate all object-valued sections (not hardcoded — covers any entity type)
         const entitySections = Object.keys(componentData).filter(k =>
@@ -348,7 +394,7 @@ import type { ParserEngine, InferenceEngine, RealizeEngine } from '@specverse/ty
         if (!realizeEngine) { console.error('No realize engine found.'); process.exit(1); }
         await realizeEngine.initialize({ manifestPath: effectiveManifestPath, workingDir: (process.env.SPECVERSE_USER_CWD || process.cwd()) });
 
-        const outputDir = options.output || resolve((process.env.SPECVERSE_USER_CWD || process.cwd()), 'generated/code');
+        const outputDir = resolve((process.env.SPECVERSE_USER_CWD || process.cwd()), options.output || 'generated/code');
         console.log('Realizing ' + type + ' from ' + file + '...');
         await (realizeEngine as any).realizeAll(inferredSpec, outputDir);
 
@@ -826,10 +872,12 @@ import { EngineRegistry } from '@specverse/entities';`,
     imports: ``,
     handler: `const { SessionManager } = await import('@specverse/engines/ai');
         const manager = new SessionManager();
-        const job = await manager.submit(sessionId, requirements, {
-          jobId: options.jobId,
-          outputPath: options.output,
-          operation: options.operation,
+        const job = await manager.submit({
+          jobId: options.jobId || ('job-' + Date.now()),
+          sessionId,
+          operation: (options.operation || 'create') as 'create' | 'analyse' | 'materialise' | 'realize',
+          requirements,
+          output: options.output,
         });
         console.log('Job submitted: ' + job.jobId);
         console.log('Status: ' + job.status);
@@ -845,8 +893,10 @@ import { EngineRegistry } from '@specverse/entities';`,
         } else {
           console.log('ID: ' + (status.sessionId || status.jobId));
           console.log('Status: ' + status.status);
-          if (status.created) console.log('Created: ' + new Date(status.created).toLocaleString());
-          if (status.jobsProcessed !== undefined) console.log('Jobs: ' + status.jobsProcessed);
+          if (status.submitted) console.log('Submitted: ' + new Date(status.submitted).toLocaleString());
+          if (status.started) console.log('Started: ' + new Date(status.started).toLocaleString());
+          if (status.completed) console.log('Completed: ' + new Date(status.completed).toLocaleString());
+          if (status.duration) console.log('Duration: ' + status.duration);
         }`
   },
   'session.process': {
@@ -854,7 +904,7 @@ import { EngineRegistry } from '@specverse/entities';`,
     handler: `const { SessionManager } = await import('@specverse/engines/ai');
         const manager = new SessionManager();
         console.log('Processing job: ' + jobId);
-        await manager.process(jobId);
+        await manager.processJob(jobId);
         console.log('Job processed successfully');`
   },
 };
@@ -879,11 +929,15 @@ function generateLeafCommand(
       : `console.log('Executing ${name}...');
       // TODO: Wire to service`;
 
-  return `const cmd = program
+  // Rename unused action params with underscore prefix so tsc's
+  // noUnusedParameters doesn't flag them.
+  const finalActionParams = renameUnusedActionParams(actionParams, handler);
+
+  return `program
     .command('${commandStr}')
     .description('${description}')
 ${optionDefs.join('\n')}
-    .action(async (${actionParams}) => {
+    .action(async (${finalActionParams}) => {
       try {
         ${handler}
       } catch (error: any) {
@@ -893,6 +947,35 @@ ${optionDefs.join('\n')}
     });`;
 }
 
+/**
+ * Commander's `.option()` default value parameter is typed as
+ * `string | boolean | string[] | undefined`. Numeric defaults from the spec
+ * need to be stringified unless the option is a boolean flag.
+ */
+function commanderDefault(value: unknown, flagType?: string): string {
+  if (flagType === 'boolean') return JSON.stringify(Boolean(value));
+  if (typeof value === 'number') return JSON.stringify(String(value));
+  return JSON.stringify(value);
+}
+
+/**
+ * Rename each action parameter with a leading underscore if its name isn't
+ * referenced in the handler body.
+ */
+function renameUnusedActionParams(actionParams: string, handler: string): string {
+  if (!actionParams.trim()) return actionParams;
+  return actionParams.split(',').map(param => {
+    const trimmed = param.trim();
+    const nameMatch = trimmed.match(/^(\w+)/);
+    if (!nameMatch) return param;
+    const name = nameMatch[1];
+    if (name.startsWith('_')) return param;
+    const re = new RegExp(`\\b${name}\\b`);
+    if (re.test(handler)) return param;
+    return param.replace(new RegExp(`\\b${name}\\b`), `_${name}`);
+  }).join(', ');
+}
+
 function generateCommandWithSubcommands(
   name: string,
   description: string,
@@ -915,7 +998,7 @@ function generateCommandWithSubcommands(
       const alias = flag.alias ? `${flag.alias}, ` : '';
       const flagType = flag.type?.toLowerCase();
       const valuePart = flagType === 'boolean' ? '' : ` <${flagName.replace(/^--/, '')}>`;
-      const defaultVal = flag.default !== undefined ? `, ${JSON.stringify(flag.default)}` : '';
+      const defaultVal = flag.default !== undefined ? `, ${commanderDefault(flag.default, flagType)}` : '';
       return `    .option('${alias}${flagName}${valuePart}', '${flag.description || flagName}'${defaultVal})`;
     });
 
@@ -935,12 +1018,14 @@ function generateCommandWithSubcommands(
       ? engineHandler.handler
       : `console.log('${name} ${subName}: not yet implemented via engine');`;
 
+    const finalSubActionParams = renameUnusedActionParams(subActionParams, handler);
+
     return `
   cmd
     .command('${subCmdStr}')
     .description('${subDesc}')
 ${subOptionDefs.join('\n')}
-    .action(async (${subActionParams}) => {
+    .action(async (${finalSubActionParams}) => {
       try {
         ${handler}
       } catch (error: any) {
@@ -989,11 +1074,16 @@ function capitalize(str: string): string {
  * Deduplicate import statements across multiple handler import blocks.
  * Merges named imports from the same module and removes exact duplicates.
  */
-function deduplicateImports(importBlocks: string[]): string {
+function deduplicateImports(importBlocks: string[], usedIn?: string): string {
   const seen = new Map<string, Set<string>>(); // module -> set of named imports
   const typeImports = new Map<string, Set<string>>(); // module -> set of type imports
   const rawLines = new Set<string>(); // non-mergeable lines
 
+  const isUsed = (name: string): boolean => {
+    if (!usedIn) return true;
+    return new RegExp(`\\b${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`).test(usedIn);
+  };
+
   for (const block of importBlocks) {
     for (const line of block.split('\n').map(l => l.trim()).filter(l => l)) {
       // Match: import { X, Y } from 'module';
@@ -1020,12 +1110,15 @@ function deduplicateImports(importBlocks: string[]): string {
 
   const result: string[] = [];
   for (const [mod, names] of seen.entries()) {
-    result.push(`import { ${[...names].join(', ')} } from '${mod}';`);
+    const used = [...names].filter(isUsed);
+    if (used.length > 0) {
+      result.push(`import { ${used.join(', ')} } from '${mod}';`);
+    }
   }
   for (const [mod, names] of typeImports.entries()) {
     // Remove type imports that are already in regular imports
     const regularNames = seen.get(mod) || new Set();
-    const typeOnly = [...names].filter(n => !regularNames.has(n));
+    const typeOnly = [...names].filter(n => !regularNames.has(n)).filter(isUsed);
     if (typeOnly.length > 0) {
       result.push(`import type { ${typeOnly.join(', ')} } from '${mod}';`);
     }

package/libs/instance-factories/communication/event-emitter.yaml

@@ -1,12 +1,12 @@
 name: EventEmitter
-version: "1.0.0"
+version: "2.0.0"
 category: communication
-description: "In-memory event bus using Node.js EventEmitter for development and testing"
+description: "Typed in-memory event bus with WebSocket bridge for real-time frontend updates"
 
 metadata:
   author: "SpecVerse Team"
   license: "MIT"
-  tags: [events, in-memory, pubsub, eventemitter, development]
+  tags: [events, in-memory, pubsub, websocket, eventemitter, development]
 
 compatibility:
   specverse: ">=3.3.0"
@@ -17,6 +17,7 @@ capabilities:
     - "messaging.pubsub"
     - "messaging.events"
     - "messaging.inmemory"
+    - "messaging.websocket"
   requires: []
 
 technology:
@@ -29,28 +30,31 @@ dependencies:
   runtime:
     - name: "eventemitter3"
       version: "^5.0.0"
+    - name: "@fastify/websocket"
+      version: "^11.0.0"
 
   dev:
     - name: "typescript"
       version: "^5.2.0"
 
 codeTemplates:
-  bus:
+  types:
     engine: typescript
-    generator: "libs/instance-factories/communication/templates/eventemitter/bus-generator.ts"
-    outputPattern: "src/events/eventBus.ts"
+    generator: "libs/instance-factories/communication/templates/eventemitter/types-generator.ts"
+    outputPattern: "{backendDir}/src/events/event-types.ts"
 
-  publisher:
+  bus:
     engine: typescript
-    generator: "libs/instance-factories/communication/templates/eventemitter/publisher-generator.ts"
-    outputPattern: "src/events/publishers/{event}Publisher.ts"
+    generator: "libs/instance-factories/communication/templates/eventemitter/bus-generator.ts"
+    outputPattern: "{backendDir}/src/events/eventBus.ts"
 
-  subscriber:
+  websocket:
     engine: typescript
-    generator: "libs/instance-factories/communication/templates/eventemitter/subscriber-generator.ts"
-    outputPattern: "src/events/subscribers/{event}Subscriber.ts"
+    generator: "libs/instance-factories/communication/templates/eventemitter/websocket-bridge-generator.ts"
+    outputPattern: "{backendDir}/src/events/websocket-bridge.ts"
 
 configuration:
   maxListeners: 100
   captureRejections: true
   errorHandling: "log"
+  websocket: true

package/libs/instance-factories/communication/templates/eventemitter/bus-generator.ts

@@ -1,33 +1,36 @@
 /**
  * EventEmitter Bus Generator
  *
- * Generates in-memory event bus using EventEmitter3
+ * Generates typed in-memory event bus using EventEmitter3.
+ * Payload types imported from generated event-types.ts.
  */
 
 import type { TemplateContext } from '@specverse/types';
 
-/**
- * Generate EventEmitter bus singleton
- */
 export default function generateEventBus(context: TemplateContext): string {
   const { spec } = context;
-
-  const events = spec.events ? Object.keys(spec.events) : [];
+  const hasEvents = spec.events && Object.keys(spec.events).length > 0;
+  const models = spec.models ? Object.keys(spec.models) : [];
 
   return `/**
  * Event Bus
- * In-memory event bus using EventEmitter3
+ * Typed in-memory event bus using EventEmitter3
  * Generated from SpecVerse specification
  */
 
-import EventEmitter from 'eventemitter3';
+import { EventEmitter } from 'eventemitter3';
+${hasEvents || models.length > 0 ? `import type { EventPayloads } from './event-types.js';` : ''}
 
-// Event type definitions
-${events.map(event => `export type ${event}Payload = any; // TODO: Define payload type`).join('\n')}
+// Re-export types for consumers
+${hasEvents || models.length > 0 ? `export type { EventPayloads, EventName } from './event-types.js';` : ''}
 
-// Event names enum
-export enum EventName {
-${events.map(event => `  ${event} = '${event}',`).join('\n')}
+/**
+ * Event history entry
+ */
+interface EventHistoryEntry {
+  event: string;
+  payload: any;
+  timestamp: Date;
 }
 
 /**
@@ -35,15 +38,13 @@ ${events.map(event => `  ${event} = '${event}',`).join('\n')}
  */
 class EventBus extends EventEmitter {
   private static instance: EventBus;
+  private history: EventHistoryEntry[] = [];
+  private maxHistory = 1000;
 
   private constructor() {
     super();
-    this.setMaxListeners(100); // Configure max listeners
   }
 
-  /**
-   * Get singleton instance
-   */
   public static getInstance(): EventBus {
     if (!EventBus.instance) {
       EventBus.instance = new EventBus();
@@ -52,37 +53,33 @@ class EventBus extends EventEmitter {
   }
 
   /**
-   * Publish an event
+   * Publish a typed event
    */
-  public publish<T = any>(event: EventName | string, payload: T): void {
-    console.log(\`[EventBus] Publishing event: \${event}\`, payload);
+  public publish<K extends string>(event: K, payload: K extends keyof EventPayloads ? EventPayloads[K] : any): void {
+    this.history.push({ event, payload, timestamp: new Date() });
+    if (this.history.length > this.maxHistory) this.history.shift();
     this.emit(event, payload);
   }
 
   /**
-   * Subscribe to an event
+   * Subscribe to a typed event
    */
-  public subscribe<T = any>(
-    event: EventName | string,
-    handler: (payload: T) => void | Promise<void>
+  public subscribe<K extends string>(
+    event: K,
+    handler: (payload: K extends keyof EventPayloads ? EventPayloads[K] : any) => void | Promise<void>
   ): () => void {
-    console.log(\`[EventBus] Subscribing to event: \${event}\`);
     this.on(event, handler);
-
-    // Return unsubscribe function
-    return () => {
-      this.off(event, handler);
-    };
+    return () => { this.off(event, handler); };
   }
 
   /**
-   * Subscribe to an event (one-time)
+   * Get event history
    */
-  public subscribeOnce<T = any>(
-    event: EventName | string,
-    handler: (payload: T) => void | Promise<void>
-  ): void {
-    this.once(event, handler);
+  public getHistory(eventName?: string, limit = 50): EventHistoryEntry[] {
+    const filtered = eventName
+      ? this.history.filter(e => e.event === eventName)
+      : this.history;
+    return filtered.slice(-limit);
   }
 }
 

package/libs/instance-factories/communication/templates/eventemitter/types-generator.ts

@@ -0,0 +1,95 @@
+/**
+ * Event Types Generator
+ *
+ * Generates typed event payload interfaces from spec event definitions.
+ * Replaces the `any` payload types in the bus generator with real types.
+ */
+
+import type { TemplateContext } from '@specverse/types';
+
+/** Map SpecVerse types to TypeScript types */
+function tsType(specType: string): string {
+  const map: Record<string, string> = {
+    String: 'string', Text: 'string', Email: 'string', URL: 'string',
+    Integer: 'number', Float: 'number', Number: 'number', Decimal: 'number', Money: 'number',
+    Boolean: 'boolean',
+    Date: 'string', DateTime: 'string', Timestamp: 'string',
+    UUID: 'string',
+    Object: 'Record<string, any>', Array: 'any[]',
+  };
+  return map[specType] || 'any';
+}
+
+export default function generateEventTypes(context: TemplateContext): string {
+  const { spec } = context;
+  const events = spec.events && typeof spec.events === 'object'
+    ? Object.entries(spec.events) : [];
+
+  if (events.length === 0) {
+    return `/**
+ * Event Types — no events defined in specification
+ */
+export type EventPayloads = Record<string, any>;
+`;
+  }
+
+  const interfaces: string[] = [];
+  const payloadMapEntries: string[] = [];
+
+  for (const [eventName, eventDef] of events) {
+    const def = eventDef as any;
+    const attrs = def.attributes || def.payload || {};
+
+    // Handle both array and object attribute formats
+    const attrEntries: Array<[string, any]> = Array.isArray(attrs)
+      ? attrs.map((a: any) => [a.name, a])
+      : Object.entries(attrs);
+
+    const fields = attrEntries.map(([name, attrDef]) => {
+      const type = typeof attrDef === 'string'
+        ? tsType(attrDef.split(' ')[0])
+        : tsType(attrDef?.type || 'String');
+      const required = typeof attrDef === 'string'
+        ? attrDef.includes('required')
+        : attrDef?.required;
+      return `  ${name}${required ? '' : '?'}: ${type};`;
+    });
+
+    interfaces.push(`export interface ${eventName}Payload {
+${fields.join('\n')}
+}`);
+
+    payloadMapEntries.push(`  ${eventName}: ${eventName}Payload;`);
+  }
+
+  // Also add standard CURED events for each model
+  const models = spec.models ? Object.keys(spec.models) : [];
+  for (const model of models) {
+    for (const suffix of ['Created', 'Updated', 'Deleted', 'Evolved']) {
+      const name = `${model}${suffix}`;
+      if (!payloadMapEntries.some(e => e.includes(name))) {
+        payloadMapEntries.push(`  ${name}: { id: string; timestamp: string; [key: string]: any };`);
+      }
+    }
+  }
+
+  return `/**
+ * Event Payload Types
+ * Generated from SpecVerse specification
+ */
+
+${interfaces.join('\n\n')}
+
+/**
+ * Map of all event names to their payload types
+ */
+export type EventPayloads = {
+${payloadMapEntries.join('\n')}
+};
+
+/**
+ * All known event names
+ */
+export type EventName = keyof EventPayloads;
+`;
+}

package/libs/instance-factories/communication/templates/eventemitter/websocket-bridge-generator.ts

@@ -0,0 +1,105 @@
+/**
+ * WebSocket Bridge Generator
+ *
+ * Generates a WebSocket server that bridges the event bus to frontend clients.
+ * Clients can subscribe to specific events and receive real-time updates.
+ */
+
+import type { TemplateContext } from '@specverse/types';
+
+export default function generateWebSocketBridge(context: TemplateContext): string {
+  const { spec } = context;
+  const models = spec.models ? Object.keys(spec.models) : [];
+
+  // Build list of all events the bridge should forward
+  const specEvents = spec.events ? Object.keys(spec.events) : [];
+  const curedEvents = models.flatMap(m =>
+    ['Created', 'Updated', 'Deleted', 'Evolved'].map(s => `${m}${s}`)
+  );
+  const allEvents = [...new Set([...specEvents, ...curedEvents])];
+
+  return `/**
+ * WebSocket Bridge
+ * Bridges the event bus to frontend clients for real-time updates.
+ * Generated from SpecVerse specification
+ */
+
+import type { FastifyInstance } from 'fastify';
+import type { WebSocket } from '@fastify/websocket';
+import { eventBus } from './eventBus.js';
+
+interface ClientSubscription {
+  ws: WebSocket;
+  events: Set<string>;
+}
+
+const clients = new Map<WebSocket, ClientSubscription>();
+
+// All events this bridge knows about
+const ALL_EVENTS = ${JSON.stringify(allEvents, null, 2)};
+
+/**
+ * Register WebSocket bridge with Fastify
+ */
+export async function registerWebSocketBridge(fastify: FastifyInstance): Promise<void> {
+  // Register @fastify/websocket plugin
+  const websocketPlugin = await import('@fastify/websocket');
+  await fastify.register(websocketPlugin.default || websocketPlugin);
+
+  // WebSocket route
+  fastify.get('/ws', { websocket: true }, (socket: WebSocket) => {
+    const subscription: ClientSubscription = { ws: socket, events: new Set() };
+    clients.set(socket, subscription);
+
+    socket.on('message', (raw: Buffer) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+
+        if (msg.type === 'subscribe' && msg.event) {
+          subscription.events.add(msg.event);
+          socket.send(JSON.stringify({ type: 'subscribed', event: msg.event }));
+        }
+
+        if (msg.type === 'unsubscribe' && msg.event) {
+          subscription.events.delete(msg.event);
+          socket.send(JSON.stringify({ type: 'unsubscribed', event: msg.event }));
+        }
+
+        if (msg.type === 'subscribe-all') {
+          ALL_EVENTS.forEach(e => subscription.events.add(e));
+          socket.send(JSON.stringify({ type: 'subscribed-all', events: ALL_EVENTS }));
+        }
+      } catch { /* ignore malformed messages */ }
+    });
+
+    socket.on('close', () => {
+      clients.delete(socket);
+    });
+
+    // Send initial connection confirmation
+    socket.send(JSON.stringify({
+      type: 'connected',
+      availableEvents: ALL_EVENTS,
+    }));
+  });
+
+  // Subscribe to all events and broadcast to interested clients
+  for (const eventName of ALL_EVENTS) {
+    eventBus.subscribe(eventName, (payload: any) => {
+      const message = JSON.stringify({
+        type: 'event',
+        event: eventName,
+        payload,
+        timestamp: new Date().toISOString(),
+      });
+
+      for (const [ws, sub] of clients) {
+        if (sub.events.has(eventName) && ws.readyState === 1) {
+          try { ws.send(message); } catch { /* client disconnected */ }
+        }
+      }
+    });
+  }
+}
+`;
+}