durable-x 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Windmill Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,166 @@
+# Durable Execution
+
+**Lightweight durable execution with checkpoint memoization and saga cleanup—no sidecar, no orchestration engine, works anywhere.**
+
+Add Temporal/Dapr-style durability and idempotency to **Windmill workflows, APIs, background jobs, CLI tools**—anywhere you run async code.
+
+## Why This Exists
+
+Temporal and Dapr are powerful but heavyweight: they require sidecars, generators, replay logic, and determinism constraints. **Most teams just want crash recovery and step memoization without the infrastructure overhead.**
+
+This library brings durability to your **existing workflows and code**:
+
+- Running a Windmill job that fetches → transforms → uploads? Add crash recovery.
+- Building an API endpoint that calls 3 services? Make it idempotent with checkpoints.
+- Processing background jobs? Memoize expensive steps, skip on retry.
+- Running a CLI migration? Resume from last checkpoint if it crashes.
+
+**No sidecar. No generators. No determinism requirements. Just checkpoints.**
+
+## Features
+
+- **Checkpoint-based progress tracking**: Survives crashes, retries resume from last checkpoint
+- **Step memoization**: Expensive/side-effectful steps cached by input hash, skipped on retry
+- **Saga-style cleanup**: Register compensations before risky operations, auto-executed on crash
+- **Platform-agnostic core**: Works with any async runtime (Node, Bun, Deno)
+- **Bring your own storage**: Postgres, Redis, SQLite, S3, Windmill datatable—anything works
+- **Functional architecture**: Pure functions, Result-based error handling, no exceptions
+- **Zero infrastructure**: Just a table and a storage adapter—no sidecars, daemons, or special runtimes
+
+## Installation
+
+```bash
+bun add @tommdavidson/durable-x
+npm install @tommdavidson/durable-x
+```
+
+***
+
+## Landscape & Decision Guide
+
+### What's Out There
+
+The durability space is fragmented. Here's what exists and what doesn't:
+
+| Tool | Scope | Sidecar | Step Memoization | Saga Cleanup | Works Anywhere | Primary Use Case |
+|------|-------|---------|------------------|--------------|---|---|
+| **Temporal** | Full orchestration | ✅ Required | ✅ (via replay) | ❌ Manual | ❌ Temporal-only | Distributed systems |
+| **Dapr** | Full orchestration | ✅ Required | ✅ (via replay) | ❌ Manual | ❌ Dapr-only | Microservices |
+| **Restate** | Full orchestration | ✅ Required | ✅ (via replay) | ❌ Manual | ❌ Restate-only | Event-driven |
+| **AWS Durable SDK** | Lambda orchestration | ❌ | ✅ (via replay) | ❌ Manual | ❌ Lambda-only | Serverless |
+| **gpahal/durable-execution** | Task workflows | ❌ | ✅ (via replay) | ❌ Manual | ✅ | AI workflows |
+| **micro-memoize** | In-memory caching | ❌ | ✅ | ❌ | ✅ (in-memory only) | Pure functions |
+| **@windmill-labs** | Multi-step resilience | ❌ | ✅ (input-based) | ✅ Built-in | ✅ | Windmill + general |
+
+***
+
+### The Gap This Library Fills
+
+**You're solving a unique combination:**
+
+1. **Checkpoint + memoization + saga cleanup** bundled together (only library with all three)
+2. **No infrastructure** (no sidecar, no special runtime, no determinism constraints)
+3. **Windmill-native** (works with Windmill's datatable out-of-box, plus Postgres/Redis/etc.)
+4. **Saga cleanup built-in** (not manual like Temporal/Dapr/Restate)
+5. **Input-based memoization** (not replay-based like AWS/Temporal)
+
+### vs `gpahal/durable-execution`
+
+| Feature | gpahal/durable-execution | @tommdavidson/durable-execution |
+|---------|--------------------------|----------------------------------|
+| **Primary focus** | AI workflows [1][2] | Windmill + general workflows |
+| **Saga cleanup** | ❌ Manual | ✅ Built-in (`beforeRisky`/`afterSafe`) |
+| **Memoization approach** | Replay-based | Input-hash based (skip unchanged steps) |
+| **Storage adapters** | Built-in | Pluggable (Windmill, Postgres, Redis, S3) |
+| **Windmill integration** | ❌ | ✅ Native datatable support |
+| **Error handling** | Unknown | neverthrow Result types |
+| **Best for** | Generic task workflows | Windmill-first + multi-platform |
+
+**Bottom line**: `gpahal/durable-execution` is task-focused and AI-oriented. This library is Windmill-native with built-in saga cleanup and pluggable storage.[2][1]
+
+***
+
+### Decision Tree
+
+**Building AI workflows with generic task engine?** → Consider `gpahal/durable-execution`  
+**Using Windmill or need saga cleanup?** → Use this library  
+**Need distributed multi-service orchestration?** → Temporal/Dapr  
+**AWS Lambda only?** → AWS Durable SDK  
+**Just need request idempotency?** → Stripe keys or custom  
+**Need to skip expensive steps on retry with cleanup?** → This library  
+
+***
+
+## Quick Start
+
+### Windmill Workflow
+
+```typescript
+import {
+  windmillStorage,
+  load,
+  durable,
+  beforeRisky,
+  afterSafe,
+  complete,
+  type CleanupRegistry,
+} from '@tommdavidson/durable-x';
+
+const cleanupRunners: CleanupRegistry = {
+  delete_temp: async (params) => {
+    await Bun.remove(params.path as string).catch(() => {});
+  },
+  rollback_upload: async (params) => {
+    await deleteFromCdn(params.url as string);
+  },
+};
+
+export async function main(fileId: string) {
+  const cp = await load(windmillStorage)(cleanupRunners)(fileId);
+  const step = durable(windmillStorage)(cp);
+
+  const downloaded = await step('download')({ fileId })(() =>
+    fetch(`https://api.example.com/files/${fileId}`).then((r) => r.json()),
+  );
+
+  const processed = await step('process')({ path: downloaded.path })(() =>
+    processFile(downloaded.path),
+  );
+
+  const uploadUrl = `s3://bucket/${fileId}.json`;
+  await beforeRisky(windmillStorage)(cp)('rollback_upload')({ url: uploadUrl });
+
+  const uploaded = await step('upload')({ url: uploadUrl })(() =>
+    uploadToCdn(processed, uploadUrl),
+  );
+
+  await afterSafe(windmillStorage)(cp)('rollback_upload');
+  await complete(windmillStorage)(cp);
+
+  return { fileId, uploadedUrl: uploadUrl };
+}
+```
+
+***
+
+## Why `@tommdavidson/durable-x`?
+
+**The name justifies itself:**
+
+1. **Scoped package** (`@windmill-labs/`) = clear differentiation from `gpahal/durable-execution`
+2. **Windmill-first** = Native integration with Windmill's ecosystem
+3. **Different target** = Not competing with `gpahal` (AI workflows vs Windmill + general)
+4. **Unique features** = Built-in saga cleanup + pluggable storage
+
+**You're NOT stepping on toes.** Different niches, different users, complementary tools.
+
+***
+
+## License
+
+MIT – Free to use, modify, distribute.
+
+## Contributing
+
+Issues and PRs welcome. Run `bun run prepublish` before submitting.
+

package/dist/adapters/windmill.d.ts

@@ -0,0 +1,3 @@
+import type { StorageAdapter } from '../types';
+export declare const windmillStorage: StorageAdapter;
+//# sourceMappingURL=windmill.d.ts.map

package/dist/adapters/windmill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"windmill.d.ts","sourceRoot":"","sources":["../../src/adapters/windmill.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAc,cAAc,EAAE,MAAM,UAAU,CAAC;AAwB3D,eAAO,MAAM,eAAe,EAAE,cAsD7B,CAAC"}

package/dist/api.d.ts

@@ -0,0 +1,17 @@
+import type { Checkpoint, CleanupRegistry, StorageAdapter } from './types';
+export declare const load: (storage: StorageAdapter) => (runners: CleanupRegistry) => (fileId: string) => Promise<Checkpoint>;
+export declare const beforeRisky: (storage: StorageAdapter) => (cp: Checkpoint) => (type: string) => (params: Record<string, unknown>) => Promise<Checkpoint>;
+export declare const afterSafe: (storage: StorageAdapter) => (cp: Checkpoint) => (type: string) => Promise<Checkpoint>;
+export declare const durable: (storage: StorageAdapter) => (cp: Checkpoint) => (name: string) => <I, T>(inputs: I) => (fn: () => Promise<T>) => Promise<T>;
+export declare const complete: (storage: StorageAdapter) => (cp: Checkpoint) => Promise<Checkpoint>;
+export declare const fail: (storage: StorageAdapter) => (cp: Checkpoint) => Promise<Checkpoint>;
+export declare const clear: (storage: StorageAdapter) => (fileId: string) => Promise<void>;
+export declare const clearStep: (storage: StorageAdapter) => (cp: Checkpoint) => (name: string) => Promise<Checkpoint>;
+export declare const sweep: (storage: StorageAdapter) => (runners: CleanupRegistry) => (staleThresholdMs?: number) => Promise<{
+    cleaned: number;
+    details: string[];
+}>;
+export declare const sweepAllCleanups: (storage: StorageAdapter) => (runners: CleanupRegistry) => () => Promise<{
+    cleaned: number;
+}>;
+//# sourceMappingURL=api.d.ts.map

package/dist/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAuB3E,eAAO,MAAM,IAAI,GACd,SAAS,cAAc,MACrB,SAAS,eAAe,MACtB,QAAQ,MAAM,KAAG,OAAO,CAAC,UAAU,CAgBX,CAAC;AAEhC,eAAO,MAAM,WAAW,GACrB,SAAS,cAAc,MACrB,IAAI,UAAU,MACZ,MAAM,MAAM,MACV,QAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,OAAO,CAAC,UAAU,CAO/C,CAAC;AAEf,eAAO,MAAM,SAAS,GACnB,SAAS,cAAc,MACrB,IAAI,UAAU,MACZ,MAAM,MAAM,KAAG,OAAO,CAAC,UAAU,CAO5B,CAAC;AAEb,eAAO,MAAM,OAAO,GACjB,SAAS,cAAc,MACrB,IAAI,UAAU,MACZ,MAAM,MAAM,MACV,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,MACb,IAAI,MAAM,OAAO,CAAC,CAAC,CAAC,KAAG,OAAO,CAAC,CAAC,CAkBhC,CAAC;AAEZ,eAAO,MAAM,QAAQ,GAClB,SAAS,cAAc,MACrB,IAAI,UAAU,KAAG,OAAO,CAAC,UAAU,CAM9B,CAAC;AAEX,eAAO,MAAM,IAAI,GACd,SAAS,cAAc,MACrB,IAAI,UAAU,KAAG,OAAO,CAAC,UAAU,CAM9B,CAAC;AAEX,eAAO,MAAM,KAAK,GACf,SAAS,cAAc,MACrB,QAAQ,MAAM,KAAG,OAAO,CAAC,IAAI,CACH,CAAC;AAEhC,eAAO,MAAM,SAAS,GACnB,SAAS,cAAc,MACrB,IAAI,UAAU,MACZ,MAAM,MAAM,KAAG,OAAO,CAAC,UAAU,CAM5B,CAAC;AAEb,eAAO,MAAM,KAAK,GACf,SAAS,cAAc,MACrB,SAAS,eAAe,MAErB,mBAAkB,MAAuB,KACxC,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAU9C,CAAC;AAEV,eAAO,MAAM,gBAAgB,GAC1B,SAAS,cAAc,MACrB,SAAS,eAAe,WACnB,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAS5B,CAAC"}

package/dist/checkpoint.d.ts

@@ -0,0 +1,18 @@
+import type { Checkpoint, CheckpointStatus, CleanupSpec, StepRecord, CacheCheck } from './types';
+export declare const emptyCheckpoint: (fileId: string) => Checkpoint;
+export declare const checkCache: <T>(step: StepRecord | undefined, inputHash: string) => CacheCheck<T>;
+export declare const withStep: (cp: Checkpoint, name: string, result: unknown, inputHash: string) => Checkpoint;
+export declare const withCleanup: (cp: Checkpoint, action: CleanupSpec) => Checkpoint;
+export declare const withoutCleanup: (cp: Checkpoint, type: string) => Checkpoint;
+export declare const withStatus: (cp: Checkpoint, status: CheckpointStatus) => Checkpoint;
+export declare const withoutStep: (cp: Checkpoint, name: string) => Checkpoint;
+export declare const rowToCheckpoint: (row: Record<string, unknown>) => Checkpoint;
+export declare const checkpointToRow: (cp: Checkpoint) => {
+    file_id: string;
+    started_at: number;
+    completed_at: number | null;
+    status: CheckpointStatus;
+    steps: string;
+    cleanup: string;
+};
+//# sourceMappingURL=checkpoint.d.ts.map

package/dist/checkpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint.d.ts","sourceRoot":"","sources":["../src/checkpoint.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,UAAU,EACV,gBAAgB,EAEhB,WAAW,EACX,UAAU,EACV,UAAU,EACX,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,eAAe,GAAI,QAAQ,MAAM,KAAG,UAO/C,CAAC;AAEH,eAAO,MAAM,UAAU,GAAI,CAAC,EAC1B,MAAM,UAAU,GAAG,SAAS,EAC5B,WAAW,MAAM,KAChB,UAAU,CAAC,CAAC,CAGK,CAAC;AAErB,eAAO,MAAM,QAAQ,GACnB,IAAI,UAAU,EACd,MAAM,MAAM,EACZ,QAAQ,OAAO,EACf,WAAW,MAAM,KAChB,UAMD,CAAC;AAEH,eAAO,MAAM,WAAW,GACtB,IAAI,UAAU,EACd,QAAQ,WAAW,KAClB,UAUD,CAAC;AAEH,eAAO,MAAM,cAAc,GAAI,IAAI,UAAU,EAAE,MAAM,MAAM,KAAG,UAG5D,CAAC;AAEH,eAAO,MAAM,UAAU,GACrB,IAAI,UAAU,EACd,QAAQ,gBAAgB,KACvB,UAID,CAAC;AAEH,eAAO,MAAM,WAAW,GAAI,IAAI,UAAU,EAAE,MAAM,MAAM,KAAG,UAG1D,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,UAa7D,CAAC;AAEH,eAAO,MAAM,eAAe,GAAI,IAAI,UAAU;;;;;;;CAO5C,CAAC"}

package/dist/cleanup.d.ts

@@ -0,0 +1,3 @@
+import type { CleanupAction, CleanupRegistry } from './types';
+export declare const executeAllCleanups: (runners: CleanupRegistry) => (actions: CleanupAction[]) => Promise<void>;
+//# sourceMappingURL=cleanup.d.ts.map

package/dist/cleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup.d.ts","sourceRoot":"","sources":["../src/cleanup.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AA4B9D,eAAO,MAAM,kBAAkB,GAC5B,SAAS,eAAe,MACtB,SAAS,aAAa,EAAE,KAAG,OAAO,CAAC,IAAI,CACiC,CAAC"}

package/dist/hash.d.ts

@@ -0,0 +1,3 @@
+export declare const sortKeys: (obj: unknown) => unknown;
+export declare const hash: (input: unknown) => string;
+//# sourceMappingURL=hash.d.ts.map

package/dist/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ,GAAI,KAAK,OAAO,KAAG,OAa7B,CAAC;AAEZ,eAAO,MAAM,IAAI,GAAI,OAAO,OAAO,KAAG,MAGrB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { load, durable, complete, fail, beforeRisky, afterSafe, clear, clearStep, sweep, sweepAllCleanups } from './api';
+export type { Checkpoint, CheckpointStatus, CleanupAction, CleanupRegistry, StorageAdapter } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAGzH,YAAY,EACV,UAAU,EACV,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,cAAc,EACf,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,506 @@
+// @bun
+// src/checkpoint.ts
+var emptyCheckpoint = (fileId) => ({
+  fileId,
+  startedAt: Date.now(),
+  completedAt: null,
+  status: "running",
+  steps: {},
+  cleanup: []
+});
+var checkCache = (step, inputHash) => step?.inputHash === inputHash ? { hit: true, result: step.result } : { hit: false };
+var withStep = (cp, name, result, inputHash) => ({
+  ...cp,
+  steps: {
+    ...cp.steps,
+    [name]: { result, inputHash, completedAt: Date.now() }
+  }
+});
+var withCleanup = (cp, action) => ({
+  ...cp,
+  cleanup: [
+    ...cp.cleanup,
+    {
+      ...action,
+      id: `${action.type}-${crypto.randomUUID()}`,
+      registeredAt: Date.now()
+    }
+  ]
+});
+var withoutCleanup = (cp, type) => ({
+  ...cp,
+  cleanup: cp.cleanup.filter((c) => c.type !== type)
+});
+var withStatus = (cp, status) => ({
+  ...cp,
+  status,
+  completedAt: status === "running" ? null : Date.now()
+});
+var withoutStep = (cp, name) => {
+  const { [name]: _removed, ...rest } = cp.steps;
+  return { ...cp, steps: rest };
+};
+
+// src/hash.ts
+var sortKeys = (obj) => Array.isArray(obj) ? obj.map(sortKeys) : obj && typeof obj === "object" ? Object.keys(obj).sort().reduce((acc, k) => ({
+  ...acc,
+  [k]: sortKeys(obj[k])
+}), {}) : obj;
+var hash = (input) => Array.from(JSON.stringify(sortKeys(input))).reduce((h, c) => (h << 5) - h + c.charCodeAt(0) | 0, 0).toString(36);
+
+// node_modules/neverthrow/dist/index.es.js
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m)
+    return m.call(o);
+  if (o && typeof o.length === "number")
+    return {
+      next: function() {
+        if (o && i >= o.length)
+          o = undefined;
+        return { value: o && o[i++], done: !o };
+      }
+    };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __await(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator)
+    throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []), i, q = [];
+  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function verb(n) {
+    if (g[n])
+      i[n] = function(v) {
+        return new Promise(function(a, b) {
+          q.push([n, v, a, b]) > 1 || resume(n, v);
+        });
+      };
+  }
+  function resume(n, v) {
+    try {
+      step(g[n](v));
+    } catch (e) {
+      settle(q[0][3], e);
+    }
+  }
+  function step(r) {
+    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+  }
+  function fulfill(value) {
+    resume("next", value);
+  }
+  function reject(value) {
+    resume("throw", value);
+  }
+  function settle(f, v) {
+    if (f(v), q.shift(), q.length)
+      resume(q[0][0], q[0][1]);
+  }
+}
+function __asyncDelegator(o) {
+  var i, p;
+  return i = {}, verb("next"), verb("throw", function(e) {
+    throw e;
+  }), verb("return"), i[Symbol.iterator] = function() {
+    return this;
+  }, i;
+  function verb(n, f) {
+    i[n] = o[n] ? function(v) {
+      return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v;
+    } : f;
+  }
+}
+function __asyncValues(o) {
+  if (!Symbol.asyncIterator)
+    throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator], i;
+  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i);
+  function verb(n) {
+    i[n] = o[n] && function(v) {
+      return new Promise(function(resolve, reject) {
+        v = o[n](v), settle(resolve, reject, v.done, v.value);
+      });
+    };
+  }
+  function settle(resolve, reject, d, v) {
+    Promise.resolve(v).then(function(v2) {
+      resolve({ value: v2, done: d });
+    }, reject);
+  }
+}
+var defaultErrorConfig = {
+  withStackTrace: false
+};
+var createNeverThrowError = (message, result, config = defaultErrorConfig) => {
+  const data = result.isOk() ? { type: "Ok", value: result.value } : { type: "Err", value: result.error };
+  const maybeStack = config.withStackTrace ? new Error().stack : undefined;
+  return {
+    data,
+    message,
+    stack: maybeStack
+  };
+};
+
+class ResultAsync {
+  constructor(res) {
+    this._promise = res;
+  }
+  static fromSafePromise(promise) {
+    const newPromise = promise.then((value) => new Ok(value));
+    return new ResultAsync(newPromise);
+  }
+  static fromPromise(promise, errorFn) {
+    const newPromise = promise.then((value) => new Ok(value)).catch((e) => new Err(errorFn(e)));
+    return new ResultAsync(newPromise);
+  }
+  static fromThrowable(fn, errorFn) {
+    return (...args) => {
+      return new ResultAsync((() => __awaiter(this, undefined, undefined, function* () {
+        try {
+          return new Ok(yield fn(...args));
+        } catch (error) {
+          return new Err(errorFn ? errorFn(error) : error);
+        }
+      }))());
+    };
+  }
+  static combine(asyncResultList) {
+    return combineResultAsyncList(asyncResultList);
+  }
+  static combineWithAllErrors(asyncResultList) {
+    return combineResultAsyncListWithAllErrors(asyncResultList);
+  }
+  map(f) {
+    return new ResultAsync(this._promise.then((res) => __awaiter(this, undefined, undefined, function* () {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      return new Ok(yield f(res.value));
+    })));
+  }
+  mapErr(f) {
+    return new ResultAsync(this._promise.then((res) => __awaiter(this, undefined, undefined, function* () {
+      if (res.isOk()) {
+        return new Ok(res.value);
+      }
+      return new Err(yield f(res.error));
+    })));
+  }
+  andThen(f) {
+    return new ResultAsync(this._promise.then((res) => {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      const newValue = f(res.value);
+      return newValue instanceof ResultAsync ? newValue._promise : newValue;
+    }));
+  }
+  orElse(f) {
+    return new ResultAsync(this._promise.then((res) => __awaiter(this, undefined, undefined, function* () {
+      if (res.isErr()) {
+        return f(res.error);
+      }
+      return new Ok(res.value);
+    })));
+  }
+  match(ok, _err) {
+    return this._promise.then((res) => res.match(ok, _err));
+  }
+  unwrapOr(t) {
+    return this._promise.then((res) => res.unwrapOr(t));
+  }
+  safeUnwrap() {
+    return __asyncGenerator(this, arguments, function* safeUnwrap_1() {
+      return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(yield __await(this._promise.then((res) => res.safeUnwrap()))))));
+    });
+  }
+  then(successCallback, failureCallback) {
+    return this._promise.then(successCallback, failureCallback);
+  }
+}
+var errAsync = (err) => new ResultAsync(Promise.resolve(new Err(err)));
+var fromPromise = ResultAsync.fromPromise;
+var fromSafePromise = ResultAsync.fromSafePromise;
+var fromAsyncThrowable = ResultAsync.fromThrowable;
+var combineResultList = (resultList) => {
+  let acc = ok([]);
+  for (const result of resultList) {
+    if (result.isErr()) {
+      acc = err(result.error);
+      break;
+    } else {
+      acc.map((list) => list.push(result.value));
+    }
+  }
+  return acc;
+};
+var combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
+var combineResultListWithAllErrors = (resultList) => {
+  let acc = ok([]);
+  for (const result of resultList) {
+    if (result.isErr() && acc.isErr()) {
+      acc.error.push(result.error);
+    } else if (result.isErr() && acc.isOk()) {
+      acc = err([result.error]);
+    } else if (result.isOk() && acc.isOk()) {
+      acc.value.push(result.value);
+    }
+  }
+  return acc;
+};
+var combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
+var Result;
+(function(Result2) {
+  function fromThrowable(fn, errorFn) {
+    return (...args) => {
+      try {
+        const result = fn(...args);
+        return ok(result);
+      } catch (e) {
+        return err(errorFn ? errorFn(e) : e);
+      }
+    };
+  }
+  Result2.fromThrowable = fromThrowable;
+  function combine(resultList) {
+    return combineResultList(resultList);
+  }
+  Result2.combine = combine;
+  function combineWithAllErrors(resultList) {
+    return combineResultListWithAllErrors(resultList);
+  }
+  Result2.combineWithAllErrors = combineWithAllErrors;
+})(Result || (Result = {}));
+var ok = (value) => new Ok(value);
+var err = (err2) => new Err(err2);
+
+class Ok {
+  constructor(value) {
+    this.value = value;
+  }
+  isOk() {
+    return true;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+  map(f) {
+    return ok(f(this.value));
+  }
+  mapErr(_f) {
+    return ok(this.value);
+  }
+  andThen(f) {
+    return f(this.value);
+  }
+  orElse(_f) {
+    return ok(this.value);
+  }
+  asyncAndThen(f) {
+    return f(this.value);
+  }
+  asyncMap(f) {
+    return ResultAsync.fromSafePromise(f(this.value));
+  }
+  unwrapOr(_v) {
+    return this.value;
+  }
+  match(ok2, _err) {
+    return ok2(this.value);
+  }
+  safeUnwrap() {
+    const value = this.value;
+    return function* () {
+      return value;
+    }();
+  }
+  _unsafeUnwrap(_) {
+    return this.value;
+  }
+  _unsafeUnwrapErr(config) {
+    throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config);
+  }
+}
+
+class Err {
+  constructor(error) {
+    this.error = error;
+  }
+  isOk() {
+    return false;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+  map(_f) {
+    return err(this.error);
+  }
+  mapErr(f) {
+    return err(f(this.error));
+  }
+  andThen(_f) {
+    return err(this.error);
+  }
+  orElse(f) {
+    return f(this.error);
+  }
+  asyncAndThen(_f) {
+    return errAsync(this.error);
+  }
+  asyncMap(_f) {
+    return errAsync(this.error);
+  }
+  unwrapOr(v) {
+    return v;
+  }
+  match(_ok, err2) {
+    return err2(this.error);
+  }
+  safeUnwrap() {
+    const error = this.error;
+    return function* () {
+      yield err(error);
+      throw new Error("Do not use this generator out of `safeTry`");
+    }();
+  }
+  _unsafeUnwrap(config) {
+    throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config);
+  }
+  _unsafeUnwrapErr(_) {
+    return this.error;
+  }
+}
+var fromThrowable = Result.fromThrowable;
+
+// src/log.ts
+var log = (emoji, tag, msg) => (value) => {
+  console.log(`${emoji} [${tag}] ${msg}`);
+  return value;
+};
+var logHit = (name, h) => log("\u23ED\uFE0F", name, `cached (${h})`);
+var logMiss = (name, h) => log("\u25B6\uFE0F", name, `exec (${h})`);
+var logSave = (name) => log("\u2705", name, "saved");
+var logCleanup = (type) => log("\uD83E\uDDF9", type, "cleanup executed");
+var logCleanupReg = (type) => log("\uD83D\uDCCB", type, "cleanup registered");
+var logCleanupClear = (type) => log("\u2713", type, "cleanup cleared");
+var logDone = (id) => log("\uD83C\uDFC1", id, "complete");
+var logFailed = (id) => log("\uD83D\uDCA5", id, "failed");
+var logRecovery = (id, count) => log("\uD83D\uDD27", id, `recovering ${count} pending cleanups`);
+
+// src/cleanup.ts
+var executeCleanup = (runners) => async (action) => {
+  const runner = runners[action.type];
+  if (!runner) {
+    console.warn(`\u26A0\uFE0F [${action.type}] no cleanup runner registered`);
+    return;
+  }
+  const result = await ResultAsync.fromPromise(runner(action.params), (e) => new Error(`[${action.type}] cleanup failed: ${String(e)}`));
+  result.match(() => {
+    logCleanup(action.type)(undefined);
+  }, (err2) => {
+    console.error(`\u26A0\uFE0F ${err2.message}`);
+  });
+};
+var executeAllCleanups = (runners) => (actions) => Promise.all(actions.map(executeCleanup(runners))).then(() => {
+  return;
+});
+
+// src/api.ts
+var load = (storage) => (runners) => (fileId) => storage.fetchOne(fileId).then((existing) => existing ?? emptyCheckpoint(fileId)).then((cp) => {
+  if (cp.cleanup.length === 0)
+    return cp;
+  logRecovery(fileId, cp.cleanup.length)(cp);
+  return executeAllCleanups(runners)(cp.cleanup).then(() => ({
+    ...cp,
+    cleanup: [],
+    startedAt: Date.now(),
+    status: "running"
+  }));
+}).then(storage.upsert);
+var beforeRisky = (storage) => (cp) => (type) => (params) => Promise.resolve(withCleanup(cp, { type, params })).then(storage.upsert).then((updated) => {
+  logCleanupReg(type)(updated);
+  Object.assign(cp, updated);
+  return updated;
+});
+var afterSafe = (storage) => (cp) => (type) => Promise.resolve(withoutCleanup(cp, type)).then(storage.upsert).then((updated) => {
+  logCleanupClear(type)(updated);
+  Object.assign(cp, updated);
+  return updated;
+});
+var durable = (storage) => (cp) => (name) => (inputs) => (fn) => {
+  const h = hash(inputs);
+  const cached = checkCache(cp.steps[name], h);
+  if (cached.hit) {
+    logHit(name, h)(cached.result);
+    return Promise.resolve(cached.result);
+  }
+  logMiss(name, h)(undefined);
+  return fn().then((result) => withStep(cp, name, result, h)).then(storage.upsert).then((updated) => {
+    logSave(name)(updated);
+    Object.assign(cp, updated);
+    return updated.steps[name].result;
+  });
+};
+var complete = (storage) => (cp) => Promise.resolve(withStatus(cp, "completed")).then(storage.upsert).then((updated) => {
+  logDone(cp.fileId)(updated);
+  return updated;
+});
+var fail = (storage) => (cp) => Promise.resolve(withStatus(cp, "failed")).then(storage.upsert).then((updated) => {
+  logFailed(cp.fileId)(updated);
+  return updated;
+});
+var clear = (storage) => (fileId) => storage.deleteOne(fileId);
+var clearStep = (storage) => (cp) => (name) => Promise.resolve(withoutStep(cp, name)).then(storage.upsert).then((updated) => {
+  Object.assign(cp, updated);
+  return updated;
+});
+var sweep = (storage) => (runners) => (staleThresholdMs = 60 * 60 * 1000) => storage.fetchStale(staleThresholdMs).then((stale) => Promise.all(stale.map((cp) => executeAllCleanups(runners)(cp.cleanup).then(() => withStatus({ ...cp, cleanup: [] }, "failed")).then(storage.upsert).then(() => cp.fileId))).then((fileIds) => ({ cleaned: fileIds.length, details: fileIds })));
+var sweepAllCleanups = (storage) => (runners) => () => storage.fetchPendingCleanups().then((cps) => Promise.all(cps.map((cp) => executeAllCleanups(runners)(cp.cleanup).then(() => storage.upsert({ ...cp, cleanup: [] })))).then((results) => ({ cleaned: results.length })));
+export {
+  sweepAllCleanups,
+  sweep,
+  load,
+  fail,
+  durable,
+  complete,
+  clearStep,
+  clear,
+  beforeRisky,
+  afterSafe
+};
+
+//# debugId=0964CEB4F2EA8B6464756E2164756E21

package/dist/index.js.map

@@ -0,0 +1,15 @@
+{
+  "version": 3,
+  "sources": ["../src/checkpoint.ts", "../src/hash.ts", "../node_modules/neverthrow/dist/index.es.js", "../src/log.ts", "../src/cleanup.ts", "../src/api.ts"],
+  "sourcesContent": [
+    "// src/checkpoint.ts\n\nimport type {\n  Checkpoint,\n  CheckpointStatus,\n  CleanupAction,\n  CleanupSpec,\n  StepRecord,\n  CacheCheck,\n} from './types';\n\nexport const emptyCheckpoint = (fileId: string): Checkpoint => ({\n  fileId,\n  startedAt: Date.now(),\n  completedAt: null,\n  status: 'running',\n  steps: {},\n  cleanup: [],\n});\n\nexport const checkCache = <T>(\n  step: StepRecord | undefined,\n  inputHash: string,\n): CacheCheck<T> =>\n  step?.inputHash === inputHash\n    ? { hit: true, result: step.result as T }\n    : { hit: false };\n\nexport const withStep = (\n  cp: Checkpoint,\n  name: string,\n  result: unknown,\n  inputHash: string,\n): Checkpoint => ({\n  ...cp,\n  steps: {\n    ...cp.steps,\n    [name]: { result, inputHash, completedAt: Date.now() },\n  },\n});\n\nexport const withCleanup = (\n  cp: Checkpoint,\n  action: CleanupSpec,\n): Checkpoint => ({\n  ...cp,\n  cleanup: [\n    ...cp.cleanup,\n    {\n      ...action,\n      id: `${action.type}-${crypto.randomUUID()}`,\n      registeredAt: Date.now(),\n    },\n  ],\n});\n\nexport const withoutCleanup = (cp: Checkpoint, type: string): Checkpoint => ({\n  ...cp,\n  cleanup: cp.cleanup.filter((c) => c.type !== type),\n});\n\nexport const withStatus = (\n  cp: Checkpoint,\n  status: CheckpointStatus,\n): Checkpoint => ({\n  ...cp,\n  status,\n  completedAt: status === 'running' ? null : Date.now(),\n});\n\nexport const withoutStep = (cp: Checkpoint, name: string): Checkpoint => {\n  const { [name]: _removed, ...rest } = cp.steps;\n  return { ...cp, steps: rest };\n};\n\nexport const rowToCheckpoint = (row: Record<string, unknown>): Checkpoint => ({\n  fileId: row.file_id as string,\n  startedAt: row.started_at as number,\n  completedAt: (row.completed_at as number | null) ?? null,\n  status: row.status as CheckpointStatus,\n  steps:\n    typeof row.steps === 'string'\n      ? JSON.parse(row.steps)\n      : ((row.steps as Record<string, StepRecord> | undefined) ?? {}),\n  cleanup:\n    typeof row.cleanup === 'string'\n      ? JSON.parse(row.cleanup)\n      : ((row.cleanup as CleanupAction[] | undefined) ?? []),\n});\n\nexport const checkpointToRow = (cp: Checkpoint) => ({\n  file_id: cp.fileId,\n  started_at: cp.startedAt,\n  completed_at: cp.completedAt,\n  status: cp.status,\n  steps: JSON.stringify(cp.steps),\n  cleanup: JSON.stringify(cp.cleanup),\n});\n\n",
+    "// src/hash.ts\n\nexport const sortKeys = (obj: unknown): unknown =>\n  Array.isArray(obj)\n    ? obj.map(sortKeys)\n    : obj && typeof obj === 'object'\n      ? Object.keys(obj as Record<string, unknown>)\n          .sort()\n          .reduce<Record<string, unknown>>(\n            (acc, k) => ({\n              ...acc,\n              [k]: sortKeys((obj as Record<string, unknown>)[k]),\n            }),\n            {},\n          )\n      : obj;\n\nexport const hash = (input: unknown): string =>\n  Array.from(JSON.stringify(sortKeys(input)))\n    .reduce((h, c) => ((h << 5) - h + c.charCodeAt(0)) | 0, 0)\n    .toString(36);\n\n",
+    "const defaultErrorConfig = {\r\n    withStackTrace: false,\r\n};\r\n// Custom error object\r\n// Context / discussion: https://github.com/supermacro/neverthrow/pull/215\r\nconst createNeverThrowError = (message, result, config = defaultErrorConfig) => {\r\n    const data = result.isOk()\r\n        ? { type: 'Ok', value: result.value }\r\n        : { type: 'Err', value: result.error };\r\n    const maybeStack = config.withStackTrace ? new Error().stack : undefined;\r\n    return {\r\n        data,\r\n        message,\r\n        stack: maybeStack,\r\n    };\r\n};\n\n/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n\r\nfunction __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nfunction __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nfunction __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nfunction __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nfunction __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nfunction __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\n\nclass ResultAsync {\r\n    constructor(res) {\r\n        this._promise = res;\r\n    }\r\n    static fromSafePromise(promise) {\r\n        const newPromise = promise.then((value) => new Ok(value));\r\n        return new ResultAsync(newPromise);\r\n    }\r\n    static fromPromise(promise, errorFn) {\r\n        const newPromise = promise\r\n            .then((value) => new Ok(value))\r\n            .catch((e) => new Err(errorFn(e)));\r\n        return new ResultAsync(newPromise);\r\n    }\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n    static fromThrowable(fn, errorFn) {\r\n        return (...args) => {\r\n            return new ResultAsync((() => __awaiter(this, void 0, void 0, function* () {\r\n                try {\r\n                    return new Ok(yield fn(...args));\r\n                }\r\n                catch (error) {\r\n                    return new Err(errorFn ? errorFn(error) : error);\r\n                }\r\n            }))());\r\n        };\r\n    }\r\n    static combine(asyncResultList) {\r\n        return combineResultAsyncList(asyncResultList);\r\n    }\r\n    static combineWithAllErrors(asyncResultList) {\r\n        return combineResultAsyncListWithAllErrors(asyncResultList);\r\n    }\r\n    map(f) {\r\n        return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {\r\n            if (res.isErr()) {\r\n                return new Err(res.error);\r\n            }\r\n            return new Ok(yield f(res.value));\r\n        })));\r\n    }\r\n    mapErr(f) {\r\n        return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {\r\n            if (res.isOk()) {\r\n                return new Ok(res.value);\r\n            }\r\n            return new Err(yield f(res.error));\r\n        })));\r\n    }\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\r\n    andThen(f) {\r\n        return new ResultAsync(this._promise.then((res) => {\r\n            if (res.isErr()) {\r\n                return new Err(res.error);\r\n            }\r\n            const newValue = f(res.value);\r\n            return newValue instanceof ResultAsync ? newValue._promise : newValue;\r\n        }));\r\n    }\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\r\n    orElse(f) {\r\n        return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {\r\n            if (res.isErr()) {\r\n                return f(res.error);\r\n            }\r\n            return new Ok(res.value);\r\n        })));\r\n    }\r\n    match(ok, _err) {\r\n        return this._promise.then((res) => res.match(ok, _err));\r\n    }\r\n    unwrapOr(t) {\r\n        return this._promise.then((res) => res.unwrapOr(t));\r\n    }\r\n    /**\r\n     * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.\r\n     */\r\n    safeUnwrap() {\r\n        return __asyncGenerator(this, arguments, function* safeUnwrap_1() {\r\n            return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(yield __await(this._promise.then((res) => res.safeUnwrap()))))));\r\n        });\r\n    }\r\n    // Makes ResultAsync implement PromiseLike<Result>\r\n    then(successCallback, failureCallback) {\r\n        return this._promise.then(successCallback, failureCallback);\r\n    }\r\n}\r\nconst okAsync = (value) => new ResultAsync(Promise.resolve(new Ok(value)));\r\nconst errAsync = (err) => new ResultAsync(Promise.resolve(new Err(err)));\r\nconst fromPromise = ResultAsync.fromPromise;\r\nconst fromSafePromise = ResultAsync.fromSafePromise;\r\nconst fromAsyncThrowable = ResultAsync.fromThrowable;\n\n/**\r\n * Short circuits on the FIRST Err value that we find\r\n */\r\nconst combineResultList = (resultList) => {\r\n    let acc = ok([]);\r\n    for (const result of resultList) {\r\n        if (result.isErr()) {\r\n            acc = err(result.error);\r\n            break;\r\n        }\r\n        else {\r\n            acc.map((list) => list.push(result.value));\r\n        }\r\n    }\r\n    return acc;\r\n};\r\n/* This is the typesafe version of Promise.all\r\n *\r\n * Takes a list of ResultAsync<T, E> and success if all inner results are Ok values\r\n * or fails if one (or more) of the inner results are Err values\r\n */\r\nconst combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);\r\n/**\r\n * Give a list of all the errors we find\r\n */\r\nconst combineResultListWithAllErrors = (resultList) => {\r\n    let acc = ok([]);\r\n    for (const result of resultList) {\r\n        if (result.isErr() && acc.isErr()) {\r\n            acc.error.push(result.error);\r\n        }\r\n        else if (result.isErr() && acc.isOk()) {\r\n            acc = err([result.error]);\r\n        }\r\n        else if (result.isOk() && acc.isOk()) {\r\n            acc.value.push(result.value);\r\n        }\r\n        // do nothing when result.isOk() && acc.isErr()\r\n    }\r\n    return acc;\r\n};\r\nconst combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);\n\n// eslint-disable-next-line @typescript-eslint/no-namespace\r\nvar Result;\r\n(function (Result) {\r\n    /**\r\n     * Wraps a function with a try catch, creating a new function with the same\r\n     * arguments but returning `Ok` if successful, `Err` if the function throws\r\n     *\r\n     * @param fn function to wrap with ok on success or err on failure\r\n     * @param errorFn when an error is thrown, this will wrap the error result if provided\r\n     */\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n    function fromThrowable(fn, errorFn) {\r\n        return (...args) => {\r\n            try {\r\n                const result = fn(...args);\r\n                return ok(result);\r\n            }\r\n            catch (e) {\r\n                return err(errorFn ? errorFn(e) : e);\r\n            }\r\n        };\r\n    }\r\n    Result.fromThrowable = fromThrowable;\r\n    function combine(resultList) {\r\n        return combineResultList(resultList);\r\n    }\r\n    Result.combine = combine;\r\n    function combineWithAllErrors(resultList) {\r\n        return combineResultListWithAllErrors(resultList);\r\n    }\r\n    Result.combineWithAllErrors = combineWithAllErrors;\r\n})(Result || (Result = {}));\r\nconst ok = (value) => new Ok(value);\r\nconst err = (err) => new Err(err);\r\nfunction safeTry(body) {\r\n    const n = body().next();\r\n    if (n instanceof Promise) {\r\n        return n.then((r) => r.value);\r\n    }\r\n    return n.value;\r\n}\r\nclass Ok {\r\n    constructor(value) {\r\n        this.value = value;\r\n    }\r\n    isOk() {\r\n        return true;\r\n    }\r\n    isErr() {\r\n        return !this.isOk();\r\n    }\r\n    map(f) {\r\n        return ok(f(this.value));\r\n    }\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    mapErr(_f) {\r\n        return ok(this.value);\r\n    }\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\r\n    andThen(f) {\r\n        return f(this.value);\r\n    }\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\r\n    orElse(_f) {\r\n        return ok(this.value);\r\n    }\r\n    asyncAndThen(f) {\r\n        return f(this.value);\r\n    }\r\n    asyncMap(f) {\r\n        return ResultAsync.fromSafePromise(f(this.value));\r\n    }\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    unwrapOr(_v) {\r\n        return this.value;\r\n    }\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    match(ok, _err) {\r\n        return ok(this.value);\r\n    }\r\n    safeUnwrap() {\r\n        const value = this.value;\r\n        /* eslint-disable-next-line require-yield */\r\n        return (function* () {\r\n            return value;\r\n        })();\r\n    }\r\n    _unsafeUnwrap(_) {\r\n        return this.value;\r\n    }\r\n    _unsafeUnwrapErr(config) {\r\n        throw createNeverThrowError('Called `_unsafeUnwrapErr` on an Ok', this, config);\r\n    }\r\n}\r\nclass Err {\r\n    constructor(error) {\r\n        this.error = error;\r\n    }\r\n    isOk() {\r\n        return false;\r\n    }\r\n    isErr() {\r\n        return !this.isOk();\r\n    }\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    map(_f) {\r\n        return err(this.error);\r\n    }\r\n    mapErr(f) {\r\n        return err(f(this.error));\r\n    }\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\r\n    andThen(_f) {\r\n        return err(this.error);\r\n    }\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\r\n    orElse(f) {\r\n        return f(this.error);\r\n    }\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    asyncAndThen(_f) {\r\n        return errAsync(this.error);\r\n    }\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    asyncMap(_f) {\r\n        return errAsync(this.error);\r\n    }\r\n    unwrapOr(v) {\r\n        return v;\r\n    }\r\n    match(_ok, err) {\r\n        return err(this.error);\r\n    }\r\n    safeUnwrap() {\r\n        const error = this.error;\r\n        return (function* () {\r\n            yield err(error);\r\n            throw new Error('Do not use this generator out of `safeTry`');\r\n        })();\r\n    }\r\n    _unsafeUnwrap(config) {\r\n        throw createNeverThrowError('Called `_unsafeUnwrap` on an Err', this, config);\r\n    }\r\n    _unsafeUnwrapErr(_) {\r\n        return this.error;\r\n    }\r\n}\r\nconst fromThrowable = Result.fromThrowable;\r\n//#endregion\n\nexport { Err, Ok, Result, ResultAsync, err, errAsync, fromAsyncThrowable, fromPromise, fromSafePromise, fromThrowable, ok, okAsync, safeTry };\n",
+    "// src/log.ts\n\nconst log =\n  <T>(emoji: string, tag: string, msg: string) =>\n  (value: T): T => {\n    console.log(`${emoji} [${tag}] ${msg}`);\n    return value;\n  };\n\nexport const logHit = (name: string, h: string) =>\n  log('⏭️', name, `cached (${h})`);\n\nexport const logMiss = (name: string, h: string) =>\n  log('▶️', name, `exec (${h})`);\n\nexport const logSave = (name: string) => log('✅', name, 'saved');\n\nexport const logCleanup = (type: string) => log('🧹', type, 'cleanup executed');\n\nexport const logCleanupReg = (type: string) =>\n  log('📋', type, 'cleanup registered');\n\nexport const logCleanupClear = (type: string) =>\n  log('✓', type, 'cleanup cleared');\n\nexport const logDone = (id: string) => log('🏁', id, 'complete');\n\nexport const logFailed = (id: string) => log('💥', id, 'failed');\n\nexport const logRecovery = (id: string, count: number) =>\n  log('🔧', id, `recovering ${count} pending cleanups`);\n",
+    "// src/cleanup.ts\n\nimport { ResultAsync } from 'neverthrow';\nimport type { CleanupAction, CleanupRegistry } from './types';\nimport { logCleanup } from './log';\n\nconst executeCleanup =\n  (runners: CleanupRegistry) =>\n    async (action: CleanupAction): Promise<void> => {\n      const runner = runners[action.type];\n\n      if (!runner) {\n        console.warn(`⚠️ [${action.type}] no cleanup runner registered`);\n        return;\n      }\n\n      const result = await ResultAsync.fromPromise(\n        runner(action.params),\n        (e: unknown) => new Error(`[${action.type}] cleanup failed: ${String(e)}`),\n      );\n\n      result.match(\n        () => {\n          logCleanup(action.type)(undefined as unknown as void);\n        },\n        (err: Error) => {\n          console.error(`⚠️ ${err.message}`);\n        },\n      );\n    };\n\nexport const executeAllCleanups =\n  (runners: CleanupRegistry) =>\n    (actions: CleanupAction[]): Promise<void> =>\n      Promise.all(actions.map(executeCleanup(runners))).then(() => undefined);\n",
+    "// src/api.ts\n\nimport type { Checkpoint, CleanupRegistry, StorageAdapter } from './types';\nimport {\n  emptyCheckpoint,\n  checkCache,\n  withStep,\n  withCleanup,\n  withoutCleanup,\n  withStatus,\n  withoutStep,\n} from './checkpoint';\nimport { hash } from './hash';\nimport { executeAllCleanups } from './cleanup';\nimport {\n  logHit,\n  logMiss,\n  logSave,\n  logCleanupReg,\n  logCleanupClear,\n  logDone,\n  logFailed,\n  logRecovery,\n} from './log';\n\nexport const load =\n  (storage: StorageAdapter) =>\n    (runners: CleanupRegistry) =>\n      (fileId: string): Promise<Checkpoint> =>\n        storage\n          .fetchOne(fileId)\n          .then((existing) => existing ?? emptyCheckpoint(fileId))\n          .then((cp) => {\n            if (cp.cleanup.length === 0) return cp;\n\n            logRecovery(fileId, cp.cleanup.length)(cp);\n\n            return executeAllCleanups(runners)(cp.cleanup).then(() => ({\n              ...cp,\n              cleanup: [],\n              startedAt: Date.now(),\n              status: 'running' as const,\n            }));\n          })\n          .then(storage.upsert);\n\nexport const beforeRisky =\n  (storage: StorageAdapter) =>\n    (cp: Checkpoint) =>\n      (type: string) =>\n        (params: Record<string, unknown>): Promise<Checkpoint> =>\n          Promise.resolve(withCleanup(cp, { type, params }))\n            .then(storage.upsert)\n            .then((updated) => {\n              logCleanupReg(type)(updated);\n              Object.assign(cp, updated);\n              return updated;\n            });\n\nexport const afterSafe =\n  (storage: StorageAdapter) =>\n    (cp: Checkpoint) =>\n      (type: string): Promise<Checkpoint> =>\n        Promise.resolve(withoutCleanup(cp, type))\n          .then(storage.upsert)\n          .then((updated) => {\n            logCleanupClear(type)(updated);\n            Object.assign(cp, updated);\n            return updated;\n          });\n\nexport const durable =\n  (storage: StorageAdapter) =>\n    (cp: Checkpoint) =>\n      (name: string) =>\n        <I, T>(inputs: I) =>\n          (fn: () => Promise<T>): Promise<T> => {\n            const h = hash(inputs);\n            const cached = checkCache<T>(cp.steps[name], h);\n\n            if (cached.hit) {\n              logHit(name, h)(cached.result);\n              return Promise.resolve(cached.result);\n            }\n\n            logMiss(name, h)(undefined);\n            return fn()\n              .then((result) => withStep(cp, name, result, h))\n              .then(storage.upsert)\n              .then((updated) => {\n                logSave(name)(updated);\n                Object.assign(cp, updated);\n                return updated.steps[name].result as T;\n              });\n          };\n\nexport const complete =\n  (storage: StorageAdapter) =>\n    (cp: Checkpoint): Promise<Checkpoint> =>\n      Promise.resolve(withStatus(cp, 'completed'))\n        .then(storage.upsert)\n        .then((updated) => {\n          logDone(cp.fileId)(updated);\n          return updated;\n        });\n\nexport const fail =\n  (storage: StorageAdapter) =>\n    (cp: Checkpoint): Promise<Checkpoint> =>\n      Promise.resolve(withStatus(cp, 'failed'))\n        .then(storage.upsert)\n        .then((updated) => {\n          logFailed(cp.fileId)(updated);\n          return updated;\n        });\n\nexport const clear =\n  (storage: StorageAdapter) =>\n    (fileId: string): Promise<void> =>\n      storage.deleteOne(fileId);\n\nexport const clearStep =\n  (storage: StorageAdapter) =>\n    (cp: Checkpoint) =>\n      (name: string): Promise<Checkpoint> =>\n        Promise.resolve(withoutStep(cp, name))\n          .then(storage.upsert)\n          .then((updated) => {\n            Object.assign(cp, updated);\n            return updated;\n          });\n\nexport const sweep =\n  (storage: StorageAdapter) =>\n    (runners: CleanupRegistry) =>\n      (\n        staleThresholdMs: number = 60 * 60 * 1000,\n      ): Promise<{ cleaned: number; details: string[] }> =>\n        storage.fetchStale(staleThresholdMs).then((stale) =>\n          Promise.all(\n            stale.map((cp) =>\n              executeAllCleanups(runners)(cp.cleanup)\n                .then(() => withStatus({ ...cp, cleanup: [] }, 'failed'))\n                .then(storage.upsert)\n                .then(() => cp.fileId),\n            ),\n          ).then((fileIds) => ({ cleaned: fileIds.length, details: fileIds })),\n        );\n\nexport const sweepAllCleanups =\n  (storage: StorageAdapter) =>\n    (runners: CleanupRegistry) =>\n      (): Promise<{ cleaned: number }> =>\n        storage.fetchPendingCleanups().then((cps) =>\n          Promise.all(\n            cps.map((cp) =>\n              executeAllCleanups(runners)(cp.cleanup).then(() =>\n                storage.upsert({ ...cp, cleanup: [] }),\n              ),\n            ),\n          ).then((results) => ({ cleaned: results.length })),\n        );\n"
+  ],
+  "mappings": "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",
+  "debugId": "0964CEB4F2EA8B6464756E2164756E21",
+  "names": []
+}

package/dist/log.d.ts

@@ -0,0 +1,10 @@
+export declare const logHit: (name: string, h: string) => (value: unknown) => unknown;
+export declare const logMiss: (name: string, h: string) => (value: unknown) => unknown;
+export declare const logSave: (name: string) => (value: unknown) => unknown;
+export declare const logCleanup: (type: string) => (value: unknown) => unknown;
+export declare const logCleanupReg: (type: string) => (value: unknown) => unknown;
+export declare const logCleanupClear: (type: string) => (value: unknown) => unknown;
+export declare const logDone: (id: string) => (value: unknown) => unknown;
+export declare const logFailed: (id: string) => (value: unknown) => unknown;
+export declare const logRecovery: (id: string, count: number) => (value: unknown) => unknown;
+//# sourceMappingURL=log.d.ts.map

package/dist/log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../src/log.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,MAAM,GAAI,MAAM,MAAM,EAAE,GAAG,MAAM,gCACZ,CAAC;AAEnC,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,EAAE,GAAG,MAAM,gCACf,CAAC;AAEjC,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,gCAA4B,CAAC;AAEjE,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,gCAAwC,CAAC;AAEhF,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,gCACH,CAAC;AAExC,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,gCACT,CAAC;AAEpC,eAAO,MAAM,OAAO,GAAI,IAAI,MAAM,gCAA8B,CAAC;AAEjE,eAAO,MAAM,SAAS,GAAI,IAAI,MAAM,gCAA4B,CAAC;AAEjE,eAAO,MAAM,WAAW,GAAI,IAAI,MAAM,EAAE,OAAO,MAAM,gCACE,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,42 @@
+export type StepRecord = {
+    result: unknown;
+    inputHash: string;
+    completedAt: number;
+};
+export type CleanupAction = {
+    id: string;
+    type: string;
+    params: Record<string, unknown>;
+    registeredAt: number;
+};
+export type CheckpointStatus = 'running' | 'completed' | 'failed';
+export type Checkpoint = {
+    fileId: string;
+    startedAt: number;
+    completedAt: number | null;
+    status: CheckpointStatus;
+    steps: Record<string, StepRecord>;
+    cleanup: CleanupAction[];
+};
+export type CleanupRunner = (params: Record<string, unknown>) => Promise<void>;
+export type CleanupRegistry = Record<string, CleanupRunner>;
+export type CacheHit<T> = {
+    hit: true;
+    result: T;
+};
+export type CacheMiss = {
+    hit: false;
+};
+export type CacheCheck<T> = CacheHit<T> | CacheMiss;
+export type CleanupSpec = {
+    type: string;
+    params: Record<string, unknown>;
+};
+export type StorageAdapter = {
+    fetchOne: (fileId: string) => Promise<Checkpoint | null>;
+    upsert: (cp: Checkpoint) => Promise<Checkpoint>;
+    deleteOne: (fileId: string) => Promise<void>;
+    fetchStale: (thresholdMs: number) => Promise<Checkpoint[]>;
+    fetchPendingCleanups: () => Promise<Checkpoint[]>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAC;AAElE,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAClC,OAAO,EAAE,aAAa,EAAE,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,CAC1B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC5B,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnB,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAE5D,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;IAAE,GAAG,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,CAAC,CAAA;CAAE,CAAC;AACnD,MAAM,MAAM,SAAS,GAAG;IAAE,GAAG,EAAE,KAAK,CAAA;CAAE,CAAC;AACvC,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;AAEpD,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IACzD,MAAM,EAAE,CAAC,EAAE,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;IAChD,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,UAAU,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IAC3D,oBAAoB,EAAE,MAAM,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;CACnD,CAAC"}

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "durable-x",
+  "version": "0.1.0",
+  "description": "Lightweight durable execution with checkpoint memoization and saga cleanup—no sidecar required. Add Temporal/Dapr-style durability to Windmill workflows, APIs, background jobs, and CLI tools.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./adapters/windmill": {
+      "import": "./dist/adapters/windmill.js",
+      "types": "./dist/adapters/windmill.d.ts"
+    }
+  },
+  "files": [
+    "dist/**",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "bun run build:types && bun run build:esm",
+    "build:types": "tsc --emitDeclarationOnly --outDir dist",
+    "build:esm": "bun build ./src/index.ts --outdir dist --format esm --target bun --sourcemap=external",
+    "test": "bun test",
+    "test:integration": "bun test tests/**/*.test.ts",
+    "test:watch": "bun test --watch",
+    "lint": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "prepublish": "bun run clean && bun run build && bun run lint && bun run test"
+  },
+  "keywords": [
+    "windmill",
+    "workflow",
+    "durable-execution",
+    "checkpoint",
+    "temporal",
+    "dapr",
+    "idempotency",
+    "saga",
+    "memoization",
+    "fault-tolerance",
+    "resilience",
+    "crash-recovery",
+    "compensation",
+    "n8n"
+  ],
+  "author": {
+    "name": "Tom Davidson",
+    "email": "tom@tomdavidson.org",
+    "url": "https://github.com/tomdavidson/"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/tommdavidson/durable-x#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tommdavidson/durable-x.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tommdavidson/durable-x/issues"
+  },
+  "dependencies": {
+    "neverthrow": "^6.0.0"
+  },
+  "peerDependencies": {
+    "windmill-client": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  }
+}