@hotmeshio/hotmesh 0.16.1 → 0.16.3

package/build/package.json

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

package/build/services/activities/activity/process.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.processEvent = void 0;
 const enums_1 = require("../../../modules/enums");
 const errors_1 = require("../../../modules/errors");
-const collator_1 = require("../../collator");
+const collator_1 = require("../../../types/collator");
+const collator_2 = require("../../collator");
 const telemetry_1 = require("../../telemetry");
 const stream_1 = require("../../../types/stream");
 // Per-instance collation error tracking for reservation timeout detection
@@ -34,7 +35,7 @@ async function processEvent(instance, status = stream_1.StreamStatus.SUCCESS, co
     try {
         const collationKey = await instance.verifyReentry();
         instance.adjacentIndex =
-            collator_1.CollatorService.getDimensionalIndex(collationKey);
+            collator_2.CollatorService.getDimensionalIndex(collationKey);
         telemetry = new telemetry_1.TelemetryService(instance.engine.appId, instance.config, instance.metadata, instance.context);
         telemetry.startActivitySpan(instance.leg);
         //bind data per status type
@@ -71,10 +72,27 @@ async function processEvent(instance, status = stream_1.StreamStatus.SUCCESS, co
     }
     catch (error) {
         if (error instanceof errors_1.CollationError) {
-            // INACTIVE is legitimate duplicate detection — the Postgres atomic
-            // CTE (collateLeg2Entry) serializes via row locks, so the GUID
-            // ledger value is correct. Silent ack is the right behavior:
-            // the work was already done by a prior delivery of this message.
+            //FORBIDDEN: Leg1 not complete — signal arrived in the window
+            //between registerHook (standalone) and Leg1 transaction commit.
+            //Rethrow so the stream message is retried with backoff; by then
+            //Leg1 will have committed and Leg2 processing will succeed.
+            //The GUID marker was already committed by notarizeLeg2Entry;
+            //on retry, collateLeg2Entry's SETNX is a no-op for the same
+            //GUID, and verifySyntheticInteger sees no steps done → allowed.
+            if (error.fault === collator_1.CollationFaultType.FORBIDDEN) {
+                instance.logger.warn('process-event-forbidden-retry', {
+                    jid: instance.context.metadata.jid,
+                    aid: instance.metadata.aid,
+                    message: 'Leg1 not committed yet; rethrowing for stream retry',
+                    error,
+                });
+                throw error;
+            }
+            // INACTIVE/DUPLICATE: legitimate duplicate detection — the
+            // Postgres atomic CTE (collateLeg2Entry) serializes via row
+            // locks, so the GUID ledger value is correct. Silent ack is
+            // the right behavior: the work was already done by a prior
+            // delivery of this message.
             const now = Date.now();
             if (now - collationWindowStart > COLLATION_WINDOW_MS) {
                 collationErrorCount = 0;

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

@@ -153,20 +153,6 @@ const KVTables = (context) => ({
         FOR EACH ROW EXECUTE FUNCTION ${schemaName}.update_jobs_updated_at();
       `);
         }
-        // v0.15.2: add dedicated is_live partial index for hot-path queries
-        const { rows: idxRows } = await client.query(`SELECT 1 FROM pg_indexes WHERE indexname = 'idx_jobs_key_live' AND schemaname = $1 LIMIT 1`, [schemaName]);
-        if (idxRows.length === 0) {
-            await client.query(`
-        CREATE INDEX IF NOT EXISTS idx_jobs_key_live
-        ON ${jobsTable} (key) WHERE is_live;
-      `);
-        }
-        // v0.15.2: partial index for sorted_set scheduler hot path
-        await client.query(`
-      CREATE INDEX IF NOT EXISTS idx_task_schedules_active
-      ON ${schemaName}.task_schedules (key, score)
-      WHERE expiry IS NULL;
-    `);
     },
     async createTables(client, appName) {
         try {
@@ -265,40 +251,27 @@ const KVTables = (context) => ({
               CREATE INDEX IF NOT EXISTS idx_${tableDef.name}_context_gin 
               ON ${fullTableName} USING GIN (context);
             `);
-                        // Create partitions with fillfactor 70: reserves 30% page space
-                        // for HOT updates (status update cycle in setStatusAndCollateGuid)
+                        // Create partitions using a DO block
                         await client.query(`
               DO $$
               BEGIN
                 FOR i IN 0..7 LOOP
                   EXECUTE format(
                     'CREATE TABLE IF NOT EXISTS ${fullTableName}_part_%s PARTITION OF ${fullTableName}
-                    FOR VALUES WITH (modulus 8, remainder %s)
-                    WITH (fillfactor = 70)',
+                    FOR VALUES WITH (modulus 8, remainder %s)',
                     i, i
                   );
                 END LOOP;
               END$$;
             `);
-                        // Original index for queries that filter on expired_at directly
-                        // (e.g. _hmget's WHERE expired_at IS NULL OR expired_at > NOW())
+                        // Create optimized indexes
                         await client.query(`
               CREATE INDEX IF NOT EXISTS idx_${tableDef.name}_key_expired_at
               ON ${fullTableName} (key, expired_at) INCLUDE (is_live);
             `);
-                        // Dedicated partial index for the hot-path (WHERE key = $1 AND is_live).
-                        // Covers the uniqueness trigger, hget, hgetall, hincrbyfloat, and
-                        // the two-pass upsert — all of which use AND is_live directly.
-                        await client.query(`
-              CREATE INDEX IF NOT EXISTS idx_${tableDef.name}_key_live
-              ON ${fullTableName} (key)
-              WHERE is_live;
-            `);
-                        // status in INCLUDE (not key) so semaphore increments don't
-                        // force index key updates — allows HOT on the hottest write path.
                         await client.query(`
               CREATE INDEX IF NOT EXISTS idx_${tableDef.name}_entity_status
-              ON ${fullTableName} (entity) INCLUDE (status);
+              ON ${fullTableName} (entity, status);
             `);
                         await client.query(`
               CREATE INDEX IF NOT EXISTS idx_${tableDef.name}_expired_at
@@ -330,9 +303,7 @@ const KVTables = (context) => ({
               BEFORE INSERT OR UPDATE ON ${fullTableName}
               FOR EACH ROW EXECUTE PROCEDURE ${schemaName}.update_is_live();
             `);
-                        // Enforce uniqueness of live jobs via trigger.
-                        // Uses is_live partial index for the EXISTS check (existing rows
-                        // have is_live maintained by trg_update_is_live).
+                        // Create function to enforce uniqueness of live jobs
                         await client.query(`
               CREATE OR REPLACE FUNCTION ${schemaName}.enforce_live_job_uniqueness()
               RETURNS TRIGGER AS $$
@@ -342,7 +313,7 @@ const KVTables = (context) => ({
                   IF EXISTS (
                     SELECT 1 FROM ${fullTableName}
                     WHERE key = NEW.key
-                    AND is_live
+                    AND (expired_at IS NULL OR expired_at > NOW())
                     AND id <> NEW.id
                   ) THEN
                     RAISE EXCEPTION 'A live job with key % already exists.', NEW.key;
@@ -413,16 +384,14 @@ const KVTables = (context) => ({
                   FOR EACH ROW
                   EXECUTE FUNCTION ${schemaName}.update_attributes_updated_at();
             `);
-                        // Create partitions with fillfactor 70: reserves 30% page space
-                        // for HOT updates (frequent upserts in hincrbyfloat/collateLeg2Entry)
+                        // Create partitions for attributes table
                         await client.query(`
               DO $$
               BEGIN
                 FOR i IN 0..7 LOOP
                   EXECUTE format(
                     'CREATE TABLE IF NOT EXISTS ${attributesTableName}_part_%s PARTITION OF ${attributesTableName}
-                    FOR VALUES WITH (modulus 8, remainder %s)
-                    WITH (fillfactor = 70)',
+                    FOR VALUES WITH (modulus 8, remainder %s)',
                     i, i
                   );
                 END LOOP;
@@ -466,14 +435,6 @@ const KVTables = (context) => ({
                         await client.query(`
               CREATE INDEX IF NOT EXISTS idx_${tableDef.name}_key_score_member
               ON ${fullTableName} (key, score, member);
-            `);
-                        // Partial index for the scheduler hot path (zrangebyscore).
-                        // Most entries have no expiry; this avoids the OR filter that
-                        // prevents clean index-only scans.
-                        await client.query(`
-              CREATE INDEX IF NOT EXISTS idx_${tableDef.name}_active
-              ON ${fullTableName} (key, score)
-              WHERE expiry IS NULL;
             `);
                         break;
                     default:

package/build/services/store/providers/postgres/kvtypes/hash/basic.js

@@ -292,19 +292,11 @@ function _hset(context, key, fields, options) {
             params.push(key, fields[':'], options?.entity ?? null);
         }
         else {
-            // Two-pass upsert: UPDATE existing live job, INSERT only if no
-            // live job exists. Avoids ON CONFLICT seq_scan on partitioned
-            // tables that lack a unique partial index.
+            // Update existing job or insert new one
             sql = `
-        WITH existing AS (
-          UPDATE ${targetTable}
-          SET status = $2
-          WHERE key = $1 AND is_live
-          RETURNING 1
-        )
         INSERT INTO ${targetTable} (id, key, status, entity)
-        SELECT gen_random_uuid(), $1, $2, $3
-        WHERE NOT EXISTS (SELECT 1 FROM existing)
+        VALUES (gen_random_uuid(), $1, $2, $3)
+        ON CONFLICT (key) WHERE is_live DO UPDATE SET status = EXCLUDED.status
         RETURNING 1 as count
       `;
             params.push(key, fields[':'], options?.entity ?? null);
@@ -511,20 +503,31 @@ function _hgetall(context, key) {
     const tableName = context.tableForKey(key, 'hash');
     const isJobsTableResult = (0, utils_1.isJobsTable)(tableName);
     if (isJobsTableResult) {
-        // Single CTE: reads jobs row once, then joins attributes
         const sql = `
       WITH valid_job AS (
         SELECT id, status, context
         FROM ${tableName}
         WHERE key = $1 AND is_live
+      ),
+      job_data AS (
+        SELECT 'status' AS field, status::text AS value
+        FROM ${tableName}
+        WHERE key = $1 AND is_live
+
+        UNION ALL
+
+        SELECT 'context' AS field, context::text AS value
+        FROM ${tableName}
+        WHERE key = $1 AND is_live
+      ),
+      attribute_data AS (
+        SELECT symbol || dimension AS field, value
+        FROM ${tableName}_attributes
+        WHERE job_id IN (SELECT id FROM valid_job)
       )
-      SELECT 'status' AS field, status::text AS value FROM valid_job
-      UNION ALL
-      SELECT 'context' AS field, context::text AS value FROM valid_job
+      SELECT * FROM job_data
       UNION ALL
-      SELECT symbol || dimension AS field, value
-      FROM ${tableName}_attributes
-      WHERE job_id = (SELECT id FROM valid_job);
+      SELECT * FROM attribute_data;
     `;
         return { sql, params: [key] };
     }

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

@@ -83,17 +83,6 @@ const zsetModule = (context) => ({
     _zrange(key, start, stop, facet) {
         const tableName = context.tableForKey(key, 'sorted_set');
         const selectColumns = facet === 'WITHSCORES' ? 'member, score' : 'member';
-        // Fast path: (0, -1) means "get all" — skip COUNT/ROW_NUMBER entirely
-        if (start === 0 && stop === -1) {
-            const sql = `
-        SELECT ${selectColumns}
-        FROM ${tableName}
-        WHERE key = $1 AND (expiry IS NULL OR expiry > NOW())
-        ORDER BY score ASC, member ASC;
-      `;
-            return { sql, params: [context.storageKey(key)] };
-        }
-        // General case: negative indices require COUNT for resolution
         const sql = `
       WITH total_entries AS (
         SELECT COUNT(*) - 1 AS max_index FROM ${tableName}

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

@@ -118,9 +118,14 @@ declare class PostgresStoreService extends StoreService<ProviderClient, Provider
     /**
      * Leg1: set hook signal, atomically detecting a pending signal.
      *
-     * Standalone (no transaction): single CTE query that reads any existing
-     * pending value, then inserts the hook signal (overwriting pending or
-     * expired entries). Returns `{success, pendingData}` in one round trip.
+     * Standalone (no transaction): acquires a per-key advisory lock to
+     * serialize with concurrent getHookSignal calls, then reads any
+     * existing pending value and inserts the hook signal.
+     *
+     * The advisory lock prevents a race where the CTE's read snapshot
+     * misses a concurrently inserted pending signal — under READ
+     * COMMITTED, ON CONFLICT sees committed writes but the SELECT CTE
+     * does not, causing the pending data to be silently overwritten.
      *
      * In a transaction: queues the setnxex; pending detection deferred.
      */
@@ -132,10 +137,13 @@ declare class PostgresStoreService extends StoreService<ProviderClient, Provider
      * Leg2: get hook signal OR atomically set a pending signal.
      *
      * When `pendingData` is provided and no hook signal exists, the
-     * pending value is inserted in the SAME SQL statement — no second
-     * round trip. This is the transactional edge that prevents the
-     * signal from being lost: by the time the query returns, the
-     * pending key is already visible to leg1's setnxex.
+     * pending value is stored so leg1's setHookSignal can detect it.
+     *
+     * Uses a per-key advisory lock to serialize with concurrent
+     * setHookSignal calls. Without the lock, a CTE race exists where
+     * the read snapshot misses a concurrently inserted hook signal AND
+     * the pending INSERT fails on conflict (the hook has valid expiry),
+     * silently losing the signal.
      *
      * When `pendingData` is omitted, behaves as a plain read.
      */

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

@@ -475,10 +475,12 @@ class PostgresStoreService extends __1.StoreService {
         const symVals = await this.getSymbolValues();
         this.serializer.resetSymbols(symKeys, symVals, dIds);
         const hashData = this.serializer.package(state, symbolNames);
-        // ':' (status) is NOT written to jobs_attributes — jobs.status is
-        // maintained by setStatus/setStatusAndCollateGuid. The attribute row
-        // was redundant, never read, and contended on every activity.
-        delete hashData[':'];
+        if (status !== null) {
+            hashData[':'] = status.toString();
+        }
+        else {
+            delete hashData[':'];
+        }
         await this.kvsql(transaction).hset(hashKey, hashData);
         return jobId;
     }
@@ -755,9 +757,14 @@ class PostgresStoreService extends __1.StoreService {
     /**
      * Leg1: set hook signal, atomically detecting a pending signal.
      *
-     * Standalone (no transaction): single CTE query that reads any existing
-     * pending value, then inserts the hook signal (overwriting pending or
-     * expired entries). Returns `{success, pendingData}` in one round trip.
+     * Standalone (no transaction): acquires a per-key advisory lock to
+     * serialize with concurrent getHookSignal calls, then reads any
+     * existing pending value and inserts the hook signal.
+     *
+     * The advisory lock prevents a race where the CTE's read snapshot
+     * misses a concurrently inserted pending signal — under READ
+     * COMMITTED, ON CONFLICT sees committed writes but the SELECT CTE
+     * does not, causing the pending data to be silently overwritten.
      *
      * In a transaction: queues the setnxex; pending detection deferred.
      */
@@ -774,37 +781,30 @@ class PostgresStoreService extends __1.StoreService {
         const kv = this.kvsql();
         const tableName = kv.tableForKey(fullKey);
         const storedKey = kv.storageKey(fullKey);
-        const sql = `
-      WITH pre AS (
-        SELECT value FROM ${tableName}
-        WHERE key = $1 AND (expiry IS NULL OR expiry > NOW())
-      ),
-      ins AS (
-        INSERT INTO ${tableName} (key, value, expiry)
-        VALUES ($1, $2, NOW() + INTERVAL '${delay} seconds')
-        ON CONFLICT (key) DO UPDATE
-          SET value = EXCLUDED.value, expiry = EXCLUDED.expiry
-          WHERE ${tableName}.expiry IS NULL
-            OR ${tableName}.expiry <= NOW()
-            OR ${tableName}.value LIKE '$pending::%'
-        RETURNING true as success
-      )
-      SELECT
-        COALESCE((SELECT success FROM ins), false) as success,
-        (SELECT value FROM pre) as existing_value
-    `;
+        //acquire per-key advisory lock (session-level) to serialize
+        //with concurrent getHookSignal for the same signal key
+        await this.pgClient.query('SELECT pg_advisory_lock(901, hashtext($1))', [storedKey]);
         try {
-            const res = await this.pgClient.query(sql, [storedKey, jobId]);
-            const row = res.rows[0] || {};
-            const success = row.success === true;
-            const existing = row.existing_value;
-            if (success && existing?.startsWith('$pending::')) {
-                return {
-                    success: true,
-                    pendingData: existing.slice('$pending::'.length),
-                };
+            //read existing value under lock
+            const readRes = await this.pgClient.query(`SELECT value FROM ${tableName}
+         WHERE key = $1 AND (expiry IS NULL OR expiry > NOW())`, [storedKey]);
+            let pendingData;
+            if (readRes.rows.length > 0) {
+                const existing = readRes.rows[0].value;
+                if (existing?.startsWith('$pending::')) {
+                    pendingData = existing.slice('$pending::'.length);
+                }
+                else {
+                    //hook already set (retry) — no change needed
+                    return { success: false };
+                }
             }
-            return { success };
+            //insert hook value (or overwrite pending)
+            await this.pgClient.query(`INSERT INTO ${tableName} (key, value, expiry)
+         VALUES ($1, $2, NOW() + INTERVAL '${delay} seconds')
+         ON CONFLICT (key) DO UPDATE
+           SET value = EXCLUDED.value, expiry = EXCLUDED.expiry`, [storedKey, jobId]);
+            return { success: true, pendingData };
         }
         catch (error) {
             if (error?.message?.includes('closed') ||
@@ -813,15 +813,26 @@ class PostgresStoreService extends __1.StoreService {
             }
             throw error;
         }
+        finally {
+            try {
+                await this.pgClient.query('SELECT pg_advisory_unlock(901, hashtext($1))', [storedKey]);
+            }
+            catch {
+                //lock auto-releases on session close
+            }
+        }
     }
     /**
      * Leg2: get hook signal OR atomically set a pending signal.
      *
      * When `pendingData` is provided and no hook signal exists, the
-     * pending value is inserted in the SAME SQL statement — no second
-     * round trip. This is the transactional edge that prevents the
-     * signal from being lost: by the time the query returns, the
-     * pending key is already visible to leg1's setnxex.
+     * pending value is stored so leg1's setHookSignal can detect it.
+     *
+     * Uses a per-key advisory lock to serialize with concurrent
+     * setHookSignal calls. Without the lock, a CTE race exists where
+     * the read snapshot misses a concurrently inserted hook signal AND
+     * the pending INSERT fails on conflict (the hook has valid expiry),
+     * silently losing the signal.
      *
      * When `pendingData` is omitted, behaves as a plain read.
      */
@@ -838,38 +849,30 @@ class PostgresStoreService extends __1.StoreService {
                 return undefined;
             return value;
         }
-        //atomic get-or-set-pending: one round trip
         const kv = this.kvsql();
         const tableName = kv.tableForKey(fullKey);
         const storedKey = kv.storageKey(fullKey);
         const expire = pendingExpire || enums_1.HMSH_PENDING_SIGNAL_EXPIRE;
         const pendingValue = `$pending::${pendingData}`;
-        const sql = `
-      WITH existing AS (
-        SELECT value FROM ${tableName}
-        WHERE key = $1 AND (expiry IS NULL OR expiry > NOW())
-      ),
-      pending AS (
-        INSERT INTO ${tableName} (key, value, expiry)
-        SELECT $1, $2, NOW() + INTERVAL '${expire} seconds'
-        WHERE NOT EXISTS (SELECT 1 FROM existing)
-        ON CONFLICT (key) DO UPDATE
-          SET value = EXCLUDED.value, expiry = EXCLUDED.expiry
-          WHERE ${tableName}.expiry IS NULL OR ${tableName}.expiry <= NOW()
-        RETURNING true as inserted
-      )
-      SELECT
-        (SELECT value FROM existing) as hook_value,
-        (SELECT inserted FROM pending) as pending_inserted
-    `;
+        //acquire per-key advisory lock (session-level) to serialize
+        //with concurrent setHookSignal for the same signal key
+        await this.pgClient.query('SELECT pg_advisory_lock(901, hashtext($1))', [storedKey]);
         try {
-            const res = await this.pgClient.query(sql, [storedKey, pendingValue]);
-            const row = res.rows[0] || {};
-            const hookValue = row.hook_value;
-            if (hookValue && !hookValue.startsWith('$pending::')) {
-                return hookValue;
+            //read existing value under lock
+            const readRes = await this.pgClient.query(`SELECT value FROM ${tableName}
+         WHERE key = $1 AND (expiry IS NULL OR expiry > NOW())`, [storedKey]);
+            if (readRes.rows.length > 0) {
+                const value = readRes.rows[0].value;
+                if (value && !value.startsWith('$pending::')) {
+                    //hook found — return it
+                    return value;
+                }
             }
-            //no hook signal; pending was inserted (or already existed)
+            //no hook signal — store pending
+            await this.pgClient.query(`INSERT INTO ${tableName} (key, value, expiry)
+         VALUES ($1, $2, NOW() + INTERVAL '${expire} seconds')
+         ON CONFLICT (key) DO UPDATE
+           SET value = EXCLUDED.value, expiry = EXCLUDED.expiry`, [storedKey, pendingValue]);
             return undefined;
         }
         catch (error) {
@@ -879,6 +882,14 @@ class PostgresStoreService extends __1.StoreService {
             }
             throw error;
         }
+        finally {
+            try {
+                await this.pgClient.query('SELECT pg_advisory_unlock(901, hashtext($1))', [storedKey]);
+            }
+            catch {
+                //lock auto-releases on session close
+            }
+        }
     }
     async deleteHookSignal(topic, resolved) {
         const key = this.mintKey(key_1.KeyType.SIGNALS, { appId: this.appId });

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

@@ -140,31 +140,21 @@ async function createTables(client, schemaName) {
     ) PARTITION BY HASH (stream_name);
   `);
     for (let i = 0; i < 8; i++) {
-        // fillfactor 70: reserves 30% page space for HOT updates (reserve/ack cycle)
         await client.query(`
       CREATE TABLE IF NOT EXISTS ${schemaName}.engine_streams_part_${i}
       PARTITION OF ${engineTable}
-      FOR VALUES WITH (modulus 8, remainder ${i})
-      WITH (fillfactor = 70);
+      FOR VALUES WITH (modulus 8, remainder ${i});
     `);
     }
-    // Dedicated dequeue index: columns match the hot-path query exactly
-    // (stream_name = $1, visible_at <= NOW(), ORDER BY id) with partial
-    // filter on reserved_at IS NULL AND expired_at IS NULL.
-    // Replaces the old active_messages index that had reserved_at as a
-    // column (redundant with the WHERE filter, displacing visible_at).
     await client.query(`
-    CREATE INDEX IF NOT EXISTS idx_engine_streams_dequeue
-    ON ${engineTable} (stream_name, visible_at, id)
+    CREATE INDEX IF NOT EXISTS idx_engine_streams_active_messages
+    ON ${engineTable} (stream_name, reserved_at, visible_at, id)
     WHERE reserved_at IS NULL AND expired_at IS NULL;
   `);
-    // Stale-reservation recovery: covers the timed-out reservation path
-    // (reserved_at < NOW() - INTERVAL) separately from the hot path so
-    // the planner can use each index cleanly without an OR.
     await client.query(`
-    CREATE INDEX IF NOT EXISTS idx_engine_streams_stale_reservations
-    ON ${engineTable} (stream_name, reserved_at, visible_at, id)
-    WHERE reserved_at IS NOT NULL AND expired_at IS NULL;
+    CREATE INDEX IF NOT EXISTS idx_engine_streams_message_fetch
+    ON ${engineTable} (stream_name, visible_at, id)
+    WHERE expired_at IS NULL;
   `);
     await client.query(`
     CREATE INDEX IF NOT EXISTS idx_engine_streams_expired_at
@@ -219,25 +209,21 @@ async function createTables(client, schemaName) {
     ) PARTITION BY HASH (stream_name);
   `);
     for (let i = 0; i < 8; i++) {
-        // fillfactor 70: reserves 30% page space for HOT updates (reserve/ack cycle)
         await client.query(`
       CREATE TABLE IF NOT EXISTS ${schemaName}.worker_streams_part_${i}
       PARTITION OF ${workerTable}
-      FOR VALUES WITH (modulus 8, remainder ${i})
-      WITH (fillfactor = 70);
+      FOR VALUES WITH (modulus 8, remainder ${i});
     `);
     }
-    // Dedicated dequeue index (see engine_streams comments above)
     await client.query(`
-    CREATE INDEX IF NOT EXISTS idx_worker_streams_dequeue
-    ON ${workerTable} (stream_name, visible_at, id)
+    CREATE INDEX IF NOT EXISTS idx_worker_streams_active_messages
+    ON ${workerTable} (stream_name, reserved_at, visible_at, id)
     WHERE reserved_at IS NULL AND expired_at IS NULL;
   `);
-    // Stale-reservation recovery (see engine_streams comments above)
     await client.query(`
-    CREATE INDEX IF NOT EXISTS idx_worker_streams_stale_reservations
-    ON ${workerTable} (stream_name, reserved_at, visible_at, id)
-    WHERE reserved_at IS NOT NULL AND expired_at IS NULL;
+    CREATE INDEX IF NOT EXISTS idx_worker_streams_message_fetch
+    ON ${workerTable} (stream_name, visible_at, id)
+    WHERE expired_at IS NULL;
   `);
     await client.query(`
     CREATE INDEX IF NOT EXISTS idx_worker_streams_expired_at

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

@@ -207,17 +207,12 @@ async function fetchMessages(client, tableName, streamName, isEngine, consumerNa
             retries++;
             const batchSize = options?.batchSize || 1;
             const reservationTimeout = options?.reservationTimeout || enums_1.HMSH_RESERVATION_TIMEOUT_S;
-            // Two-pass dequeue: stale reservations first (FIFO — they have
-            // lower ids and have waited longest), then fresh messages. Split
-            // avoids an OR that prevents the planner from using partial
-            // indexes cleanly. Stale check is a fast no-op (empty index scan)
-            // when there are no timed-out reservations.
-            let res = await client.query(`UPDATE ${tableName}
+            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 reserved_at < NOW() - INTERVAL '${reservationTimeout} seconds'
+             AND (reserved_at IS NULL OR reserved_at < NOW() - INTERVAL '${reservationTimeout} seconds')
              AND expired_at IS NULL
              AND visible_at <= NOW()
            ORDER BY id
@@ -225,22 +220,6 @@ async function fetchMessages(client, tableName, streamName, isEngine, consumerNa
            FOR UPDATE SKIP LOCKED
          )
          RETURNING ${returningClause}`, [streamName, batchSize, consumerName]);
-            // Fresh messages: unreserved, visible, not expired
-            if (res.rows.length === 0) {
-                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 reserved_at IS NULL
-               AND expired_at IS NULL
-               AND visible_at <= NOW()
-             ORDER BY id
-             LIMIT $2
-             FOR UPDATE SKIP LOCKED
-           )
-           RETURNING ${returningClause}`, [streamName, batchSize, consumerName]);
-            }
             const messages = res.rows.map((row) => {
                 const data = (0, utils_1.parseStreamMessage)(row.message);
                 const hasDefaultRetryPolicy = (row.max_retry_attempts === 3 || row.max_retry_attempts === 5) &&

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

@@ -54,16 +54,13 @@ function getCreateProceduresSQL(schemaName) {
     SET search_path = ${schemaName}, pg_temp
     AS $$
     ${STREAM_ACCESS_CHECK}
-      -- Two-pass dequeue: stale reservations first (FIFO — lower ids,
-      -- waited longest), then fresh. Split avoids OR that prevents
-      -- partial index usage. Stale check is a fast no-op when empty.
       RETURN QUERY
       UPDATE ${workerTable} ws
       SET reserved_at = NOW(), reserved_by = p_consumer_id
       WHERE ws.id IN (
         SELECT ws2.id FROM ${workerTable} ws2
         WHERE ws2.stream_name = p_stream_name
-          AND ws2.reserved_at < NOW() - (p_reservation_timeout_sec || ' seconds')::INTERVAL
+          AND (ws2.reserved_at IS NULL OR ws2.reserved_at < NOW() - (p_reservation_timeout_sec || ' seconds')::INTERVAL)
           AND ws2.expired_at IS NULL
           AND ws2.visible_at <= NOW()
         ORDER BY ws2.id
@@ -72,25 +69,6 @@ function getCreateProceduresSQL(schemaName) {
       )
       RETURNING ws.id, ws.message, ws.workflow_name, ws.max_retry_attempts,
                 ws.backoff_coefficient, ws.maximum_interval_seconds, ws.retry_attempt;
-
-      -- Fresh messages: unreserved, visible, not expired
-      IF NOT FOUND THEN
-        RETURN QUERY
-        UPDATE ${workerTable} ws
-        SET reserved_at = NOW(), reserved_by = p_consumer_id
-        WHERE ws.id IN (
-          SELECT ws2.id FROM ${workerTable} ws2
-          WHERE ws2.stream_name = p_stream_name
-            AND ws2.reserved_at IS NULL
-            AND ws2.expired_at IS NULL
-            AND ws2.visible_at <= NOW()
-          ORDER BY ws2.id
-          LIMIT p_batch_size
-          FOR UPDATE SKIP LOCKED
-        )
-        RETURNING ws.id, ws.message, ws.workflow_name, ws.max_retry_attempts,
-                  ws.backoff_coefficient, ws.maximum_interval_seconds, ws.retry_attempt;
-      END IF;
     END;
     $$;`,
         // -- worker_ack --

package/package.json

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