@hotmeshio/hotmesh 0.15.1 → 0.16.1

package/build/modules/storage.d.ts

@@ -2,3 +2,4 @@
 import { AsyncLocalStorage } from 'async_hooks';
 export declare const asyncLocalStorage: AsyncLocalStorage<Map<string, any>>;
 export declare const activityAsyncLocalStorage: AsyncLocalStorage<Map<string, any>>;
+export declare const virtualAsyncLocalStorage: AsyncLocalStorage<Map<string, any>>;

package/build/modules/storage.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.activityAsyncLocalStorage = exports.asyncLocalStorage = void 0;
+exports.virtualAsyncLocalStorage = exports.activityAsyncLocalStorage = exports.asyncLocalStorage = void 0;
 const async_hooks_1 = require("async_hooks");
 exports.asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
 exports.activityAsyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
+exports.virtualAsyncLocalStorage = new async_hooks_1.AsyncLocalStorage();

package/build/package.json

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

package/build/services/activities/activity/state.d.ts

@@ -30,7 +30,7 @@ interface StateContext {
 export declare function setState(instance: StateContext, transaction?: ProviderTransaction): Promise<string>;
 export declare function getState(instance: StateContext): Promise<void>;
 export declare function setStatus(instance: StateContext, amount: number, transaction?: ProviderTransaction): Promise<void | any>;
-export declare function bindJobMetadata(instance: StateContext): void;
+export declare function bindJobMetadata(_instance: StateContext): void;
 export declare function bindActivityMetadata(instance: StateContext): void;
 export declare function bindJobState(instance: StateContext, state: StringAnyType): Promise<void>;
 export declare function bindActivityState(instance: StateContext, state: StringAnyType): void;

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

@@ -68,8 +68,9 @@ async function setStatus(instance, amount, transaction) {
 }
 exports.setStatus = setStatus;
 //─── metadata binding ────────────────────────────────────────────────
-function bindJobMetadata(instance) {
-    instance.context.metadata.ju = (0, utils_1.formatISODate)(new Date());
+function bindJobMetadata(_instance) {
+    // ju (job_updated) is maintained by the jobs.updated_at trigger —
+    // no need to serialize it into jobs_attributes on every activity.
 }
 exports.bindJobMetadata = bindJobMetadata;
 function bindActivityMetadata(instance) {

package/build/services/durable/exporter.js

@@ -676,9 +676,23 @@ class ExporterService {
         const metadata = state?.output?.metadata ?? state?.metadata;
         const stateData = state?.output?.data ?? state?.data;
         const jobCreated = metadata?.jc ?? stateData?.jc ?? metadata?.ac;
-        const jobUpdated = metadata?.ju ?? stateData?.ju ?? metadata?.au;
         const startTime = parseTimestamp(jobCreated);
-        const closeTime = parseTimestamp(jobUpdated);
+        // Derive close time from the latest activity update (au) in the
+        // timeline, falling back to metadata.au. ju is no longer updated
+        // after creation — jobs.updated_at is the authoritative source,
+        // but it's not available in the DurableJobExport format.
+        let latestAu = null;
+        for (const entry of raw.timeline || []) {
+            const val = entry.value;
+            const au = val?.au;
+            if (au) {
+                const parsed = parseTimestamp(au);
+                if (parsed && (!latestAu || parsed > latestAu)) {
+                    latestAu = parsed;
+                }
+            }
+        }
+        const closeTime = latestAu ?? parseTimestamp(metadata?.au);
         // ── Synthetic workflow_execution_started ─────────────────────────
         if (startTime) {
             events.push(makeEvent(nextId++, 'workflow_execution_started', 'workflow', startTime, null, false, {

package/build/services/pipe/functions/cron.js

@@ -30,6 +30,9 @@ class CronHandler {
      * ```
      */
     nextDelay(cronExpression) {
+        if (cronExpression == null || typeof cronExpression !== 'string') {
+            return -1;
+        }
         if (!(0, utils_1.isValidCron)(cronExpression)) {
             throw new Error(`Invalid cron expression: ${cronExpression}`);
         }

package/build/services/serializer/index.js

@@ -35,7 +35,7 @@ exports.MDATA_SYMBOLS = {
         ],
     },
     JOB_UPDATE: {
-        KEYS: ['ju', 'err'],
+        KEYS: ['err'],
     },
 };
 class SerializerService {

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

@@ -153,6 +153,20 @@ 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 {
@@ -251,27 +265,40 @@ const KVTables = (context) => ({
               CREATE INDEX IF NOT EXISTS idx_${tableDef.name}_context_gin 
               ON ${fullTableName} USING GIN (context);
             `);
-                        // Create partitions using a DO block
+                        // Create partitions with fillfactor 70: reserves 30% page space
+                        // for HOT updates (status update cycle in setStatusAndCollateGuid)
                         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)',
+                    'CREATE TABLE IF NOT EXISTS ${fullTableName}_part_%s PARTITION OF ${fullTableName}
+                    FOR VALUES WITH (modulus 8, remainder %s)
+                    WITH (fillfactor = 70)',
                     i, i
                   );
                 END LOOP;
               END$$;
             `);
-                        // Create optimized indexes
+                        // Original index for queries that filter on expired_at directly
+                        // (e.g. _hmget's WHERE expired_at IS NULL OR expired_at > NOW())
                         await client.query(`
-              CREATE INDEX IF NOT EXISTS idx_${tableDef.name}_key_expired_at 
+              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}_entity_status 
-              ON ${fullTableName} (entity, status);
+              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);
             `);
                         await client.query(`
               CREATE INDEX IF NOT EXISTS idx_${tableDef.name}_expired_at
@@ -303,7 +330,9 @@ const KVTables = (context) => ({
               BEFORE INSERT OR UPDATE ON ${fullTableName}
               FOR EACH ROW EXECUTE PROCEDURE ${schemaName}.update_is_live();
             `);
-                        // Create function to enforce uniqueness of live jobs
+                        // 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).
                         await client.query(`
               CREATE OR REPLACE FUNCTION ${schemaName}.enforce_live_job_uniqueness()
               RETURNS TRIGGER AS $$
@@ -312,8 +341,8 @@ const KVTables = (context) => ({
                   PERFORM pg_advisory_xact_lock(hashtextextended(NEW.key, 0));
                   IF EXISTS (
                     SELECT 1 FROM ${fullTableName}
-                    WHERE key = NEW.key 
-                    AND (expired_at IS NULL OR expired_at > NOW())
+                    WHERE key = NEW.key
+                    AND is_live
                     AND id <> NEW.id
                   ) THEN
                     RAISE EXCEPTION 'A live job with key % already exists.', NEW.key;
@@ -384,14 +413,16 @@ const KVTables = (context) => ({
                   FOR EACH ROW
                   EXECUTE FUNCTION ${schemaName}.update_attributes_updated_at();
             `);
-                        // Create partitions for attributes table
+                        // Create partitions with fillfactor 70: reserves 30% page space
+                        // for HOT updates (frequent upserts in hincrbyfloat/collateLeg2Entry)
                         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)',
+                    'CREATE TABLE IF NOT EXISTS ${attributesTableName}_part_%s PARTITION OF ${attributesTableName}
+                    FOR VALUES WITH (modulus 8, remainder %s)
+                    WITH (fillfactor = 70)',
                     i, i
                   );
                 END LOOP;
@@ -433,8 +464,16 @@ const KVTables = (context) => ({
               );
             `);
                         await client.query(`
-              CREATE INDEX IF NOT EXISTS idx_${tableDef.name}_key_score_member 
+              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,11 +292,19 @@ function _hset(context, key, fields, options) {
             params.push(key, fields[':'], options?.entity ?? null);
         }
         else {
-            // Update existing job or insert new one
+            // 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.
             sql = `
+        WITH existing AS (
+          UPDATE ${targetTable}
+          SET status = $2
+          WHERE key = $1 AND is_live
+          RETURNING 1
+        )
         INSERT INTO ${targetTable} (id, key, status, entity)
-        VALUES (gen_random_uuid(), $1, $2, $3)
-        ON CONFLICT (key) WHERE is_live DO UPDATE SET status = EXCLUDED.status
+        SELECT gen_random_uuid(), $1, $2, $3
+        WHERE NOT EXISTS (SELECT 1 FROM existing)
         RETURNING 1 as count
       `;
             params.push(key, fields[':'], options?.entity ?? null);
@@ -503,31 +511,20 @@ 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 * FROM job_data
+      SELECT 'status' AS field, status::text AS value FROM valid_job
+      UNION ALL
+      SELECT 'context' AS field, context::text AS value FROM valid_job
       UNION ALL
-      SELECT * FROM attribute_data;
+      SELECT symbol || dimension AS field, value
+      FROM ${tableName}_attributes
+      WHERE job_id = (SELECT id FROM valid_job);
     `;
         return { sql, params: [key] };
     }

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

@@ -83,6 +83,17 @@ 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.js

@@ -475,12 +475,10 @@ class PostgresStoreService extends __1.StoreService {
         const symVals = await this.getSymbolValues();
         this.serializer.resetSymbols(symKeys, symVals, dIds);
         const hashData = this.serializer.package(state, symbolNames);
-        if (status !== null) {
-            hashData[':'] = status.toString();
-        }
-        else {
-            delete hashData[':'];
-        }
+        // ':' (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[':'];
         await this.kvsql(transaction).hset(hashKey, hashData);
         return jobId;
     }

package/build/services/task/index.js

@@ -42,7 +42,7 @@ class TaskService {
     async registerTimeHook(jobId, gId, activityId, type, inSeconds = enums_1.HMSH_FIDELITY_SECONDS, dad, transaction) {
         const fromNow = Date.now() + inSeconds * 1000;
         const fidelityMS = enums_1.HMSH_FIDELITY_SECONDS * 1000;
-        const awakenTimeSlot = Math.floor(fromNow / fidelityMS) * fidelityMS;
+        const awakenTimeSlot = Math.ceil(fromNow / fidelityMS) * fidelityMS;
         await this.store.registerTimeHook(jobId, gId, activityId, type, awakenTimeSlot, dad, transaction);
     }
     /**

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

@@ -1,5 +1,5 @@
 import { HotMesh } from '../hotmesh';
-import { VirtualConnectParams, VirtualCronParams, VirtualExecParams, VirtualFlushParams, VirtualInstanceOptions, VirtualInterruptParams } from '../../types/virtual';
+import { VirtualConnectParams, VirtualContext, VirtualCronParams, VirtualExecParams, VirtualFlushParams, VirtualInstanceOptions, VirtualInterruptParams } from '../../types/virtual';
 import { ProviderConfig, ProvidersConfig } from '../../types/provider';
 /**
  * Virtual creates a virtual network of functions, connecting any
@@ -185,6 +185,27 @@ declare class Virtual {
      * ```
      */
     static interrupt(params: VirtualInterruptParams): Promise<boolean>;
+    /**
+     * Returns the execution context for the current Virtual callback.
+     * Must be called from inside a `Virtual.cron` or `Virtual.exec`
+     * callback — throws if called outside that scope.
+     *
+     * @example
+     * ```typescript
+     * await Virtual.cron({
+     *   topic: 'my.cron',
+     *   connection,
+     *   args: [],
+     *   options: { id: 'daily', interval: '0 0 * * *' },
+     *   callback: async () => {
+     *     const ctx = Virtual.getContext();
+     *     console.log(ctx.workflowId); // 'daily'
+     *     console.log(ctx.attempt);    // 1
+     *   },
+     * });
+     * ```
+     */
+    static getContext(): VirtualContext;
     /**
      * Shuts down all virtual instances. Call this method
      * from the SIGTERM handler in your application.

package/build/services/virtual/index.js

@@ -6,8 +6,14 @@ const hotmesh_1 = require("../hotmesh");
 const enums_1 = require("../../modules/enums");
 const utils_1 = require("../../modules/utils");
 const key_1 = require("../../modules/key");
+const storage_1 = require("../../modules/storage");
 const cron_1 = require("../pipe/functions/cron");
 const factory_1 = require("./schemas/factory");
+const DEFAULT_RETRY_POLICY = {
+    maximumAttempts: 3,
+    backoffCoefficient: 2,
+    maximumInterval: 30,
+};
 /**
  * Virtual creates a virtual network of functions, connecting any
  * function as an idempotent, cacheable endpoint. Call functions
@@ -173,13 +179,19 @@ class Virtual {
                 {
                     topic: params.topic,
                     connection,
-                    retry: params.retry ?? {
-                        maximumAttempts: 3,
-                        backoffCoefficient: 2,
-                        maximumInterval: 30,
-                    },
+                    retry: params.retry ?? DEFAULT_RETRY_POLICY,
                     callback: async function (input) {
-                        const response = await params.callback.apply(this, input.data.args);
+                        const context = new Map([
+                            ['topic', params.topic],
+                            ['workflowId', input.metadata.jid ?? ''],
+                            ['workflowName', input.metadata.wfn ?? ''],
+                            ['dimension', input.metadata.dad ?? ''],
+                            ['attempt', input.metadata.try ?? 1],
+                            ['guid', input.metadata.guid],
+                            ['traceId', input.metadata.trc ?? ''],
+                            ['spanId', input.metadata.spn ?? ''],
+                        ]);
+                        const response = await storage_1.virtualAsyncLocalStorage.run(context, () => params.callback.apply(this, input.data.args));
                         return {
                             metadata: { ...input.metadata },
                             data: { response },
@@ -386,6 +398,42 @@ class Virtual {
         }
         return true;
     }
+    /**
+     * Returns the execution context for the current Virtual callback.
+     * Must be called from inside a `Virtual.cron` or `Virtual.exec`
+     * callback — throws if called outside that scope.
+     *
+     * @example
+     * ```typescript
+     * await Virtual.cron({
+     *   topic: 'my.cron',
+     *   connection,
+     *   args: [],
+     *   options: { id: 'daily', interval: '0 0 * * *' },
+     *   callback: async () => {
+     *     const ctx = Virtual.getContext();
+     *     console.log(ctx.workflowId); // 'daily'
+     *     console.log(ctx.attempt);    // 1
+     *   },
+     * });
+     * ```
+     */
+    static getContext() {
+        const store = storage_1.virtualAsyncLocalStorage.getStore();
+        if (!store) {
+            throw new Error('Virtual.getContext() called outside of a Virtual callback execution context');
+        }
+        return {
+            topic: store.get('topic'),
+            workflowId: store.get('workflowId'),
+            workflowName: store.get('workflowName'),
+            dimension: store.get('dimension'),
+            attempt: store.get('attempt'),
+            guid: store.get('guid'),
+            traceId: store.get('traceId'),
+            spanId: store.get('spanId'),
+        };
+    }
     /**
      * Shuts down all virtual instances. Call this method
      * from the SIGTERM handler in your application.

package/build/types/index.d.ts

@@ -15,7 +15,7 @@ export { ExtensionType, JobCompletionOptions, JobData, JobsData, JobInterruptOpt
 export { MappingStatements } from './map';
 export { Pipe, PipeContext, PipeItem, PipeItems, PipeObject, ReduceObject, } from './pipe';
 export { ProviderClass, ProviderClient, ProviderConfig, ProviderTransaction, Providers, TransactionResultList, ProviderNativeClient, ProviderOptions, } from './provider';
-export { VirtualConnectParams, VirtualExecParams, VirtualCronParams, VirtualExecOptions, VirtualCronOptions, VirtualInterruptOptions, VirtualInterruptParams, VirtualFlushParams, } from './virtual';
+export { VirtualConnectParams, VirtualContext, VirtualExecParams, VirtualCronParams, VirtualExecOptions, VirtualCronOptions, VirtualInterruptOptions, VirtualInterruptParams, VirtualFlushParams, } from './virtual';
 export { PostgresClassType, PostgresClientOptions, PostgresClientType, PostgresConsumerGroup, PostgresPendingMessage, PostgresPoolClientType, PostgresQueryConfigType, PostgresQueryResultType, PostgresStreamMessage, PostgresStreamOptions, PostgresTransaction, } from './postgres';
 export { ActivateMessage, CronMessage, JobMessage, JobMessageCallback, PingMessage, PongMessage, QuorumMessage, QuorumMessageCallback, QuorumProfile, RollCallMessage, RollCallOptions, SubscriptionCallback, SubscriptionOptions, SystemHealth, ThrottleMessage, ThrottleOptions, WorkMessage, } from './quorum';
 export { NatsAckPolicy, NatsAckPolicyExplicitType, NatsClassType, NatsClientType, NatsClientOptions, NatsConsumerConfigType, NatsJetStreamManager, NatsConnection, NatsJetStreamType, NatsConnectionOptions, NatsConsumerConfig, NatsConsumerInfo, NatsConsumerManager, NatsDeliveryInfo, NatsJetStreamOptions, NatsError, NatsErrorType, NatsJetStreamClient, NatsJsMsg, NatsMessageType, NatsMsgExpect, NatsPubAck, NatsPubAckType, NatsPublishOptions, NatsRetentionPolicy, NatsRetentionPolicyWorkqueueType, NatsSequenceInfo, NatsStorageMemoryType, NatsStorageType, NatsStreamConfig, NatsStreamInfo, NatsStreamManager, NatsStreamConfigType, NatsStreamInfoType, NatsStreamOptions, NatsStreamState, NatsTransaction, } from './nats';

package/build/types/virtual.d.ts

@@ -208,4 +208,72 @@ interface VirtualInterruptParams {
      */
     options: VirtualInterruptOptions;
 }
-export { VirtualConnectParams, VirtualExecParams, VirtualCronParams, VirtualExecOptions, VirtualCronOptions, VirtualInterruptOptions, VirtualInterruptParams, VirtualFlushOptions, VirtualFlushParams, VirtualInstanceOptions, };
+/**
+ * Execution context available inside Virtual callbacks via
+ * `Virtual.getContext()`.  Populated automatically by the
+ * AsyncLocalStorage wrapper in `Virtual.connect()`.
+ *
+ * @example
+ * ```typescript
+ * await Virtual.cron({
+ *   topic: 'billing.daily',
+ *   connection,
+ *   args: [],
+ *   options: { id: 'billing-run', interval: '0 0 * * *' },
+ *   callback: async () => {
+ *     const ctx = Virtual.getContext();
+ *     // ctx.workflowId  === 'billing-run'
+ *     // ctx.topic        === 'billing.daily'
+ *     // ctx.guid         === unique per invocation
+ *   },
+ * });
+ * ```
+ */
+interface VirtualContext {
+    /**
+     * The worker topic that routed this invocation.
+     * Matches the `topic` passed to `Virtual.cron()` or
+     * `Virtual.connect()`.
+     */
+    topic: string;
+    /**
+     * Workflow / job ID.  For cron callbacks this is the `id`
+     * from `options.id`.  For `Virtual.exec` calls this is the
+     * auto-generated or user-supplied job identifier.
+     */
+    workflowId: string;
+    /**
+     * Internal workflow name (the graph subscription topic,
+     * e.g. `hmsh.cron` or `hmsh.call`).
+     */
+    workflowName: string;
+    /**
+     * Dimensional address for this execution within the
+     * workflow's DAG.  Encodes the cycle iteration and
+     * parallel branch position.
+     */
+    dimension: string;
+    /**
+     * Current retry attempt (1-based).  `1` on the first try,
+     * incremented on each retry per the `RetryPolicy`.
+     */
+    attempt: number;
+    /**
+     * Globally unique identifier for the stream message that
+     * triggered this callback.  A new GUID is minted for every
+     * invocation, including retries and cycle iterations, so it
+     * serves as an idempotency key for exactly-once processing.
+     */
+    guid: string;
+    /**
+     * OpenTelemetry trace ID propagated from the originating
+     * workflow.  Empty string when tracing is not configured.
+     */
+    traceId: string;
+    /**
+     * OpenTelemetry span ID propagated from the parent activity.
+     * Empty string when tracing is not configured.
+     */
+    spanId: string;
+}
+export { VirtualConnectParams, VirtualContext, VirtualExecParams, VirtualCronParams, VirtualExecOptions, VirtualCronOptions, VirtualInterruptOptions, VirtualInterruptParams, VirtualFlushOptions, VirtualFlushParams, VirtualInstanceOptions, };

package/package.json

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