@effect/platform-cloudflare 0.0.0 → 4.1.3

package/dist/internal/queueStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queueStorage.js","names":[],"sources":["../../src/internal/queueStorage.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/internal/registry.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A module-level registration map shared between the Worker layer and the
+ * Durable Object instances of the same isolate. Unregistering only removes
+ * the exact registration that was added, so a finalizer racing a re-register
+ * cannot drop the replacement.
+ *
+ * @internal
+ */
+export {};
+//# sourceMappingURL=registry.d.ts.map

package/dist/internal/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/internal/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/internal/registry.js

@@ -0,0 +1,24 @@
+/**
+ * A module-level registration map shared between the Worker layer and the
+ * Durable Object instances of the same isolate. Unregistering only removes
+ * the exact registration that was added, so a finalizer racing a re-register
+ * cannot drop the replacement.
+ *
+ * @internal
+ */
+/** @internal */
+export const makeRegistry = () => {
+  const registrations = new Map();
+  return {
+    get: key => registrations.get(key),
+    register: (key, value) => {
+      if (registrations.has(key)) return false;
+      registrations.set(key, value);
+      return true;
+    },
+    unregister: (key, value) => {
+      if (registrations.get(key) === value) registrations.delete(key);
+    }
+  };
+};
+//# sourceMappingURL=registry.js.map

package/dist/internal/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","names":[],"sources":["../../src/internal/registry.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;AAgBA;AACA,OAAO,MAAM,YAAY,GAAG,MAAqB;EAC/C,MAAM,aAAa,GAAG,IAAI,GAAG,EAAa;EAC1C,OAAO;IACL,GAAG,EAAG,GAAG,IAAK,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC;IACpC,QAAQ,EAAE,CAAC,GAAG,EAAE,KAAK,KAAI;MACvB,IAAI,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,OAAO,KAAK;MACxC,aAAa,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC;MAC7B,OAAO,IAAI;IACb,CAAC;IACD,UAAU,EAAE,CAAC,GAAG,EAAE,KAAK,KAAI;MACzB,IAAI,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,CAAC;IACjE;GACD;AACH,CAAC","ignoreList":[]}

package/dist/internal/singletonRegistry.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=singletonRegistry.d.ts.map

package/dist/internal/singletonRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singletonRegistry.d.ts","sourceRoot":"","sources":["../../src/internal/singletonRegistry.ts"],"names":[],"mappings":""}

package/dist/internal/singletonRegistry.js

@@ -0,0 +1,9 @@
+import { makeRegistry } from "./registry.js";
+const registry = /*#__PURE__*/makeRegistry();
+/** @internal */
+export const getSingletonRegistration = registry.get;
+/** @internal */
+export const registerSingleton = registry.register;
+/** @internal */
+export const unregisterSingleton = registry.unregister;
+//# sourceMappingURL=singletonRegistry.js.map

package/dist/internal/singletonRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"singletonRegistry.js","names":[],"sources":["../../src/internal/singletonRegistry.ts"],"sourcesContent":[null],"mappings":"AAGA,SAAS,YAAY,QAAQ,eAAe;AAQ5C,MAAM,QAAQ,gBAAG,YAAY,EAAyB;AAEtD;AACA,OAAO,MAAM,wBAAwB,GAAwD,QAAQ,CAAC,GAAG;AAEzG;AACA,OAAO,MAAM,iBAAiB,GAAmE,QAAQ,CAAC,QAAQ;AAElH;AACA,OAAO,MAAM,mBAAmB,GAAgE,QAAQ,CAAC,UAAU","ignoreList":[]}

package/dist/internal/singletonRuntime.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=singletonRuntime.d.ts.map

package/dist/internal/singletonRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singletonRuntime.d.ts","sourceRoot":"","sources":["../../src/internal/singletonRuntime.ts"],"names":[],"mappings":""}

package/dist/internal/singletonRuntime.js

