@hotmeshio/hotmesh 0.22.0 → 0.22.1

package/build/modules/utils.d.ts

@@ -13,6 +13,8 @@ export declare function getSystemHealth(): Promise<SystemHealth>;
 export declare function deepCopy<T>(obj: T): T;
 export declare function deterministicRandom(seed: number): number;
 export declare function guid(size?: number): string;
+/** Returns a standard RFC 4122 v4 UUID (e.g. for use as a DB primary key). */
+export declare function uuid(): string;
 export declare function sleepFor(ms: number): Promise<void>;
 export declare function sleepImmediate(): Promise<void>;
 export declare function XSleepFor(ms: number): {

package/build/modules/utils.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.arrayToHash = exports.isStreamMessage = exports.parseStreamMessage = exports.normalizeRetryPolicy = exports.s = exports.isValidCron = exports.restoreHierarchy = exports.getValueByPath = exports.getIndexedHash = exports.getSymVal = exports.getSymKey = exports.formatISODate = exports.getTimeSeries = exports.getSubscriptionTopic = exports.findSubscriptionForTrigger = exports.findTopKey = exports.matchesStatus = exports.matchesStatusCode = exports.polyfill = exports.identifyProvider = exports.XSleepFor = exports.sleepImmediate = exports.sleepFor = exports.guid = exports.deterministicRandom = exports.deepCopy = exports.getSystemHealth = exports.hashOptions = void 0;
+exports.arrayToHash = exports.isStreamMessage = exports.parseStreamMessage = exports.normalizeRetryPolicy = exports.s = exports.isValidCron = exports.restoreHierarchy = exports.getValueByPath = exports.getIndexedHash = exports.getSymVal = exports.getSymKey = exports.formatISODate = exports.getTimeSeries = exports.getSubscriptionTopic = exports.findSubscriptionForTrigger = exports.findTopKey = exports.matchesStatus = exports.matchesStatusCode = exports.polyfill = exports.identifyProvider = exports.XSleepFor = exports.sleepImmediate = exports.sleepFor = exports.uuid = exports.guid = exports.deterministicRandom = exports.deepCopy = exports.getSystemHealth = exports.hashOptions = void 0;
 const os_1 = __importDefault(require("os"));
 const crypto_1 = require("crypto");
 const cron_parser_1 = require("cron-parser");
@@ -47,6 +47,11 @@ function guid(size = enums_1.HMSH_GUID_SIZE) {
     return `H` + (0, nanoid_1.nanoid)(size);
 }
 exports.guid = guid;
+/** Returns a standard RFC 4122 v4 UUID (e.g. for use as a DB primary key). */
+function uuid() {
+    return (0, crypto_1.randomUUID)();
+}
+exports.uuid = uuid;
 async function sleepFor(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.22.0",
+    "version": "0.22.1",
     "description": "Durable Workflow",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",
@@ -50,7 +50,7 @@
         "test:durable:signal": "vitest run tests/durable/signal/postgres.test.ts",
         "test:durable:readonly": "docker compose --profile readonly up -d --build && docker compose exec hotmesh-readonly npx vitest run --config tests/durable/readonly/vitest.config.mts",
         "test:durable:unknown": "vitest run tests/durable/unknown/postgres.test.ts",
-        "test:durable:esclations": "HMSH_LOGLEVEL=info vitest run tests/durable/escalations",
+        "test:durable:escalations": "HMSH_LOGLEVEL=info vitest run tests/durable/escalations",
         "test:durable:exporter": "HMSH_LOGLEVEL=info vitest run tests/durable/exporter",
         "test:durable:exporter:debug": "EXPORT_DEBUG=1 HMSH_LOGLEVEL=error vitest run tests/durable/basic/postgres.test.ts",
         "test:durable:codec": "vitest run tests/durable/codec/postgres.test.ts",
@@ -85,7 +85,12 @@
         "test:sub:nats": "vitest run tests/functional/sub/providers/nats/nats.test.ts",
         "test:trigger": "vitest run tests/unit/services/activities/trigger.test.ts",
         "test:virtual": "vitest run tests/virtual",
-        "test:unit": "vitest run tests/unit"
+        "test:unit": "vitest run tests/unit",
+        "prove": "docker compose exec hotmesh npx vitest run tests/durable 2>&1 | tee /tmp/hmsh-durable.txt && grep -E 'FAIL|Tests |Files ' /tmp/hmsh-durable.txt | tail -5",
+        "prove:escalations": "docker compose exec hotmesh npx vitest run tests/durable/escalations/postgres.test.ts 2>&1 | tee /tmp/hmsh-escalations.txt && grep -E 'FAIL|Tests |Files ' /tmp/hmsh-escalations.txt | tail -5",
+        "prove:functional": "docker compose exec hotmesh npx vitest run tests/functional 2>&1 | tee /tmp/hmsh-functional.txt && grep -E 'FAIL|Tests |Files ' /tmp/hmsh-functional.txt | tail -5",
+        "prove:all": "docker compose exec hotmesh npx vitest run tests/ 2>&1 | tee /tmp/hmsh-all.txt && grep -E 'FAIL|Tests |Files ' /tmp/hmsh-all.txt | tail -5",
+        "prove:file": "f() { docker compose exec hotmesh npx vitest run \"$@\" 2>&1 | tee /tmp/hmsh-file.txt && grep -E 'FAIL|Tests |Files ' /tmp/hmsh-file.txt | tail -5; }; f"
     },
     "keywords": [
         "Invisible Infrastructure",

package/build/services/durable/client.d.ts

@@ -1,6 +1,6 @@
 import { HotMesh } from '../hotmesh';
 import { ClientConfig, ClientWorkflow, Connection, WorkflowOptions } from '../../types/durable';
-import { EscalationEntry, ClaimEscalationResult, ClaimByMetadataResult, ReleaseEscalationResult, ResolveEscalationResult, CancelEscalationResult, ListEscalationsParams, CreateEscalationParams, UpdateEscalationParams, AppendMilestonesParams, ClaimEscalationParams, ClaimByMetadataParams, ReleaseEscalationParams, ResolveEscalationParams, ResolveByMetadataParams, EscalateToRoleParams } from '../../types/hmsh_escalations';
+import { EscalationEntry, ClaimEscalationResult, ClaimByMetadataResult, ReleaseEscalationResult, ResolveEscalationResult, CancelEscalationResult, ListEscalationsParams, CreateEscalationParams, UpdateEscalationParams, AppendMilestonesParams, ClaimEscalationParams, ClaimByMetadataParams, ReleaseEscalationParams, ResolveEscalationParams, ResolveByMetadataParams, EscalateToRoleParams, MigrateEscalationParams } from '../../types/hmsh_escalations';
 /**
  * Workflow client. Starts workflows, sends signals, and reads results.
  *
@@ -320,6 +320,26 @@ export declare class ClientService {
          * ```
          */
         resolveByMetadata: (params: ResolveByMetadataParams, namespace?: string) => Promise<ResolveEscalationResult>;
+        /**
+         * Full-fidelity migration: inserts an escalation row preserving the original
+         * UUID and all lifecycle state. Returns the inserted row, or `null` if the
+         * UUID already exists (idempotent — safe to call multiple times with the same
+         * `params.id`). Use this to migrate rows from a legacy escalation table to
+         * `hmsh_escalations` without losing original IDs or state.
+         *
+         * @example
+         * ```typescript
+         * const entry = await client.escalations.migrate({
+         *   id: 'original-uuid',
+         *   status: 'resolved',
+         *   resolvedAt: new Date('2025-01-01'),
+         *   type: 'order-approval',
+         *   role: 'approver',
+         * });
+         * // null on subsequent calls with the same id — idempotent
+         * ```
+         */
+        migrate: (params: MigrateEscalationParams, namespace?: string) => Promise<EscalationEntry | null>;
         /**
          * Releases all claimed escalations whose `claim_expires_at` has lapsed,
          * returning them to `pending` so they can be claimed again. Returns the
@@ -334,6 +354,21 @@ export declare class ClientService {
          */
         releaseExpired: (namespace?: string) => Promise<number>;
     };
+    /**
+     * Delivers a signal to the registered escalation topic.
+     *
+     * When the topic is known (stored at condition() time), we deliver only to that
+     * topic. This avoids writing a stale pending entry to the alternate stream, which
+     * would interfere with concurrent consumers in other workflows or tests.
+     *
+     * When topic is null (legacy/standalone rows with no registered topic), we try
+     * both wfs.signal and wfs.wait unconditionally — engine.signal() on the wrong
+     * topic stores pending without throwing, so a sequential fallback would skip
+     * the second topic and leave single-condition workflows permanently suspended.
+     *
+     * @private
+     */
+    private _deliverEscalationSignal;
     /**
      * @private
      */

package/build/services/durable/client.js

@@ -528,33 +528,26 @@ class ClientService {
                 const ns = (params.namespace ?? namespace) ?? factory_1.APP_ID;
                 const hotMeshClient = await this.getHotMeshClient(null, ns);
                 const store = hotMeshClient.engine.store;
-                // UUID primary-key lookup — no namespace filter needed; use existing.namespace for the UPDATE.
-                const existing = await store.getEscalation(params.id);
-                if (!existing)
-                    return { ok: false, reason: 'not-found' };
-                if (existing.status === 'resolved')
-                    return { ok: false, reason: 'already-resolved' };
-                if (existing.status === 'cancelled')
-                    return { ok: false, reason: 'already-cancelled' };
-                // Build a single atomic transaction: signal stream INSERTs + escalation UPDATE in one BEGIN/COMMIT.
-                // engine.signal() with a transaction queues an INSERT into the stream table without executing;
-                // queueResolveEscalation() queues the status UPDATE; txn.exec() commits all in one round-trip.
-                const txn = store.transact();
-                if (existing.signal_key && existing.topic) {
-                    const signalPayload = { id: existing.signal_key, data: params.resolverPayload ?? {} };
-                    try {
-                        const sc = await this.getHotMeshClient(`${ns}.wfs.signal`, ns);
-                        await sc.engine.signal(`${ns}.wfs.signal`, signalPayload, types_1.StreamStatus.SUCCESS, 200, txn);
-                    }
-                    catch { /* no collator hook rule — skip */ }
-                    try {
-                        const wc = await this.getHotMeshClient(`${ns}.wfs.wait`, ns);
-                        await wc.engine.signal(`${ns}.wfs.wait`, signalPayload, types_1.StreamStatus.SUCCESS, 200, txn);
-                    }
-                    catch { /* no waiter hook rule — skip */ }
+                // store.resolveEscalation() uses FOR UPDATE inside its CTE, serializing concurrent
+                // callers at the DB level. The second caller blocks on the row lock, reads
+                // 'already-resolved' after the first commits, and returns — no signal is queued.
+                // This eliminates the double-signal race that the previous KVTransaction approach
+                // had: two concurrent callers could both pass the unlocked getEscalation() read,
+                // both queue signal INSERTs, and both commit them — even though only one UPDATE won.
+                const dbResult = await store.resolveEscalation({
+                    id: params.id,
+                    resolverPayload: params.resolverPayload,
+                    // namespace intentionally omitted — UUID lookup; passing ns would miss rows
+                    // stored under namespace 'hmsh' (the engine default) when ns = APP_ID = 'durable'.
+                });
+                if (!dbResult.ok)
+                    return dbResult;
+                if (dbResult.signalKey) {
+                    const signalPayload = { id: dbResult.signalKey, data: params.resolverPayload ?? {} };
+                    const delivered = await this._deliverEscalationSignal(ns, dbResult.topic, signalPayload);
+                    if (!delivered)
+                        return { ok: false, reason: 'signal-failed' };
                 }
-                store.queueResolveEscalation({ id: params.id, namespace: existing.namespace ?? ns, resolverPayload: params.resolverPayload }, txn);
-                await txn.exec();
                 return { ok: true };
             },
             /**
@@ -575,33 +568,49 @@ class ClientService {
                 const ns = (params.namespace ?? namespace) ?? factory_1.APP_ID;
                 const hotMeshClient = await this.getHotMeshClient(null, ns);
                 const store = hotMeshClient.engine.store;
-                // Metadata lookup: filter by namespace to scope correctly, but use existing.namespace for the UPDATE.
-                const existing = await store.findEscalationByMetadata(params.key, params.value, params.roles ?? null);
-                if (!existing)
-                    return { ok: false, reason: 'not-found' };
-                if (existing.status === 'resolved')
-                    return { ok: false, reason: 'already-resolved' };
-                if (existing.status === 'cancelled')
-                    return { ok: false, reason: 'already-cancelled' };
-                // Same atomic pattern as resolve(): signal INSERTs + UPDATE in one transaction.
-                const txn = store.transact();
-                if (existing.signal_key && existing.topic) {
-                    const signalPayload = { id: existing.signal_key, data: params.resolverPayload ?? {} };
-                    try {
-                        const sc = await this.getHotMeshClient(`${ns}.wfs.signal`, ns);
-                        await sc.engine.signal(`${ns}.wfs.signal`, signalPayload, types_1.StreamStatus.SUCCESS, 200, txn);
-                    }
-                    catch { /* no collator hook rule — skip */ }
-                    try {
-                        const wc = await this.getHotMeshClient(`${ns}.wfs.wait`, ns);
-                        await wc.engine.signal(`${ns}.wfs.wait`, signalPayload, types_1.StreamStatus.SUCCESS, 200, txn);
-                    }
-                    catch { /* no waiter hook rule — skip */ }
+                // Same FOR UPDATE CTE serialization as resolve(). Metadata filter selects
+                // the highest-priority matching row; the lock prevents concurrent callers
+                // from both resolving it.
+                const dbResult = await store.resolveEscalationByMetadata({
+                    key: params.key,
+                    value: params.value,
+                    resolverPayload: params.resolverPayload,
+                    roles: params.roles,
+                });
+                if (!dbResult.ok)
+                    return dbResult;
+                if (dbResult.signalKey) {
+                    const signalPayload = { id: dbResult.signalKey, data: params.resolverPayload ?? {} };
+                    const delivered = await this._deliverEscalationSignal(ns, dbResult.topic, signalPayload);
+                    if (!delivered)
+                        return { ok: false, reason: 'signal-failed' };
                 }
-                store.queueResolveEscalation({ id: existing.id, namespace: existing.namespace ?? ns, resolverPayload: params.resolverPayload }, txn);
-                await txn.exec();
                 return { ok: true };
             },
