@fabricorg/platform-host 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -24,9 +24,8 @@ function createGovernedActionHost(options) {
     }
     const actionInvocationId = platform.createFabricId("act");
     const correlationId = input.correlationId ?? platform.createFabricId("corr");
-    const workflowId = `action-invocation-${actionInvocationId}`;
     const durableParameters = options.redactActionParameters ? options.redactActionParameters(input.actionId, input.parameters) : input.parameters;
-    await options.store.createActionInvocation({
+    const durableInvocation = await options.store.createActionInvocation({
       id: actionInvocationId,
       tenantId: input.tenantId,
       spaceId: input.spaceId,
@@ -38,26 +37,37 @@ function createGovernedActionHost(options) {
       parameters: durableParameters,
       result: {},
       correlationId,
-      ...input.causationId ? { causationId: input.causationId } : {}
+      ...input.causationId ? { causationId: input.causationId } : {},
+      ...input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {}
     });
+    const durableWorkflowId = `action-invocation-${durableInvocation.id}`;
+    if (durableInvocation.id !== actionInvocationId && isTerminal(durableInvocation.status)) {
+      return {
+        actionInvocationId: durableInvocation.id,
+        status: durableInvocation.status,
+        workflowId: durableWorkflowId,
+        result: durableInvocation.result,
+        ...durableInvocation.error ? { error: durableInvocation.error } : {}
+      };
+    }
     if (options.dispatcher) {
       try {
         const dispatched = await options.dispatcher.dispatch({
-          actionInvocationId,
+          actionInvocationId: durableInvocation.id,
           tenantId: input.tenantId,
           spaceId: input.spaceId,
-          workflowId
+          workflowId: durableWorkflowId
         });
         return {
-          actionInvocationId,
-          status: "pending",
+          actionInvocationId: durableInvocation.id,
+          status: durableInvocation.status,
           workflowId: dispatched.workflowId,
           ...dispatched.runId ? { runId: dispatched.runId } : {}
         };
       } catch (error) {
         const message = errorMessage(error);
         await options.store.updateActionInvocation(
-          actionInvocationId,
+          durableInvocation.id,
           input.tenantId,
           input.spaceId,
           { status: "failed", error: message }
@@ -66,11 +76,11 @@ function createGovernedActionHost(options) {
       }
     }
     const executed = await executeInvocation(
-      actionInvocationId,
+      durableInvocation.id,
       input.tenantId,
       input.spaceId
     );
-    return { ...executed, workflowId };
+    return { ...executed, workflowId: durableWorkflowId };
   }
   async function executeInvocation(actionInvocationId, tenantId, spaceId) {
     const invocation = await options.store.getActionInvocation(
@@ -94,215 +104,219 @@ function createGovernedActionHost(options) {
     await options.store.updateActionInvocation(actionInvocationId, tenantId, spaceId, {
       status: "running"
     });
-    const parsed = action.schema.safeParse(invocation.parameters);
-    if (!parsed.success) {
-      const message = parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
-      return fail(invocation, "validation_failed", message);
-    }
-    const authorizationInput = toAuthorizationInput(action, invocation);
-    const definitions = options.resolvePolicies ? await options.resolvePolicies({
-      ...authorizationInput,
-      declaredPolicyIds: action.policies ?? []
-    }) : declaredPolicies(action.policies ?? []);
-    const outcomes = await platform.evaluatePolicyDefinitions(definitions, {
-      tenantId,
-      spaceId,
-      actionInvocationId,
-      actionId: action.actionId,
-      actorId: invocation.actorId,
-      actorType: invocation.actorType,
-      parameters: parsed.data,
-      db: options.store.db,
-      services: options.services,
-      mode: "execute"
-    });
-    for (const outcome of outcomes) {
-      await options.store.appendPolicyEvaluation({
-        id: platform.createFabricId("pol"),
-        actionInvocationId,
+    try {
+      const parsed = action.schema.safeParse(invocation.parameters);
+      if (!parsed.success) {
+        const message = parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+        return fail(invocation, "validation_failed", message);
+      }
+      const authorizationInput = toAuthorizationInput(action, invocation);
+      const definitions = options.resolvePolicies ? await options.resolvePolicies({
+        ...authorizationInput,
+        declaredPolicyIds: action.policies ?? []
+      }) : declaredPolicies(action.policies ?? []);
+      const outcomes = await platform.evaluatePolicyDefinitions(definitions, {
         tenantId,
         spaceId,
-        outcome,
-        createdAt: now()
-      });
-    }
-    const aggregate = platform.aggregatePolicyOutcomes(outcomes);
-    if (aggregate?.result === "block") {
-      const reason = aggregate.reason ?? `Blocked by policy ${aggregate.policyId}`;
-      await appendEvent(invocation, {
-        eventType: "ComplianceBlocked",
-        subjectType: "ActionInvocation",
-        subjectId: actionInvocationId,
-        payload: { actionId: action.actionId, policyId: aggregate.policyId, reason }
+        actionInvocationId,
+        actionId: action.actionId,
+        actorId: invocation.actorId,
+        actorType: invocation.actorType,
+        parameters: parsed.data,
+        db: options.store.db,
+        services: options.services,
+        mode: "execute"
       });
-      return fail(invocation, "blocked_by_policy", reason);
-    }
-    const binding = action.stateMachine;
-    if (binding) {
-      const entityId = binding.getEntityId(parsed.data);
-      const currentState = entityId ? await options.store.getEntityState(
-        tenantId,
-        spaceId,
-        binding.entityType,
-        entityId
-      ) ?? initialState(binding.entityType) : initialState(binding.entityType);
-      const targetState = typeof binding.targetState === "function" ? binding.targetState(parsed.data) : binding.targetState;
-      const transition = platform.validateTransition(
-        binding.entityType,
-        currentState,
-        targetState,
-        action.actionId
-      );
-      if (!transition.valid) {
-        return fail(invocation, "failed", transition.error ?? "Invalid state transition");
+      for (const outcome of outcomes) {
+        await options.store.appendPolicyEvaluation({
+          id: platform.createFabricId("pol"),
+          actionInvocationId,
+          tenantId,
+          spaceId,
+          outcome,
+          createdAt: now()
+        });
       }
-    }
-    let data;
-    let domainEvents = [];
-    try {
-      const handlerResult = await options.store.transaction(
-        (db) => action.handler ? action.handler(
-          {
-            actionInvocationId,
-            tenantId,
-            spaceId,
-            actorId: invocation.actorId,
-            actorType: invocation.actorType,
-            correlationId: invocation.correlationId,
-            ...invocation.causationId ? { causationId: invocation.causationId } : {},
-            db,
-            services: options.services
-          },
-          parsed.data
-        ) : Promise.resolve({ success: true, data: {} })
-      );
-      if (!handlerResult.success) {
-        return fail(invocation, "failed", handlerResult.error ?? "Action handler failed");
+      const aggregate = platform.aggregatePolicyOutcomes(outcomes);
+      if (aggregate?.result === "block") {
+        const reason = aggregate.reason ?? `Blocked by policy ${aggregate.policyId}`;
+        await appendEvent(invocation, {
+          eventType: "ComplianceBlocked",
+          subjectType: "ActionInvocation",
+          subjectId: actionInvocationId,
+          payload: { actionId: action.actionId, policyId: aggregate.policyId, reason }
+        });
+        return fail(invocation, "blocked_by_policy", reason);
       }
-      data = handlerResult.data ?? {};
-      domainEvents = extractEvents(data);
-      if (action.eventPhase !== "after_adapters") {
-        for (const event of domainEvents) await appendEvent(invocation, event);
+      const binding = action.stateMachine;
+      if (binding) {
+        const entityId = binding.getEntityId(parsed.data);
+        const currentState = entityId ? await options.store.getEntityState(
+          tenantId,
+          spaceId,
+          binding.entityType,
+          entityId
+        ) ?? initialState(binding.entityType) : initialState(binding.entityType);
+        const targetState = typeof binding.targetState === "function" ? binding.targetState(parsed.data) : binding.targetState;
+        const transition = platform.validateTransition(
+          binding.entityType,
+          currentState,
+          targetState,
+          action.actionId
+        );
+        if (!transition.valid) {
+          return fail(invocation, "failed", transition.error ?? "Invalid state transition");
+        }
       }
-    } catch (error) {
-      return fail(invocation, "failed", errorMessage(error));
-    }
-    for (const step of action.adapterSteps ?? []) {
-      const input = step.getInput(parsed.data, data);
-      if (!input) continue;
-      const adapter = adapters.require(step.adapterType, step.operation);
-      const adapterInvocationId = platform.createFabricId("adp");
-      const adapterEventSubject = options.adapterEventSubject?.(
-        action.actionId,
-        parsed.data,
-        data
-      ) ?? { subjectType: "AdapterInvocation", subjectId: adapterInvocationId };
-      const recordedInput = options.redactAdapterInput ? options.redactAdapterInput(
-        action.actionId,
-        step.adapterType,
-        step.operation,
-        input
-      ) : input;
-      const startedAt = now();
-      const record = {
-        id: adapterInvocationId,
-        actionInvocationId,
-        tenantId,
-        spaceId,
-        adapterType: step.adapterType,
-        operation: step.operation,
-        vendor: adapter.vendor,
-        status: "running",
-        input: recordedInput,
-        attempt: 1,
-        createdAt: startedAt,
-        updatedAt: startedAt
-      };
-      await options.store.createAdapterInvocation(record);
-      await appendEvent(invocation, {
-        eventType: "AdapterInvocationStarted",
-        subjectType: adapterEventSubject.subjectType,
-        subjectId: adapterEventSubject.subjectId,
-        payload: { adapterType: step.adapterType, operation: step.operation }
-      });
+      let data;
+      let domainEvents = [];
       try {
-        const result2 = await platform.executeWithAdapterRetry({
-          policy: step.retryPolicy ?? adapter.retryPolicy,
-          defaultIdempotent: adapter.idempotent,
-          execute: async (attempt, maxAttempts) => {
-            await options.store.updateAdapterInvocation(adapterInvocationId, {
-              attempt,
-              updatedAt: now()
-            });
-            return adapter.execute(input, {
+        const handlerResult = await options.store.transaction(
+          (db) => action.handler ? action.handler(
+            {
+              actionInvocationId,
               tenantId,
               spaceId,
-              actionInvocationId,
-              adapterInvocationId,
+              actorId: invocation.actorId,
+              actorType: invocation.actorType,
               correlationId: invocation.correlationId,
               ...invocation.causationId ? { causationId: invocation.causationId } : {},
-              attempt,
-              maxAttempts
-            });
-          },
-          isSuccessful: (result3) => result3.success,
-          getError: (result3) => result3.error
+              db,
+              services: options.services
+            },
+            parsed.data
+          ) : Promise.resolve({ success: true, data: {} })
+        );
+        if (!handlerResult.success) {
+          return fail(invocation, "failed", handlerResult.error ?? "Action handler failed");
+        }
+        data = handlerResult.data ?? {};
+        domainEvents = extractEvents(data);
+        if (action.eventPhase !== "after_adapters") {
+          for (const event of domainEvents) await appendEvent(invocation, event);
+        }
+      } catch (error) {
+        return fail(invocation, "failed", errorMessage(error));
+      }
+      for (const step of action.adapterSteps ?? []) {
+        const input = step.getInput(parsed.data, data);
+        if (!input) continue;
+        const adapter = adapters.require(step.adapterType, step.operation);
+        const adapterInvocationId = platform.createFabricId("adp");
+        const adapterEventSubject = options.adapterEventSubject?.(
+          action.actionId,
+          parsed.data,
+          data
+        ) ?? { subjectType: "AdapterInvocation", subjectId: adapterInvocationId };
+        const recordedInput = options.redactAdapterInput ? options.redactAdapterInput(
+          action.actionId,
+          step.adapterType,
+          step.operation,
+          input
+        ) : input;
+        const startedAt = now();
+        const record = {
+          id: adapterInvocationId,
+          actionInvocationId,
+          tenantId,
+          spaceId,
+          adapterType: step.adapterType,
+          operation: step.operation,
+          vendor: adapter.vendor,
+          status: "running",
+          input: recordedInput,
+          attempt: 1,
+          createdAt: startedAt,
+          updatedAt: startedAt
+        };
+        await options.store.createAdapterInvocation(record);
+        await appendEvent(invocation, {
+          eventType: "AdapterInvocationStarted",
+          subjectType: adapterEventSubject.subjectType,
+          subjectId: adapterEventSubject.subjectId,
+          payload: { adapterType: step.adapterType, operation: step.operation }
         });
-        if (!result2.success) {
+        try {
+          const result2 = await platform.executeWithAdapterRetry({
+            policy: step.retryPolicy ?? adapter.retryPolicy,
+            defaultIdempotent: adapter.idempotent,
+            execute: async (attempt, maxAttempts) => {
+              await options.store.updateAdapterInvocation(adapterInvocationId, {
+                attempt,
+                updatedAt: now()
+              });
+              return adapter.execute(input, {
+                tenantId,
+                spaceId,
+                actionInvocationId,
+                adapterInvocationId,
+                correlationId: invocation.correlationId,
+                ...invocation.causationId ? { causationId: invocation.causationId } : {},
+                attempt,
+                maxAttempts
+              });
+            },
+            isSuccessful: (result3) => result3.success,
+            getError: (result3) => result3.error
+          });
+          if (!result2.success) {
+            await options.store.updateAdapterInvocation(adapterInvocationId, {
+              status: "failed",
+              error: result2.error ?? "Adapter failed",
+              updatedAt: now()
+            });
+            await appendEvent(invocation, {
+              eventType: "AdapterInvocationFailed",
+              subjectType: adapterEventSubject.subjectType,
+              subjectId: adapterEventSubject.subjectId,
+              payload: { adapterType: step.adapterType, operation: step.operation }
+            });
+            return fail(invocation, "failed", result2.error ?? "Adapter failed");
+          }
+          const resultRecord = result2;
+          const output = isRecord(resultRecord.output) ? resultRecord.output : Object.fromEntries(
+            Object.entries(resultRecord).filter(
+              ([key]) => key !== "success" && key !== "error"
+            )
+          );
           await options.store.updateAdapterInvocation(adapterInvocationId, {
-            status: "failed",
-            error: result2.error ?? "Adapter failed",
+            status: "succeeded",
+            output,
             updatedAt: now()
           });
           await appendEvent(invocation, {
-            eventType: "AdapterInvocationFailed",
+            eventType: "AdapterInvocationSucceeded",
             subjectType: adapterEventSubject.subjectType,
             subjectId: adapterEventSubject.subjectId,
-            payload: { adapterType: step.adapterType, operation: step.operation }
+            payload: {
+              adapterType: step.adapterType,
+              operation: step.operation,
+              input: recordedInput,
+              output
+            }
+          });
+        } catch (error) {
+          const message = errorMessage(error);
+          await options.store.updateAdapterInvocation(adapterInvocationId, {
+            status: "failed",
+            error: message,
+            updatedAt: now()
           });
-          return fail(invocation, "failed", result2.error ?? "Adapter failed");
+          return fail(invocation, "failed", message);
         }
-        const resultRecord = result2;
-        const output = isRecord(resultRecord.output) ? resultRecord.output : Object.fromEntries(
-          Object.entries(resultRecord).filter(
-            ([key]) => key !== "success" && key !== "error"
-          )
-        );
-        await options.store.updateAdapterInvocation(adapterInvocationId, {
-          status: "succeeded",
-          output,
-          updatedAt: now()
-        });
-        await appendEvent(invocation, {
-          eventType: "AdapterInvocationSucceeded",
-          subjectType: adapterEventSubject.subjectType,
-          subjectId: adapterEventSubject.subjectId,
-          payload: {
-            adapterType: step.adapterType,
-            operation: step.operation,
-            input: recordedInput,
-            output
-          }
-        });
-      } catch (error) {
-        const message = errorMessage(error);
-        await options.store.updateAdapterInvocation(adapterInvocationId, {
-          status: "failed",
-          error: message,
-          updatedAt: now()
-        });
-        return fail(invocation, "failed", message);
       }
+      if (action.eventPhase === "after_adapters") {
+        for (const event of domainEvents) await appendEvent(invocation, event);
+      }
+      const result = withoutPrivateHostFields(data);
+      await options.store.updateActionInvocation(actionInvocationId, tenantId, spaceId, {
+        status: "completed",
+        result
+      });
+      return { actionInvocationId, status: "completed", result };
+    } catch (error) {
+      return fail(invocation, "failed", errorMessage(error));
     }
-    if (action.eventPhase === "after_adapters") {
-      for (const event of domainEvents) await appendEvent(invocation, event);
-    }
-    const result = withoutPrivateHostFields(data);
-    await options.store.updateActionInvocation(actionInvocationId, tenantId, spaceId, {
-      status: "completed",
-      result
-    });
-    return { actionInvocationId, status: "completed", result };
   }
   async function appendEvent(invocation, event) {
     const timestamp = now();
@@ -392,8 +406,14 @@ var MemoryPlatformHostStore = class {
     return run(this.db);
   }
   async createActionInvocation(input) {
+    if (input.idempotencyKey) {
+      const existing = this.invocations.find(
+        (record2) => record2.tenantId === input.tenantId && record2.spaceId === input.spaceId && record2.actionId === input.actionId && record2.idempotencyKey === input.idempotencyKey
+      );
+      if (existing) return existing;
+    }
     const now = /* @__PURE__ */ new Date();
-    const record = { ...input, createdAt: now, updatedAt: now };
+    const record = { ...input, attemptCount: 0, createdAt: now, updatedAt: now };
     this.invocations.push(record);
     return record;
   }
@@ -435,6 +455,28 @@ var MemoryPlatformHostStore = class {
     }
     return state;
   }
+  async listActionInvocations(input = {}) {
+    return this.invocations.filter(
+      (record) => (!input.tenantId || record.tenantId === input.tenantId) && (!input.spaceId || record.spaceId === input.spaceId) && (!input.statuses?.length || input.statuses.includes(record.status)) && (!input.updatedBefore || record.updatedAt < input.updatedBefore)
+    ).sort((left, right) => left.createdAt.getTime() - right.createdAt.getTime()).slice(0, input.limit ?? 100);
+  }
+  async claimActionInvocations(input) {
+    const current = input.now ?? /* @__PURE__ */ new Date();
+    const eligible = this.invocations.filter(
+      (record) => (!input.tenantId || record.tenantId === input.tenantId) && (!input.spaceId || record.spaceId === input.spaceId) && (record.status === "pending" || record.status === "running" && (!record.leaseExpiresAt || record.leaseExpiresAt <= current))
+    ).sort((left, right) => left.createdAt.getTime() - right.createdAt.getTime()).slice(0, input.limit ?? 10);
+    for (const record of eligible) {
+      record.status = "running";
+      record.leaseOwner = input.workerId;
+      record.leaseExpiresAt = new Date(current.getTime() + input.leaseDurationMs);
+      record.attemptCount += 1;
+      record.updatedAt = current;
+    }
+    return eligible;
+  }
+  async listEvents(tenantId, spaceId) {
+    return this.events.filter((event) => event.tenantId === tenantId && event.spaceId === spaceId).sort((left, right) => left.sequence - right.sequence);
+  }
 };
 
 // src/postgres-store.ts
@@ -453,9 +495,22 @@ var PostgresPlatformHostStore = class {
 				action_id text NOT NULL, action_version integer NOT NULL,
 				actor_id text NOT NULL, actor_type text NOT NULL, status text NOT NULL,
 				parameters jsonb NOT NULL, result jsonb NOT NULL DEFAULT '{}'::jsonb,
-				correlation_id text NOT NULL, causation_id text, error text,
+				correlation_id text NOT NULL, causation_id text, idempotency_key text, error text,
+				attempt_count integer NOT NULL DEFAULT 0, lease_owner text,
+				lease_expires_at timestamptz,
 				created_at timestamptz NOT NULL, updated_at timestamptz NOT NULL
 			);
+			ALTER TABLE fabric_platform.action_invocations
+				ADD COLUMN IF NOT EXISTS idempotency_key text,
+				ADD COLUMN IF NOT EXISTS attempt_count integer NOT NULL DEFAULT 0,
+				ADD COLUMN IF NOT EXISTS lease_owner text,
+				ADD COLUMN IF NOT EXISTS lease_expires_at timestamptz;
+			CREATE UNIQUE INDEX IF NOT EXISTS action_invocations_idempotency_idx
+				ON fabric_platform.action_invocations
+				(tenant_id, space_id, action_id, idempotency_key)
+				WHERE idempotency_key IS NOT NULL;
+			CREATE INDEX IF NOT EXISTS action_invocations_worker_idx
+				ON fabric_platform.action_invocations (status, lease_expires_at, created_at);
 			CREATE TABLE IF NOT EXISTS fabric_platform.policy_evaluations (
 				id text PRIMARY KEY, action_invocation_id text NOT NULL,
 				tenant_id text NOT NULL, space_id text NOT NULL, outcome jsonb NOT NULL,
@@ -492,11 +547,14 @@ var PostgresPlatformHostStore = class {
   }
   async createActionInvocation(input) {
     const now = /* @__PURE__ */ new Date();
-    await this.sql.query(
+    const result = await this.sql.query(
       `INSERT INTO fabric_platform.action_invocations
 			 (id,tenant_id,space_id,action_id,action_version,actor_id,actor_type,status,
-			  parameters,result,correlation_id,causation_id,error,created_at,updated_at)
-			 VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9::jsonb,$10::jsonb,$11,$12,$13,$14,$14)`,
+			  parameters,result,correlation_id,causation_id,idempotency_key,error,created_at,updated_at)
+			 VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9::jsonb,$10::jsonb,$11,$12,$13,$14,$15,$15)
+			 ON CONFLICT (tenant_id,space_id,action_id,idempotency_key)
+			 WHERE idempotency_key IS NOT NULL DO UPDATE SET id=fabric_platform.action_invocations.id
+			 RETURNING *`,
       [
         input.id,
         input.tenantId,
@@ -510,11 +568,12 @@ var PostgresPlatformHostStore = class {
         JSON.stringify(input.result),
         input.correlationId,
         input.causationId ?? null,
+        input.idempotencyKey ?? null,
         input.error ?? null,
         now
       ]
     );
-    return { ...input, createdAt: now, updatedAt: now };
+    return toActionRecord(result.rows[0]);
   }
   async getActionInvocation(id, tenantId, spaceId) {
     const result = await this.sql.query(
@@ -528,7 +587,12 @@ var PostgresPlatformHostStore = class {
     await this.sql.query(
       `UPDATE fabric_platform.action_invocations SET
 			 status=COALESCE($4,status), result=COALESCE($5::jsonb,result),
-			 error=CASE WHEN $6::boolean THEN $7 ELSE error END, updated_at=now()
+			 error=CASE WHEN $6::boolean THEN $7 ELSE error END,
+			 lease_owner=CASE WHEN $4 IN ('completed','failed','blocked_by_policy','validation_failed')
+			                  THEN NULL ELSE lease_owner END,
+			 lease_expires_at=CASE WHEN $4 IN ('completed','failed','blocked_by_policy','validation_failed')
+			                       THEN NULL ELSE lease_expires_at END,
+			 updated_at=now()
 			 WHERE id=$1 AND tenant_id=$2 AND space_id=$3`,
       [
         id,
@@ -643,6 +707,57 @@ var PostgresPlatformHostStore = class {
     );
     return result.rows[0]?.state;
   }
+  async listActionInvocations(input = {}) {
+    const conditions = [];
+    const values = [];
+    const add = (condition, value) => {
+      values.push(value);
+      conditions.push(condition.replace("?", `$${values.length}`));
+    };
+    if (input.tenantId) add("tenant_id=?", input.tenantId);
+    if (input.spaceId) add("space_id=?", input.spaceId);
+    if (input.statuses?.length) add("status = ANY(?::text[])", [...input.statuses]);
+    if (input.updatedBefore) add("updated_at<?", input.updatedBefore);
+    values.push(Math.max(1, Math.min(input.limit ?? 100, 1e3)));
+    const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+    const result = await this.sql.query(
+      `SELECT * FROM fabric_platform.action_invocations ${where}
+			 ORDER BY created_at LIMIT $${values.length}`,
+      values
+    );
+    return result.rows.map(toActionRecord);
+  }
+  async claimActionInvocations(input) {
+    const current = input.now ?? /* @__PURE__ */ new Date();
+    const limit = Math.max(1, Math.min(input.limit ?? 10, 100));
+    const leaseExpiresAt = new Date(current.getTime() + input.leaseDurationMs);
+    const result = await this.sql.query(
+      `WITH claimable AS (
+				SELECT id FROM fabric_platform.action_invocations
+				WHERE (status='pending' OR
+				       (status='running' AND (lease_expires_at IS NULL OR lease_expires_at <= $1)))
+				  AND ($2::text IS NULL OR tenant_id=$2)
+				  AND ($3::text IS NULL OR space_id=$3)
+				ORDER BY created_at
+				FOR UPDATE SKIP LOCKED
+				LIMIT $4
+			)
+			UPDATE fabric_platform.action_invocations AS invocation
+			SET status='running', lease_owner=$5, lease_expires_at=$6,
+			    attempt_count=attempt_count+1, updated_at=$1
+			FROM claimable WHERE invocation.id=claimable.id
+			RETURNING invocation.*`,
+      [
+        current,
+        input.tenantId ?? null,
+        input.spaceId ?? null,
+        limit,
+        input.workerId,
+        leaseExpiresAt
+      ]
+    );
+    return result.rows.map(toActionRecord);
+  }
   async listEvents(tenantId, spaceId) {
     const result = await this.sql.query(
       `SELECT * FROM fabric_platform.asset_events
@@ -666,6 +781,10 @@ function toActionRecord(row) {
     result: row.result,
     correlationId: String(row.correlation_id),
     ...row.causation_id ? { causationId: String(row.causation_id) } : {},
+    ...row.idempotency_key ? { idempotencyKey: String(row.idempotency_key) } : {},
+    attemptCount: Number(row.attempt_count ?? 0),
+    ...row.lease_owner ? { leaseOwner: String(row.lease_owner) } : {},
+    ...row.lease_expires_at ? { leaseExpiresAt: new Date(row.lease_expires_at) } : {},
     ...row.error ? { error: String(row.error) } : {},
     createdAt: new Date(row.created_at),
     updatedAt: new Date(row.updated_at)
@@ -692,8 +811,71 @@ function toEventRecord(row) {
   };
 }
 
+// src/worker.ts
+var DEFAULT_BATCH_SIZE = 10;
+var DEFAULT_LEASE_DURATION_MS = 5 * 6e4;
+var DEFAULT_POLL_INTERVAL_MS = 1e3;
+function createStoreBackedActionDispatcher() {
+  return {
+    dispatch: async (input) => ({ workflowId: input.workflowId })
+  };
+}
+async function runPlatformActionWorkerCycle(options) {
+  const claimed = await options.store.claimActionInvocations({
+    workerId: options.workerId,
+    limit: options.batchSize ?? DEFAULT_BATCH_SIZE,
+    leaseDurationMs: options.leaseDurationMs ?? DEFAULT_LEASE_DURATION_MS,
+    ...options.tenantId ? { tenantId: options.tenantId } : {},
+    ...options.spaceId ? { spaceId: options.spaceId } : {}
+  });
+  let completed = 0;
+  let failed = 0;
+  for (const invocation of claimed) {
+    try {
+      const result = await options.host.executeInvocation(
+        invocation.id,
+        invocation.tenantId,
+        invocation.spaceId
+      );
+      if (result.status === "completed") completed += 1;
+      else failed += 1;
+    } catch (error) {
+      failed += 1;
+      options.onError?.(error, invocation);
+    }
+  }
+  return { claimed: claimed.length, completed, failed };
+}
+async function runPlatformActionWorker(options) {
+  while (!options.signal?.aborted) {
+    try {
+      await runPlatformActionWorkerCycle(options);
+    } catch (error) {
+      options.onError?.(error);
+    }
+    await abortableDelay(options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS, options.signal);
+  }
+}
+async function abortableDelay(milliseconds, signal) {
+  if (signal?.aborted) return;
+  await new Promise((resolve) => {
+    const timeout = setTimeout(resolve, milliseconds);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timeout);
+        resolve();
+      },
+      { once: true }
+    );
+  });
+}
+
 exports.MemoryPlatformHostStore = MemoryPlatformHostStore;
 exports.PostgresPlatformHostStore = PostgresPlatformHostStore;
 exports.createGovernedActionHost = createGovernedActionHost;
+exports.createStoreBackedActionDispatcher = createStoreBackedActionDispatcher;
+exports.runPlatformActionWorker = runPlatformActionWorker;
+exports.runPlatformActionWorkerCycle = runPlatformActionWorkerCycle;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map