@@ -0,0 +1,42 @@
+import * as Effect from "effect/Effect";
+import { armAlarm } from "./entityStorage.js";
+import { beginSingletonWake, completeSingletonWake, ensureSingletonStorage, loadSingletonState } from "./singletonStorage.js";
+/**
+ * How far ahead the watchdog alarm is armed while a wake is running.
+ */
+const watchdogMillis = 60_000;
+/** @internal */
+export const makeSingletonRuntime = options => {
+  ensureSingletonStorage(options.sql);
+  let inFlight;
+  const armWatchdog = () => Effect.suspend(() => armAlarm(options.alarm, options.now() + watchdogMillis));
+  const runPending = arm => {
+    const run = options.run.pipe(Effect.ensuring(Effect.promise(() => options.alarm.deleteAlarm()).pipe(Effect.ensuring(Effect.sync(() => completeSingletonWake(options.sql))))));
+    const operation = Effect.runPromise(arm ? Effect.andThen(armWatchdog(), run) : run);
+    inFlight = operation;
+    void operation.then(() => {
+      inFlight = undefined;
+    }, () => {
+      inFlight = undefined;
+    });
+    return operation;
+  };
+  return {
+    wake: () => {
+      if (inFlight !== undefined) return Promise.resolve();
+      const pending = loadSingletonState(options.sql).wakeAt;
+      if (pending !== undefined) return runPending(false);
+      const now = options.now();
+      if (!beginSingletonWake(options.sql, now)) return Promise.resolve();
+      return runPending(true);
+    },
+    // Cloudflare consumes the alarm before invoking this handler, so an alarm
+    // that fires during a run must arm the next watchdog before returning.
+    runAlarm: () => {
+      if (loadSingletonState(options.sql).wakeAt === undefined) return Promise.resolve();
+      if (inFlight !== undefined) return Effect.runPromise(armWatchdog());
+      return runPending(false);
+    }
+  };
+};
+//# sourceMappingURL=singletonRuntime.js.map

package/dist/internal/singletonRuntime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"singletonRuntime.js","names":[],"sources":["../../src/internal/singletonRuntime.ts"],"sourcesContent":[null],"mappings":"AAYA,OAAO,KAAK,MAAM,MAAM,eAAe;AACvC,SAAS,QAAQ,QAAQ,oBAAoB;AAC7C,SACE,kBAAkB,EAClB,qBAAqB,EACrB,sBAAsB,EACtB,kBAAkB,QACb,uBAAuB;AAE9B;;;AAGA,MAAM,cAAc,GAAG,MAAM;AAgB7B;AACA,OAAO,MAAM,oBAAoB,GAAI,OAAgC,IAAsB;EACzF,sBAAsB,CAAC,OAAO,CAAC,GAAG,CAAC;EACnC,IAAI,QAAmC;EAEvC,MAAM,WAAW,GAAG,MAClB,MAAM,CAAC,OAAO,CAAC,MAAM,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,EAAE,GAAG,cAAc,CAAC,CAAC;EAE/E,MAAM,UAAU,GAAI,GAAY,IAAmB;IACjD,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAC1B,MAAM,CAAC,QAAQ,CACb,MAAM,CAAC,OAAO,CAAC,MAAM,OAAO,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC,IAAI,CACpD,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,qBAAqB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CACvE,CACF,CACF;IACD,MAAM,SAAS,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,GAAG,MAAM,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,GAAG,CAAC,GAAG,GAAG,CAAC;IACnF,QAAQ,GAAG,SAAS;IACpB,KAAK,SAAS,CAAC,IAAI,CACjB,MAAK;MACH,QAAQ,GAAG,SAAS;IACtB,CAAC,EACD,MAAK;MACH,QAAQ,GAAG,SAAS;IACtB,CAAC,CACF;IACD,OAAO,SAAS;EAClB,CAAC;EAED,OAAO;IACL,IAAI,EAAE,MAAK;MACT,IAAI,QAAQ,KAAK,SAAS,EAAE,OAAO,OAAO,CAAC,OAAO,EAAE;MACpD,MAAM,OAAO,GAAG,kBAAkB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM;MACtD,IAAI,OAAO,KAAK,SAAS,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;MACnD,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE;MACzB,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,OAAO,OAAO,CAAC,OAAO,EAAE;MACnE,OAAO,UAAU,CAAC,IAAI,CAAC;IACzB,CAAC;IAED;IACA;IACA,QAAQ,EAAE,MAAK;MACb,IAAI,kBAAkB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,KAAK,SAAS,EAAE,OAAO,OAAO,CAAC,OAAO,EAAE;MAClF,IAAI,QAAQ,KAAK,SAAS,EAAE,OAAO,MAAM,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC;MACnE,OAAO,UAAU,CAAC,KAAK,CAAC;IAC1B;GACD;AACH,CAAC","ignoreList":[]}

package/dist/internal/singletonStorage.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=singletonStorage.d.ts.map

package/dist/internal/singletonStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singletonStorage.d.ts","sourceRoot":"","sources":["../../src/internal/singletonStorage.ts"],"names":[],"mappings":""}

package/dist/internal/singletonStorage.js

