@hotmeshio/hotmesh 0.10.2 → 0.11.0

package/build/services/stream/providers/postgres/messages.js

@@ -8,11 +8,10 @@ const utils_1 = require("../../../../modules/utils");
  * When a transaction is provided, the SQL is added to the transaction
  * and executed atomically with other operations.
  */
-async function publishMessages(client, tableName, streamName, messages, options, logger) {
-    const { sql, params } = buildPublishSQL(tableName, streamName, messages, options);
+async function publishMessages(client, tableName, streamName, isEngine, messages, options, logger) {
+    const { sql, params } = buildPublishSQL(tableName, streamName, isEngine, messages, options);
     if (options?.transaction &&
         typeof options.transaction.addCommand === 'function') {
-        // Add to transaction and return the transaction object
         options.transaction.addCommand(sql, params, 'array', (rows) => rows.map((row) => row.id.toString()));
         return options.transaction;
     }
@@ -36,11 +35,11 @@ async function publishMessages(client, tableName, streamName, messages, options,
 exports.publishMessages = publishMessages;
 /**
  * Build SQL for publishing messages with retry policies and visibility delays.
- * Optimizes the INSERT statement based on whether retry config is present.
+ * Routes to engine_streams or worker_streams based on isEngine flag.
+ * Worker messages include a workflow_name column extracted from metadata.wfn.
  */
-function buildPublishSQL(tableName, streamName, messages, options) {
-    const groupName = streamName.endsWith(':') ? 'ENGINE' : 'WORKER';
-    // Parse messages to extract retry config and visibility options
+function buildPublishSQL(tableName, streamName, isEngine, messages, options) {
+    // Parse messages to extract retry config, visibility options, and workflow name
     const parsedMessages = messages.map(msg => {
         const data = JSON.parse(msg);
         const retryConfig = data._streamRetryConfig;
@@ -50,6 +49,8 @@ function buildPublishSQL(tableName, streamName, messages, options) {
         delete data._streamRetryConfig;
         delete data._visibilityDelayMs;
         delete data._retryAttempt;
+        // Extract workflow name for worker streams
+        const workflowName = data.metadata?.wfn || '';
         // Determine if this message has explicit retry config
         const hasExplicitConfig = (retryConfig && 'max_retry_attempts' in retryConfig) || options?.retryPolicy;
         let normalizedPolicy = null;
@@ -69,63 +70,106 @@ function buildPublishSQL(tableName, streamName, messages, options) {
             retryPolicy: normalizedPolicy,
             visibilityDelayMs: visibilityDelayMs || 0,
             retryAttempt: retryAttempt || 0,
+            workflowName,
         };
     });
-    const params = [streamName, groupName];
+    const params = [streamName];
     let valuesClauses = [];
     let insertColumns;
-    // Check if ALL messages have explicit config or ALL don't
     const allHaveConfig = parsedMessages.every(pm => pm.hasExplicitConfig);
     const noneHaveConfig = parsedMessages.every(pm => !pm.hasExplicitConfig);
     const hasVisibilityDelays = parsedMessages.some(pm => pm.visibilityDelayMs > 0);
-    if (noneHaveConfig && !hasVisibilityDelays) {
-        // Omit retry columns entirely - let DB defaults apply
-        insertColumns = '(stream_name, group_name, message)';
-        parsedMessages.forEach((pm, idx) => {
-            const base = idx * 1;
-            valuesClauses.push(`($1, $2, $${base + 3})`);
-            params.push(pm.message);
-        });
-    }
-    else if (noneHaveConfig && hasVisibilityDelays) {
-        // Only visibility delays, no retry config
-        insertColumns = '(stream_name, group_name, message, visible_at, retry_attempt)';
-        parsedMessages.forEach((pm, idx) => {
-            const base = idx * 2;
-            if (pm.visibilityDelayMs > 0) {
-                const visibleAtSQL = `NOW() + INTERVAL '${pm.visibilityDelayMs} milliseconds'`;
-                valuesClauses.push(`($1, $2, $${base + 3}, ${visibleAtSQL}, $${base + 4})`);
-                params.push(pm.message, pm.retryAttempt);
-            }
-            else {
-                valuesClauses.push(`($1, $2, $${base + 3}, DEFAULT, $${base + 4})`);
-                params.push(pm.message, pm.retryAttempt);
-            }
-        });
+    if (isEngine) {
+        // Engine table: no group_name, no workflow_name
+        if (noneHaveConfig && !hasVisibilityDelays) {
+            insertColumns = '(stream_name, message)';
+            parsedMessages.forEach((pm, idx) => {
+                const base = idx * 1;
+                valuesClauses.push(`($1, $${base + 2})`);
+                params.push(pm.message);
+            });
+        }
+        else if (noneHaveConfig && hasVisibilityDelays) {
+            insertColumns = '(stream_name, message, visible_at, retry_attempt)';
+            parsedMessages.forEach((pm, idx) => {
+                const base = idx * 2;
+                if (pm.visibilityDelayMs > 0) {
+                    const visibleAtSQL = `NOW() + INTERVAL '${pm.visibilityDelayMs} milliseconds'`;
+                    valuesClauses.push(`($1, $${base + 2}, ${visibleAtSQL}, $${base + 3})`);
+                    params.push(pm.message, pm.retryAttempt);
+                }
+                else {
+                    valuesClauses.push(`($1, $${base + 2}, DEFAULT, $${base + 3})`);
+                    params.push(pm.message, pm.retryAttempt);
+                }
+            });
+        }
+        else {
+            insertColumns = '(stream_name, message, max_retry_attempts, backoff_coefficient, maximum_interval_seconds, visible_at, retry_attempt)';
+            parsedMessages.forEach((pm) => {
+                const visibleAtClause = pm.visibilityDelayMs > 0
+                    ? `NOW() + INTERVAL '${pm.visibilityDelayMs} milliseconds'`
+                    : 'DEFAULT';
+                if (pm.hasExplicitConfig) {
+                    const paramOffset = params.length + 1;
+                    valuesClauses.push(`($1, $${paramOffset}, $${paramOffset + 1}, $${paramOffset + 2}, $${paramOffset + 3}, ${visibleAtClause}, $${paramOffset + 4})`);
+                    params.push(pm.message, pm.retryPolicy.max_retry_attempts, pm.retryPolicy.backoff_coefficient, pm.retryPolicy.maximum_interval_seconds, pm.retryAttempt);
+                }
+                else {
+                    const paramOffset = params.length + 1;
+                    valuesClauses.push(`($1, $${paramOffset}, DEFAULT, DEFAULT, DEFAULT, ${visibleAtClause}, $${paramOffset + 1})`);
+                    params.push(pm.message, pm.retryAttempt);
+                }
+            });
+        }
     }
     else {
-        // Include retry columns and optionally visibility
-        insertColumns = '(stream_name, group_name, message, max_retry_attempts, backoff_coefficient, maximum_interval_seconds, visible_at, retry_attempt)';
-        parsedMessages.forEach((pm, idx) => {
-            const visibleAtClause = pm.visibilityDelayMs > 0
-                ? `NOW() + INTERVAL '${pm.visibilityDelayMs} milliseconds'`
-                : 'DEFAULT';
-            if (pm.hasExplicitConfig) {
-                const paramOffset = params.length + 1; // Current param count + 1 for next param
-                valuesClauses.push(`($1, $2, $${paramOffset}, $${paramOffset + 1}, $${paramOffset + 2}, $${paramOffset + 3}, ${visibleAtClause}, $${paramOffset + 4})`);
-                params.push(pm.message, pm.retryPolicy.max_retry_attempts, pm.retryPolicy.backoff_coefficient, pm.retryPolicy.maximum_interval_seconds, pm.retryAttempt);
-            }
-            else {
-                // This message doesn't have config but others do - use DEFAULT keyword
+        // Worker table: includes workflow_name, no group_name
+        if (noneHaveConfig && !hasVisibilityDelays) {
+            insertColumns = '(stream_name, workflow_name, message)';
+            parsedMessages.forEach((pm) => {
                 const paramOffset = params.length + 1;
-                valuesClauses.push(`($1, $2, $${paramOffset}, DEFAULT, DEFAULT, DEFAULT, ${visibleAtClause}, $${paramOffset + 1})`);
-                params.push(pm.message, pm.retryAttempt);
-            }
-        });
+                valuesClauses.push(`($1, $${paramOffset}, $${paramOffset + 1})`);
+                params.push(pm.workflowName, pm.message);
+            });
+        }
+        else if (noneHaveConfig && hasVisibilityDelays) {
+            insertColumns = '(stream_name, workflow_name, message, visible_at, retry_attempt)';
+            parsedMessages.forEach((pm) => {
+                const paramOffset = params.length + 1;
+                if (pm.visibilityDelayMs > 0) {
+                    const visibleAtSQL = `NOW() + INTERVAL '${pm.visibilityDelayMs} milliseconds'`;
+                    valuesClauses.push(`($1, $${paramOffset}, $${paramOffset + 1}, ${visibleAtSQL}, $${paramOffset + 2})`);
+                    params.push(pm.workflowName, pm.message, pm.retryAttempt);
+                }
+                else {
+                    valuesClauses.push(`($1, $${paramOffset}, $${paramOffset + 1}, DEFAULT, $${paramOffset + 2})`);
+                    params.push(pm.workflowName, pm.message, pm.retryAttempt);
+                }
+            });
+        }
+        else {
+            insertColumns = '(stream_name, workflow_name, message, max_retry_attempts, backoff_coefficient, maximum_interval_seconds, visible_at, retry_attempt)';
+            parsedMessages.forEach((pm) => {
+                const visibleAtClause = pm.visibilityDelayMs > 0
+                    ? `NOW() + INTERVAL '${pm.visibilityDelayMs} milliseconds'`
+                    : 'DEFAULT';
+                if (pm.hasExplicitConfig) {
+                    const paramOffset = params.length + 1;
+                    valuesClauses.push(`($1, $${paramOffset}, $${paramOffset + 1}, $${paramOffset + 2}, $${paramOffset + 3}, $${paramOffset + 4}, ${visibleAtClause}, $${paramOffset + 5})`);
+                    params.push(pm.workflowName, pm.message, pm.retryPolicy.max_retry_attempts, pm.retryPolicy.backoff_coefficient, pm.retryPolicy.maximum_interval_seconds, pm.retryAttempt);
+                }
+                else {
+                    const paramOffset = params.length + 1;
+                    valuesClauses.push(`($1, $${paramOffset}, $${paramOffset + 1}, DEFAULT, DEFAULT, DEFAULT, ${visibleAtClause}, $${paramOffset + 2})`);
+                    params.push(pm.workflowName, pm.message, pm.retryAttempt);
+                }
+            });
+        }
     }
     return {
         sql: `INSERT INTO ${tableName} ${insertColumns}
-      VALUES ${valuesClauses.join(', ')} 
+      VALUES ${valuesClauses.join(', ')}
       RETURNING id`,
         params,
     };
@@ -134,38 +178,39 @@ exports.buildPublishSQL = buildPublishSQL;
 /**
  * Fetch messages from the stream with optional exponential backoff.
  * Uses SKIP LOCKED for high-concurrency consumption.
+ * No group_name filter needed - the table itself determines engine vs worker.
  */
-async function fetchMessages(client, tableName, streamName, groupName, consumerName, options = {}, logger) {
+async function fetchMessages(client, tableName, streamName, isEngine, consumerName, options = {}, logger) {
     const enableBackoff = options?.enableBackoff ?? false;
-    const initialBackoff = options?.initialBackoff ?? 100; // Default initial backoff: 100ms
-    const maxBackoff = options?.maxBackoff ?? 3000; // Default max backoff: 3 seconds
-    const maxRetries = options?.maxRetries ?? 3; // Set a finite default, e.g., 3 retries
+    const initialBackoff = options?.initialBackoff ?? 100;
+    const maxBackoff = options?.maxBackoff ?? 3000;
+    const maxRetries = options?.maxRetries ?? 3;
     let backoff = initialBackoff;
     let retries = 0;
+    // Include workflow_name in RETURNING for worker streams
+    const returningClause = isEngine
+        ? 'id, message, max_retry_attempts, backoff_coefficient, maximum_interval_seconds, retry_attempt'
+        : 'id, message, workflow_name, max_retry_attempts, backoff_coefficient, maximum_interval_seconds, retry_attempt';
     try {
         while (retries < maxRetries) {
             retries++;
             const batchSize = options?.batchSize || 1;
             const reservationTimeout = options?.reservationTimeout || 30;
-            // Simplified query for better performance - especially for notification-triggered fetches
-            const res = await client.query(`UPDATE ${tableName} 
-         SET reserved_at = NOW(), reserved_by = $4
+            const res = await client.query(`UPDATE ${tableName}
+         SET reserved_at = NOW(), reserved_by = $3
          WHERE id IN (
            SELECT id FROM ${tableName}
-           WHERE stream_name = $1 
-             AND group_name = $2
+           WHERE stream_name = $1
              AND (reserved_at IS NULL OR reserved_at < NOW() - INTERVAL '${reservationTimeout} seconds')
              AND expired_at IS NULL
              AND visible_at <= NOW()
            ORDER BY id
-           LIMIT $3
+           LIMIT $2
            FOR UPDATE SKIP LOCKED
          )
-         RETURNING id, message, max_retry_attempts, backoff_coefficient, maximum_interval_seconds, retry_attempt`, [streamName, groupName, batchSize, consumerName]);
+         RETURNING ${returningClause}`, [streamName, batchSize, consumerName]);
             const messages = res.rows.map((row) => {
                 const data = (0, utils_1.parseStreamMessage)(row.message);
-                // Inject retry policy only if not using default values
-                // Default values indicate old retry mechanism should be used (policies.retry)
                 const hasDefaultRetryPolicy = (row.max_retry_attempts === 3 || row.max_retry_attempts === 5) &&
                     parseFloat(row.backoff_coefficient) === 10 &&
                     row.maximum_interval_seconds === 120;
@@ -176,10 +221,15 @@ async function fetchMessages(client, tableName, streamName, groupName, consumerN
                         maximum_interval_seconds: row.maximum_interval_seconds,
                     };
                 }
-                // Inject retry_attempt from database
                 if (row.retry_attempt !== undefined && row.retry_attempt !== null) {
                     data._retryAttempt = row.retry_attempt;
                 }
+                // Inject workflow_name from DB column into metadata for dispatch routing
+                if (!isEngine && row.workflow_name) {
+                    if (data.metadata) {
+                        data.metadata.wfn = row.workflow_name;
+                    }
+                }
                 return {
                     id: row.id.toString(),
                     data,
@@ -193,11 +243,9 @@ async function fetchMessages(client, tableName, streamName, groupName, consumerN
             if (messages.length > 0 || !enableBackoff) {
                 return messages;
             }
-            // Apply backoff if enabled and no messages found
             await (0, utils_1.sleepFor)(backoff);
-            backoff = Math.min(backoff * 2, maxBackoff); // Exponential backoff
+            backoff = Math.min(backoff * 2, maxBackoff);
         }
-        // Return empty array if maxRetries is reached and still no messages
         return [];
     }
     catch (error) {
@@ -212,20 +260,19 @@ exports.fetchMessages = fetchMessages;
  * Acknowledge messages (no-op for PostgreSQL - uses soft delete pattern).
  */
 async function acknowledgeMessages(messageIds) {
-    // No-op for this implementation
     return messageIds.length;
 }
 exports.acknowledgeMessages = acknowledgeMessages;
 /**
  * Delete messages by soft-deleting them (setting expired_at).
+ * No group_name needed - stream_name + table is sufficient.
  */
-async function deleteMessages(client, tableName, streamName, groupName, messageIds, logger) {
+async function deleteMessages(client, tableName, streamName, messageIds, logger) {
     try {
         const ids = messageIds.map((id) => parseInt(id));
-        // Perform a soft delete by setting `expired_at` to the current timestamp
         await client.query(`UPDATE ${tableName}
        SET expired_at = NOW()
-       WHERE stream_name = $1 AND id = ANY($2::bigint[]) AND group_name = $3`, [streamName, ids, groupName]);
+       WHERE stream_name = $1 AND id = ANY($2::bigint[])`, [streamName, ids]);
         return messageIds.length;
     }
     catch (error) {
@@ -239,15 +286,14 @@ exports.deleteMessages = deleteMessages;
 /**
  * Acknowledge and delete messages in one operation.
  */
-async function ackAndDelete(client, tableName, streamName, groupName, messageIds, logger) {
-    return await deleteMessages(client, tableName, streamName, groupName, messageIds, logger);
+async function ackAndDelete(client, tableName, streamName, messageIds, logger) {
+    return await deleteMessages(client, tableName, streamName, messageIds, logger);
 }
 exports.ackAndDelete = ackAndDelete;
 /**
  * Retry messages (placeholder for future implementation).
  */
 async function retryMessages(streamName, groupName, options) {
-    // Implement retry logic if needed
     return [];
 }
 exports.retryMessages = retryMessages;

package/build/services/stream/providers/postgres/notifications.d.ts

@@ -5,6 +5,9 @@ import { ProviderClient } from '../../../../types/provider';
 /**
  * Manages PostgreSQL LISTEN/NOTIFY for stream message notifications.
  * Handles static state shared across all service instances using the same client.
+ *
+ * Channel naming uses table-type prefixes (eng_ / wrk_) instead of group_name,
+ * since engine_streams and worker_streams are separate tables.
  */
 export declare class NotificationManager<TService> {
     private client;
@@ -27,15 +30,16 @@ export declare class NotificationManager<TService> {
     startClientFallbackPoller(checkForMissedMessages: () => Promise<void>): void;
     /**
      * Check for missed messages (fallback polling).
-     * Handles errors gracefully to avoid noise during shutdown.
      */
     checkForMissedMessages(fetchMessages: (instance: TService, consumer: NotificationConsumer) => Promise<StreamMessage[]>): Promise<void>;
     /**
      * Handle incoming PostgreSQL notification.
+     * Channels use table-type prefixes: eng_ for engine, wrk_ for worker.
      */
     private handleNotification;
     /**
      * Set up notification consumer for a stream/group.
+     * Uses table-type channel naming (eng_ / wrk_).
      */
     setupNotificationConsumer(serviceInstance: TService, streamName: string, groupName: string, consumerName: string, callback: (messages: StreamMessage[]) => void): Promise<void>;
     /**
@@ -44,7 +48,6 @@ export declare class NotificationManager<TService> {
     stopNotificationConsumer(serviceInstance: TService, streamName: string, groupName: string): Promise<void>;
     /**
      * Clean up notification consumers for this instance.
-     * Stops fallback poller FIRST to prevent race conditions during shutdown.
      */
     cleanup(serviceInstance: TService): Promise<void>;
     /**

package/build/services/stream/providers/postgres/notifications.js

@@ -6,6 +6,9 @@ const kvtables_1 = require("./kvtables");
 /**
  * Manages PostgreSQL LISTEN/NOTIFY for stream message notifications.
  * Handles static state shared across all service instances using the same client.
+ *
+ * Channel naming uses table-type prefixes (eng_ / wrk_) instead of group_name,
+ * since engine_streams and worker_streams are separate tables.
  */
 class NotificationManager {
     constructor(client, getTableName, getFallbackInterval, logger) {
@@ -24,13 +27,10 @@ class NotificationManager {
         if (NotificationManager.clientNotificationHandlers.get(this.client)) {
             return;
         }
-        // Initialize notification consumer map for this client
         if (!NotificationManager.clientNotificationConsumers.has(this.client)) {
             NotificationManager.clientNotificationConsumers.set(this.client, new Map());
         }
-        // Set up the notification handler
         this.client.on('notification', this.notificationHandlerBound);
-        // Mark this client as having a notification handler
         NotificationManager.clientNotificationHandlers.set(this.client, true);
     }
     /**
@@ -50,7 +50,6 @@ class NotificationManager {
     }
     /**
      * Check for missed messages (fallback polling).
-     * Handles errors gracefully to avoid noise during shutdown.
      */
     async checkForMissedMessages(fetchMessages) {
         const now = Date.now();
@@ -67,10 +66,7 @@ class NotificationManager {
             }
         }
         catch (error) {
-            // Silently ignore errors during shutdown (client closed, etc.)
-            // Function might not exist in older schemas
             if (error.message?.includes('Client was closed')) {
-                // Client is shutting down, silently return
                 return;
             }
             this.logger.debug('postgres-stream-visibility-function-unavailable', {
@@ -82,7 +78,6 @@ class NotificationManager {
         if (!clientNotificationConsumers) {
             return;
         }
-        // Check consumers that haven't been checked recently
         for (const [consumerKey, instanceMap,] of clientNotificationConsumers.entries()) {
             for (const [instance, consumer] of instanceMap.entries()) {
                 if (consumer.isListening &&
@@ -100,9 +95,7 @@ class NotificationManager {
                         consumer.lastFallbackCheck = now;
                     }
                     catch (error) {
-                        // Silently ignore errors during shutdown
                         if (error.message?.includes('Client was closed')) {
-                            // Client is shutting down, stop checking this consumer
                             consumer.isListening = false;
                             return;
                         }
@@ -118,11 +111,12 @@ class NotificationManager {
     }
     /**
      * Handle incoming PostgreSQL notification.
+     * Channels use table-type prefixes: eng_ for engine, wrk_ for worker.
      */
     handleNotification(notification) {
         try {
-            // Only handle stream notifications
-            if (!notification.channel.startsWith('stream_')) {
+            // Only handle stream notifications (eng_ or wrk_ prefixed)
+            if (!notification.channel.startsWith('eng_') && !notification.channel.startsWith('wrk_')) {
                 this.logger.debug('postgres-stream-ignoring-sub-notification', {
                     channel: notification.channel,
                     payloadPreview: notification.payload.substring(0, 100),
@@ -133,14 +127,16 @@ class NotificationManager {
                 channel: notification.channel,
             });
             const payload = JSON.parse(notification.payload);
-            const { stream_name, group_name } = payload;
-            if (!stream_name || !group_name) {
+            const { stream_name, table_type } = payload;
+            if (!stream_name || !table_type) {
                 this.logger.warn('postgres-stream-invalid-notification', {
                     notification,
                 });
                 return;
             }
-            const consumerKey = this.getConsumerKey(stream_name, group_name);
+            // Derive groupName from table_type for consumer key lookup
+            const groupName = table_type === 'engine' ? 'ENGINE' : 'WORKER';
+            const consumerKey = this.getConsumerKey(stream_name, groupName);
             const clientNotificationConsumers = NotificationManager.clientNotificationConsumers.get(this.client);
             if (!clientNotificationConsumers) {
                 return;
@@ -149,7 +145,6 @@ class NotificationManager {
             if (!instanceMap) {
                 return;
             }
-            // Trigger immediate message fetch for all instances with this consumer
             for (const [instance, consumer] of instanceMap.entries()) {
                 if (consumer.isListening) {
                     const serviceInstance = instance;
@@ -168,11 +163,21 @@ class NotificationManager {
     }
     /**
      * Set up notification consumer for a stream/group.
+     * Uses table-type channel naming (eng_ / wrk_).
      */
     async setupNotificationConsumer(serviceInstance, streamName, groupName, consumerName, callback) {
         const startTime = Date.now();
-        const consumerKey = this.getConsumerKey(streamName, groupName);
-        const channelName = (0, kvtables_1.getNotificationChannelName)(streamName, groupName);
+        const isEngine = groupName === 'ENGINE';
+        // Resolve the stream name to get the simplified form for channel naming and consumer key
+        const serviceAny = serviceInstance;
+        let resolvedStreamName = streamName;
+        if (serviceAny.resolveStreamTarget) {
+            const target = serviceAny.resolveStreamTarget(streamName);
+            resolvedStreamName = target.streamName;
+        }
+        // Use resolved stream name for consumer key so it matches notification payloads
+        const consumerKey = this.getConsumerKey(resolvedStreamName, groupName);
+        const channelName = (0, kvtables_1.getNotificationChannelName)(resolvedStreamName, isEngine);
         // Get or create notification consumer map for this client
         let clientNotificationConsumers = NotificationManager.clientNotificationConsumers.get(this.client);
         if (!clientNotificationConsumers) {
@@ -202,7 +207,7 @@ class NotificationManager {
                     channelName,
                     error,
                 });
-                throw error; // Propagate error to caller
+                throw error;
             }
         }
         // Register consumer for this instance
@@ -215,7 +220,6 @@ class NotificationManager {
             lastFallbackCheck: Date.now(),
         };
         instanceMap.set(serviceInstance, consumer);
-        // Track this consumer for cleanup
         this.instanceNotificationConsumers.add(consumerKey);
         this.logger.debug('postgres-stream-notification-setup-complete', {
             streamName,
@@ -228,7 +232,14 @@ class NotificationManager {
      * Stop notification consumer for a stream/group.
      */
     async stopNotificationConsumer(serviceInstance, streamName, groupName) {
-        const consumerKey = this.getConsumerKey(streamName, groupName);
+        const isEngine = groupName === 'ENGINE';
+        const serviceAny = serviceInstance;
+        let resolvedStreamName = streamName;
+        if (serviceAny.resolveStreamTarget) {
+            const target = serviceAny.resolveStreamTarget(streamName);
+            resolvedStreamName = target.streamName;
+        }
+        const consumerKey = this.getConsumerKey(resolvedStreamName, groupName);
         const clientNotificationConsumers = NotificationManager.clientNotificationConsumers.get(this.client);
         if (!clientNotificationConsumers) {
             return;
@@ -241,12 +252,10 @@ class NotificationManager {
         if (consumer) {
             consumer.isListening = false;
             instanceMap.delete(serviceInstance);
-            // Remove from instance tracking
             this.instanceNotificationConsumers.delete(consumerKey);
-            // If no more instances for this consumer key, stop listening
             if (instanceMap.size === 0) {
                 clientNotificationConsumers.delete(consumerKey);
-                const channelName = (0, kvtables_1.getNotificationChannelName)(streamName, groupName);
+                const channelName = (0, kvtables_1.getNotificationChannelName)(resolvedStreamName, isEngine);
                 try {
                     await this.client.query(`UNLISTEN "${channelName}"`);
                     this.logger.debug('postgres-stream-unlisten', {
@@ -268,7 +277,6 @@ class NotificationManager {
     }
     /**
      * Clean up notification consumers for this instance.
-     * Stops fallback poller FIRST to prevent race conditions during shutdown.
      */
     async cleanup(serviceInstance) {
         const clientNotificationConsumers = NotificationManager.clientNotificationConsumers.get(this.client);
@@ -279,7 +287,6 @@ class NotificationManager {
             NotificationManager.clientFallbackPollers.delete(this.client);
         }
         if (clientNotificationConsumers) {
-            // Remove this instance from all consumer maps
             for (const consumerKey of this.instanceNotificationConsumers) {
                 const instanceMap = clientNotificationConsumers.get(consumerKey);
                 if (instanceMap) {
@@ -287,10 +294,13 @@ class NotificationManager {
                     if (consumer) {
                         consumer.isListening = false;
                         instanceMap.delete(serviceInstance);
-                        // If no more instances for this consumer, stop listening
                         if (instanceMap.size === 0) {
                             clientNotificationConsumers.delete(consumerKey);
-                            const channelName = (0, kvtables_1.getNotificationChannelName)(consumer.streamName, consumer.groupName);
+                            // Extract resolved stream name and isEngine from the consumer key
+                            // Consumer key format: resolvedStreamName:groupName
+                            const isEngine = consumer.groupName === 'ENGINE';
+                            const resolvedStreamName = consumerKey.substring(0, consumerKey.lastIndexOf(':'));
+                            const channelName = (0, kvtables_1.getNotificationChannelName)(resolvedStreamName, isEngine);
                             try {
                                 await this.client.query(`UNLISTEN "${channelName}"`);
                                 this.logger.debug('postgres-stream-cleanup-unlisten', {
@@ -300,7 +310,6 @@ class NotificationManager {
                                 });
                             }
                             catch (error) {
-                                // Silently ignore errors during shutdown
                                 if (!error.message?.includes('Client was closed')) {
                                     this.logger.error('postgres-stream-cleanup-unlisten-error', {
                                         streamName: consumer.streamName,
@@ -315,15 +324,10 @@ class NotificationManager {
                 }
             }
         }
-        // Clear instance tracking
         this.instanceNotificationConsumers.clear();
-        // If no more consumers exist for this client, clean up static resources
         if (clientNotificationConsumers && clientNotificationConsumers.size === 0) {
-            // Remove client from static maps
             NotificationManager.clientNotificationConsumers.delete(this.client);
             NotificationManager.clientNotificationHandlers.delete(this.client);
-            // Fallback poller already stopped above
-            // Remove notification handler
             if (this.client.removeAllListeners) {
                 this.client.removeAllListeners('notification');
             }
@@ -352,6 +356,6 @@ function getFallbackInterval(config) {
 }
 exports.getFallbackInterval = getFallbackInterval;
 function getNotificationTimeout(config) {
-    return config?.postgres?.notificationTimeout || 5000; // Default: 5 seconds
+    return config?.postgres?.notificationTimeout || 5000;
 }
 exports.getNotificationTimeout = getNotificationTimeout;