@hotmeshio/hotmesh 0.14.6 → 0.14.8

package/build/services/durable/worker.js

@@ -377,15 +377,13 @@ class WorkerService {
                     //use code 599 as a proxy for all retryable errors
                     // (basically anything not 596, 597, 598)
                     return {
-                        status: stream_1.StreamStatus.SUCCESS,
+                        status: stream_1.StreamStatus.ERROR,
                         code: 599,
                         metadata: { ...data.metadata },
                         data: {
-                            $error: {
-                                message: err.message,
-                                stack: err.stack,
-                                code: enums_1.HMSH_CODE_DURABLE_RETRYABLE,
-                            },
+                            message: err.message,
+                            stack: err.stack,
+                            code: enums_1.HMSH_CODE_DURABLE_RETRYABLE,
                         },
                     };
                 }
@@ -607,15 +605,13 @@ class WorkerService {
                     //use code 599 as a proxy for all retryable errors
                     // (basically anything not 596, 597, 598)
                     return {
-                        status: stream_1.StreamStatus.SUCCESS,
+                        status: stream_1.StreamStatus.ERROR,
                         code: enums_1.HMSH_CODE_DURABLE_RETRYABLE,
                         metadata: { ...data.metadata },
                         data: {
-                            $error: {
-                                message: err.message,
-                                stack: err.stack,
-                                timestamp: (0, utils_1.formatISODate)(new Date()),
-                            },
+                            message: err.message,
+                            stack: err.stack,
+                            code: enums_1.HMSH_CODE_DURABLE_RETRYABLE,
                         },
                     };
                 }
@@ -963,9 +959,24 @@ class WorkerService {
                     }, telemetry_3.SpanStatusCode.ERROR, err.message);
                 }
                 isProcessing = true;