@@ -0,0 +1,34 @@
+const ddl = `CREATE TABLE IF NOT EXISTS singleton_state (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  name TEXT,
+  wake_at INTEGER
+)`;
+/** @internal */
+export const ensureSingletonStorage = sql => {
+  sql.exec(ddl);
+};
+/** @internal */
+export const loadSingletonState = sql => {
+  const row = sql.exec("SELECT name, wake_at FROM singleton_state WHERE id = 1").toArray()[0];
+  return {
+    name: row?.name ?? undefined,
+    wakeAt: row?.wake_at ?? undefined
+  };
+};
+/** @internal */
+export const rememberSingletonName = (sql, name) => {
+  sql.exec(`INSERT INTO singleton_state (id, name) VALUES (1, ?)
+     ON CONFLICT(id) DO UPDATE SET name = excluded.name`, name);
+};
+/** @internal */
+export const beginSingletonWake = (sql, wakeAt) => {
+  if (loadSingletonState(sql).wakeAt !== undefined) return false;
+  sql.exec(`INSERT INTO singleton_state (id, wake_at) VALUES (1, ?)
+     ON CONFLICT(id) DO UPDATE SET wake_at = excluded.wake_at`, wakeAt);
+  return true;
+};
+/** @internal */
+export const completeSingletonWake = sql => {
+  sql.exec("UPDATE singleton_state SET wake_at = NULL WHERE id = 1");
+};
+//# sourceMappingURL=singletonStorage.js.map

package/dist/internal/singletonStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"singletonStorage.js","names":[],"sources":["../../src/internal/singletonStorage.ts"],"sourcesContent":[null],"mappings":"AASA,MAAM,GAAG,GAAG;;;;EAIV;AAEF;AACA,OAAO,MAAM,sBAAsB,GAAI,GAAe,IAAU;EAC9D,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC;AACf,CAAC;AAaD;AACA,OAAO,MAAM,kBAAkB,GAAI,GAAe,IAAoB;EACpE,MAAM,GAAG,GAAG,GAAG,CAAC,IAAI,CAAoB,wDAAwD,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;EAC9G,OAAO;IACL,IAAI,EAAE,GAAG,EAAE,IAAI,IAAI,SAAS;IAC5B,MAAM,EAAE,GAAG,EAAE,OAAO,IAAI;GACzB;AACH,CAAC;AAED;AACA,OAAO,MAAM,qBAAqB,GAAG,CAAC,GAAe,EAAE,IAAY,KAAU;EAC3E,GAAG,CAAC,IAAI,CACN;wDACoD,EACpD,IAAI,CACL;AACH,CAAC;AAED;AACA,OAAO,MAAM,kBAAkB,GAAG,CAAC,GAAe,EAAE,MAAc,KAAa;EAC7E,IAAI,kBAAkB,CAAC,GAAG,CAAC,CAAC,MAAM,KAAK,SAAS,EAAE,OAAO,KAAK;EAC9D,GAAG,CAAC,IAAI,CACN;8DAC0D,EAC1D,MAAM,CACP;EACD,OAAO,IAAI;AACb,CAAC;AAED;AACA,OAAO,MAAM,qBAAqB,GAAI,GAAe,IAAU;EAC7D,GAAG,CAAC,IAAI,CAAC,wDAAwD,CAAC;AACpE,CAAC","ignoreList":[]}

package/dist/internal/transport.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=transport.d.ts.map

package/dist/internal/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/internal/transport.ts"],"names":[],"mappings":""}

package/dist/internal/transport.js

@@ -0,0 +1,49 @@
+/** @internal */
+import { PersistenceError } from "effect/cluster/ClusterError";
+import * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+/**
+ * Whether a failed Durable Object call may be retried. Cloudflare marks
+ * transient failures `retryable`, and an `overloaded` object must not be
+ * retried, as retrying only adds load.
+ *
+ * @internal
+ */
+export const isRetryable = error => {
+  const cause = error.cause;
+  return typeof cause === "object" && cause !== null && cause.retryable === true && cause.overloaded !== true;
+};
+/**
+ * The bounded retry policy for idempotent calls outside a workflow: a few
+ * quick attempts, then the caller sees the typed error.
+ *
+ * @internal
+ */
+export const boundedRetry = /*#__PURE__*/Schedule.max([/*#__PURE__*/Schedule.exponential(100, 2), /*#__PURE__*/Schedule.recurs(4)]);
+/**
+ * Makes one Worker-to-Durable Object stub call.
+ *
+ * **Details**
+ *
+ * A rejection becomes a `PersistenceError` whose `cause` is the rejected
+ * value, so Cloudflare's `retryable`, `overloaded` and `remote` flags stay
+ * readable. Each attempt resolves a fresh stub with `resolve`, because
+ * Cloudflare advises against reusing a stub after it throws. With `retry`, the
+ * call is retried on that schedule while the error is retryable; only pass it
+ * for idempotent calls.
+ *
+ * @internal
+ */
+export const callDurableObject = options => {
+  const attempt = Effect.tryPromise({
+    try: () => options.call(options.resolve()),
+    catch: cause => new PersistenceError({
+      cause
+    })
+  });
+  return options.retry === undefined ? attempt : Effect.retry(attempt, {
+    schedule: options.retry,
+    while: isRetryable
+  });
+};
+//# sourceMappingURL=transport.js.map