+            /**
+             * Full-fidelity migration: inserts an escalation row preserving the original
+             * UUID and all lifecycle state. Returns the inserted row, or `null` if the
+             * UUID already exists (idempotent — safe to call multiple times with the same
+             * `params.id`). Use this to migrate rows from a legacy escalation table to
+             * `hmsh_escalations` without losing original IDs or state.
+             *
+             * @example
+             * ```typescript
+             * const entry = await client.escalations.migrate({
+             *   id: 'original-uuid',
+             *   status: 'resolved',
+             *   resolvedAt: new Date('2025-01-01'),
+             *   type: 'order-approval',
+             *   role: 'approver',
+             * });
+             * // null on subsequent calls with the same id — idempotent
+             * ```
+             */
+            migrate: async (params, namespace) => {
+                const ns = (params.namespace ?? namespace) ?? factory_1.APP_ID;
+                const hotMeshClient = await this.getHotMeshClient(null, ns);
+                return hotMeshClient.engine.store.createEscalationForMigration(params);
+            },
             /**
              * Releases all claimed escalations whose `claim_expires_at` has lapsed,
              * returning them to `pending` so they can be claimed again. Returns the
@@ -694,6 +703,46 @@ class ClientService {
             }
         }
     }
+    /**
+     * Delivers a signal to the registered escalation topic.
+     *
+     * When the topic is known (stored at condition() time), we deliver only to that
+     * topic. This avoids writing a stale pending entry to the alternate stream, which
+     * would interfere with concurrent consumers in other workflows or tests.
+     *
+     * When topic is null (legacy/standalone rows with no registered topic), we try
+     * both wfs.signal and wfs.wait unconditionally — engine.signal() on the wrong
+     * topic stores pending without throwing, so a sequential fallback would skip
+     * the second topic and leave single-condition workflows permanently suspended.
+     *
+     * @private
+     */
+    async _deliverEscalationSignal(ns, topic, signalPayload) {
+        if (topic) {
+            // Registered topic known — deliver precisely, no stream pollution.
+            try {
+                const tc = await this.getHotMeshClient(topic, ns);
+                await tc.engine.signal(topic, signalPayload, types_1.StreamStatus.SUCCESS, 200);
+                return true;
+            }
+            catch { /* topic not currently registered — fall through */ }
+        }
+        // Topic unknown or primary delivery failed — try both topics unconditionally.
+        let delivered = false;
+        try {
+            const sc = await this.getHotMeshClient(`${ns}.wfs.signal`, ns);
+            await sc.engine.signal(`${ns}.wfs.signal`, signalPayload, types_1.StreamStatus.SUCCESS, 200);
+            delivered = true;
+        }
+        catch { /* no collator hook rule for this workflow */ }
+        try {
+            const wc = await this.getHotMeshClient(`${ns}.wfs.wait`, ns);
+            await wc.engine.signal(`${ns}.wfs.wait`, signalPayload, types_1.StreamStatus.SUCCESS, 200);
+            delivered = true;
+        }
+        catch { /* no waiter hook rule for this workflow */ }
+        return delivered;
+    }
     /**
      * @private
      */

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