+                const errorCode = err.code || new errors_1.DurableRetryError(err.message).code;
+                if (errorCode === enums_1.HMSH_CODE_DURABLE_RETRYABLE) {
+                    // Retryable errors use status: ERROR so the engine-level
+                    // retry mechanism (handleRetry + _streamRetryConfig) kicks in
+                    return withPatchMarkers({
+                        status: stream_1.StreamStatus.ERROR,
+                        code: errorCode,
+                        metadata: { ...data.metadata },
+                        data: {
+                            message: err.message,
+                            stack: err.stack,
+                            code: errorCode,
+                        },
+                    });
+                }
                 return withPatchMarkers({
                     status: stream_1.StreamStatus.SUCCESS,
-                    code: err.code || new errors_1.DurableRetryError(err.message).code,
+                    code: errorCode,
                     metadata: { ...data.metadata },
                     data: {
                         $error: {
@@ -973,7 +984,7 @@ class WorkerService {
                             type: err.name,
                             name: err.name,
                             stack: err.stack,
-                            code: err.code || new errors_1.DurableRetryError(err.message).code,
+                            code: errorCode,
                         },
                     },
                 });

package/build/services/router/config/index.d.ts

@@ -1,4 +1,4 @@
-import { HMSH_BLOCK_TIME_MS, HMSH_MAX_RETRIES, HMSH_MAX_TIMEOUT_MS, HMSH_GRADUATED_INTERVAL_MS, HMSH_CODE_UNACKED, HMSH_CODE_UNKNOWN, HMSH_STATUS_UNKNOWN, HMSH_XCLAIM_COUNT, HMSH_XCLAIM_DELAY_MS, HMSH_XPENDING_COUNT, HMSH_BATCH_SIZE, HMSH_RESERVATION_TIMEOUT_S, MAX_DELAY, MAX_STREAM_BACKOFF, INITIAL_STREAM_BACKOFF, MAX_STREAM_RETRIES, HMSH_POISON_MESSAGE_THRESHOLD } from '../../../modules/enums';
+import { HMSH_BLOCK_TIME_MS, HMSH_MAX_RETRIES, HMSH_MAX_TIMEOUT_MS, HMSH_GRADUATED_INTERVAL_MS, HMSH_CODE_UNACKED, HMSH_CODE_UNKNOWN, HMSH_STATUS_UNKNOWN, HMSH_XCLAIM_COUNT, HMSH_XCLAIM_DELAY_MS, HMSH_XPENDING_COUNT, HMSH_BATCH_SIZE, HMSH_BATCH_SIZE_MIN, HMSH_RESERVATION_TIMEOUT_S, HMSH_RESERVATION_TIMEOUT_MAX_S, MAX_DELAY, MAX_STREAM_BACKOFF, INITIAL_STREAM_BACKOFF, MAX_STREAM_RETRIES, HMSH_POISON_MESSAGE_THRESHOLD } from '../../../modules/enums';
 import { RouterConfig } from '../../../types/stream';
 export declare class RouterConfigManager {
     static validateThrottle(delayInMillis: number): void;
@@ -8,4 +8,4 @@ export declare class RouterConfigManager {
         readonly: boolean;
     };
 }
-export { HMSH_BLOCK_TIME_MS, HMSH_MAX_RETRIES, HMSH_MAX_TIMEOUT_MS, HMSH_GRADUATED_INTERVAL_MS, HMSH_CODE_UNACKED, HMSH_CODE_UNKNOWN, HMSH_STATUS_UNKNOWN, HMSH_XCLAIM_COUNT, HMSH_XCLAIM_DELAY_MS, HMSH_XPENDING_COUNT, HMSH_BATCH_SIZE, HMSH_RESERVATION_TIMEOUT_S, MAX_DELAY, MAX_STREAM_BACKOFF, INITIAL_STREAM_BACKOFF, MAX_STREAM_RETRIES, HMSH_POISON_MESSAGE_THRESHOLD, };
+export { HMSH_BLOCK_TIME_MS, HMSH_MAX_RETRIES, HMSH_MAX_TIMEOUT_MS, HMSH_GRADUATED_INTERVAL_MS, HMSH_CODE_UNACKED, HMSH_CODE_UNKNOWN, HMSH_STATUS_UNKNOWN, HMSH_XCLAIM_COUNT, HMSH_XCLAIM_DELAY_MS, HMSH_XPENDING_COUNT, HMSH_BATCH_SIZE, HMSH_BATCH_SIZE_MIN, HMSH_RESERVATION_TIMEOUT_S, HMSH_RESERVATION_TIMEOUT_MAX_S, MAX_DELAY, MAX_STREAM_BACKOFF, INITIAL_STREAM_BACKOFF, MAX_STREAM_RETRIES, HMSH_POISON_MESSAGE_THRESHOLD, };

package/build/services/router/config/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HMSH_POISON_MESSAGE_THRESHOLD = exports.MAX_STREAM_RETRIES = exports.INITIAL_STREAM_BACKOFF = exports.MAX_STREAM_BACKOFF = exports.MAX_DELAY = exports.HMSH_RESERVATION_TIMEOUT_S = exports.HMSH_BATCH_SIZE = exports.HMSH_XPENDING_COUNT = exports.HMSH_XCLAIM_DELAY_MS = exports.HMSH_XCLAIM_COUNT = exports.HMSH_STATUS_UNKNOWN = exports.HMSH_CODE_UNKNOWN = exports.HMSH_CODE_UNACKED = exports.HMSH_GRADUATED_INTERVAL_MS = exports.HMSH_MAX_TIMEOUT_MS = exports.HMSH_MAX_RETRIES = exports.HMSH_BLOCK_TIME_MS = exports.RouterConfigManager = void 0;
+exports.HMSH_POISON_MESSAGE_THRESHOLD = exports.MAX_STREAM_RETRIES = exports.INITIAL_STREAM_BACKOFF = exports.MAX_STREAM_BACKOFF = exports.MAX_DELAY = exports.HMSH_RESERVATION_TIMEOUT_MAX_S = exports.HMSH_RESERVATION_TIMEOUT_S = exports.HMSH_BATCH_SIZE_MIN = exports.HMSH_BATCH_SIZE = exports.HMSH_XPENDING_COUNT = exports.HMSH_XCLAIM_DELAY_MS = exports.HMSH_XCLAIM_COUNT = exports.HMSH_STATUS_UNKNOWN = exports.HMSH_CODE_UNKNOWN = exports.HMSH_CODE_UNACKED = exports.HMSH_GRADUATED_INTERVAL_MS = exports.HMSH_MAX_TIMEOUT_MS = exports.HMSH_MAX_RETRIES = exports.HMSH_BLOCK_TIME_MS = exports.RouterConfigManager = void 0;
 const enums_1 = require("../../../modules/enums");
 Object.defineProperty(exports, "HMSH_BLOCK_TIME_MS", { enumerable: true, get: function () { return enums_1.HMSH_BLOCK_TIME_MS; } });
 Object.defineProperty(exports, "HMSH_MAX_RETRIES", { enumerable: true, get: function () { return enums_1.HMSH_MAX_RETRIES; } });
@@ -13,7 +13,9 @@ Object.defineProperty(exports, "HMSH_XCLAIM_COUNT", { enumerable: true, get: fun
 Object.defineProperty(exports, "HMSH_XCLAIM_DELAY_MS", { enumerable: true, get: function () { return enums_1.HMSH_XCLAIM_DELAY_MS; } });
 Object.defineProperty(exports, "HMSH_XPENDING_COUNT", { enumerable: true, get: function () { return enums_1.HMSH_XPENDING_COUNT; } });
 Object.defineProperty(exports, "HMSH_BATCH_SIZE", { enumerable: true, get: function () { return enums_1.HMSH_BATCH_SIZE; } });
+Object.defineProperty(exports, "HMSH_BATCH_SIZE_MIN", { enumerable: true, get: function () { return enums_1.HMSH_BATCH_SIZE_MIN; } });
 Object.defineProperty(exports, "HMSH_RESERVATION_TIMEOUT_S", { enumerable: true, get: function () { return enums_1.HMSH_RESERVATION_TIMEOUT_S; } });
+Object.defineProperty(exports, "HMSH_RESERVATION_TIMEOUT_MAX_S", { enumerable: true, get: function () { return enums_1.HMSH_RESERVATION_TIMEOUT_MAX_S; } });
 Object.defineProperty(exports, "MAX_DELAY", { enumerable: true, get: function () { return enums_1.MAX_DELAY; } });
 Object.defineProperty(exports, "MAX_STREAM_BACKOFF", { enumerable: true, get: function () { return enums_1.MAX_STREAM_BACKOFF; } });
 Object.defineProperty(exports, "INITIAL_STREAM_BACKOFF", { enumerable: true, get: function () { return enums_1.INITIAL_STREAM_BACKOFF; } });

package/build/services/router/consumption/index.d.ts

@@ -27,19 +27,20 @@ export declare class ConsumptionManager<S extends StreamService<ProviderClient,
     private router;
     private retry;
     private adaptiveReservationTimeout;
+    private adaptiveBatchSize;
     private lastDepthCheckAt;
     private static readonly DEPTH_CHECK_INTERVAL_MS;
     private static readonly DEPTH_SCALE_UP_THRESHOLD;
     private static readonly DEPTH_SCALE_DOWN_THRESHOLD;
-    private static readonly RESERVATION_TIMEOUT_MAX_S;
     constructor(stream: S, logger: ILogger, throttleManager: ThrottleManager, errorHandler: ErrorHandler, lifecycleManager: LifecycleManager<S>, reclaimDelay: number, reclaimCount: number, appId: string, role: any, router: any, retry?: import('../../../types/stream').RetryPolicy);
     /**
      * Adjusts reservation timeout based on stream depth. Called periodically
-     * from the consume loop. When depth is high, messages take longer to
-     * process, so the reservation window must grow to prevent re-delivery.
-     * When depth drops, the timeout shrinks back toward the configured default.
+     * from the consume loop. When depth is high:
+     *   - reservation timeout grows (prevents duplicate re-reservation)
+     *   - batch size shrinks (reduces in-memory blocking, shares the stream)
+     * When depth drops, both restore toward configured defaults.
      */
-    private adjustReservationTimeout;
+    private adjustConsumptionPressure;
     createGroup(stream: string, group: string): Promise<void>;
     publishMessage(topic: string, streamData: StreamData | StreamDataResponse, transaction?: ProviderTransaction): Promise<string | ProviderTransaction>;
     consumeMessages(stream: string, group: string, consumer: string, callback: (streamData: StreamData) => Promise<StreamDataResponse | void>): Promise<void>;

package/build/services/router/consumption/index.js

@@ -17,10 +17,13 @@ class ConsumptionManager {
     get hasReachedMaxBackoff() { return this.router.hasReachedMaxBackoff; }
     set hasReachedMaxBackoff(v) { this.router.hasReachedMaxBackoff = v; }
     constructor(stream, logger, throttleManager, errorHandler, lifecycleManager, reclaimDelay, reclaimCount, appId, role, router, retry) {
-        // Adaptive reservation timeout — scales with stream depth to prevent
-        // duplicate message delivery under load. When the stream backs up,
-        // processing takes longer, so the reservation window must grow.
+        // Adaptive consumption pressure — scales reservation timeout AND batch
+        // size based on stream depth. Under load: timeout grows (prevents
+        // duplicate re-reservation) and batch size shrinks (reduces in-memory
+        // blocking, lets other consumers share the stream). When idle, both
+        // restore toward configured defaults.
         this.adaptiveReservationTimeout = config_1.HMSH_RESERVATION_TIMEOUT_S;
+        this.adaptiveBatchSize = config_1.HMSH_BATCH_SIZE;
         this.lastDepthCheckAt = 0;
         this.stream = stream;
         this.logger = logger;
@@ -36,11 +39,12 @@ class ConsumptionManager {
     }
     /**
      * Adjusts reservation timeout based on stream depth. Called periodically
-     * from the consume loop. When depth is high, messages take longer to
-     * process, so the reservation window must grow to prevent re-delivery.
-     * When depth drops, the timeout shrinks back toward the configured default.
+     * from the consume loop. When depth is high:
+     *   - reservation timeout grows (prevents duplicate re-reservation)
+     *   - batch size shrinks (reduces in-memory blocking, shares the stream)
+     * When depth drops, both restore toward configured defaults.
      */
-    async adjustReservationTimeout(stream) {
+    async adjustConsumptionPressure(stream) {
         const now = Date.now();
         if (now - this.lastDepthCheckAt < ConsumptionManager.DEPTH_CHECK_INTERVAL_MS) {
             return;
@@ -48,27 +52,37 @@ class ConsumptionManager {
         this.lastDepthCheckAt = now;
         try {
             const depth = await this.stream.getStreamDepth(stream);
-            const prev = this.adaptiveReservationTimeout;
+            const prevTimeout = this.adaptiveReservationTimeout;
+            const prevBatch = this.adaptiveBatchSize;
             if (depth > ConsumptionManager.DEPTH_SCALE_UP_THRESHOLD) {
-                // Scale up: double the timeout, capped at max
-                this.adaptiveReservationTimeout = Math.min(this.adaptiveReservationTimeout * 2, ConsumptionManager.RESERVATION_TIMEOUT_MAX_S);
+                // Scale up timeout, scale down batch size
+                this.adaptiveReservationTimeout = Math.min(this.adaptiveReservationTimeout * 2, config_1.HMSH_RESERVATION_TIMEOUT_MAX_S);
+                this.adaptiveBatchSize = Math.max(Math.floor(this.adaptiveBatchSize / 2), config_1.HMSH_BATCH_SIZE_MIN);
             }
             else if (depth < ConsumptionManager.DEPTH_SCALE_DOWN_THRESHOLD) {
-                // Scale down: halve toward the configured default
+                // Scale down timeout, scale up batch size
                 this.adaptiveReservationTimeout = Math.max(Math.floor(this.adaptiveReservationTimeout / 2), config_1.HMSH_RESERVATION_TIMEOUT_S);
+                this.adaptiveBatchSize = Math.min(this.adaptiveBatchSize * 2, config_1.HMSH_BATCH_SIZE);
             }
-            if (this.adaptiveReservationTimeout !== prev) {
-                // Update the stream provider so notification-path fetches
-                // also use the adaptive timeout
+            if (this.adaptiveReservationTimeout !== prevTimeout) {
                 this.stream.reservationTimeout = this.adaptiveReservationTimeout;
                 this.logger.info('stream-reservation-timeout-adjusted', {
                     stream,
                     depth,
-                    previousTimeoutS: prev,
+                    previousTimeoutS: prevTimeout,
                     newTimeoutS: this.adaptiveReservationTimeout,
                     configuredDefaultS: config_1.HMSH_RESERVATION_TIMEOUT_S,
                 });
             }
+            if (this.adaptiveBatchSize !== prevBatch) {
+                this.logger.info('stream-batch-size-adjusted', {
+                    stream,
+                    depth,
+                    previousBatchSize: prevBatch,
+                    newBatchSize: this.adaptiveBatchSize,
+                    configuredDefaultBatchSize: config_1.HMSH_BATCH_SIZE,
+                });
+            }
         }
         catch {
             // Stream depth check is best-effort; don't fail the consume loop
@@ -153,7 +167,7 @@ class ConsumptionManager {
                 return;
             }
             // Adapt reservation timeout based on stream depth
-            await this.adjustReservationTimeout(stream);
+            await this.adjustConsumptionPressure(stream);
             await this.throttleManager.customSleep(); // respect throttle
             if (this.lifecycleManager.isStopped(group, consumer, stream) ||
                 this.throttleManager.isPaused()) {
@@ -274,12 +288,12 @@ class ConsumptionManager {
             try {
                 let messages = [];
                 // Adapt reservation timeout based on stream depth
-                await this.adjustReservationTimeout(stream);
+                await this.adjustConsumptionPressure(stream);
                 if (!this.hasReachedMaxBackoff) {
                     // Normal mode: try with backoff and finite retries
                     const features = this.stream.getProviderSpecificFeatures();
                     const isPostgres = features.supportsParallelProcessing;
-                    const batchSize = isPostgres ? config_1.HMSH_BATCH_SIZE : 1;
+                    const batchSize = isPostgres ? this.adaptiveBatchSize : 1;
                     messages = await this.stream.consumeMessages(stream, group, consumer, {
                         blockTimeout: streamDuration,
                         batchSize,
@@ -294,7 +308,7 @@ class ConsumptionManager {
                     // Fallback mode: just try once, no backoff
                     const features = this.stream.getProviderSpecificFeatures();
                     const isPostgres = features.supportsParallelProcessing;
-                    const batchSize = isPostgres ? config_1.HMSH_BATCH_SIZE : 1;
+                    const batchSize = isPostgres ? this.adaptiveBatchSize : 1;
                     messages = await this.stream.consumeMessages(stream, group, consumer, {
                         blockTimeout: streamDuration,
                         batchSize,
@@ -571,14 +585,23 @@ class ConsumptionManager {
                 // Extract retry policy with priority:
                 // 1. Use message-level _streamRetryConfig (from database columns or previous retry)
                 // 2. Fall back to router-level retry (from worker config)
-                const retry = input._streamRetryConfig
+                const streamRetryConfig = input._streamRetryConfig;
+                const retry = streamRetryConfig
                     ? {
-                        maximumAttempts: input._streamRetryConfig.max_retry_attempts,
-                        backoffCoefficient: input._streamRetryConfig.backoff_coefficient,
-                        maximumInterval: input._streamRetryConfig.maximum_interval_seconds,
+                        maximumAttempts: streamRetryConfig.max_retry_attempts,
+                        backoffCoefficient: streamRetryConfig.backoff_coefficient,
+                        maximumInterval: streamRetryConfig.maximum_interval_seconds,
+                        initialInterval: streamRetryConfig.initialInterval ?? input.data?.initialInterval ?? 1,
                     }
                     : this.retry;
-                return await this.errorHandler.handleRetry(input, output, this.publishMessage.bind(this), retry);
+                return await this.errorHandler.handleRetry(input, output, this.publishMessage.bind(this), retry, (topic, delayMs) => {
+                    // Schedule a targeted NOTIFY so the consumer wakes up
+                    // when the visibility-delayed retry message becomes visible
+                    if (typeof this.stream.scheduleStreamNotify === 'function') {
+                        const streamKey = this.stream.mintKey(key_1.KeyType.STREAMS, { topic });
+                        this.stream.scheduleStreamNotify(streamKey, delayMs);
+                    }
+                });
             }
             else if (typeof output.metadata !== 'object') {
                 output.metadata = { ...input.metadata, guid: (0, utils_1.guid)() };
@@ -597,5 +620,4 @@ class ConsumptionManager {
 ConsumptionManager.DEPTH_CHECK_INTERVAL_MS = 10000;
 ConsumptionManager.DEPTH_SCALE_UP_THRESHOLD = 100;
 ConsumptionManager.DEPTH_SCALE_DOWN_THRESHOLD = 10;
-ConsumptionManager.RESERVATION_TIMEOUT_MAX_S = 600;
 exports.ConsumptionManager = ConsumptionManager;

package/build/services/router/error-handling/index.d.ts

@@ -4,5 +4,5 @@ export declare class ErrorHandler {
     structureUnhandledError(input: StreamData, err: Error): StreamDataResponse;
     structureUnacknowledgedError(input: StreamData): StreamDataResponse;
     structureError(input: StreamData, output: StreamDataResponse): StreamDataResponse;
-    handleRetry(input: StreamData, output: StreamDataResponse, publishMessage: (topic: string, streamData: StreamData | StreamDataResponse) => Promise<string>, retry?: RetryPolicy): Promise<string>;
+    handleRetry(input: StreamData, output: StreamDataResponse, publishMessage: (topic: string, streamData: StreamData | StreamDataResponse) => Promise<string>, retry?: RetryPolicy, onRetryScheduled?: (topic: string, delayMs: number) => void): Promise<string>;
 }

package/build/services/router/error-handling/index.js

@@ -14,16 +14,11 @@ class ErrorHandler {
             const maxInterval = typeof retry.maximumInterval === 'string'
                 ? parseInt(retry.maximumInterval)
                 : (retry.maximumInterval || 120);
-            // Check if we can retry (next attempt would be attempt #tryCount+2, must be <= maxAttempts)
-            // tryCount=0 is 1st attempt, tryCount=1 is 2nd attempt, etc.
-            // So after tryCount, we've made (tryCount + 1) attempts
-            // We can retry if (tryCount + 1) < maxAttempts
+            const initialIntervalS = retry.initialInterval || 1;
             if ((tryCount + 1) < maxAttempts) {
-                // Exponential backoff: min(coefficient^(try+1), maxInterval)
-                // First retry (after try=0): coefficient^1
-                // Second retry (after try=1): coefficient^2, etc.
-                const backoffSeconds = Math.min(Math.pow(backoffCoeff, tryCount + 1), maxInterval);
-                return [true, backoffSeconds * 1000]; // Convert to milliseconds
+                // Exponential backoff: min(initialInterval * coefficient^(try+1), maxInterval)
+                const backoffSeconds = Math.min(initialIntervalS * Math.pow(backoffCoeff, tryCount + 1), maxInterval);
+                return [true, backoffSeconds * 1000];
             }
             return [false, 0];
         }
@@ -101,7 +96,7 @@ class ErrorHandler {
             data,
         };
     }
-    async handleRetry(input, output, publishMessage, retry) {
+    async handleRetry(input, output, publishMessage, retry, onRetryScheduled) {
         const [shouldRetry, timeout] = this.shouldRetry(input, output, retry);
         if (shouldRetry) {
             // Only sleep if no retry (legacy behavior for backward compatibility)
@@ -126,7 +121,13 @@ class ErrorHandler {
             // Track retry attempt count in database
             const currentAttempt = input._retryAttempt || 0;
             newMessage._retryAttempt = currentAttempt + 1;
-            return (await publishMessage(input.metadata.topic, newMessage));
+            const messageId = (await publishMessage(input.metadata.topic, newMessage));
+            // Schedule a targeted NOTIFY so the consumer wakes up when
+            // the visibility-delayed message becomes visible
+            if (retry && timeout > 0 && onRetryScheduled) {
+                onRetryScheduled(input.metadata.topic, timeout);
+            }
+            return messageId;
         }
         else {
             const structuredError = this.structureError(input, output);

package/build/services/store/providers/postgres/exporter-sql.d.ts

@@ -15,6 +15,10 @@ export declare const GET_JOB_ATTRIBUTES = "\n  SELECT symbol || dimension AS fie
  * Matches all activity jobs for the given workflow and extracts their input arguments.
  */
 export declare const GET_ACTIVITY_INPUTS = "\n  SELECT j.key, ja.value\n  FROM {schema}.jobs j\n  JOIN {schema}.jobs_attributes ja ON ja.job_id = j.id\n  WHERE j.key LIKE $1\n    AND ja.symbol = $2 AND ja.dimension = $3\n";
+/**
+ * Fetch activity inputs from worker_streams for direct worker proxyer activities.
+ */
+export declare const GET_PROXYER_STREAM_INPUTS = "\n  SELECT message\n  FROM {schema}.worker_streams\n  WHERE jid = $1\n    AND aid IN ('proxyer', 'collator_proxyer', 'signaler_proxyer')\n  ORDER BY created_at, id\n";
 /**
  * Fetch all worker stream messages for a job AND its child activities.
  * Child activity jobs use the pattern: -{parentJobId}-$activityName-N

package/build/services/store/providers/postgres/exporter-sql.js

@@ -4,7 +4,7 @@
  * These queries support the exporter's input enrichment and direct query features.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildChildWorkflowInputsQuery = exports.GET_STREAM_HISTORY_BY_JID_AND_AID = exports.GET_STREAM_HISTORY_BY_JID_AND_TYPE = exports.GET_STREAM_HISTORY_BY_JID = exports.GET_ACTIVITY_INPUTS = exports.GET_JOB_ATTRIBUTES = exports.GET_JOB_BY_KEY = void 0;
+exports.buildChildWorkflowInputsQuery = exports.GET_STREAM_HISTORY_BY_JID_AND_AID = exports.GET_STREAM_HISTORY_BY_JID_AND_TYPE = exports.GET_STREAM_HISTORY_BY_JID = exports.GET_PROXYER_STREAM_INPUTS = exports.GET_ACTIVITY_INPUTS = exports.GET_JOB_ATTRIBUTES = exports.GET_JOB_BY_KEY = void 0;
 /**
  * Fetch job record by key.
  */
@@ -34,6 +34,16 @@ exports.GET_ACTIVITY_INPUTS = `
   WHERE j.key LIKE $1
     AND ja.symbol = $2 AND ja.dimension = $3
 `;
+/**
+ * Fetch activity inputs from worker_streams for direct worker proxyer activities.
+ */
+exports.GET_PROXYER_STREAM_INPUTS = `
+  SELECT message
+  FROM {schema}.worker_streams
+  WHERE jid = $1
+    AND aid IN ('proxyer', 'collator_proxyer', 'signaler_proxyer')
+  ORDER BY created_at, id
+`;
 /**
  * Fetch all worker stream messages for a job AND its child activities.
  * Child activity jobs use the pattern: -{parentJobId}-$activityName-N

package/build/services/store/providers/postgres/postgres.js

@@ -1442,6 +1442,30 @@ class PostgresStoreService extends __1.StoreService {
                 // Skip unparseable values
             }
         }
+        // If no results from legacy approach, try direct worker approach:
+        // extract arguments from proxyer messages in worker_streams
+        if (byNameIndex.size === 0) {
+            const { GET_PROXYER_STREAM_INPUTS } = await Promise.resolve().then(() => __importStar(require('./exporter-sql')));
+            const streamSql = GET_PROXYER_STREAM_INPUTS.replace(/{schema}/g, schemaName);
+            const streamResult = await this.pgClient.query(streamSql, [workflowId]);
+            for (const row of streamResult.rows) {
+                try {
+                    const msg = typeof row.message === 'string' ? JSON.parse(row.message) : row.message;
+                    const data = msg?.data;
+                    if (data?.activityName && data?.arguments) {
+                        const activityName = data.activityName;
+                        const wfId = data.workflowId || '';
+                        const idxMatch = wfId.match(/-(\d+)$/);
+                        const execIndex = idxMatch ? idxMatch[1] : '0';
+                        byNameIndex.set(`${activityName}:${execIndex}`, data.arguments);
+                        byJobId.set(wfId, data.arguments);
+                    }
+                }
+                catch {
+                    // Skip unparseable messages
+                }
+            }
+        }
         return { byJobId, byNameIndex };
     }
     /**

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

@@ -58,6 +58,12 @@ declare class PostgresStreamService extends StreamService<PostgresClientType & P
      * added to the transaction for atomic execution.
      */
     publishMessages(streamName: string, messages: string[], options?: PublishMessageConfig): Promise<string[] | ProviderTransaction>;
+    /**
+     * Schedule a NOTIFY for a worker stream after a delay. Used to wake up
+     * consumers when a visibility-delayed retry message becomes visible,
+     * avoiding the need to wait for the scout's fallback poll.
+     */
+    scheduleStreamNotify(streamName: string, delayMs: number): void;
     _publishMessages(streamName: string, messages: string[], options?: PublishMessageConfig): {
         sql: string;
         params: any[];

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

@@ -174,6 +174,31 @@ class PostgresStreamService extends index_1.StreamService {
         const target = this.resolveStreamTarget(streamName);
         return Messages.publishMessages(this.streamClient, target.tableName, target.streamName, target.isEngine, messages, options, this.logger);
     }
+    /**
+     * Schedule a NOTIFY for a worker stream after a delay. Used to wake up
+     * consumers when a visibility-delayed retry message becomes visible,
+     * avoiding the need to wait for the scout's fallback poll.
+     */
+    scheduleStreamNotify(streamName, delayMs) {
+        const target = this.resolveStreamTarget(streamName);
+        const prefix = target.isEngine ? 'eng_' : 'wrk_';
+        let channelName = `${prefix}${target.streamName}`;
+        if (channelName.length > 63) {
+            channelName = channelName.substring(0, 63);
+        }
+        const payload = JSON.stringify({
+            stream_name: target.streamName,
+            table_type: target.isEngine ? 'engine' : 'worker',
+        });
+        setTimeout(async () => {
+            try {
+                await this.streamClient.query(`SELECT pg_notify($1, $2)`, [channelName, payload]);
+            }
+            catch {
+                // Best-effort; the scout fallback will pick it up
+            }
+        }, delayMs);
+    }
     _publishMessages(streamName, messages, options) {
         const target = this.resolveStreamTarget(streamName);
         return Messages.buildPublishSQL(target.tableName, target.streamName, target.isEngine, messages, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.14.6",
+  "version": "0.14.8",
   "description": "Durable Workflow",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",