package/dist/internal/transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","names":[],"sources":["../../src/internal/transport.ts"],"sourcesContent":[null],"mappings":"AAAA;AACA,SAAS,gBAAgB,QAAQ,6BAA6B;AAC9D,OAAO,KAAK,MAAM,MAAM,eAAe;AACvC,OAAO,KAAK,QAAQ,MAAM,iBAAiB;AAc3C;;;;;;;AAOA,OAAO,MAAM,WAAW,GAAI,KAAuB,IAAa;EAC9D,MAAM,KAAK,GAAG,KAAK,CAAC,KAA+C;EACnE,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,CAAC,SAAS,KAAK,IAAI,IAAI,KAAK,CAAC,UAAU,KAAK,IAAI;AAC7G,CAAC;AAED;;;;;;AAMA,OAAO,MAAM,YAAY,gBAA+B,QAAQ,CAAC,GAAG,CAAC,cACnE,QAAQ,CAAC,WAAW,CAAC,GAAG,EAAE,CAAC,CAAC,eAC5B,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CACnB,CAAC;AAEF;;;;;;;;;;;;;;AAcA,OAAO,MAAM,iBAAiB,GAAa,OAI1C,IAAwC;EACvC,MAAM,OAAO,GAAG,MAAM,CAAC,UAAU,CAAC;IAChC,GAAG,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;IAC1C,KAAK,EAAG,KAAK,IAAK,IAAI,gBAAgB,CAAC;MAAE;IAAK,CAAE;GACjD,CAAC;EACF,OAAO,OAAO,CAAC,KAAK,KAAK,SAAS,GAC9B,OAAO,GACP,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE;IAAE,QAAQ,EAAE,OAAO,CAAC,KAAK;IAAE,KAAK,EAAE;EAAW,CAAE,CAAC;AAC5E,CAAC","ignoreList":[]}

package/dist/internal/workflowRegistry.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=workflowRegistry.d.ts.map

package/dist/internal/workflowRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflowRegistry.d.ts","sourceRoot":"","sources":["../../src/internal/workflowRegistry.ts"],"names":[],"mappings":""}

package/dist/internal/workflowRegistry.js

@@ -0,0 +1,29 @@
+/**
+ * Module-level workflow state shared between the Worker layer and the workflow
+ * Durable Object instances of the same isolate. Registrations are recorded at
+ * Worker init; a running execution provides its own handle through
+ * `CurrentExecutionHandle` so engine operations inside the run hit local
+ * SQLite instead of a self-RPC.
+ *
+ * @internal
+ */
+import * as Context from "effect/Context";
+import * as WorkflowEngine from "effect/workflow/WorkflowEngine";
+import { makeRegistry } from "./registry.js";
+const registry = /*#__PURE__*/makeRegistry();
+/** @internal */
+export const getWorkflowRegistration = registry.get;
+/** @internal */
+export const registerWorkflow = registry.register;
+/** @internal */
+export const unregisterWorkflow = registry.unregister;
+/**
+ * The handle of the workflow execution currently running in this fiber,
+ * provided by the workflow Durable Object runtime around each run attempt.
+ *
+ * @internal
+ */
+export class CurrentExecutionHandle extends /*#__PURE__*/Context.Service()("@effect/platform-cloudflare/CloudflareWorkflowEngine/CurrentExecutionHandle") {}
+/** @internal */
+export const deferredState = /*#__PURE__*/WorkflowEngine.makeDeferredState();
+//# sourceMappingURL=workflowRegistry.js.map

