@develit-services/bank 5.7.1 → 5.8.0

package/dist/base.cjs

@@ -2,11 +2,11 @@
 
 const backendSdk = require('@develit-io/backend-sdk');
 const paymentDirection = require('./shared/bank.CQjuudum.cjs');
+const bank = require('./shared/bank.Cy7xa566.cjs');
 const drizzleOrm = require('drizzle-orm');
 const cloudflare_workers = require('cloudflare:workers');
 const d1 = require('drizzle-orm/d1');
 require('jose');
-const bank = require('./shared/bank.B0DNtuUM.cjs');
 const zod = require('zod');
 const database_schema = require('./shared/bank.9Yw4KHyl.cjs');
 const generalCodes = require('@develit-io/general-codes');
@@ -15,21 +15,37 @@ require('node:crypto');
 require('drizzle-orm/zod');
 require('drizzle-orm/sqlite-core');
 
+const STALE_SYNC_INTERVAL_MULTIPLIER = 3;
+function assessSyncStaleness({ syncIntervalS, lastSyncAt, createdAt }, nowMs, minGraceMs) {
+  const baseline = lastSyncAt ?? createdAt;
+  if (baseline == null) return null;
+  return {
+    staleForMs: nowMs - baseline.getTime(),
+    thresholdMs: Math.max(
+      syncIntervalS * STALE_SYNC_INTERVAL_MULTIPLIER * 1e3,
+      minGraceMs
+    )
+  };
+}
+
 const DEAD_STATUSES = /* @__PURE__ */ new Set([
   "complete",
   "terminated",
   "errored",
   "unknown"
 ]);
