@hotmeshio/hotmesh 0.7.0 → 0.8.0

package/build/services/search/factory.js

@@ -3,20 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SearchServiceFactory = void 0;
 const utils_1 = require("../../modules/utils");
 const postgres_1 = require("./providers/postgres/postgres");
-const ioredis_1 = require("./providers/redis/ioredis");
-const redis_1 = require("./providers/redis/redis");
 class SearchServiceFactory {
     static async init(providerClient, storeProviderClient, namespace, appId, logger) {
         let service;
         if ((0, utils_1.identifyProvider)(providerClient) === 'postgres') {
             service = new postgres_1.PostgresSearchService(providerClient, storeProviderClient);
-        }
-        else if ((0, utils_1.identifyProvider)(providerClient) === 'redis') {
-            service = new redis_1.RedisSearchService(providerClient, storeProviderClient);
-        }
-        else {
-            service = new ioredis_1.IORedisSearchService(providerClient, storeProviderClient);
-        }
+        } //etc
         await service.init(namespace, appId, logger);
         return service;
     }

package/build/services/store/factory.js

@@ -2,19 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StoreServiceFactory = void 0;
 const utils_1 = require("../../modules/utils");
-const ioredis_1 = require("./providers/redis/ioredis");
-const redis_1 = require("./providers/redis/redis");
 const postgres_1 = require("./providers/postgres/postgres");
 class StoreServiceFactory {
     static async init(providerClient, namespace, appId, logger) {
         let service;
-        if ((0, utils_1.identifyProvider)(providerClient) === 'redis') {
-            service = new redis_1.RedisStoreService(providerClient);
-        }
-        else if ((0, utils_1.identifyProvider)(providerClient) === 'ioredis') {
-            service = new ioredis_1.IORedisStoreService(providerClient);
-        }
-        else if ((0, utils_1.identifyProvider)(providerClient) === 'postgres') {
+        if ((0, utils_1.identifyProvider)(providerClient) === 'postgres') {
             service = new postgres_1.PostgresStoreService(providerClient);
         } //etc
         await service.init(namespace, appId, logger);

package/build/services/store/index.d.ts

@@ -40,6 +40,10 @@ declare abstract class StoreService<Provider extends ProviderClient, Transaction
     abstract getJobStats(jobKeys: string[]): Promise<JobStatsRange>;
     abstract getJobIds(indexKeys: string[], idRange: [number, number]): Promise<IdsData>;
     abstract setStatus(collationKeyStatus: number, jobId: string, appId: string, transaction?: TransactionProvider): Promise<any>;
+    abstract setStatusAndCollateGuid(statusDelta: number, // typically (N - 1)
+    threshold: number, // typically 0 (but supports 0,1,12,...)
+    jobId: string, appId: string, guidField: string, // 
+    guidWeight: number, transaction?: ProviderTransaction): Promise<any>;
     abstract getStatus(jobId: string, appId: string): Promise<number>;
     abstract setStateNX(jobId: string, appId: string, status?: number, entity?: string): Promise<boolean>;
     abstract setState(state: StringAnyType, status: number | null, jobId: string, symbolNames: string[], dIds: StringStringType, transaction?: TransactionProvider): Promise<string>;
@@ -47,6 +51,7 @@ declare abstract class StoreService<Provider extends ProviderClient, Transaction
     abstract getState(jobId: string, consumes: Consumes, dIds: StringStringType): Promise<[StringAnyType, number] | undefined>;
     abstract getRaw(jobId: string): Promise<StringStringType>;
     abstract collate(jobId: string, activityId: string, amount: number, dIds: StringStringType, transaction?: TransactionProvider): Promise<number>;
+    abstract collateLeg2Entry(jobId: string, activityId: string, guid: string, dIds: StringStringType, transaction?: TransactionProvider): Promise<[number, number]>;
     abstract collateSynthetic(jobId: string, guid: string, amount: number, transaction?: TransactionProvider): Promise<number>;
     abstract getSchema(activityId: string, appVersion: AppVID): Promise<any>;
     abstract getSchemas(appVersion: AppVID): Promise<Record<string, any>>;

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

@@ -58,6 +58,10 @@ export declare class KVSQL {
     _hmget: (key: string, fields: string[]) => import("./kvtypes/hash/types").SqlResult;
     hgetall: (key: string, multi?: ProviderTransaction) => Promise<Record<string, string>>;
     hincrbyfloat: (key: string, field: string, increment: number, multi?: ProviderTransaction) => Promise<number>;
+    collateLeg2Entry: (key: string, activityField: string, increment: number, guidField: string, multi?: ProviderTransaction) => Promise<[number, number]>;
+    _collateLeg2Entry: (key: string, activityField: string, increment: number, guidField: string) => import("./kvtypes/hash/types").SqlResult;
+    setStatusAndCollateGuid: (key: string, statusDelta: number, threshold: number, guidField: string, guidWeight: number, multi?: ProviderTransaction) => Promise<number>;
+    _setStatusAndCollateGuid: (key: string, statusDelta: number, threshold: number, guidField: string, guidWeight: number) => import("./kvtypes/hash/types").SqlResult;
     _hincrbyfloat: (key: string, field: string, increment: number) => import("./kvtypes/hash/types").SqlResult;
     hscan: (key: string, cursor: string, count?: number, pattern?: string, multi?: ProviderTransaction) => Promise<import("./kvtypes/hash/index").HScanResult>;
     _hscan: (key: string, cursor: string, count: number, pattern?: string) => import("./kvtypes/hash/types").SqlResult;

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

@@ -34,6 +34,10 @@ class KVSQL {
         this._hmget = (...args) => this.hash._hmget(...args);
         this.hgetall = (...args) => this.hash.hgetall(...args);
         this.hincrbyfloat = (...args) => this.hash.hincrbyfloat(...args);
+        this.collateLeg2Entry = (...args) => this.hash.collateLeg2Entry(...args);
+        this._collateLeg2Entry = (...args) => this.hash._collateLeg2Entry(...args);
+        this.setStatusAndCollateGuid = (...args) => this.hash.setStatusAndCollateGuid(...args);
+        this._setStatusAndCollateGuid = (...args) => this.hash._setStatusAndCollateGuid(...args);
         this._hincrbyfloat = (...args) => this.hash._hincrbyfloat(...args);
         this.hscan = (...args) => this.hash.hscan(...args);
         this._hscan = (...args) => this.hash._hscan(...args);

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

@@ -31,6 +31,8 @@ export declare class KVTransaction implements KVSQLProviderTransaction {
     zrem(key: string, member: string): this;
     zrank(key: string, member: string): this;
     scan(cursor: number, count?: number): this;
+    collateLeg2Entry(key: string, activityField: string, increment: number, guidField: string): this;
+    setStatusAndCollateGuid(key: string, statusDelta: number, threshold: number, guidField: string, guidWeight: number): this;
     rename(oldKey: string, newKey: string): this;
     exec(): Promise<any[]>;
 }

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

@@ -8,8 +8,13 @@ const pg_format_1 = __importDefault(require("pg-format"));
 /**
  * Utility function to format SQL commands with parameters.
  * Replaces $1, $2, etc., with %L or %s based on parameter types.
+ * Commands with no parameters (e.g., NOTIFY with inline values)
+ * are returned as-is to avoid pg-format corrupting the SQL.
  */
 function formatSqlCommand(sql, params) {
+    if (!params || params.length === 0) {
+        return sql;
+    }
     const formatParams = [];
     // Replace $1, $2, etc., with %L or %s and collect parameters
     const formattedSql = sql.replace(/\$(\d+)/g, (match, p1) => {
@@ -182,6 +187,18 @@ class KVTransaction {
         };
         return this.addCommand(sql, params, 'object', transform);
     }
+    collateLeg2Entry(key, activityField, increment, guidField) {
+        const { sql, params } = this.kvsql._collateLeg2Entry(key, activityField, increment, guidField);
+        return this.addCommand(sql, params, 'array', (rows) => {
+            return [parseFloat(rows[0].activity_value), parseFloat(rows[0].guid_value)];
+        });
+    }
+    setStatusAndCollateGuid(key, statusDelta, threshold, guidField, guidWeight) {
+        const { sql, params } = this.kvsql._setStatusAndCollateGuid(key, statusDelta, threshold, guidField, guidWeight);
+        return this.addCommand(sql, params, 'number', (rows) => {
+            return parseFloat(rows[0].value);
+        });
+    }
     rename(oldKey, newKey) {
         const { sql, params } = this.kvsql._rename(oldKey, newKey);
         return this.addCommand(sql, params, 'void');
@@ -240,6 +257,12 @@ class KVTransaction {
             return results;
         }
         catch (err) {
+            console.error('kvtransaction-exec-error', {
+                error: err.message,
+                commandCount: this.commands.length,
+                commandTypes: this.commands.map(c => c.returnType),
+                commandSqlPreviews: this.commands.map(c => c.sql.substring(0, 80)),
+            });
             await client.query('ROLLBACK');
             throw err;
         }

package/build/services/store/providers/postgres/kvtypes/hash/basic.d.ts

@@ -7,6 +7,25 @@ export declare function createBasicOperations(context: HashContext['context']):
     hmget(key: string, fields: string[], multi?: ProviderTransaction): Promise<(string | null)[]>;
     hgetall(key: string, multi?: ProviderTransaction): Promise<Record<string, string>>;
     hincrbyfloat(key: string, field: string, increment: number, multi?: ProviderTransaction): Promise<number>;
+    /**
+     * 2b) KVSQL METHOD: Leg2 Entry Compound
+     * --------------------------------------
+     * Atomically increments the activity Leg2 entry counter and seeds
+     * the GUID ledger with the ordinal IF NOT EXISTS.
+     *
+     * Returns: [activityValue, guidValue] as [number, number]
+     */
+    collateLeg2Entry(key: string, activityField: string, increment: number, guidField: string, multi?: ProviderTransaction): Promise<[number, number]>;
+    /**
+     * 2) KVSQL METHOD (non-transactional + transactional)
+     * ---------------------------------------------------
+     * Matches hincrbyfloat() pattern:
+     * - when multi is present: enqueue command and return 0 immediately
+     * - when multi absent: execute immediately and return parsed numeric value
+     *
+     * Returns: thresholdHit (0/1) as number
+     */
+    setStatusAndCollateGuid(key: string, statusDelta: number, threshold: number, guidField: string, guidWeight: number, multi?: ProviderTransaction): Promise<number>;
 };
 export declare function _hset(context: HashContext['context'], key: string, fields: Record<string, string>, options?: HSetOptions): SqlResult;
 export declare function _hget(context: HashContext['context'], key: string, field: string): SqlResult;
@@ -14,3 +33,35 @@ export declare function _hdel(context: HashContext['context'], key: string, fiel
 export declare function _hmget(context: HashContext['context'], key: string, fields: string[]): SqlResult;
 export declare function _hgetall(context: HashContext['context'], key: string): SqlResult;
 export declare function _hincrbyfloat(context: HashContext['context'], key: string, field: string, increment: number): SqlResult;
+/**
+ * 3b) LOW-LEVEL SQL GENERATOR: Leg2 Entry Compound
+ * -------------------------------------------------
+ * Atomically:
+ * - increments the activity collation field by +1 (Leg2 entry counter)
+ * - seeds the GUID ledger with the ordinal (last 8 digits of activity value)
+ *   IF the GUID row does not yet exist; returns the existing value if it does
+ * - returns both (activity_value, guid_value) for the caller
+ *
+ * The GUID seed uses ON CONFLICT DO UPDATE SET value = existing.value
+ * (a no-op update) so that RETURNING fires in both insert and conflict cases.
+ */
+export declare function _collateLeg2Entry(context: HashContext['context'], key: string, // jobKey
+activityField: string, // serialized activity collation field name
+increment: number, // always 1 for Leg2 entry
+guidField: string): SqlResult;
+/**
+ * 3) LOW-LEVEL SQL GENERATOR
+ * --------------------------
+ * This is the core compound statement. It must:
+ * - update jobs.status by statusDelta
+ * - compute thresholdHit (0/1) when status_after == threshold
+ * - increment the guidField by thresholdHit * guidWeight (typically 100B digit)
+ * - return thresholdHit as "value" so it fits the existing return parsing
+ *
+ * Notes:
+ * - Uses tableForKey(key, 'hash') which will resolve to the jobs table for job keys.
+ * - Assumes jobs_attributes table is `${jobsTableName}_attributes` (same as _hincrbyfloat)
+ * - Uses deriveType(guidField) to be consistent with your attribute typing system.
+ */
+export declare function _setStatusAndCollateGuid(context: HashContext['context'], key: string, // jobKey
+statusDelta: number, threshold: number, guidField: string, guidWeight: number): SqlResult;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._hincrbyfloat = exports._hgetall = exports._hmget = exports._hdel = exports._hget = exports._hset = exports.createBasicOperations = void 0;
+exports._setStatusAndCollateGuid = exports._collateLeg2Entry = exports._hincrbyfloat = exports._hgetall = exports._hmget = exports._hdel = exports._hget = exports._hset = exports.createBasicOperations = void 0;
 const utils_1 = require("./utils");
 function createBasicOperations(context) {
     return {
@@ -184,6 +184,77 @@ function createBasicOperations(context) {
                 }
             }
         },
+        /**
+         * 2b) KVSQL METHOD: Leg2 Entry Compound
+         * --------------------------------------
+         * Atomically increments the activity Leg2 entry counter and seeds
+         * the GUID ledger with the ordinal IF NOT EXISTS.
+         *
+         * Returns: [activityValue, guidValue] as [number, number]
+         */
+        async collateLeg2Entry(key, // jobKey
+        activityField, // serialized activity collation field
+        increment, // always 1
+        guidField, // GUID string
+        multi) {
+            const { sql, params } = _collateLeg2Entry(context, key, activityField, increment, guidField);
+            if (multi) {
+                multi.addCommand(sql, params, 'array', (rows) => {
+                    return [parseFloat(rows[0].activity_value), parseFloat(rows[0].guid_value)];
+                });
+                return Promise.resolve([0, 0]);
+            }
+            else {
+                try {
+                    const res = await context.pgClient.query(sql, params);
+                    return [parseFloat(res.rows[0].activity_value), parseFloat(res.rows[0].guid_value)];
+                }
+                catch (error) {
+                    if (error?.message?.includes('closed') ||
+                        error?.message?.includes('queryable')) {
+                        return [0, 0];
+                    }
+                    throw error;
+                }
+            }
+        },
+        /**
+         * 2) KVSQL METHOD (non-transactional + transactional)
+         * ---------------------------------------------------
+         * Matches hincrbyfloat() pattern:
+         * - when multi is present: enqueue command and return 0 immediately
+         * - when multi absent: execute immediately and return parsed numeric value
+         *
+         * Returns: thresholdHit (0/1) as number
+         */
+        async setStatusAndCollateGuid(key, // jobKey
+        statusDelta, // semaphore delta
+        threshold, // desired threshold (usually 0)
+        guidField, // jobs_attributes.field for the guid ledger
+        guidWeight, // e.g. 100B digit increment
+        multi) {
+            const { sql, params } = _setStatusAndCollateGuid(context, key, statusDelta, threshold, guidField, guidWeight);
+            if (multi) {
+                multi.addCommand(sql, params, 'number', (rows) => {
+                    return parseFloat(rows[0].value);
+                });
+                return Promise.resolve(0);
+            }
+            else {
+                try {
+                    const res = await context.pgClient.query(sql, params);
+                    return parseFloat(res.rows[0].value);
+                }
+                catch (error) {
+                    // Connection closed during test cleanup - return 0
+                    if (error?.message?.includes('closed') ||
+                        error?.message?.includes('queryable')) {
+                        return 0;
+                    }
+                    throw error;
+                }
+            }
+        },
     };
 }
 exports.createBasicOperations = createBasicOperations;
@@ -508,3 +579,124 @@ function _hincrbyfloat(context, key, field, increment) {
     }
 }
 exports._hincrbyfloat = _hincrbyfloat;
+/**
+ * 3b) LOW-LEVEL SQL GENERATOR: Leg2 Entry Compound
+ * -------------------------------------------------
+ * Atomically:
+ * - increments the activity collation field by +1 (Leg2 entry counter)
+ * - seeds the GUID ledger with the ordinal (last 8 digits of activity value)
+ *   IF the GUID row does not yet exist; returns the existing value if it does
+ * - returns both (activity_value, guid_value) for the caller
+ *
+ * The GUID seed uses ON CONFLICT DO UPDATE SET value = existing.value
+ * (a no-op update) so that RETURNING fires in both insert and conflict cases.
+ */
+function _collateLeg2Entry(context, key, // jobKey
+activityField, // serialized activity collation field name
+increment, // always 1 for Leg2 entry
+guidField) {
+    const jobsTableName = context.tableForKey(key, 'hash');
+    if (!(0, utils_1.isJobsTable)(jobsTableName)) {
+        throw new Error(`_collateLeg2Entry requires a jobs table key; got table ${jobsTableName}`);
+    }
+    const attrsTable = `${jobsTableName}_attributes`;
+    const sql = `
+    WITH activity_update AS (
+      INSERT INTO ${attrsTable} (job_id, field, value, type)
+      SELECT id, $2, ($3::double precision)::text, $4
+      FROM ${jobsTableName}
+      WHERE key = $1 AND is_live
+      ON CONFLICT (job_id, field) DO UPDATE
+      SET value = ((COALESCE(${attrsTable}.value, '0')::double precision) + $3::double precision)::text,
+          type = EXCLUDED.type
+      RETURNING job_id, value::double precision AS activity_value
+    ),
+    guid_upsert AS (
+      INSERT INTO ${attrsTable} (job_id, field, value, type)
+      SELECT
+        job_id,
+        $5,
+        ((activity_value::bigint) % 100000000)::text,
+        $6
+      FROM activity_update
+      ON CONFLICT (job_id, field) DO UPDATE
+      SET value = ${attrsTable}.value
+      RETURNING value::double precision AS guid_value
+    )
+    SELECT
+      (SELECT activity_value FROM activity_update) AS activity_value,
+      (SELECT guid_value FROM guid_upsert) AS guid_value
+  `;
+    return {
+        sql,
+        params: [
+            key,
+            activityField,
+            increment,
+            (0, utils_1.deriveType)(activityField),
+            guidField,
+            (0, utils_1.deriveType)(guidField), // $6
+        ],
+    };
+}
+exports._collateLeg2Entry = _collateLeg2Entry;
+/**
+ * 3) LOW-LEVEL SQL GENERATOR
+ * --------------------------
+ * This is the core compound statement. It must:
+ * - update jobs.status by statusDelta
+ * - compute thresholdHit (0/1) when status_after == threshold
+ * - increment the guidField by thresholdHit * guidWeight (typically 100B digit)
+ * - return thresholdHit as "value" so it fits the existing return parsing
+ *
+ * Notes:
+ * - Uses tableForKey(key, 'hash') which will resolve to the jobs table for job keys.
+ * - Assumes jobs_attributes table is `${jobsTableName}_attributes` (same as _hincrbyfloat)
+ * - Uses deriveType(guidField) to be consistent with your attribute typing system.
+ */
+function _setStatusAndCollateGuid(context, key, // jobKey
+statusDelta, threshold, guidField, guidWeight) {
+    const jobsTableName = context.tableForKey(key, 'hash');
+    if (!(0, utils_1.isJobsTable)(jobsTableName)) {
+        throw new Error(`_setStatusAndCollateGuid requires a jobs table key; got table ${jobsTableName}`);
+    }
+    const sql = `
+    WITH status_update AS (
+      UPDATE ${jobsTableName}
+      SET status = status + $2
+      WHERE key = $1 AND is_live
+      RETURNING id AS job_id, status AS status_after
+    ),
+    hit AS (
+      SELECT
+        job_id,
+        CASE WHEN status_after = $3 THEN 1 ELSE 0 END AS threshold_hit,
+        CASE WHEN status_after = $3 THEN ($4::double precision) ELSE 0::double precision END AS guid_increment
+      FROM status_update
+    )
+    INSERT INTO ${jobsTableName}_attributes (job_id, field, value, type)
+    SELECT
+      job_id,
+      $5 AS field,
+      (guid_increment)::text AS value,
+      $6
+    FROM hit
+    ON CONFLICT (job_id, field) DO UPDATE
+    SET
+      value = ((COALESCE(${jobsTableName}_attributes.value, '0')::double precision) + EXCLUDED.value::double precision)::text,
+      type = EXCLUDED.type
+    RETURNING (SELECT threshold_hit::text FROM hit) AS value
+  `;
+    return {
+        sql,
+        params: [
+            key,
+            statusDelta,
+            threshold,
+            guidWeight,
+            guidField,
+            (0, utils_1.deriveType)(guidField), // $6
+        ],
+    };
+}
+exports._setStatusAndCollateGuid = _setStatusAndCollateGuid;

package/build/services/store/providers/postgres/kvtypes/hash/index.d.ts

@@ -8,6 +8,8 @@ export declare const hashModule: (context: KVSQL) => {
     _hdel: (key: string, fields: string[]) => import("./types").SqlResult;
     _hmget: (key: string, fields: string[]) => import("./types").SqlResult;
     _hincrbyfloat: (key: string, field: string, increment: number) => import("./types").SqlResult;
+    _collateLeg2Entry: (key: string, activityField: string, increment: number, guidField: string) => import("./types").SqlResult;
+    _setStatusAndCollateGuid: (key: string, statusDelta: number, threshold: number, guidField: string, guidWeight: number) => import("./types").SqlResult;
     _hscan: (key: string, cursor: string, count: number, pattern?: string) => import("./types").SqlResult;
     _expire: (key: string, seconds: number) => import("./types").SqlResult;
     _scan: (cursor: number, count: number, pattern?: string) => import("./types").SqlResult;
@@ -24,6 +26,8 @@ export declare const hashModule: (context: KVSQL) => {
     hmget(key: string, fields: string[], multi?: import("./types").ProviderTransaction): Promise<string[]>;
     hgetall(key: string, multi?: import("./types").ProviderTransaction): Promise<Record<string, string>>;
     hincrbyfloat(key: string, field: string, increment: number, multi?: import("./types").ProviderTransaction): Promise<number>;
+    collateLeg2Entry(key: string, activityField: string, increment: number, guidField: string, multi?: import("./types").ProviderTransaction): Promise<[number, number]>;
+    setStatusAndCollateGuid(key: string, statusDelta: number, threshold: number, guidField: string, guidWeight: number, multi?: import("./types").ProviderTransaction): Promise<number>;
 };
 export { isJobsTable, deriveType } from './utils';
 export * from './types';

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

@@ -199,6 +199,12 @@ const hashModule = (context) => {
         _hincrbyfloat: (key, field, increment) => {
             return (0, basic_1._hincrbyfloat)(context, key, field, increment);
         },
+        _collateLeg2Entry: (key, activityField, increment, guidField) => {
+            return (0, basic_1._collateLeg2Entry)(context, key, activityField, increment, guidField);
+        },
+        _setStatusAndCollateGuid: (key, statusDelta, threshold, guidField, guidWeight) => {
+            return (0, basic_1._setStatusAndCollateGuid)(context, key, statusDelta, threshold, guidField, guidWeight);
+        },
         _hscan: (key, cursor, count, pattern) => {
             return (0, scan_1._hscan)(context, key, cursor, count, pattern);
         },

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

@@ -61,6 +61,20 @@ declare class PostgresStoreService extends StoreService<ProviderClient, Provider
     getJobStats(jobKeys: string[]): Promise<JobStatsRange>;
     getJobIds(indexKeys: string[], idRange: [number, number]): Promise<IdsData>;
     setStatus(collationKeyStatus: number, jobId: string, appId: string, transaction?: ProviderTransaction): Promise<any>;
+    /**
+     * 1) HIGH-LEVEL STORE METHOD (engine/activity-facing)
+     * ---------------------------------------------------
+     * Mirrors setStatus(), but performs the compound Step-2 requirement:
+     * - apply delta to job semaphore (jobs.status)
+     * - compute thresholdHit (0/1) for desired threshold
+     * - persist thresholdHit onto the Leg2 GUID ledger by incrementing the 100B digit (or other weight)
+     * - return thresholdHit (0/1)
+     */
+    setStatusAndCollateGuid(statusDelta: number, // typically (N - 1)
+    threshold: number, // typically 0 (but supports 0,1,12,...)
+    jobId: string, appId: string, guidField: string, // the jobs_attributes.field for the Leg2 GUID ledger row
+    guidWeight: number, // e.g. 100_000_000_000 for GUID 100B digit
+    transaction?: ProviderTransaction): Promise<number>;
     getStatus(jobId: string, appId: string): Promise<number>;
     setState({ ...state }: StringAnyType, status: number | null, jobId: string, symbolNames: string[], dIds: StringStringType, transaction?: ProviderTransaction): Promise<string>;
     /**
@@ -76,6 +90,12 @@ declare class PostgresStoreService extends StoreService<ProviderClient, Provider
      * in order to track their progress during processing.
      */
     collate(jobId: string, activityId: string, amount: number, dIds: StringStringType, transaction?: ProviderTransaction): Promise<number>;
+    /**
+     * Compound Leg2 entry: atomically increments the activity Leg2 entry
+     * counter and seeds the GUID ledger with the ordinal IF NOT EXISTS.
+     * Returns [activityValue, guidValue].
+     */
+    collateLeg2Entry(jobId: string, activityId: string, guid: string, dIds: StringStringType, transaction?: ProviderTransaction): Promise<[number, number]>;
     /**
      * Synthentic collation affects those activities in the graph
      * that represent the synthetic DAG that was materialized during compilation;

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

@@ -439,6 +439,23 @@ class PostgresStoreService extends __1.StoreService {
         const jobKey = this.mintKey(key_1.KeyType.JOB_STATE, { appId, jobId });
         return await this.kvsql(transaction).hincrbyfloat(jobKey, ':', collationKeyStatus);
     }
+    /**
+     * 1) HIGH-LEVEL STORE METHOD (engine/activity-facing)
+     * ---------------------------------------------------
+     * Mirrors setStatus(), but performs the compound Step-2 requirement:
+     * - apply delta to job semaphore (jobs.status)
+     * - compute thresholdHit (0/1) for desired threshold
+     * - persist thresholdHit onto the Leg2 GUID ledger by incrementing the 100B digit (or other weight)
+     * - return thresholdHit (0/1)
+     */
+    async setStatusAndCollateGuid(statusDelta, // typically (N - 1)
+    threshold, // typically 0 (but supports 0,1,12,...)
+    jobId, appId, guidField, // the jobs_attributes.field for the Leg2 GUID ledger row
+    guidWeight, // e.g. 100_000_000_000 for GUID 100B digit
+    transaction) {
+        const jobKey = this.mintKey(key_1.KeyType.JOB_STATE, { appId, jobId });
+        return await this.kvsql(transaction).setStatusAndCollateGuid(jobKey, statusDelta, threshold, guidField, guidWeight);
+    }
     async getStatus(jobId, appId) {
         const jobKey = this.mintKey(key_1.KeyType.JOB_STATE, { appId, jobId });
         const status = await this.kvsql().hget(jobKey, ':');
@@ -551,6 +568,26 @@ class PostgresStoreService extends __1.StoreService {
         const targetId = Object.keys(hashData)[0];
         return await this.kvsql(transaction).hincrbyfloat(jobKey, targetId, amount);
     }
+    /**
+     * Compound Leg2 entry: atomically increments the activity Leg2 entry
+     * counter and seeds the GUID ledger with the ordinal IF NOT EXISTS.
+     * Returns [activityValue, guidValue].
+     */
+    async collateLeg2Entry(jobId, activityId, guid, dIds, transaction) {
+        const jobKey = this.mintKey(key_1.KeyType.JOB_STATE, {
+            appId: this.appId,
+            jobId,
+        });
+        const collationKey = `${activityId}/output/metadata/as`;
+        const symbolNames = [activityId];
+        const symKeys = await this.getSymbolKeys(symbolNames);
+        const symVals = await this.getSymbolValues();
+        this.serializer.resetSymbols(symKeys, symVals, dIds);
+        const payload = { [collationKey]: '1' };
+        const hashData = this.serializer.package(payload, symbolNames);
+        const targetId = Object.keys(hashData)[0];
+        return await this.kvsql(transaction).collateLeg2Entry(jobKey, targetId, 1, guid);
+    }
     /**
      * Synthentic collation affects those activities in the graph
      * that represent the synthetic DAG that was materialized during compilation;
@@ -1044,7 +1081,7 @@ class PostgresStoreService extends __1.StoreService {
             const sql = (0, time_notify_1.getTimeNotifySql)(schemaName);
             // Execute the entire SQL as one statement (functions contain $$ blocks with semicolons)
             await client.query(sql);
-            this.logger.info('postgres-time-notifications-deployed', {
+            this.logger.debug('postgres-time-notifications-deployed', {
                 appId,
                 schemaName,
                 message: 'Time-aware notifications ENABLED - using LISTEN/NOTIFY instead of polling',

package/build/services/stream/factory.js

@@ -2,8 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamServiceFactory = void 0;
 const utils_1 = require("../../modules/utils");
-const ioredis_1 = require("./providers/redis/ioredis");
-const redis_1 = require("./providers/redis/redis");
 const nats_1 = require("./providers/nats/nats");
 const postgres_1 = require("./providers/postgres/postgres");
 class StreamServiceFactory {
@@ -11,24 +9,10 @@ class StreamServiceFactory {
         let service;
         const providerType = (0, utils_1.identifyProvider)(provider);
         if (providerType === 'nats') {
-            let redisStoreProvider;
-            if ((0, utils_1.identifyProvider)(storeProvider) === 'redis') {
-                redisStoreProvider = storeProvider;
-            }
-            else {
-                //ioredis
-                redisStoreProvider = storeProvider;
-            }
-            service = new nats_1.NatsStreamService(provider, redisStoreProvider);
+            service = new nats_1.NatsStreamService(provider, storeProvider);
         }
         else if (providerType === 'postgres') {
             service = new postgres_1.PostgresStreamService(provider, storeProvider);
-        }
-        else if (providerType === 'redis') {
-            service = new redis_1.RedisStreamService(provider, storeProvider);
-        }
-        else if (providerType === 'ioredis') {
-            service = new ioredis_1.IORedisStreamService(provider, storeProvider);
         } //etc register other providers here
         await service.init(namespace, appId, logger);
         return service;

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

@@ -31,7 +31,7 @@ class ScoutManager {
         this.pollForVisibleMessagesLoop().catch((error) => {
             this.logger.error('postgres-stream-router-scout-start-error', { error });
         });
-        this.logger.info('postgres-stream-router-scout-started', {
+        this.logger.debug('postgres-stream-router-scout-started', {
             appId: this.appId,
             pollInterval: this.getRouterScoutInterval(),
             scoutInterval: enums_1.HMSH_ROUTER_SCOUT_INTERVAL_SECONDS,
@@ -204,7 +204,7 @@ class ScoutManager {
      */
     logPollingMetrics() {
         if (this.pollCount === 0) {
-            this.logger.info('postgres-stream-router-scout-metrics', {
+            this.logger.debug('postgres-stream-router-scout-metrics', {
                 message: 'No polling occurred during this session',
                 appId: this.appId,
             });

package/build/services/sub/factory.js

@@ -2,10 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SubServiceFactory = void 0;
 const utils_1 = require("../../modules/utils");
-const redis_1 = require("./providers/redis/redis");
 const postgres_1 = require("./providers/postgres/postgres");
 const nats_1 = require("./providers/nats/nats");
-const ioredis_1 = require("./providers/redis/ioredis");
 class SubServiceFactory {
     static async init(providerSubClient, providerPubClient, namespace, appId, engineId, logger) {
         let service;
@@ -13,15 +11,9 @@ class SubServiceFactory {
         if (providerType === 'nats') {
             service = new nats_1.NatsSubService(providerSubClient, providerPubClient);
         }
-        else if (providerType === 'redis') {
-            service = new redis_1.RedisSubService(providerSubClient, providerPubClient);
-        }
         else if (providerType === 'postgres') {
             service = new postgres_1.PostgresSubService(providerSubClient, providerPubClient);
-        }
-        else {
-            service = new ioredis_1.IORedisSubService(providerSubClient, providerPubClient);
-        }
+        } //etc
         await service.init(namespace, appId, engineId, logger);
         return service;
     }

package/build/services/sub/index.d.ts

@@ -17,6 +17,6 @@ declare abstract class SubService<ClientProvider extends ProviderClient> {
     abstract unsubscribe(keyType: KeyType.QUORUM, appId: string, topic?: string): Promise<void>;
     abstract psubscribe(keyType: KeyType.QUORUM, callback: SubscriptionCallback, appId: string, topic?: string): Promise<void>;
     abstract punsubscribe(keyType: KeyType.QUORUM, appId: string, topic?: string): Promise<void>;
-    abstract publish(keyType: KeyType, message: Record<string, any>, appId: string, topic?: string): Promise<boolean>;
+    abstract publish(keyType: KeyType, message: Record<string, any>, appId: string, topic?: string, transaction?: ProviderTransaction): Promise<boolean>;
 }
 export { SubService };

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

@@ -22,7 +22,7 @@ declare class PostgresSubService extends SubService<PostgresClientType & Provide
      * Should be called when the SubService instance is being destroyed.
      */
     cleanup(): Promise<void>;
-    publish(keyType: KeyType.QUORUM, message: Record<string, any>, appId: string, topic?: string): Promise<boolean>;
+    publish(keyType: KeyType.QUORUM, message: Record<string, any>, appId: string, topic?: string, transaction?: ProviderTransaction): Promise<boolean>;
     psubscribe(): Promise<void>;
     punsubscribe(): Promise<void>;
 }