package/dist/internal/workflowRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflowRegistry.js","names":[],"sources":["../../src/internal/workflowRegistry.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;AASA,OAAO,KAAK,OAAO,MAAM,gBAAgB;AAGzC,OAAO,KAAK,cAAc,MAAM,gCAAgC;AAEhE,SAAS,YAAY,QAAQ,eAAe;AAY5C,MAAM,QAAQ,gBAAG,YAAY,EAAwB;AAErD;AACA,OAAO,MAAM,uBAAuB,GAAuD,QAAQ,CAAC,GAAG;AAEvG;AACA,OAAO,MAAM,gBAAgB,GAAkE,QAAQ,CAAC,QAAQ;AAEhH;AACA,OAAO,MAAM,kBAAkB,GAA+D,QAAQ,CAAC,UAAU;AA+BjH;;;;;;AAMA,OAAM,MAAO,sBAAuB,sBAAQ,OAAO,CAAC,OAAO,EAAmD,CAC5G,6EAA6E,CAC9E;AAED;AACA,OAAO,MAAM,aAAa,gBAAG,cAAc,CAAC,iBAAiB,EAAE","ignoreList":[]}

package/dist/internal/workflowRuntime.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=workflowRuntime.d.ts.map

package/dist/internal/workflowRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflowRuntime.d.ts","sourceRoot":"","sources":["../../src/internal/workflowRuntime.ts"],"names":[],"mappings":""}

package/dist/internal/workflowRuntime.js