+const STALE_MIN_GRACE_MS = 15 * 60 * 1e3;
 async function heartbeatSyncWorkflows({
   entities,
   resetAfterIterations,
   getInstance,
   createInstance,
-  logger
+  logger,
+  now = Date.now
 }) {
   await Promise.all(
-    entities.map(async ({ id, iterationCount }) => {
+    entities.map(async (entity) => {
+      const { id, iterationCount, lastSyncAt } = entity;
       try {
         const instance = await getInstance(id);
         const { status } = await instance.status();
@@ -41,6 +57,24 @@ async function heartbeatSyncWorkflows({
           });
           return;
         }
+        const staleness = assessSyncStaleness(entity, now(), STALE_MIN_GRACE_MS);
+        if (staleness == null) {
+          logger.warn("sync-workflow.heartbeat.sync-age-unknown", {
+            id,
+            status
+          });
+        } else if (staleness.staleForMs > staleness.thresholdMs) {
+          await instance.restart();
+          logger.info("sync-workflow.heartbeat.stale-recovery", {
+            id,
+            status,
+            iterationCount,
+            lastSyncAt: lastSyncAt?.toISOString() ?? null,
+            staleForS: Math.round(staleness.staleForMs / 1e3),
+            thresholdS: Math.round(staleness.thresholdMs / 1e3)
+          });
+          return;
+        }
         if (iterationCount == null) {
           logger.warn("sync-workflow.heartbeat.iteration-count-missing", {
             id,
@@ -73,6 +107,88 @@ async function heartbeatSyncWorkflows({
   );
 }
 
+const DISPATCH_RECOVERY_WINDOW_MS = 5 * 60 * 1e3;
+function buildDispatchInstanceId(accountId, nowMs, recoveryWindowMs = DISPATCH_RECOVERY_WINDOW_MS) {
+  return `${accountId}-${Math.floor(nowMs / recoveryWindowMs)}`;
+}
+function buildDispatchCreateOptions(instanceId, accountId, maxIterations) {
+  return {
+    id: instanceId,
+    // Omitted (not undefined) when unresolved: the workflow treats a missing
+    // budget as unbounded — degraded but syncing.
+    params: maxIterations == null ? { accountId } : { accountId, maxIterations },
+    // Dispatch mints ~24 instances per account per day and step outputs carry
+    // bank payloads — the default 30-day retention would pile up billable
+    // storage for state nobody reads after success.
+    retention: {
+      successRetention: "1 day",
+      errorRetention: "7 days"
+    }
+  };
+}
+function isAlreadyExists(err) {
+  const message = err instanceof Error ? err.message : typeof err === "object" && err !== null && "message" in err ? String(err.message) : "";
+  return /already exists/i.test(message);
+}
+
+const DEFAULT_MIN_GRACE_MS = 3 * 60 * 1e3;
+async function dispatchSyncWorkflows({
+  entities,
+  createInstance,
+  logger,
+  now = Date.now,
+  minGraceMs = DEFAULT_MIN_GRACE_MS,
+  recoveryWindowMs = DISPATCH_RECOVERY_WINDOW_MS
+}) {
+  const at = now();
+  await Promise.all(
+    entities.map(async (entity) => {
+      const { id, lastSyncAt } = entity;
+      const staleness = assessSyncStaleness(entity, at, minGraceMs);
+      if (staleness == null) {
+        logger.warn("sync-workflow.dispatch.sync-age-unknown", { id });
+        return;
+      }
+      if (staleness.staleForMs <= staleness.thresholdMs) return;
+      const instanceId = buildDispatchInstanceId(id, at, recoveryWindowMs);
+      try {
+        await createInstance(instanceId, id);
+        logger.info("sync-workflow.dispatch.created", {
+          id,
+          instanceId,
+          lastSyncAt: lastSyncAt?.toISOString() ?? null,
+          staleForS: Math.round(staleness.staleForMs / 1e3),
+          thresholdS: Math.round(staleness.thresholdMs / 1e3)
+        });
+      } catch (err) {
+        if (isAlreadyExists(err)) {
+          logger.info("sync-workflow.dispatch.already-running", {
+            id,
+            instanceId
+          });
+          return;
+        }
+        logger.error("sync-workflow.dispatch.failed", {
+          id,
+          instanceId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    })
+  );
+}
+
+function isDispatchEnabled(accountId, selection) {
+  const raw = selection?.trim();
+  if (!raw) return false;
+  if (raw.toLowerCase() === "all") return true;
+  return raw.split(",").map((id) => id.trim()).includes(accountId);
+}
+function isDispatchActive(accountId, selection, dispatchCron) {
+  if (!dispatchCron?.trim()) return false;
+  return isDispatchEnabled(accountId, selection);
+}
+
 const FINITE_STATUSES = /* @__PURE__ */ new Set([
   "complete",
   "errored",
@@ -750,6 +866,11 @@ var __decorateClass = (decorators, target, key, kind) => {
   if (kind && result) __defProp(target, key, result);
   return result;
 };
+const syncEventConsoleLogger = {
+  info: (event, data) => console.log(JSON.stringify({ level: "info", event, ...data })),
+  warn: (event, data) => console.warn(JSON.stringify({ level: "warn", event, ...data })),
+  error: (event, data) => console.error(JSON.stringify({ level: "error", event, ...data }))
+};
 exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker(cloudflare_workers.WorkerEntrypoint) {
   constructor(ctx, env, config) {
     super(ctx, env);
@@ -852,6 +973,29 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
       { data: input, schema: syncAccountInputSchema },
       { successMessage: "Account sync workflow started" },
       async ({ accountId }) => {
+        if (isDispatchActive(
+          accountId,
+          this.env.SYNC_DISPATCH_ACCOUNT_IDS,
+          this.env.CRON_SYNC_WORKFLOW_DISPATCH
+        )) {
+          const instanceId = buildDispatchInstanceId(accountId, Date.now());
+          const maxIterations = bank.parseIterationBudgetParam(
+            this.env.SYNC_WORKFLOW_MAX_ITERATIONS
+          );
+          let instance2;
+          try {
+            instance2 = await this.env.SYNC_ACCOUNT_PAYMENTS_WORKFLOW.create(
+              buildDispatchCreateOptions(instanceId, accountId, maxIterations)
+            );
+          } catch (err) {
+            if (!isAlreadyExists(err)) throw err;
+            instance2 = await this.env.SYNC_ACCOUNT_PAYMENTS_WORKFLOW.get(instanceId);
+          }
+          return {
+            instanceId: instance2.id,
+            details: await instance2.status()
+          };
+        }
         const instance = await this.env.SYNC_ACCOUNT_PAYMENTS_WORKFLOW.create({
           id: accountId,
           params: {
@@ -870,7 +1014,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
       { data: input, schema: syncAccountStatusInputSchema },
       { successMessage: "Account sync workflow status retrieved" },
       async ({ accountId }) => {
-        const instance = await this.env.SYNC_ACCOUNT_PAYMENTS_WORKFLOW.get(accountId);
+        const instance = await this.getCurrentSyncInstance(accountId);
         return {
           instanceId: instance.id,
           details: await instance.status()
@@ -883,7 +1027,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
       { data: input, schema: syncAccountRestartInputSchema },
       { successMessage: "Account sync workflow restarted" },
       async ({ accountId }) => {
-        const instance = await this.env.SYNC_ACCOUNT_PAYMENTS_WORKFLOW.get(accountId);
+        const instance = await this.getCurrentSyncInstance(accountId);
         await instance.restart();
         return {
           instanceId: instance.id,
@@ -897,7 +1041,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
       { data: input, schema: syncAccountTerminateInputSchema },
       { successMessage: "Account sync workflow terminated" },
       async ({ accountId }) => {
-        const instance = await this.env.SYNC_ACCOUNT_PAYMENTS_WORKFLOW.get(accountId);
+        const instance = await this.getCurrentSyncInstance(accountId);
         await terminateSyncWorkflow(instance);
         return {
           instanceId: instance.id
@@ -1181,17 +1325,62 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
     if (controller.cron === this.env.CRON_PAYMENT_STATUSES) {
       console.log("Scheduled CRON payment request statuses");
       await this.updatePaymentRequestStatuses();
-      return;
+    }
+    if (controller.cron === this.env.CRON_SYNC_WORKFLOW_DISPATCH) {
+      await this.dispatchSyncWorkflows();
     }
     if (controller.cron === this.env.CRON_SYNC_WORKFLOW_HEARTBEAT) {
       console.log("Scheduled CRON sync workflow heartbeat");
       await this.heartbeatSyncWorkflows();
     }
   }
+  /**
+   * Lifecycle actions must target the instance that actually syncs the
+   * account — under dispatch that is the windowed instance recorded with the
+   * last sync write, not the legacy canonical id.
+   */
+  async getCurrentSyncInstance(accountId) {
+    const account = await bank.getAccountByIdQuery(this.db, { accountId });
+    return this.env.SYNC_ACCOUNT_PAYMENTS_WORKFLOW.get(
+      bank.resolveCurrentSyncInstanceId(
+        accountId,
+        account?.lastSyncMetadata?.instanceId
+      )
+    );
+  }
+  async dispatchSyncWorkflows() {
+    const selection = this.env.SYNC_DISPATCH_ACCOUNT_IDS;
+    if (!selection?.trim()) return;
+    const accounts = await this.db.select({
+      id: paymentDirection.tables.account.id,
+      syncIntervalS: paymentDirection.tables.account.syncIntervalS,
+      lastSyncAt: paymentDirection.tables.account.lastSyncAt,
+      createdAt: paymentDirection.tables.account.createdAt
+    }).from(paymentDirection.tables.account).where(drizzleOrm.eq(paymentDirection.tables.account.status, "AUTHORIZED")).all();
+    const maxIterations = bank.parseIterationBudgetParam(
+      this.env.SYNC_WORKFLOW_MAX_ITERATIONS
+    );
+    if (maxIterations == null) {
+      syncEventConsoleLogger.error(
+        "sync-workflow.dispatch.invalid-max-iterations",
+        { value: this.env.SYNC_WORKFLOW_MAX_ITERATIONS }
+      );
+    }
+    await dispatchSyncWorkflows({
+      entities: accounts.filter((a) => isDispatchEnabled(a.id, selection)),
+      createInstance: (instanceId, accountId) => this.env.SYNC_ACCOUNT_PAYMENTS_WORKFLOW.create(
+        buildDispatchCreateOptions(instanceId, accountId, maxIterations)
+      ),
+      logger: syncEventConsoleLogger
+    });
+  }
   async heartbeatSyncWorkflows() {
     const accounts = await this.db.select({
       id: paymentDirection.tables.account.id,
-      lastSyncMetadata: paymentDirection.tables.account.lastSyncMetadata
+      lastSyncMetadata: paymentDirection.tables.account.lastSyncMetadata,
+      syncIntervalS: paymentDirection.tables.account.syncIntervalS,
+      lastSyncAt: paymentDirection.tables.account.lastSyncAt,
+      createdAt: paymentDirection.tables.account.createdAt
     }).from(paymentDirection.tables.account).where(drizzleOrm.eq(paymentDirection.tables.account.status, "AUTHORIZED")).all();
     const resetAfterIterations = Number(
       this.env.SYNC_WORKFLOW_RESET_AFTER_ITERATIONS
@@ -1204,9 +1393,18 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
       return;
     }
     await heartbeatSyncWorkflows({
-      entities: accounts.map((a) => ({
+      entities: accounts.filter(
+        (a) => !isDispatchActive(
+          a.id,
+          this.env.SYNC_DISPATCH_ACCOUNT_IDS,
+          this.env.CRON_SYNC_WORKFLOW_DISPATCH
+        )
+      ).map((a) => ({
         id: a.id,
-        iterationCount: a.lastSyncMetadata?.iterationCount
+        iterationCount: a.lastSyncMetadata?.iterationCount,
+        syncIntervalS: a.syncIntervalS,
+        lastSyncAt: a.lastSyncAt,
+        createdAt: a.createdAt
       })),
       resetAfterIterations,
       getInstance: (id) => this.env.SYNC_ACCOUNT_PAYMENTS_WORKFLOW.get(id),
@@ -1214,11 +1412,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
         id,
         params: { accountId: id }
       }),
-      logger: {
-        info: (event, data) => console.log(JSON.stringify({ level: "info", event, ...data })),
-        warn: (event, data) => console.warn(JSON.stringify({ level: "warn", event, ...data })),
-        error: (event, data) => console.error(JSON.stringify({ level: "error", event, ...data }))
-      }
+      logger: syncEventConsoleLogger
     });
   }
   async handleAuthorizationCallback(input) {
@@ -1977,7 +2171,12 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
             if (includeWorkflow) {
               let status;
               try {
-                const instance = await this.env.SYNC_ACCOUNT_PAYMENTS_WORKFLOW.get(a.id);
+                const instance = await this.env.SYNC_ACCOUNT_PAYMENTS_WORKFLOW.get(
+                  bank.resolveCurrentSyncInstanceId(
+                    a.id,
+                    a.lastSyncMetadata?.instanceId
+                  )
+                );
                 status = await instance.status();
               } catch (_) {
                 status = null;
@@ -2081,7 +2280,12 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
           });
         }
         try {
-          const instance = await this.env.SYNC_ACCOUNT_PAYMENTS_WORKFLOW.get(accountId);
+          const instance = await this.env.SYNC_ACCOUNT_PAYMENTS_WORKFLOW.get(
+            bank.resolveCurrentSyncInstanceId(
+              accountId,
+              account.lastSyncMetadata?.instanceId
+            )
+          );
           await terminateSyncWorkflow(instance);
         } catch (error) {
           this.log({

package/dist/base.d.cts

@@ -1,5 +1,5 @@
-import { B as BatchSelectType, P as PaymentRequestSelectType, A as AccountSelectType, a as PaymentSelectType, L as LastSyncMetadata, C as ConnectorConfig, t as tables, b as ConnectorKey, c as ConfigEnvironmentBank, I as IBankConnector, d as PaymentType, e as CurrencyCode, H as HandleAuthorizationCallbackInput, f as HandleAuthorizationCallbackOutput } from './shared/bank.BQwwtIR4.cjs';
-import { S as SendPaymentInput, a as SendPaymentOutput, b as SendPaymentSyncInput, c as SendPaymentSyncOutput, F as FinbricksSupportedBanksResponse } from './shared/bank.BUzoc8p6.cjs';
+import { B as BatchSelectType, P as PaymentRequestSelectType, A as AccountSelectType, a as PaymentSelectType, L as LastSyncMetadata, C as ConnectorConfig, t as tables, b as ConnectorKey, c as ConfigEnvironmentBank, I as IBankConnector, d as PaymentType, e as CurrencyCode, H as HandleAuthorizationCallbackInput, f as HandleAuthorizationCallbackOutput } from './shared/bank.CefGTNH1.cjs';
+import { S as SendPaymentInput, a as SendPaymentOutput, b as SendPaymentSyncInput, c as SendPaymentSyncOutput, F as FinbricksSupportedBanksResponse } from './shared/bank.CtIkqQG9.cjs';
 import * as _develit_io_backend_sdk from '@develit-io/backend-sdk';
 import { WorkflowInstanceStatus, IRPCResponse } from '@develit-io/backend-sdk';
 import { WorkerEntrypoint } from 'cloudflare:workers';
@@ -2711,15 +2711,15 @@ declare const getBatchesInputSchema: z.ZodObject<{
     filterBatchAccountId: z.ZodOptional<z.ZodUnion<readonly [z.ZodUUID, z.ZodArray<z.ZodUUID>]>>;
     filterBatchStatus: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
         AUTHORIZED: "AUTHORIZED";
+        COMPLETED: "COMPLETED";
         PROCESSING: "PROCESSING";
         READY_TO_SIGN: "READY_TO_SIGN";
-        COMPLETED: "COMPLETED";
         FAILED: "FAILED";
     }>, z.ZodArray<z.ZodEnum<{
         AUTHORIZED: "AUTHORIZED";
+        COMPLETED: "COMPLETED";
         PROCESSING: "PROCESSING";
         READY_TO_SIGN: "READY_TO_SIGN";
-        COMPLETED: "COMPLETED";
         FAILED: "FAILED";
     }>>]>>;
 }, z.core.$strip>;
@@ -2825,9 +2825,9 @@ declare const getPaymentsInputSchema: z.ZodObject<{
     limit: z.ZodNumber;
     sort: z.ZodObject<{
         column: z.ZodEnum<{
+            amount: "amount";
             createdAt: "createdAt";
             updatedAt: "updatedAt";
-            amount: "amount";
         }>;
         direction: z.ZodEnum<{
             asc: "asc";
@@ -2956,20 +2956,20 @@ declare const getPaymentsInputSchema: z.ZodObject<{
     filterPaymentDateFrom: z.ZodOptional<z.ZodDate>;
     filterPaymentDateTo: z.ZodOptional<z.ZodDate>;
     filterPaymentStatus: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        BOOKED: "BOOKED";
+        REJECTED: "REJECTED";
         PROCESSING: "PROCESSING";
         PENDING: "PENDING";
-        BOOKED: "BOOKED";
         CANCELLED: "CANCELLED";
-        REJECTED: "REJECTED";
         SCHEDULED: "SCHEDULED";
         HOLD: "HOLD";
         INFO: "INFO";
     }>, z.ZodArray<z.ZodEnum<{
+        BOOKED: "BOOKED";
+        REJECTED: "REJECTED";
         PROCESSING: "PROCESSING";
         PENDING: "PENDING";
-        BOOKED: "BOOKED";
         CANCELLED: "CANCELLED";
-        REJECTED: "REJECTED";
         SCHEDULED: "SCHEDULED";
         HOLD: "HOLD";
         INFO: "INFO";
@@ -3875,9 +3875,9 @@ declare const getPaymentRequestsInputSchema: z.ZodObject<{
     limit: z.ZodNumber;
     sort: z.ZodObject<{
         column: z.ZodEnum<{
+            amount: "amount";
             createdAt: "createdAt";
             updatedAt: "updatedAt";
-            amount: "amount";
         }>;
         direction: z.ZodEnum<{
             asc: "asc";
@@ -3886,20 +3886,20 @@ declare const getPaymentRequestsInputSchema: z.ZodObject<{
     }, z.core.$strip>;
     filterAccountId: z.ZodOptional<z.ZodUnion<readonly [z.ZodUUID, z.ZodArray<z.ZodUUID>]>>;
     filterStatus: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        OPENED: "OPENED";
         AUTHORIZED: "AUTHORIZED";
         COMPLETED: "COMPLETED";
         BOOKED: "BOOKED";
-        REJECTED: "REJECTED";
-        OPENED: "OPENED";
         SETTLED: "SETTLED";
+        REJECTED: "REJECTED";
         CLOSED: "CLOSED";
     }>, z.ZodArray<z.ZodEnum<{
+        OPENED: "OPENED";
         AUTHORIZED: "AUTHORIZED";
         COMPLETED: "COMPLETED";
         BOOKED: "BOOKED";
-        REJECTED: "REJECTED";
-        OPENED: "OPENED";
         SETTLED: "SETTLED";
+        REJECTED: "REJECTED";
         CLOSED: "CLOSED";
     }>>]>>;
     filterPaymentType: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
@@ -4193,6 +4193,13 @@ declare class BankServiceBase extends BankServiceBase_base {
         statusChanged: number;
     }>>;
     scheduled(controller: ScheduledController): Promise<void>;
+    /**
+     * Lifecycle actions must target the instance that actually syncs the
+     * account — under dispatch that is the windowed instance recorded with the
+     * last sync write, not the legacy canonical id.
+     */
+    private getCurrentSyncInstance;
+    private dispatchSyncWorkflows;
     private heartbeatSyncWorkflows;
     handleAuthorizationCallback(input: HandleAuthorizationCallbackInput): Promise<IRPCResponse<HandleAuthorizationCallbackOutput>>;
     closePaymentRequest(input: ClosePaymentRequestInput): Promise<IRPCResponse<ClosePaymentRequestOutput>>;

package/dist/base.d.mts

@@ -1,5 +1,5 @@
-import { B as BatchSelectType, P as PaymentRequestSelectType, A as AccountSelectType, a as PaymentSelectType, L as LastSyncMetadata, C as ConnectorConfig, t as tables, b as ConnectorKey, c as ConfigEnvironmentBank, I as IBankConnector, d as PaymentType, e as CurrencyCode, H as HandleAuthorizationCallbackInput, f as HandleAuthorizationCallbackOutput } from './shared/bank.BQwwtIR4.mjs';
-import { S as SendPaymentInput, a as SendPaymentOutput, b as SendPaymentSyncInput, c as SendPaymentSyncOutput, F as FinbricksSupportedBanksResponse } from './shared/bank.DZ3Ow4bP.mjs';
+import { B as BatchSelectType, P as PaymentRequestSelectType, A as AccountSelectType, a as PaymentSelectType, L as LastSyncMetadata, C as ConnectorConfig, t as tables, b as ConnectorKey, c as ConfigEnvironmentBank, I as IBankConnector, d as PaymentType, e as CurrencyCode, H as HandleAuthorizationCallbackInput, f as HandleAuthorizationCallbackOutput } from './shared/bank.CefGTNH1.mjs';
+import { S as SendPaymentInput, a as SendPaymentOutput, b as SendPaymentSyncInput, c as SendPaymentSyncOutput, F as FinbricksSupportedBanksResponse } from './shared/bank.oNDZ44du.mjs';
 import * as _develit_io_backend_sdk from '@develit-io/backend-sdk';
 import { WorkflowInstanceStatus, IRPCResponse } from '@develit-io/backend-sdk';
 import { WorkerEntrypoint } from 'cloudflare:workers';
@@ -2711,15 +2711,15 @@ declare const getBatchesInputSchema: z.ZodObject<{
     filterBatchAccountId: z.ZodOptional<z.ZodUnion<readonly [z.ZodUUID, z.ZodArray<z.ZodUUID>]>>;
     filterBatchStatus: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
         AUTHORIZED: "AUTHORIZED";
+        COMPLETED: "COMPLETED";
         PROCESSING: "PROCESSING";
         READY_TO_SIGN: "READY_TO_SIGN";
-        COMPLETED: "COMPLETED";
         FAILED: "FAILED";
     }>, z.ZodArray<z.ZodEnum<{
         AUTHORIZED: "AUTHORIZED";
+        COMPLETED: "COMPLETED";
         PROCESSING: "PROCESSING";
         READY_TO_SIGN: "READY_TO_SIGN";
-        COMPLETED: "COMPLETED";
         FAILED: "FAILED";
     }>>]>>;
 }, z.core.$strip>;
@@ -2825,9 +2825,9 @@ declare const getPaymentsInputSchema: z.ZodObject<{
     limit: z.ZodNumber;
     sort: z.ZodObject<{
         column: z.ZodEnum<{
+            amount: "amount";
             createdAt: "createdAt";
             updatedAt: "updatedAt";
-            amount: "amount";
         }>;
         direction: z.ZodEnum<{
             asc: "asc";
@@ -2956,20 +2956,20 @@ declare const getPaymentsInputSchema: z.ZodObject<{
     filterPaymentDateFrom: z.ZodOptional<z.ZodDate>;
     filterPaymentDateTo: z.ZodOptional<z.ZodDate>;
     filterPaymentStatus: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        BOOKED: "BOOKED";
+        REJECTED: "REJECTED";
         PROCESSING: "PROCESSING";
         PENDING: "PENDING";
-        BOOKED: "BOOKED";
         CANCELLED: "CANCELLED";
-        REJECTED: "REJECTED";
         SCHEDULED: "SCHEDULED";
         HOLD: "HOLD";
         INFO: "INFO";
     }>, z.ZodArray<z.ZodEnum<{
+        BOOKED: "BOOKED";
+        REJECTED: "REJECTED";
         PROCESSING: "PROCESSING";
         PENDING: "PENDING";
-        BOOKED: "BOOKED";
         CANCELLED: "CANCELLED";
-        REJECTED: "REJECTED";
         SCHEDULED: "SCHEDULED";
         HOLD: "HOLD";
         INFO: "INFO";
@@ -3875,9 +3875,9 @@ declare const getPaymentRequestsInputSchema: z.ZodObject<{
     limit: z.ZodNumber;
     sort: z.ZodObject<{
         column: z.ZodEnum<{
+            amount: "amount";
             createdAt: "createdAt";
             updatedAt: "updatedAt";
-            amount: "amount";
         }>;
         direction: z.ZodEnum<{
             asc: "asc";
@@ -3886,20 +3886,20 @@ declare const getPaymentRequestsInputSchema: z.ZodObject<{
     }, z.core.$strip>;
     filterAccountId: z.ZodOptional<z.ZodUnion<readonly [z.ZodUUID, z.ZodArray<z.ZodUUID>]>>;
     filterStatus: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        OPENED: "OPENED";
         AUTHORIZED: "AUTHORIZED";
         COMPLETED: "COMPLETED";
         BOOKED: "BOOKED";
-        REJECTED: "REJECTED";
-        OPENED: "OPENED";
         SETTLED: "SETTLED";
+        REJECTED: "REJECTED";
         CLOSED: "CLOSED";
     }>, z.ZodArray<z.ZodEnum<{
+        OPENED: "OPENED";
         AUTHORIZED: "AUTHORIZED";
         COMPLETED: "COMPLETED";
         BOOKED: "BOOKED";
-        REJECTED: "REJECTED";
-        OPENED: "OPENED";
         SETTLED: "SETTLED";
+        REJECTED: "REJECTED";
         CLOSED: "CLOSED";
     }>>]>>;
     filterPaymentType: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
@@ -4193,6 +4193,13 @@ declare class BankServiceBase extends BankServiceBase_base {
         statusChanged: number;
     }>>;
     scheduled(controller: ScheduledController): Promise<void>;
+    /**
+     * Lifecycle actions must target the instance that actually syncs the
+     * account — under dispatch that is the windowed instance recorded with the
+     * last sync write, not the legacy canonical id.
+     */
+    private getCurrentSyncInstance;
+    private dispatchSyncWorkflows;
     private heartbeatSyncWorkflows;
     handleAuthorizationCallback(input: HandleAuthorizationCallbackInput): Promise<IRPCResponse<HandleAuthorizationCallbackOutput>>;
     closePaymentRequest(input: ClosePaymentRequestInput): Promise<IRPCResponse<ClosePaymentRequestOutput>>;