@@ -1,6 +1,6 @@
 import { HotMesh } from '../hotmesh';
 import { ContextType, WorkflowInboundCallsInterceptor, WorkflowOutboundCallsInterceptor, ActivityInboundCallsInterceptor } from '../../types/durable';
-import { guid } from '../../modules/utils';
+import { guid, uuid } from '../../modules/utils';
 import { ClientService } from './client';
 import { ConnectionService } from './connection';
 import { Search } from './search';
@@ -277,6 +277,12 @@ declare class DurableClass {
      * Generate a unique identifier for workflow IDs
      */
     static guid: typeof guid;
+    /**
+     * Generate a standard RFC 4122 v4 UUID — use for DB primary keys and
+     * any context that requires a hyphenated UUID format rather than the
+     * compact HotMesh guid format.
+     */
+    static uuid: typeof uuid;
     /**
      * Provision a scoped Postgres role for a worker. The role can only
      * dequeue, ack, and respond on its assigned stream names via stored

package/build/services/durable/index.js

@@ -310,6 +310,12 @@ DurableClass.interceptorService = new interceptor_1.InterceptorService();
  * Generate a unique identifier for workflow IDs
  */
 DurableClass.guid = utils_1.guid;
+/**
+ * Generate a standard RFC 4122 v4 UUID — use for DB primary keys and
+ * any context that requires a hyphenated UUID format rather than the
+ * compact HotMesh guid format.
+ */
+DurableClass.uuid = utils_1.uuid;
 /**
  * Provision a scoped Postgres role for a worker. The role can only
  * dequeue, ack, and respond on its assigned stream names via stored

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

@@ -237,6 +237,13 @@ declare class PostgresStoreService extends StoreService<ProviderClient, Provider
      * idempotent re-runs after a crash.
      */
     addEscalationToTransaction(params: import('../../../../types/hmsh_escalations').CreateEscalationParams, transaction: import('../../../../types/provider').ProviderTransaction): void;
+    /**
+     * Full-fidelity INSERT for data migration. Preserves the original `id` (UUID),
+     * lifecycle state, and timestamps from the source table. Uses
+     * `ON CONFLICT (id) DO NOTHING` so re-running a migration batch is safe —
+     * rows that already exist are skipped and `null` is returned for them.
+     */
+    createEscalationForMigration(params: import('../../../../types/hmsh_escalations').MigrateEscalationParams): Promise<import('../../../../types/hmsh_escalations').EscalationEntry | null>;
     getEscalation(id: string, namespace?: string): Promise<import('../../../../types/hmsh_escalations').EscalationEntry | null>;
     getEscalationBySignalKey(signalKey: string, namespace?: string): Promise<import('../../../../types/hmsh_escalations').EscalationEntry | null>;
     listEscalations(params?: import('../../../../types/hmsh_escalations').ListEscalationsParams): Promise<import('../../../../types/hmsh_escalations').EscalationEntry[]>;

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

@@ -1440,6 +1440,68 @@ class PostgresStoreService extends __1.StoreService {
     addEscalationToTransaction(params, transaction) {
         transaction.addCommand(this._escalationInsertSql, this._escalationInsertParams(params), 'void');
     }
+    /**
+     * Full-fidelity INSERT for data migration. Preserves the original `id` (UUID),
+     * lifecycle state, and timestamps from the source table. Uses
+     * `ON CONFLICT (id) DO NOTHING` so re-running a migration batch is safe —
+     * rows that already exist are skipped and `null` is returned for them.
+     */
+    async createEscalationForMigration(params) {
+        const { id, namespace, appId, signalKey, topic, workflowId, taskQueue, workflowType, type, subtype, entity, description, role, priority, originId, parentId, initiatedBy, createdBy, traceId, spanId, escalationPayload, metadata, envelope, expiresAt, status, assignedTo, claimExpiresAt, claimedAt, resolvedAt, resolverPayload, milestones, createdAt, updatedAt, } = params;
+        const result = await this.pgClient.query(`
+      INSERT INTO public.hmsh_escalations
+        (id, namespace, app_id, signal_key, topic, workflow_id, task_queue, workflow_type,
+         type, subtype, entity, description, role, priority,
+         origin_id, parent_id, initiated_by, created_by, trace_id, span_id,
+         escalation_payload, metadata, envelope, expires_at,
+         status, assigned_to, claim_expires_at, claimed_at, resolved_at,
+         resolver_payload, milestones, created_at, updated_at)
+      VALUES
+        ($1,  $2,  $3,  $4,  $5,  $6,  $7,  $8,
+         $9,  $10, $11, $12, $13, $14,
+         $15, $16, $17, $18, $19, $20,
+         $21, $22, $23, $24,
+         $25, $26, $27, $28, $29,
+         $30, $31, $32, $33)
+      ON CONFLICT (id) DO NOTHING
+      RETURNING *
+    `, [
+            id,
+            namespace ?? 'hmsh',
+            appId ?? 'hmsh',
+            signalKey ?? null,
+            topic ?? null,
+            workflowId ?? null,
+            taskQueue ?? null,
+            workflowType ?? null,
+            type ?? null,
+            subtype ?? null,
+            entity ?? null,
+            description ?? null,
+            role ?? null,
+            priority ?? 5,
+            originId ?? null,
+            parentId ?? null,
+            initiatedBy ?? null,
+            createdBy ?? null,
+            traceId ?? null,
+            spanId ?? null,
+            escalationPayload ? JSON.stringify(escalationPayload) : null,
+            metadata ? JSON.stringify(metadata) : null,
+            envelope ? JSON.stringify(envelope) : null,
+            expiresAt ?? null,
+            status ?? 'pending',
+            assignedTo ?? null,
+            claimExpiresAt ?? null,
+            claimedAt ?? null,
+            resolvedAt ?? null,
+            resolverPayload ? JSON.stringify(resolverPayload) : null,
+            milestones ? JSON.stringify(milestones) : '[]',
+            createdAt ?? new Date(),
+            updatedAt ?? new Date(),
+        ]);
+        return result.rows[0] ?? null;
+    }
     async getEscalation(id, namespace) {
         const result = await this.pgClient.query(`SELECT * FROM public.hmsh_escalations WHERE id = $1${namespace ? ' AND namespace = $2' : ''}`, namespace ? [id, namespace] : [id]);
         return result.rows[0] ?? null;

package/build/types/hmsh_escalations.d.ts

@@ -210,3 +210,31 @@ export interface EscalateToRoleParams {
     targetRole: string;
     namespace?: string;
 }
+/**
+ * Full-fidelity migration params. Extends `CreateEscalationParams` with:
+ * - `id` (required) — preserves the original UUID; no auto-generation
+ * - lifecycle state fields (`status`, `assignedTo`, `claimExpiresAt`, …) — carry over
+ *   the exact state of the migrated row so in-flight escalations land correctly
+ * - `createdAt` / `updatedAt` — preserve original timestamps
+ *
+ * The underlying INSERT uses `ON CONFLICT (id) DO NOTHING`, so calling
+ * `migrate()` multiple times with the same ID is safe — subsequent calls
+ * return `null` without touching the existing row.
+ */
+export interface MigrateEscalationParams extends CreateEscalationParams {
+    /** Required — preserve the original UUID from the source table. */
+    id: string;
+    status?: 'pending' | 'claimed' | 'resolved' | 'cancelled' | 'expired';
+    assignedTo?: string;
+    claimExpiresAt?: Date;
+    claimedAt?: Date;
+    resolvedAt?: Date;
+    resolverPayload?: Record<string, unknown>;
+    milestones?: Array<{
+        name: string;
+        value: unknown;
+        [key: string]: unknown;
+    }>;
+    createdAt?: Date;
+    updatedAt?: Date;
+}

package/build/types/index.d.ts

@@ -25,4 +25,4 @@ export { ReclaimedMessageType, RetryPolicy, RouterConfig, StreamCode, StreamConf
 export { context, Context, Counter, Meter, metrics, propagation, SpanContext, Span, SpanStatus, SpanStatusCode, SpanKind, trace, Tracer, ValueType, } from './telemetry';
 export { WorkListTaskType } from './task';
 export { TransitionMatch, TransitionRule, Transitions } from './transition';
-export { ConditionQueueConfig, EscalationEntry, ClaimEscalationResult, ClaimByMetadataResult, ReleaseEscalationResult, ResolveEscalationResult, CancelEscalationResult, ListEscalationsParams, CreateEscalationParams, UpdateEscalationParams, AppendMilestonesParams, ClaimEscalationParams, ClaimByMetadataParams, ReleaseEscalationParams, ResolveEscalationParams, ResolveByMetadataParams, EscalateToRoleParams, } from './hmsh_escalations';
+export { ConditionQueueConfig, EscalationEntry, ClaimEscalationResult, ClaimByMetadataResult, ReleaseEscalationResult, ResolveEscalationResult, CancelEscalationResult, ListEscalationsParams, CreateEscalationParams, UpdateEscalationParams, AppendMilestonesParams, ClaimEscalationParams, ClaimByMetadataParams, ReleaseEscalationParams, ResolveEscalationParams, ResolveByMetadataParams, EscalateToRoleParams, MigrateEscalationParams, } from './hmsh_escalations';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.22.0",
+  "version": "0.22.1",
   "description": "Durable Workflow",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -50,7 +50,7 @@
     "test:durable:signal": "vitest run tests/durable/signal/postgres.test.ts",
     "test:durable:readonly": "docker compose --profile readonly up -d --build && docker compose exec hotmesh-readonly npx vitest run --config tests/durable/readonly/vitest.config.mts",
     "test:durable:unknown": "vitest run tests/durable/unknown/postgres.test.ts",
-    "test:durable:esclations": "HMSH_LOGLEVEL=info vitest run tests/durable/escalations",
+    "test:durable:escalations": "HMSH_LOGLEVEL=info vitest run tests/durable/escalations",
     "test:durable:exporter": "HMSH_LOGLEVEL=info vitest run tests/durable/exporter",
     "test:durable:exporter:debug": "EXPORT_DEBUG=1 HMSH_LOGLEVEL=error vitest run tests/durable/basic/postgres.test.ts",
     "test:durable:codec": "vitest run tests/durable/codec/postgres.test.ts",
@@ -85,7 +85,13 @@
     "test:sub:nats": "vitest run tests/functional/sub/providers/nats/nats.test.ts",
     "test:trigger": "vitest run tests/unit/services/activities/trigger.test.ts",
     "test:virtual": "vitest run tests/virtual",
-    "test:unit": "vitest run tests/unit"
+    "test:unit": "vitest run tests/unit",
+
+    "prove": "docker compose exec hotmesh npx vitest run tests/durable 2>&1 | tee /tmp/hmsh-durable.txt && grep -E 'FAIL|Tests |Files ' /tmp/hmsh-durable.txt | tail -5",
+    "prove:escalations": "docker compose exec hotmesh npx vitest run tests/durable/escalations/postgres.test.ts 2>&1 | tee /tmp/hmsh-escalations.txt && grep -E 'FAIL|Tests |Files ' /tmp/hmsh-escalations.txt | tail -5",
+    "prove:functional": "docker compose exec hotmesh npx vitest run tests/functional 2>&1 | tee /tmp/hmsh-functional.txt && grep -E 'FAIL|Tests |Files ' /tmp/hmsh-functional.txt | tail -5",
+    "prove:all": "docker compose exec hotmesh npx vitest run tests/ 2>&1 | tee /tmp/hmsh-all.txt && grep -E 'FAIL|Tests |Files ' /tmp/hmsh-all.txt | tail -5",
+    "prove:file": "f() { docker compose exec hotmesh npx vitest run \"$@\" 2>&1 | tee /tmp/hmsh-file.txt && grep -E 'FAIL|Tests |Files ' /tmp/hmsh-file.txt | tail -5; }; f"
   },
   "keywords": [
     "Invisible Infrastructure",