@@ -0,0 +1,322 @@
+import * as Cause from "effect/Cause";
+import * as Context from "effect/Context";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as Schedule from "effect/Schedule";
+import * as Scope from "effect/Scope";
+import * as DurableClock from "effect/workflow/DurableClock";
+import * as Workflow from "effect/workflow/Workflow";
+import * as WorkflowEngine from "effect/workflow/WorkflowEngine";
+import { decodeName, encodeName } from "./clusterName.js";
+import { armAlarm } from "./entityStorage.js";
+import { CurrentExecutionHandle, deferredState, getWorkflowRegistration } from "./workflowRegistry.js";
+import * as WorkflowStorage from "./workflowStorage.js";
+import { decodePayload, encodeDefectResult, encodeExit, encodeResult } from "./workflowWire.js";
+/** @internal */
+export const InterruptSignalName = "Workflow/InterruptSignal";
+const resumeGuardMillis = 60_000;
+let voidExitCache;
+const voidExitText = () => voidExitCache ??= Effect.runPromise(encodeExit(Exit.void, Context.empty()));
+const mergeWake = (current, mode) => current === "explicit" ? current : mode;
+/** @internal */
+export const makeWorkflowRuntime = options => {
+  const name = decodeName(options.name);
+  if (name === undefined) {
+    throw new Error("ClusterWorkflow requires a canonical workflow Durable Object name");
+  }
+  const workflowName = name.type;
+  const executionId = name.id;
+  const sql = options.sql;
+  WorkflowStorage.ensureWorkflowStorage(sql);
+  let inflight;
+  let resumeRequested;
+  // Parent of every attempt's scope. As in the memory engine, scopes of
+  // attempts that suspended stay open under it, so their finalizers and
+  // resources last until the execution completes or an attempt defects.
+  let executionScope = Scope.makeUnsafe();
+  // The final attempt's scope has already closed with the real exit. Closing
+  // the parent closes earlier attempts' scopes in reverse order with
+  // `Exit.void`, so their superseded compensations are skipped. A fresh
+  // parent is swapped in first: a later replay must not fork from a closed
+  // scope, which would run its finalizers as soon as they are registered.
+  const closeExecutionScope = Effect.suspend(() => {
+    const closing = executionScope;
+    executionScope = Scope.makeUnsafe();
+    return Scope.close(closing, Exit.void);
+  });
+  const detach = promise => {
+    options.waitUntil(promise.then(() => undefined, () => undefined));
+  };
+  const parseResult = result => JSON.parse(result);
+  const isComplete = result => result !== undefined && parseResult(result)._tag === "Complete";
+  // As in the memory engine, only an explicit wake replays a failure suspension.
+  const isUnwakeable = (result, mode) => {
+    if (result === undefined) return false;
+    const parsed = parseResult(result);
+    return parsed._tag === "Complete" || mode === "automatic" && parsed.failed === true;
+  };
+  /**
+   * Records a wake durably. A running attempt queues it and decides when it
+   * settles, since its result may still become a failure suspension. Returns
+   * whether a replay is now pending.
+   */
+  const requestWake = mode => {
+    const row = WorkflowStorage.loadExecution(sql);
+    if (row === undefined || isComplete(row.result)) return false;
+    if (inflight === undefined && isUnwakeable(row.result, mode)) return false;
+    const pending = mergeWake(row.resumePending, mode);
+    if (pending !== row.resumePending) WorkflowStorage.setResumePending(sql, pending);
+    if (inflight !== undefined) resumeRequested = mergeWake(resumeRequested, mode);
+    return true;
+  };
+  const armResumeGuard = Effect.suspend(() => armAlarm(options.alarm, options.now() + resumeGuardMillis));
+  const resumeParent = parent => Effect.promise(() => options.getStub(encodeName(parent.workflowName, parent.executionId)).resume("automatic")).pipe(Effect.sandbox, Effect.retry({
+    times: 5,
+    schedule: Schedule.exponential(200)
+  }));
+  const logResumeParentFailure = cause => Effect.logError("Workflow parent resume failed", cause);
+  const deliverParentWake = Effect.suspend(() => {
+    const row = WorkflowStorage.loadExecution(sql);
+    if (row === undefined || row.resumePending === undefined || !isComplete(row.result) || row.parent === undefined) {
+      return Effect.void;
+    }
+    // Re-arm before sending so a crash or exhausted retries leave another attempt.
+    return armResumeGuard.pipe(Effect.andThen(resumeParent(row.parent).pipe(Effect.tap(() => Effect.sync(() => WorkflowStorage.setResumePending(sql, undefined))), Effect.catchCause(logResumeParentFailure))));
+  });
+  // An attempt the machinery cannot finish (a defect with `CaptureDefects`
+  // off, a payload that no longer decodes, a result that fails to encode, a
+  // dying finalizer, a missing registration) completes the execution with the
+  // defect, as `ClusterWorkflowEngine` stores an exhausted defect retry. The
+  // object never rejects `run` for such a reason, so a caller can tell the
+  // child's own defect from a transport failure, and a parent replaying a
+  // discarded child finds the result instead of restarting it.
+  const failAttempt = cause => Effect.runPromise(Effect.gen(function* () {
+    yield* Effect.logError("Workflow execution failed", cause);
+    const text = yield* encodeDefectResult(Cause.squash(cause));
+    const parent = WorkflowStorage.loadExecution(sql)?.parent;
+    if (parent !== undefined) yield* armResumeGuard;
+    WorkflowStorage.saveCompletion(sql, text, parent !== undefined);
+    inflight = undefined;
+    resumeRequested = undefined;
+    if (parent !== undefined) options.waitUntil(Effect.runPromise(deliverParentWake));
+    return text;
+  }));
+  const startAttempt = row => {
+    const registration = getWorkflowRegistration(workflowName);
+    if (registration === undefined) {
+      return failAttempt(Cause.die(new Error(`No workflow registered for name: ${workflowName}`)));
+    }
+    const workflow = registration.workflow;
+    const instance = WorkflowEngine.WorkflowInstance.initial(workflow, executionId, {
+      scope: Scope.forkUnsafe(executionScope)
+    });
+    const execute = decodePayload(workflow, row.payload, registration.context).pipe(Effect.flatMap(payload => registration.execute(payload, executionId)), Effect.onExit(exit => {
+      const suspendOnFailure = Context.get(workflow.annotations, Workflow.SuspendOnFailure);
+      if (!instance.suspended && !(suspendOnFailure && exit._tag === "Failure")) {
+        return Effect.void;
+      }
+      if (WorkflowStorage.loadDeferred(sql, InterruptSignalName) === undefined) {
+        return Effect.void;
+      }
+      instance.suspended = false;
+      instance.interrupted = true;
+      return Effect.withFiber(fiber => Effect.interruptible(Fiber.interrupt(fiber)));
+    }), Workflow.intoResult, effect => deferredState.trackRun(instance, effect), Effect.flatMap(result => Effect.map(encodeResult(workflow, result, registration.context), text => ({
+      result,
+      text
+    }))), Effect.provideService(DurableClock.InMemoryThreshold, Duration.zero), Effect.provideService(CurrentExecutionHandle, runtime));
+    const persist = ({
+      result,
+      text
+    }) => Effect.runPromise(Effect.gen(function* () {
+      const parent = WorkflowStorage.loadExecution(sql)?.parent;
+      if (result._tag === "Complete" && parent !== undefined) {
+        // Arm before the atomic result/pending save so a persisted
+        // completion always has a delivery wake.
+        yield* armResumeGuard;
+      }
+      // Stay in flight until the result is saved so a concurrent resume
+      // queues behind this attempt instead of replaying alongside it.
+      if (result._tag === "Complete") {
+        WorkflowStorage.saveCompletion(sql, text, parent !== undefined);
+        inflight = undefined;
+        resumeRequested = undefined;
+        if (parent !== undefined) options.waitUntil(Effect.runPromise(deliverParentWake));
+        return text;
+      }
+      const replay = resumeRequested !== undefined && !isUnwakeable(text, resumeRequested) ? resumeRequested : undefined;
+      WorkflowStorage.saveSuspension(sql, text, replay);
+      inflight = undefined;
+      resumeRequested = undefined;
+      if (replay !== undefined) detach(startAttempt(row));
+      return text;
+    }).pipe(Effect.tapCause(() => Effect.sync(() => {
+      inflight = undefined;
+    }))));
+    const finish = attempt => {
+      if (attempt.result._tag !== "Complete") return persist(attempt);
+      // Close retained scopes before saving, so a durable completion never
+      // has unrun finalizers. A dying finalizer fails the attempt instead.
+      return Effect.runPromise(Effect.exit(closeExecutionScope)).then(closed => Exit.isSuccess(closed) ? persist(attempt) : failAttempt(closed.cause));
+    };
+    const fiber = Effect.runFork(execute);
+    const promise = Effect.runPromise(Fiber.await(fiber)).then(exit => {
+      if (Exit.isSuccess(exit)) return finish(exit.value);
+      if (Cause.hasInterruptsOnly(exit.cause) && (instance.interrupted || instance.suspended)) {
+        // A hard interrupt (or a completion preempting the fiber after it
+        // already produced its result) kills the fiber before it can encode;
+        // synthesize the result from the instance state so it still persists.
+        const result = instance.interrupted ? new Workflow.Complete({
+          exit: exit
+        }) : new Workflow.Suspended({});
+        return Effect.runPromise(encodeResult(workflow, result, registration.context)).then(text => finish({
+          result,
+          text
+        }));
+      }
+      // A defect ends every retained attempt; a replay starts in fresh scopes.
+      // Stay in flight while closing so cleanup precedes any replay.
+      return Effect.runPromise(Effect.exit(closeExecutionScope)).then(closed => failAttempt(Exit.isSuccess(closed) ? exit.cause : Cause.combine(exit.cause, closed.cause)));
+    });
+    inflight = {
+      instance,
+      fiber,
+      promise
+    };
+    return promise;
+  };
+  const run = (payload, opts) => {
+    let row = WorkflowStorage.loadExecution(sql);
+    if (row === undefined) {
+      WorkflowStorage.createExecution(sql, workflowName, executionId, payload, opts.parent);
+      row = {
+        workflowName,
+        executionId,
+        payload,
+        parent: opts.parent,
+        result: undefined,
+        resumePending: undefined
+      };
+    } else if (opts.parent !== undefined && row.parent === undefined) {
+      // An execution started standalone can gain a parent later; keep the
+      // first parent so its completion still wakes that parent.
+      WorkflowStorage.setParent(sql, opts.parent);
+      row = {
+        ...row,
+        parent: opts.parent
+      };
+    }
+    if (inflight !== undefined) return opts.discard ? Promise.resolve("") : inflight.promise;
+    if (row.result !== undefined) return Promise.resolve(opts.discard ? "" : row.result);
+    // The attempt stays pending under the guard alarm until it persists a
+    // result, so an attempt lost with this object is replayed even when no
+    // caller awaits it.
+    WorkflowStorage.setResumePending(sql, mergeWake(row.resumePending, "automatic"));
+    const attempt = startAttempt(row);
+    const armed = Effect.runPromise(armResumeGuard);
+    if (opts.discard) {
+      detach(attempt);
+      return armed.then(() => "");
+    }
+    return Promise.all([attempt, armed]).then(([text]) => text);
+  };
+  const startPending = () => {
+    const row = WorkflowStorage.loadExecution(sql);
+    if (row === undefined || row.resumePending === undefined || inflight !== undefined) return;
+    if (isUnwakeable(row.result, row.resumePending)) return;
+    detach(startAttempt(row));
+  };
+  const resume = (mode = "explicit") => {
+    if (!requestWake(mode)) return Promise.resolve();
+    // Persist and guard the resume before acknowledging it, so an abort after
+    // the RPC returns is still recovered.
+    return Effect.runPromise(armResumeGuard).then(startPending);
+  };
+  const completeDeferred = (deferredName, exitText, mode) => {
+    if (!WorkflowStorage.saveDeferred(sql, deferredName, exitText)) return Promise.resolve();
+    // Persisted with the exit in the same write batch: if this wake is lost
+    // before the replay finishes, the next wake (or the guard alarm) replays
+    // the execution. The in-flight request is set synchronously so a settling
+    // attempt cannot clear the pending resume without a restart.
+    if (!requestWake(mode)) return Promise.resolve();
+    return Effect.runPromise(armResumeGuard.pipe(Effect.andThen(deferredState.deferredDone(executionId, deferredName)))).then(() => resume(mode));
+  };
+  const deferredDone = (deferredName, exitText) => completeDeferred(deferredName, exitText, "automatic");
+  // The caller belongs to the run this wake interrupts, so awaiting that run
+  // would wait on the caller's own cleanup. As in the memory engine, the wake
+  // starts on a separate fiber after the caller continues.
+  const completeOwnDeferred = (deferredName, exitText) => Effect.suspend(() => {
+    if (!WorkflowStorage.saveDeferred(sql, deferredName, exitText) || !requestWake("automatic")) {
+      return Effect.void;
+    }
+    const wake = deferredState.deferredDone(executionId, deferredName).pipe(Effect.andThen(Effect.suspend(() => inflight === undefined ? Effect.promise(() => resume("automatic")) : Effect.void)));
+    return armResumeGuard.pipe(Effect.andThen(Effect.forkDetach(wake)), Effect.flatMap(fiber => Effect.sync(() => detach(Effect.runPromise(Fiber.await(fiber))))));
+  });
+  const interrupt = () => {
+    const row = WorkflowStorage.loadExecution(sql);
+    if (row === undefined || isComplete(row.result)) return Promise.resolve();
+    return voidExitText().then(exitText => completeDeferred(InterruptSignalName, exitText, "explicit"));
+  };
+  const interruptUnsafe = () => {
+    const current = inflight;
+    const signalled = interrupt();
+    if (current === undefined) return signalled;
+    current.instance.interrupted = true;
+    return signalled.then(() => Effect.runPromise(Fiber.interrupt(current.fiber))).then(() => undefined);
+  };
+  const scheduleClock = (clockName, deferredName, wakeUp) => {
+    WorkflowStorage.saveClock(sql, clockName, deferredName, wakeUp);
+    const earliest = WorkflowStorage.earliestClockWakeUp(sql);
+    return earliest === undefined ? Promise.resolve() : Effect.runPromise(armAlarm(options.alarm, earliest));
+  };
+  const runAlarm = () => voidExitText().then(voidExit => {
+    const completed = WorkflowStorage.dueClocks(sql, options.now()).filter(clock => {
+      WorkflowStorage.markClockFired(sql, clock.name);
+      return WorkflowStorage.saveDeferred(sql, clock.deferredName, voidExit);
+    });
+    if (completed.length > 0) requestWake("automatic");
+    return Effect.runPromise(Effect.forEach(completed, clock => deferredState.deferredDone(executionId, clock.deferredName), {
+      discard: true
+    })).then(() => {
+      const row = WorkflowStorage.loadExecution(sql);
+      const mode = row?.resumePending;
+      const pending = mode !== undefined && !isUnwakeable(row?.result, mode);
+      // A live attempt is not lost: only re-arm the guard. Requesting a wake
+      // would replay the attempt once it suspends, for no reason.
+      return (pending && inflight === undefined ? resume(mode) : Promise.resolve()).then(() => {
+        // While a resume is pending a guard alarm stays armed, so a replay
+        // lost with this isolate is retried instead of sleeping forever.
+        const targets = [WorkflowStorage.earliestClockWakeUp(sql), pending ? options.now() + resumeGuardMillis : undefined].filter(target => target !== undefined);
+        if (targets.length === 0) return undefined;
+        // The alarm that fired is spent, so set the next one outright:
+        // `armAlarm` only ever moves an alarm earlier.
+        return options.alarm.setAlarm(Math.min(...targets));
+      });
+    });
+  }).then(() => Effect.runPromise(deliverParentWake)).then(() => undefined);
+  const runtime = {
+    executionId,
+    run,
+    poll: () => Promise.resolve(WorkflowStorage.loadExecution(sql)?.result),
+    resume,
+    interrupt,
+    interruptUnsafe,
+    deferredDone,
+    scheduleClock,
+    runAlarm,
+    loadActivity: key => WorkflowStorage.loadActivity(sql, key),
+    saveActivity: (key, exit) => WorkflowStorage.saveActivity(sql, key, exit),
+    loadDeferred: deferredName => WorkflowStorage.loadDeferred(sql, deferredName),
+    completeOwnDeferred
+  };
+  // Self-heal on wake: a resume recorded by deferredDone but lost with the
+  // previous isolate replays now instead of waiting for external contact.
+  const pending = WorkflowStorage.loadExecution(sql)?.resumePending;
+  if (pending !== undefined) {
+    void resume(pending);
+  }
+  return runtime;
+};
+//# sourceMappingURL=workflowRuntime.js.map