effect-distributed-lock 0.0.1

package/README.md

@@ -0,0 +1,15 @@
+# effect-distributed-lock
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.2.12. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.

package/bun.lock

@@ -0,0 +1,249 @@
+{
+  "lockfileVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "effect-distributed-lock",
+      "dependencies": {
+        "effect": "^3.19.13",
+      },
+      "devDependencies": {
+        "@types/bun": "latest",
+        "ioredis": "^5.4.1",
+        "tsup": "^8.5.1",
+      },
+      "peerDependencies": {
+        "effect": "^3.0.0",
+        "ioredis": "^5.0.0",
+        "typescript": "^5",
+      },
+      "optionalPeers": [
+        "ioredis",
+      ],
+    },
+  },
+  "packages": {
+    "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.27.2", "", { "os": "aix", "cpu": "ppc64" }, "sha512-GZMB+a0mOMZs4MpDbj8RJp4cw+w1WV5NYD6xzgvzUJ5Ek2jerwfO2eADyI6ExDSUED+1X8aMbegahsJi+8mgpw=="],
+
+    "@esbuild/android-arm": ["@esbuild/android-arm@0.27.2", "", { "os": "android", "cpu": "arm" }, "sha512-DVNI8jlPa7Ujbr1yjU2PfUSRtAUZPG9I1RwW4F4xFB1Imiu2on0ADiI/c3td+KmDtVKNbi+nffGDQMfcIMkwIA=="],
+
+    "@esbuild/android-arm64": ["@esbuild/android-arm64@0.27.2", "", { "os": "android", "cpu": "arm64" }, "sha512-pvz8ZZ7ot/RBphf8fv60ljmaoydPU12VuXHImtAs0XhLLw+EXBi2BLe3OYSBslR4rryHvweW5gmkKFwTiFy6KA=="],
+
+    "@esbuild/android-x64": ["@esbuild/android-x64@0.27.2", "", { "os": "android", "cpu": "x64" }, "sha512-z8Ank4Byh4TJJOh4wpz8g2vDy75zFL0TlZlkUkEwYXuPSgX8yzep596n6mT7905kA9uHZsf/o2OJZubl2l3M7A=="],
+
+    "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.27.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-davCD2Zc80nzDVRwXTcQP/28fiJbcOwvdolL0sOiOsbwBa72kegmVU0Wrh1MYrbuCL98Omp5dVhQFWRKR2ZAlg=="],
+
+    "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.27.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-ZxtijOmlQCBWGwbVmwOF/UCzuGIbUkqB1faQRf5akQmxRJ1ujusWsb3CVfk/9iZKr2L5SMU5wPBi1UWbvL+VQA=="],
+
+    "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.27.2", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-lS/9CN+rgqQ9czogxlMcBMGd+l8Q3Nj1MFQwBZJyoEKI50XGxwuzznYdwcav6lpOGv5BqaZXqvBSiB/kJ5op+g=="],
+
+    "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.27.2", "", { "os": "freebsd", "cpu": "x64" }, "sha512-tAfqtNYb4YgPnJlEFu4c212HYjQWSO/w/h/lQaBK7RbwGIkBOuNKQI9tqWzx7Wtp7bTPaGC6MJvWI608P3wXYA=="],
+
+    "@esbuild/linux-arm": ["@esbuild/linux-arm@0.27.2", "", { "os": "linux", "cpu": "arm" }, "sha512-vWfq4GaIMP9AIe4yj1ZUW18RDhx6EPQKjwe7n8BbIecFtCQG4CfHGaHuh7fdfq+y3LIA2vGS/o9ZBGVxIDi9hw=="],
+
+    "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.27.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-hYxN8pr66NsCCiRFkHUAsxylNOcAQaxSSkHMMjcpx0si13t1LHFphxJZUiGwojB1a/Hd5OiPIqDdXONia6bhTw=="],
+
+    "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.27.2", "", { "os": "linux", "cpu": "ia32" }, "sha512-MJt5BRRSScPDwG2hLelYhAAKh9imjHK5+NE/tvnRLbIqUWa+0E9N4WNMjmp/kXXPHZGqPLxggwVhz7QP8CTR8w=="],
+
+    "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.27.2", "", { "os": "linux", "cpu": "none" }, "sha512-lugyF1atnAT463aO6KPshVCJK5NgRnU4yb3FUumyVz+cGvZbontBgzeGFO1nF+dPueHD367a2ZXe1NtUkAjOtg=="],
+
+    "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.27.2", "", { "os": "linux", "cpu": "none" }, "sha512-nlP2I6ArEBewvJ2gjrrkESEZkB5mIoaTswuqNFRv/WYd+ATtUpe9Y09RnJvgvdag7he0OWgEZWhviS1OTOKixw=="],
+
+    "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.27.2", "", { "os": "linux", "cpu": "ppc64" }, "sha512-C92gnpey7tUQONqg1n6dKVbx3vphKtTHJaNG2Ok9lGwbZil6DrfyecMsp9CrmXGQJmZ7iiVXvvZH6Ml5hL6XdQ=="],
+
+    "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.27.2", "", { "os": "linux", "cpu": "none" }, "sha512-B5BOmojNtUyN8AXlK0QJyvjEZkWwy/FKvakkTDCziX95AowLZKR6aCDhG7LeF7uMCXEJqwa8Bejz5LTPYm8AvA=="],
+
+    "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.27.2", "", { "os": "linux", "cpu": "s390x" }, "sha512-p4bm9+wsPwup5Z8f4EpfN63qNagQ47Ua2znaqGH6bqLlmJ4bx97Y9JdqxgGZ6Y8xVTixUnEkoKSHcpRlDnNr5w=="],
+
+    "@esbuild/linux-x64": ["@esbuild/linux-x64@0.27.2", "", { "os": "linux", "cpu": "x64" }, "sha512-uwp2Tip5aPmH+NRUwTcfLb+W32WXjpFejTIOWZFw/v7/KnpCDKG66u4DLcurQpiYTiYwQ9B7KOeMJvLCu/OvbA=="],
+
+    "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.27.2", "", { "os": "none", "cpu": "arm64" }, "sha512-Kj6DiBlwXrPsCRDeRvGAUb/LNrBASrfqAIok+xB0LxK8CHqxZ037viF13ugfsIpePH93mX7xfJp97cyDuTZ3cw=="],
+
+    "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.27.2", "", { "os": "none", "cpu": "x64" }, "sha512-HwGDZ0VLVBY3Y+Nw0JexZy9o/nUAWq9MlV7cahpaXKW6TOzfVno3y3/M8Ga8u8Yr7GldLOov27xiCnqRZf0tCA=="],
+
+    "@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.27.2", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-DNIHH2BPQ5551A7oSHD0CKbwIA/Ox7+78/AWkbS5QoRzaqlev2uFayfSxq68EkonB+IKjiuxBFoV8ESJy8bOHA=="],
+
+    "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.27.2", "", { "os": "openbsd", "cpu": "x64" }, "sha512-/it7w9Nb7+0KFIzjalNJVR5bOzA9Vay+yIPLVHfIQYG/j+j9VTH84aNB8ExGKPU4AzfaEvN9/V4HV+F+vo8OEg=="],
+
+    "@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.27.2", "", { "os": "none", "cpu": "arm64" }, "sha512-LRBbCmiU51IXfeXk59csuX/aSaToeG7w48nMwA6049Y4J4+VbWALAuXcs+qcD04rHDuSCSRKdmY63sruDS5qag=="],
+
+    "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.27.2", "", { "os": "sunos", "cpu": "x64" }, "sha512-kMtx1yqJHTmqaqHPAzKCAkDaKsffmXkPHThSfRwZGyuqyIeBvf08KSsYXl+abf5HDAPMJIPnbBfXvP2ZC2TfHg=="],
+
+    "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.27.2", "", { "os": "win32", "cpu": "arm64" }, "sha512-Yaf78O/B3Kkh+nKABUF++bvJv5Ijoy9AN1ww904rOXZFLWVc5OLOfL56W+C8F9xn5JQZa3UX6m+IktJnIb1Jjg=="],
+
+    "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.27.2", "", { "os": "win32", "cpu": "ia32" }, "sha512-Iuws0kxo4yusk7sw70Xa2E2imZU5HoixzxfGCdxwBdhiDgt9vX9VUCBhqcwY7/uh//78A1hMkkROMJq9l27oLQ=="],
+
+    "@esbuild/win32-x64": ["@esbuild/win32-x64@0.27.2", "", { "os": "win32", "cpu": "x64" }, "sha512-sRdU18mcKf7F+YgheI/zGf5alZatMUTKj/jNS6l744f9u3WFu4v7twcUI9vu4mknF4Y9aDlblIie0IM+5xxaqQ=="],
+
+    "@ioredis/commands": ["@ioredis/commands@1.4.0", "", {}, "sha512-aFT2yemJJo+TZCmieA7qnYGQooOS7QfNmYrzGtsYd3g9j5iDP8AimYYAesf79ohjbLG12XxC4nG5DyEnC88AsQ=="],
+
+    "@jridgewell/gen-mapping": ["@jridgewell/gen-mapping@0.3.13", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.0", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA=="],
+
+    "@jridgewell/resolve-uri": ["@jridgewell/resolve-uri@3.1.2", "", {}, "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw=="],
+
+    "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.5", "", {}, "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="],
+
+    "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="],
+
+    "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.54.0", "", { "os": "android", "cpu": "arm" }, "sha512-OywsdRHrFvCdvsewAInDKCNyR3laPA2mc9bRYJ6LBp5IyvF3fvXbbNR0bSzHlZVFtn6E0xw2oZlyjg4rKCVcng=="],
+
+    "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.54.0", "", { "os": "android", "cpu": "arm64" }, "sha512-Skx39Uv+u7H224Af+bDgNinitlmHyQX1K/atIA32JP3JQw6hVODX5tkbi2zof/E69M1qH2UoN3Xdxgs90mmNYw=="],
+
+    "@rollup/rollup-darwin-arm64": ["@rollup/rollup-darwin-arm64@4.54.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-k43D4qta/+6Fq+nCDhhv9yP2HdeKeP56QrUUTW7E6PhZP1US6NDqpJj4MY0jBHlJivVJD5P8NxrjuobZBJTCRw=="],
+
+    "@rollup/rollup-darwin-x64": ["@rollup/rollup-darwin-x64@4.54.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-cOo7biqwkpawslEfox5Vs8/qj83M/aZCSSNIWpVzfU2CYHa2G3P1UN5WF01RdTHSgCkri7XOlTdtk17BezlV3A=="],
+
+    "@rollup/rollup-freebsd-arm64": ["@rollup/rollup-freebsd-arm64@4.54.0", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-miSvuFkmvFbgJ1BevMa4CPCFt5MPGw094knM64W9I0giUIMMmRYcGW/JWZDriaw/k1kOBtsWh1z6nIFV1vPNtA=="],
+
+    "@rollup/rollup-freebsd-x64": ["@rollup/rollup-freebsd-x64@4.54.0", "", { "os": "freebsd", "cpu": "x64" }, "sha512-KGXIs55+b/ZfZsq9aR026tmr/+7tq6VG6MsnrvF4H8VhwflTIuYh+LFUlIsRdQSgrgmtM3fVATzEAj4hBQlaqQ=="],
+
+    "@rollup/rollup-linux-arm-gnueabihf": ["@rollup/rollup-linux-arm-gnueabihf@4.54.0", "", { "os": "linux", "cpu": "arm" }, "sha512-EHMUcDwhtdRGlXZsGSIuXSYwD5kOT9NVnx9sqzYiwAc91wfYOE1g1djOEDseZJKKqtHAHGwnGPQu3kytmfaXLQ=="],
+
+    "@rollup/rollup-linux-arm-musleabihf": ["@rollup/rollup-linux-arm-musleabihf@4.54.0", "", { "os": "linux", "cpu": "arm" }, "sha512-+pBrqEjaakN2ySv5RVrj/qLytYhPKEUwk+e3SFU5jTLHIcAtqh2rLrd/OkbNuHJpsBgxsD8ccJt5ga/SeG0JmA=="],
+
+    "@rollup/rollup-linux-arm64-gnu": ["@rollup/rollup-linux-arm64-gnu@4.54.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-NSqc7rE9wuUaRBsBp5ckQ5CVz5aIRKCwsoa6WMF7G01sX3/qHUw/z4pv+D+ahL1EIKy6Enpcnz1RY8pf7bjwng=="],
+
+    "@rollup/rollup-linux-arm64-musl": ["@rollup/rollup-linux-arm64-musl@4.54.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-gr5vDbg3Bakga5kbdpqx81m2n9IX8M6gIMlQQIXiLTNeQW6CucvuInJ91EuCJ/JYvc+rcLLsDFcfAD1K7fMofg=="],
+
+    "@rollup/rollup-linux-loong64-gnu": ["@rollup/rollup-linux-loong64-gnu@4.54.0", "", { "os": "linux", "cpu": "none" }, "sha512-gsrtB1NA3ZYj2vq0Rzkylo9ylCtW/PhpLEivlgWe0bpgtX5+9j9EZa0wtZiCjgu6zmSeZWyI/e2YRX1URozpIw=="],
+
+    "@rollup/rollup-linux-ppc64-gnu": ["@rollup/rollup-linux-ppc64-gnu@4.54.0", "", { "os": "linux", "cpu": "ppc64" }, "sha512-y3qNOfTBStmFNq+t4s7Tmc9hW2ENtPg8FeUD/VShI7rKxNW7O4fFeaYbMsd3tpFlIg1Q8IapFgy7Q9i2BqeBvA=="],
+
+    "@rollup/rollup-linux-riscv64-gnu": ["@rollup/rollup-linux-riscv64-gnu@4.54.0", "", { "os": "linux", "cpu": "none" }, "sha512-89sepv7h2lIVPsFma8iwmccN7Yjjtgz0Rj/Ou6fEqg3HDhpCa+Et+YSufy27i6b0Wav69Qv4WBNl3Rs6pwhebQ=="],
+
+    "@rollup/rollup-linux-riscv64-musl": ["@rollup/rollup-linux-riscv64-musl@4.54.0", "", { "os": "linux", "cpu": "none" }, "sha512-ZcU77ieh0M2Q8Ur7D5X7KvK+UxbXeDHwiOt/CPSBTI1fBmeDMivW0dPkdqkT4rOgDjrDDBUed9x4EgraIKoR2A=="],
+
+    "@rollup/rollup-linux-s390x-gnu": ["@rollup/rollup-linux-s390x-gnu@4.54.0", "", { "os": "linux", "cpu": "s390x" }, "sha512-2AdWy5RdDF5+4YfG/YesGDDtbyJlC9LHmL6rZw6FurBJ5n4vFGupsOBGfwMRjBYH7qRQowT8D/U4LoSvVwOhSQ=="],
+
+    "@rollup/rollup-linux-x64-gnu": ["@rollup/rollup-linux-x64-gnu@4.54.0", "", { "os": "linux", "cpu": "x64" }, "sha512-WGt5J8Ij/rvyqpFexxk3ffKqqbLf9AqrTBbWDk7ApGUzaIs6V+s2s84kAxklFwmMF/vBNGrVdYgbblCOFFezMQ=="],
+
+    "@rollup/rollup-linux-x64-musl": ["@rollup/rollup-linux-x64-musl@4.54.0", "", { "os": "linux", "cpu": "x64" }, "sha512-JzQmb38ATzHjxlPHuTH6tE7ojnMKM2kYNzt44LO/jJi8BpceEC8QuXYA908n8r3CNuG/B3BV8VR3Hi1rYtmPiw=="],
+
+    "@rollup/rollup-openharmony-arm64": ["@rollup/rollup-openharmony-arm64@4.54.0", "", { "os": "none", "cpu": "arm64" }, "sha512-huT3fd0iC7jigGh7n3q/+lfPcXxBi+om/Rs3yiFxjvSxbSB6aohDFXbWvlspaqjeOh+hx7DDHS+5Es5qRkWkZg=="],
+
+    "@rollup/rollup-win32-arm64-msvc": ["@rollup/rollup-win32-arm64-msvc@4.54.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-c2V0W1bsKIKfbLMBu/WGBz6Yci8nJ/ZJdheE0EwB73N3MvHYKiKGs3mVilX4Gs70eGeDaMqEob25Tw2Gb9Nqyw=="],
+
+    "@rollup/rollup-win32-ia32-msvc": ["@rollup/rollup-win32-ia32-msvc@4.54.0", "", { "os": "win32", "cpu": "ia32" }, "sha512-woEHgqQqDCkAzrDhvDipnSirm5vxUXtSKDYTVpZG3nUdW/VVB5VdCYA2iReSj/u3yCZzXID4kuKG7OynPnB3WQ=="],
+
+    "@rollup/rollup-win32-x64-gnu": ["@rollup/rollup-win32-x64-gnu@4.54.0", "", { "os": "win32", "cpu": "x64" }, "sha512-dzAc53LOuFvHwbCEOS0rPbXp6SIhAf2txMP5p6mGyOXXw5mWY8NGGbPMPrs4P1WItkfApDathBj/NzMLUZ9rtQ=="],
+
+    "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.54.0", "", { "os": "win32", "cpu": "x64" }, "sha512-hYT5d3YNdSh3mbCU1gwQyPgQd3T2ne0A3KG8KSBdav5TiBg6eInVmV+TeR5uHufiIgSFg0XsOWGW5/RhNcSvPg=="],
+
+    "@standard-schema/spec": ["@standard-schema/spec@1.1.0", "", {}, "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w=="],
+
+    "@types/bun": ["@types/bun@1.3.5", "", { "dependencies": { "bun-types": "1.3.5" } }, "sha512-RnygCqNrd3srIPEWBd5LFeUYG7plCoH2Yw9WaZGyNmdTEei+gWaHqydbaIRkIkcbXwhBT94q78QljxN0Sk838w=="],
+
+    "@types/estree": ["@types/estree@1.0.8", "", {}, "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w=="],
+
+    "@types/node": ["@types/node@25.0.3", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-W609buLVRVmeW693xKfzHeIV6nJGGz98uCPfeXI1ELMLXVeKYZ9m15fAMSaUPBHYLGFsVRcMmSCksQOrZV9BYA=="],
+
+    "acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
+
+    "any-promise": ["any-promise@1.3.0", "", {}, "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A=="],
+
+    "bun-types": ["bun-types@1.3.5", "", { "dependencies": { "@types/node": "*" } }, "sha512-inmAYe2PFLs0SUbFOWSVD24sg1jFlMPxOjOSSCYqUgn4Hsc3rDc7dFvfVYjFPNHtov6kgUeulV4SxbuIV/stPw=="],
+
+    "bundle-require": ["bundle-require@5.1.0", "", { "dependencies": { "load-tsconfig": "^0.2.3" }, "peerDependencies": { "esbuild": ">=0.18" } }, "sha512-3WrrOuZiyaaZPWiEt4G3+IffISVC9HYlWueJEBWED4ZH4aIAC2PnkdnuRrR94M+w6yGWn4AglWtJtBI8YqvgoA=="],
+
+    "cac": ["cac@6.7.14", "", {}, "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ=="],
+
+    "chokidar": ["chokidar@4.0.3", "", { "dependencies": { "readdirp": "^4.0.1" } }, "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA=="],
+
+    "cluster-key-slot": ["cluster-key-slot@1.1.2", "", {}, "sha512-RMr0FhtfXemyinomL4hrWcYJxmX6deFdCxpJzhDttxgO1+bcCnkk+9drydLVDmAMG7NE6aN/fl4F7ucU/90gAA=="],
+
+    "commander": ["commander@4.1.1", "", {}, "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA=="],
+
+    "confbox": ["confbox@0.1.8", "", {}, "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w=="],
+
+    "consola": ["consola@3.4.2", "", {}, "sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA=="],
+
+    "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
+
+    "denque": ["denque@2.1.0", "", {}, "sha512-HVQE3AAb/pxF8fQAoiqpvg9i3evqug3hoiwakOyZAwJm+6vZehbkYXZ0l4JxS+I3QxM97v5aaRNhj8v5oBhekw=="],
+
+    "effect": ["effect@3.19.13", "", { "dependencies": { "@standard-schema/spec": "^1.0.0", "fast-check": "^3.23.1" } }, "sha512-8MZ783YuHRwHZX2Mmm+bpGxq+7XPd88sWwYAz2Ysry80sEKpftDZXs2Hg9ZyjESi1IBTNHF0oDKe0zJRkUlyew=="],
+
+    "esbuild": ["esbuild@0.27.2", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.27.2", "@esbuild/android-arm": "0.27.2", "@esbuild/android-arm64": "0.27.2", "@esbuild/android-x64": "0.27.2", "@esbuild/darwin-arm64": "0.27.2", "@esbuild/darwin-x64": "0.27.2", "@esbuild/freebsd-arm64": "0.27.2", "@esbuild/freebsd-x64": "0.27.2", "@esbuild/linux-arm": "0.27.2", "@esbuild/linux-arm64": "0.27.2", "@esbuild/linux-ia32": "0.27.2", "@esbuild/linux-loong64": "0.27.2", "@esbuild/linux-mips64el": "0.27.2", "@esbuild/linux-ppc64": "0.27.2", "@esbuild/linux-riscv64": "0.27.2", "@esbuild/linux-s390x": "0.27.2", "@esbuild/linux-x64": "0.27.2", "@esbuild/netbsd-arm64": "0.27.2", "@esbuild/netbsd-x64": "0.27.2", "@esbuild/openbsd-arm64": "0.27.2", "@esbuild/openbsd-x64": "0.27.2", "@esbuild/openharmony-arm64": "0.27.2", "@esbuild/sunos-x64": "0.27.2", "@esbuild/win32-arm64": "0.27.2", "@esbuild/win32-ia32": "0.27.2", "@esbuild/win32-x64": "0.27.2" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-HyNQImnsOC7X9PMNaCIeAm4ISCQXs5a5YasTXVliKv4uuBo1dKrG0A+uQS8M5eXjVMnLg3WgXaKvprHlFJQffw=="],
+
+    "fast-check": ["fast-check@3.23.2", "", { "dependencies": { "pure-rand": "^6.1.0" } }, "sha512-h5+1OzzfCC3Ef7VbtKdcv7zsstUQwUDlYpUTvjeUsJAssPgLn7QzbboPtL5ro04Mq0rPOsMzl7q5hIbRs2wD1A=="],
+
+    "fdir": ["fdir@6.5.0", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg=="],
+
+    "fix-dts-default-cjs-exports": ["fix-dts-default-cjs-exports@1.0.1", "", { "dependencies": { "magic-string": "^0.30.17", "mlly": "^1.7.4", "rollup": "^4.34.8" } }, "sha512-pVIECanWFC61Hzl2+oOCtoJ3F17kglZC/6N94eRWycFgBH35hHx0Li604ZIzhseh97mf2p0cv7vVrOZGoqhlEg=="],
+
+    "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
+
+    "ioredis": ["ioredis@5.8.2", "", { "dependencies": { "@ioredis/commands": "1.4.0", "cluster-key-slot": "^1.1.0", "debug": "^4.3.4", "denque": "^2.1.0", "lodash.defaults": "^4.2.0", "lodash.isarguments": "^3.1.0", "redis-errors": "^1.2.0", "redis-parser": "^3.0.0", "standard-as-callback": "^2.1.0" } }, "sha512-C6uC+kleiIMmjViJINWk80sOQw5lEzse1ZmvD+S/s8p8CWapftSaC+kocGTx6xrbrJ4WmYQGC08ffHLr6ToR6Q=="],
+
+    "joycon": ["joycon@3.1.1", "", {}, "sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw=="],
+
+    "lilconfig": ["lilconfig@3.1.3", "", {}, "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw=="],
+
+    "lines-and-columns": ["lines-and-columns@1.2.4", "", {}, "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg=="],
+
+    "load-tsconfig": ["load-tsconfig@0.2.5", "", {}, "sha512-IXO6OCs9yg8tMKzfPZ1YmheJbZCiEsnBdcB03l0OcfK9prKnJb96siuHCr5Fl37/yo9DnKU+TLpxzTUspw9shg=="],
+
+    "lodash.defaults": ["lodash.defaults@4.2.0", "", {}, "sha512-qjxPLHd3r5DnsdGacqOMU6pb/avJzdh9tFX2ymgoZE27BmjXrNy/y4LoaiTeAb+O3gL8AfpJGtqfX/ae2leYYQ=="],
+
+    "lodash.isarguments": ["lodash.isarguments@3.1.0", "", {}, "sha512-chi4NHZlZqZD18a0imDHnZPrDeBbTtVN7GXMwuGdRH9qotxAjYs3aVLKc7zNOG9eddR5Ksd8rvFEBc9SsggPpg=="],
+
+    "magic-string": ["magic-string@0.30.21", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.5" } }, "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ=="],
+
+    "mlly": ["mlly@1.8.0", "", { "dependencies": { "acorn": "^8.15.0", "pathe": "^2.0.3", "pkg-types": "^1.3.1", "ufo": "^1.6.1" } }, "sha512-l8D9ODSRWLe2KHJSifWGwBqpTZXIXTeo8mlKjY+E2HAakaTeNpqAyBZ8GSqLzHgw4XmHmC8whvpjJNMbFZN7/g=="],
+
+    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+
+    "mz": ["mz@2.7.0", "", { "dependencies": { "any-promise": "^1.0.0", "object-assign": "^4.0.1", "thenify-all": "^1.0.0" } }, "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q=="],
+
+    "object-assign": ["object-assign@4.1.1", "", {}, "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg=="],
+
+    "pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
+
+    "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="],
+
+    "picomatch": ["picomatch@4.0.3", "", {}, "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q=="],
+
+    "pirates": ["pirates@4.0.7", "", {}, "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA=="],
+
+    "pkg-types": ["pkg-types@1.3.1", "", { "dependencies": { "confbox": "^0.1.8", "mlly": "^1.7.4", "pathe": "^2.0.1" } }, "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ=="],
+
+    "postcss-load-config": ["postcss-load-config@6.0.1", "", { "dependencies": { "lilconfig": "^3.1.1" }, "peerDependencies": { "jiti": ">=1.21.0", "postcss": ">=8.0.9", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["jiti", "postcss", "tsx", "yaml"] }, "sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g=="],
+
+    "pure-rand": ["pure-rand@6.1.0", "", {}, "sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA=="],
+
+    "readdirp": ["readdirp@4.1.2", "", {}, "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg=="],
+
+    "redis-errors": ["redis-errors@1.2.0", "", {}, "sha512-1qny3OExCf0UvUV/5wpYKf2YwPcOqXzkwKKSmKHiE6ZMQs5heeE/c8eXK+PNllPvmjgAbfnsbpkGZWy8cBpn9w=="],
+
+    "redis-parser": ["redis-parser@3.0.0", "", { "dependencies": { "redis-errors": "^1.0.0" } }, "sha512-DJnGAeenTdpMEH6uAJRK/uiyEIH9WVsUmoLwzudwGJUwZPp80PDBWPHXSAGNPwNvIXAbe7MSUB1zQFugFml66A=="],
+
+    "resolve-from": ["resolve-from@5.0.0", "", {}, "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw=="],
+
+    "rollup": ["rollup@4.54.0", "", { "dependencies": { "@types/estree": "1.0.8" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.54.0", "@rollup/rollup-android-arm64": "4.54.0", "@rollup/rollup-darwin-arm64": "4.54.0", "@rollup/rollup-darwin-x64": "4.54.0", "@rollup/rollup-freebsd-arm64": "4.54.0", "@rollup/rollup-freebsd-x64": "4.54.0", "@rollup/rollup-linux-arm-gnueabihf": "4.54.0", "@rollup/rollup-linux-arm-musleabihf": "4.54.0", "@rollup/rollup-linux-arm64-gnu": "4.54.0", "@rollup/rollup-linux-arm64-musl": "4.54.0", "@rollup/rollup-linux-loong64-gnu": "4.54.0", "@rollup/rollup-linux-ppc64-gnu": "4.54.0", "@rollup/rollup-linux-riscv64-gnu": "4.54.0", "@rollup/rollup-linux-riscv64-musl": "4.54.0", "@rollup/rollup-linux-s390x-gnu": "4.54.0", "@rollup/rollup-linux-x64-gnu": "4.54.0", "@rollup/rollup-linux-x64-musl": "4.54.0", "@rollup/rollup-openharmony-arm64": "4.54.0", "@rollup/rollup-win32-arm64-msvc": "4.54.0", "@rollup/rollup-win32-ia32-msvc": "4.54.0", "@rollup/rollup-win32-x64-gnu": "4.54.0", "@rollup/rollup-win32-x64-msvc": "4.54.0", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-3nk8Y3a9Ea8szgKhinMlGMhGMw89mqule3KWczxhIzqudyHdCIOHw8WJlj/r329fACjKLEh13ZSk7oE22kyeIw=="],
+
+    "source-map": ["source-map@0.7.6", "", {}, "sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ=="],
+
+    "standard-as-callback": ["standard-as-callback@2.1.0", "", {}, "sha512-qoRRSyROncaz1z0mvYqIE4lCd9p2R90i6GxW3uZv5ucSu8tU7B5HXUP1gG8pVZsYNVaXjk8ClXHPttLyxAL48A=="],
+
+    "sucrase": ["sucrase@3.35.1", "", { "dependencies": { "@jridgewell/gen-mapping": "^0.3.2", "commander": "^4.0.0", "lines-and-columns": "^1.1.6", "mz": "^2.7.0", "pirates": "^4.0.1", "tinyglobby": "^0.2.11", "ts-interface-checker": "^0.1.9" }, "bin": { "sucrase": "bin/sucrase", "sucrase-node": "bin/sucrase-node" } }, "sha512-DhuTmvZWux4H1UOnWMB3sk0sbaCVOoQZjv8u1rDoTV0HTdGem9hkAZtl4JZy8P2z4Bg0nT+YMeOFyVr4zcG5Tw=="],
+
+    "thenify": ["thenify@3.3.1", "", { "dependencies": { "any-promise": "^1.0.0" } }, "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw=="],
+
+    "thenify-all": ["thenify-all@1.6.0", "", { "dependencies": { "thenify": ">= 3.1.0 < 4" } }, "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA=="],
+
+    "tinyexec": ["tinyexec@0.3.2", "", {}, "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA=="],
+
+    "tinyglobby": ["tinyglobby@0.2.15", "", { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.3" } }, "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ=="],
+
+    "tree-kill": ["tree-kill@1.2.2", "", { "bin": { "tree-kill": "cli.js" } }, "sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A=="],
+
+    "ts-interface-checker": ["ts-interface-checker@0.1.13", "", {}, "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA=="],
+
+    "tsup": ["tsup@8.5.1", "", { "dependencies": { "bundle-require": "^5.1.0", "cac": "^6.7.14", "chokidar": "^4.0.3", "consola": "^3.4.0", "debug": "^4.4.0", "esbuild": "^0.27.0", "fix-dts-default-cjs-exports": "^1.0.0", "joycon": "^3.1.1", "picocolors": "^1.1.1", "postcss-load-config": "^6.0.1", "resolve-from": "^5.0.0", "rollup": "^4.34.8", "source-map": "^0.7.6", "sucrase": "^3.35.0", "tinyexec": "^0.3.2", "tinyglobby": "^0.2.11", "tree-kill": "^1.2.2" }, "peerDependencies": { "@microsoft/api-extractor": "^7.36.0", "@swc/core": "^1", "postcss": "^8.4.12", "typescript": ">=4.5.0" }, "optionalPeers": ["@microsoft/api-extractor", "@swc/core", "postcss", "typescript"], "bin": { "tsup": "dist/cli-default.js", "tsup-node": "dist/cli-node.js" } }, "sha512-xtgkqwdhpKWr3tKPmCkvYmS9xnQK3m3XgxZHwSUjvfTjp7YfXe5tT3GgWi0F2N+ZSMsOeWeZFh7ZZFg5iPhing=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "ufo": ["ufo@1.6.1", "", {}, "sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA=="],
+
+    "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="],
+  }
+}

package/examples/index.ts

@@ -0,0 +1,89 @@
+/**
+ * Example usage of the distributed mutex library.
+ *
+ * Run with: bun run example.ts
+ * Requires REDIS_URL environment variable.
+ */
+import { Effect, Console, Duration } from "effect";
+import Redis from "ioredis";
+import { DistributedMutex, RedisBacking } from "../src/index.ts";
+
+// Create Redis client
+const redis = new Redis(process.env.REDIS_URL ?? "redis://localhost:6379");
+
+// Create the Redis backing layer
+const RedisLayer = RedisBacking.layer(redis, "example:");
+
+// Example 1: Using withLock for a critical section
+const example1 = Effect.gen(function* () {
+  yield* Console.log("=== Example 1: withLock ===");
+
+  const mutex = yield* DistributedMutex.make("my-resource", {
+    ttl: Duration.seconds(10),
+    acquireTimeout: Duration.seconds(5),
+  });
+
+  yield* mutex.withLock(
+    Effect.gen(function* () {
+      yield* Console.log("Lock acquired! Doing critical work...");
+      yield* Effect.sleep(2000);
+      yield* Console.log("Critical work done!");
+    })
+  );
+
+  yield* Console.log("Lock released automatically");
+});
+
+// Example 2: Using tryAcquire (non-blocking)
+const example2 = Effect.gen(function* () {
+  yield* Console.log("\n=== Example 2: withLockIfAvailable ===");
+
+  const mutex = yield* DistributedMutex.make("another-resource", {
+    ttl: Duration.seconds(10),
+  });
+
+  const result = yield* mutex.withLockIfAvailable(
+    Effect.gen(function* () {
+      yield* Console.log("Got the lock without waiting!");
+      return "success";
+    })
+  );
+
+  yield* Console.log(`Result: ${JSON.stringify(result)}`);
+});
+
+// Example 3: Manual scope management with acquire()
+const example3 = Effect.gen(function* () {
+  yield* Console.log("\n=== Example 3: Manual acquire with Scope ===");
+
+  const mutex = yield* DistributedMutex.make("manual-resource", {
+    ttl: Duration.seconds(10),
+    acquireTimeout: Duration.seconds(5),
+  });
+
+  // Using Effect.scoped to manage the lock lifecycle
+  yield* Effect.scoped(
+    Effect.gen(function* () {
+      yield* mutex.acquire;
+      yield* Console.log("Lock acquired via acquire()");
+      yield* Effect.sleep(1000);
+      yield* Console.log("About to exit scope...");
+      // Lock is automatically released when scope closes
+    })
+  );
+
+  yield* Console.log("Scope closed, lock released");
+});
+
+// Run all examples
+const main = Effect.gen(function* () {
+  yield* example1;
+  yield* example2;
+  yield* example3;
+  yield* Console.log("\n✓ All examples completed!");
+}).pipe(
+  Effect.ensuring(Effect.promise(() => redis.quit())),
+  Effect.provide(RedisLayer)
+);
+
+Effect.runPromise(main).catch(console.error);

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "effect-distributed-lock",
+  "version": "0.0.1",
+  "description": "A distributed mutex library for Effect with pluggable backends",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "check": "tsc --noEmit"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "ioredis": "^5.4.1"
+  },
+  "peerDependencies": {
+    "typescript": "^5",
+    "effect": "^3.0.0",
+    "ioredis": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "ioredis": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "effect": "^3.19.13"
+  }
+}

package/src/DistributedMutex.ts

@@ -0,0 +1,304 @@
+import { Context, Duration, Effect, Option, Schedule, Scope } from "effect";
+import {
+  AcquireTimeoutError,
+  BackingError,
+  LockLostError,
+  NotYetAcquiredError,
+} from "./Errors.js";
+
+// =============================================================================
+// Backing Service
+// =============================================================================
+
+/**
+ * Low-level backing store interface for distributed mutex operations.
+ * Implementations handle the actual storage (Redis, etcd, DynamoDB, etc.)
+ */
+export interface DistributedMutexBacking {
+  /**
+   * Try to acquire the lock. Returns true if acquired, false if already held.
+   * Must set TTL on the lock.
+   */
+  readonly tryAcquire: (
+    key: string,
+    holderId: string,
+    ttlMs: number
+  ) => Effect.Effect<boolean, BackingError>;
+
+  /**
+   * Release the lock. Only succeeds if we are the current holder.
+   * Returns true if released, false if we weren't the holder.
+   */
+  readonly release: (
+    key: string,
+    holderId: string
+  ) => Effect.Effect<boolean, BackingError>;
+
+  /**
+   * Refresh the TTL on a lock we hold.
+   * Returns true if refreshed, false if lock was lost.
+   */
+  readonly refresh: (
+    key: string,
+    holderId: string,
+    ttlMs: number
+  ) => Effect.Effect<boolean, BackingError>;
+
+  /**
+   * Check if the lock is currently held (by anyone).
+   */
+  readonly isLocked: (key: string) => Effect.Effect<boolean, BackingError>;
+
+  /**
+   * Get the current holder ID, if any.
+   */
+  readonly getHolder: (
+    key: string
+  ) => Effect.Effect<Option.Option<string>, BackingError>;
+}
+
+export const DistributedMutexBacking =
+  Context.GenericTag<DistributedMutexBacking>(
+    "@effect-distributed-lock/DistributedMutexBacking"
+  );
+
+// =============================================================================
+// Mutex Configuration
+// =============================================================================
+
+export interface DistributedMutexConfig {
+  /**
+   * TTL for the lock. If the holder crashes, the lock auto-releases after this.
+   * @default 30 seconds
+   */
+  readonly ttl?: Duration.DurationInput;
+
+  /**
+   * How often to refresh the TTL while holding the lock.
+   * Should be less than TTL to avoid losing the lock.
+   * @default 1/3 of TTL
+   */
+  readonly refreshInterval?: Duration.DurationInput;
+
+  /**
+   * How often to poll when waiting to acquire the lock.
+   * @default 100ms
+   */
+  readonly retryInterval?: Duration.DurationInput;
+
+  /**
+   * Maximum time to wait when acquiring the lock.
+   * If not set, will wait forever.
+   */
+  readonly acquireTimeout?: Duration.DurationInput;
+}
+
+const DEFAULT_TTL = Duration.seconds(30);
+const DEFAULT_RETRY_INTERVAL = Duration.millis(100);
+
+// =============================================================================
+// Distributed Mutex Interface
+// =============================================================================
+
+/**
+ * A distributed mutex that can be used across multiple processes/services.
+ */
+export interface DistributedMutex {
+  /**
+   * The key identifying this mutex in the backing store.
+   */
+  readonly key: string;
+
+  /**
+   * Acquire the lock, run the effect, then release.
+   * If acquisition fails within timeout, returns AcquireTimeoutError.
+   * The lock TTL is refreshed automatically while the effect runs.
+   */
+  readonly withLock: <A, E, R>(
+    effect: Effect.Effect<A, E, R>
+  ) => Effect.Effect<
+    A,
+    E | AcquireTimeoutError | LockLostError | BackingError,
+    R
+  >;
+
+  /**
+   * Try to acquire the lock immediately without waiting.
+   * Returns Some(result) if lock was acquired and effect ran,
+   * None if lock was not available.
+   */
+  readonly withLockIfAvailable: <A, E, R>(
+    effect: Effect.Effect<A, E, R>
+  ) => Effect.Effect<Option.Option<A>, E | LockLostError | BackingError, R>;
+
+  /**
+   * Acquire the lock, waiting if necessary.
+   * The lock is held until the scope is closed.
+   * The lock TTL is refreshed automatically while held.
+   */
+  readonly acquire: Effect.Effect<
+    void,
+    AcquireTimeoutError | LockLostError | BackingError,
+    Scope.Scope
+  >;
+
+  /**
+   * Try to acquire immediately without waiting.
+   * Returns Some(void) if acquired (lock held until scope closes),
+   * None if lock was not available.
+   */
+  readonly tryAcquire: Effect.Effect<
+    Option.Option<void>,
+    LockLostError | BackingError,
+    Scope.Scope
+  >;
+
+  /**
+   * Check if the lock is currently held.
+   */
+  readonly isLocked: Effect.Effect<boolean, BackingError>;
+}
+
+// =============================================================================
+// Factory
+// =============================================================================
+
+/**
+ * Create a distributed mutex for the given key.
+ */
+export const make = (
+  key: string,
+  config: DistributedMutexConfig = {}
+): Effect.Effect<DistributedMutex, never, DistributedMutexBacking> =>
+  Effect.gen(function* () {
+    const backing = yield* DistributedMutexBacking;
+
+    // Generate unique holder ID for this instance
+    const holderId = crypto.randomUUID();
+
+    // Resolve config with defaults
+    const ttl = config.ttl ? Duration.decode(config.ttl) : DEFAULT_TTL;
+    const ttlMs = Duration.toMillis(ttl);
+    const refreshInterval = config.refreshInterval
+      ? Duration.decode(config.refreshInterval)
+      : Duration.millis(ttlMs / 3);
+    const retryInterval = config.retryInterval
+      ? Duration.decode(config.retryInterval)
+      : DEFAULT_RETRY_INTERVAL;
+    const acquireTimeout = config.acquireTimeout
+      ? Option.some(Duration.decode(config.acquireTimeout))
+      : Option.none<Duration.Duration>();
+
+    // Keep the lock alive by refreshing TTL periodically.
+    // This effect runs forever until interrupted (when scope closes).
+    const keepAlive = Effect.repeat(
+      Effect.gen(function* () {
+        const refreshed = yield* backing.refresh(key, holderId, ttlMs);
+        if (!refreshed) {
+          return yield* new LockLostError({ key });
+        }
+      }),
+      Schedule.spaced(refreshInterval)
+    );
+
+    // Try to acquire immediately, returns Option
+    const tryAcquire: Effect.Effect<
+      Option.Option<void>,
+      LockLostError | BackingError,
+      Scope.Scope
+    > = Effect.gen(function* () {
+      const acquired = yield* backing.tryAcquire(key, holderId, ttlMs);
+      if (!acquired) {
+        return Option.none();
+      }
+
+      // Start keepalive fiber, tied to this scope
+      yield* Effect.forkScoped(keepAlive);
+
+      // Add finalizer to release lock when scope closes
+      yield* Effect.addFinalizer(() =>
+        backing.release(key, holderId).pipe(Effect.ignore)
+      );
+
+      return Option.some(undefined as void);
+    });
+
+    // Acquire with retry/timeout, returns void when acquired
+    const acquire: Effect.Effect<
+      void,
+      AcquireTimeoutError | LockLostError | BackingError,
+      Scope.Scope
+    > = Effect.gen(function* () {
+      // Build retry schedule with optional timeout
+      const schedule = Option.match(acquireTimeout, {
+        onNone: () => Schedule.spaced(retryInterval),
+        onSome: (timeout) =>
+          Schedule.spaced(retryInterval).pipe(Schedule.upTo(timeout)),
+      });
+
+      // Retry until we acquire the lock
+      yield* Effect.retry(
+        Effect.gen(function* () {
+          const maybeAcquired = yield* tryAcquire;
+          if (Option.isNone(maybeAcquired)) {
+            return yield* new NotYetAcquiredError();
+          }
+        }),
+        schedule
+      ).pipe(
+        Effect.catchTag(
+          "NotYetAcquiredError",
+          () =>
+            new AcquireTimeoutError({
+              key,
+              timeoutMs: Option.match(acquireTimeout, {
+                onNone: () => -1,
+                onSome: Duration.toMillis,
+              }),
+            })
+        )
+      );
+    });
+
+    // Convenience: acquire lock, run effect, release when done
+    const withLock = <A, E, R>(
+      effect: Effect.Effect<A, E, R>
+    ): Effect.Effect<
+      A,
+      E | AcquireTimeoutError | LockLostError | BackingError,
+      R
+    > =>
+      Effect.scoped(
+        Effect.gen(function* () {
+          yield* acquire;
+          return yield* effect;
+        })
+      );
+
+    // Convenience: try to acquire, run effect if successful
+    const withLockIfAvailable = <A, E, R>(
+      effect: Effect.Effect<A, E, R>
+    ): Effect.Effect<Option.Option<A>, E | LockLostError | BackingError, R> =>
+      Effect.scoped(
+        Effect.gen(function* () {
+          const maybeAcquired = yield* tryAcquire;
+          if (Option.isNone(maybeAcquired)) {
+            return Option.none<A>();
+          }
+          const result = yield* effect;
+          return Option.some(result);
+        })
+      );
+
+    const isLocked: Effect.Effect<boolean, BackingError> =
+      backing.isLocked(key);
+
+    return {
+      key,
+      withLock,
+      withLockIfAvailable,
+      acquire,
+      tryAcquire,
+      isLocked,
+    } satisfies DistributedMutex;
+  });

package/src/Errors.ts

@@ -0,0 +1,56 @@
+import { Data } from "effect";
+
+/**
+ * Base error for all distributed mutex errors
+ */
+export class DistributedMutexError extends Data.TaggedError(
+  "DistributedMutexError"
+)<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+
+/**
+ * Failed to acquire the lock within the timeout period
+ */
+export class AcquireTimeoutError extends Data.TaggedError(
+  "AcquireTimeoutError"
+)<{
+  readonly key: string;
+  readonly timeoutMs: number;
+}> {
+  get message() {
+    return `Failed to acquire lock "${this.key}" within ${this.timeoutMs}ms`;
+  }
+}
+
+/**
+ * The lock was lost (TTL expired while we thought we held it)
+ */
+export class LockLostError extends Data.TaggedError("LockLostError")<{
+  readonly key: string;
+}> {
+  get message() {
+    return `Lock "${this.key}" was lost (TTL expired or taken by another holder)`;
+  }
+}
+
+/**
+ * Error from the backing store (Redis, etc.)
+ */
+export class BackingError extends Data.TaggedError("BackingError")<{
+  readonly operation: string;
+  readonly cause: unknown;
+}> {
+  get message() {
+    return `Backing store error during "${this.operation}": ${this.cause}`;
+  }
+}
+
+/**
+ * Internal error: lock not yet acquired (used for retry logic)
+ * @internal
+ */
+export class NotYetAcquiredError extends Data.TaggedError(
+  "NotYetAcquiredError"
+)<{}> {}

package/src/RedisBacking.ts

@@ -0,0 +1,268 @@
+import { Effect, Layer, Option } from "effect";
+import type { Redis } from "ioredis";
+import { DistributedMutexBacking } from "./DistributedMutex.js";
+import { BackingError } from "./Errors.js";
+
+/**
+ * Lua script for atomic lock acquisition.
+ * SET key value NX PX ttl - set only if not exists, with TTL
+ */
+const ACQUIRE_SCRIPT = `
+local key = KEYS[1]
+local holderId = ARGV[1]
+local ttlMs = tonumber(ARGV[2])
+
+local result = redis.call('SET', key, holderId, 'NX', 'PX', ttlMs)
+if result then
+  return 1
+else
+  return 0
+end
+`;
+
+/**
+ * Lua script for atomic lock release.
+ * Only deletes if we are the current holder.
+ */
+const RELEASE_SCRIPT = `
+local key = KEYS[1]
+local holderId = ARGV[1]
+
+local currentHolder = redis.call('GET', key)
+if currentHolder == holderId then
+  redis.call('DEL', key)
+  return 1
+else
+  return 0
+end
+`;
+
+/**
+ * Lua script for atomic TTL refresh.
+ * Only refreshes if we are the current holder.
+ */
+const REFRESH_SCRIPT = `
+local key = KEYS[1]
+local holderId = ARGV[1]
+local ttlMs = tonumber(ARGV[2])
+
+local currentHolder = redis.call('GET', key)
+if currentHolder == holderId then
+  redis.call('PEXPIRE', key, ttlMs)
+  return 1
+else
+  return 0
+end
+`;
+
+/**
+ * Create a Redis-backed distributed mutex backing layer.
+ *
+ * @param redis - An ioredis client instance
+ * @param keyPrefix - Optional prefix for all keys (default: "dmutex:")
+ */
+export const layer = (
+  redis: Redis,
+  keyPrefix = "dmutex:"
+): Layer.Layer<DistributedMutexBacking> => {
+  const prefixKey = (key: string) => `${keyPrefix}${key}`;
+
+  const tryAcquire = (
+    key: string,
+    holderId: string,
+    ttlMs: number
+  ): Effect.Effect<boolean, BackingError> =>
+    Effect.tryPromise({
+      try: async () => {
+        const result = await redis.eval(
+          ACQUIRE_SCRIPT,
+          1,
+          prefixKey(key),
+          holderId,
+          ttlMs.toString()
+        );
+        return result === 1;
+      },
+      catch: (cause) => new BackingError({ operation: "tryAcquire", cause }),
+    });
+
+  const release = (
+    key: string,
+    holderId: string
+  ): Effect.Effect<boolean, BackingError> =>
+    Effect.tryPromise({
+      try: async () => {
+        const result = await redis.eval(
+          RELEASE_SCRIPT,
+          1,
+          prefixKey(key),
+          holderId
+        );
+        return result === 1;
+      },
+      catch: (cause) => new BackingError({ operation: "release", cause }),
+    });
+
+  const refresh = (
+    key: string,
+    holderId: string,
+    ttlMs: number
+  ): Effect.Effect<boolean, BackingError> =>
+    Effect.tryPromise({
+      try: async () => {
+        const result = await redis.eval(
+          REFRESH_SCRIPT,
+          1,
+          prefixKey(key),
+          holderId,
+          ttlMs.toString()
+        );
+        return result === 1;
+      },
+      catch: (cause) => new BackingError({ operation: "refresh", cause }),
+    });
+
+  const isLocked = (key: string): Effect.Effect<boolean, BackingError> =>
+    Effect.tryPromise({
+      try: async () => {
+        const exists = await redis.exists(prefixKey(key));
+        return exists === 1;
+      },
+      catch: (cause) => new BackingError({ operation: "isLocked", cause }),
+    });
+
+  const getHolder = (
+    key: string
+  ): Effect.Effect<Option.Option<string>, BackingError> =>
+    Effect.tryPromise({
+      try: async () => {
+        const holder = await redis.get(prefixKey(key));
+        return holder ? Option.some(holder) : Option.none();
+      },
+      catch: (cause) => new BackingError({ operation: "getHolder", cause }),
+    });
+
+  return Layer.succeed(DistributedMutexBacking, {
+    tryAcquire,
+    release,
+    refresh,
+    isLocked,
+    getHolder,
+  });
+};
+
+/**
+ * Create a Redis backing from a connection URL.
+ * This creates and manages the Redis connection lifecycle.
+ */
+export const layerFromUrl = (
+  url: string,
+  keyPrefix = "dmutex:"
+): Layer.Layer<DistributedMutexBacking, BackingError> =>
+  Layer.scoped(
+    DistributedMutexBacking,
+    Effect.gen(function* () {
+      // Dynamic import to avoid requiring ioredis at module load time
+      const { default: Redis } = yield* Effect.tryPromise({
+        try: () => import("ioredis"),
+        catch: (cause) =>
+          new BackingError({
+            operation: "import",
+            cause: `Failed to import ioredis: ${cause}`,
+          }),
+      });
+
+      const redis = new Redis(url);
+
+      // Ensure cleanup on scope close
+      yield* Effect.addFinalizer(() =>
+        Effect.promise(() => redis.quit().catch(() => {}))
+      );
+
+      const prefixKey = (key: string) => `${keyPrefix}${key}`;
+
+      const tryAcquire = (
+        key: string,
+        holderId: string,
+        ttlMs: number
+      ): Effect.Effect<boolean, BackingError> =>
+        Effect.tryPromise({
+          try: async () => {
+            const result = await redis.eval(
+              ACQUIRE_SCRIPT,
+              1,
+              prefixKey(key),
+              holderId,
+              ttlMs.toString()
+            );
+            return result === 1;
+          },
+          catch: (cause) =>
+            new BackingError({ operation: "tryAcquire", cause }),
+        });
+
+      const release = (
+        key: string,
+        holderId: string
+      ): Effect.Effect<boolean, BackingError> =>
+        Effect.tryPromise({
+          try: async () => {
+            const result = await redis.eval(
+              RELEASE_SCRIPT,
+              1,
+              prefixKey(key),
+              holderId
+            );
+            return result === 1;
+          },
+          catch: (cause) => new BackingError({ operation: "release", cause }),
+        });
+
+      const refresh = (
+        key: string,
+        holderId: string,
+        ttlMs: number
+      ): Effect.Effect<boolean, BackingError> =>
+        Effect.tryPromise({
+          try: async () => {
+            const result = await redis.eval(
+              REFRESH_SCRIPT,
+              1,
+              prefixKey(key),
+              holderId,
+              ttlMs.toString()
+            );
+            return result === 1;
+          },
+          catch: (cause) => new BackingError({ operation: "refresh", cause }),
+        });
+
+      const isLocked = (key: string): Effect.Effect<boolean, BackingError> =>
+        Effect.tryPromise({
+          try: async () => {
+            const exists = await redis.exists(prefixKey(key));
+            return exists === 1;
+          },
+          catch: (cause) => new BackingError({ operation: "isLocked", cause }),
+        });
+
+      const getHolder = (
+        key: string
+      ): Effect.Effect<Option.Option<string>, BackingError> =>
+        Effect.tryPromise({
+          try: async () => {
+            const holder = await redis.get(prefixKey(key));
+            return holder ? Option.some(holder) : Option.none();
+          },
+          catch: (cause) => new BackingError({ operation: "getHolder", cause }),
+        });
+
+      return {
+        tryAcquire,
+        release,
+        refresh,
+        isLocked,
+        getHolder,
+      } satisfies DistributedMutexBacking;
+    })
+  );

package/src/index.ts

@@ -0,0 +1,50 @@
+/**
+ * Effect Distributed Lock
+ *
+ * A distributed mutex library for Effect with pluggable backends.
+ *
+ * @example
+ * ```ts
+ * import { DistributedMutex, makeRedisBackingLayer } from "effect-distributed-lock";
+ * import { Effect } from "effect";
+ * import Redis from "ioredis";
+ *
+ * const redis = new Redis(process.env.REDIS_URL);
+ *
+ * const program = Effect.gen(function* () {
+ *   // Create a mutex for a specific resource
+ *   const mutex = yield* DistributedMutex.make("my-resource-lock", {
+ *     ttl: "30 seconds",
+ *     acquireTimeout: "10 seconds",
+ *   });
+ *
+ *   // Use the lock
+ *   yield* mutex.withLock(
+ *     Effect.gen(function* () {
+ *       // Critical section - only one process can be here at a time
+ *       yield* doSomethingExclusive();
+ *     })
+ *   );
+ * });
+ *
+ * program.pipe(
+ *   Effect.provide(makeRedisBackingLayer(redis)),
+ *   Effect.runPromise
+ * );
+ * ```
+ *
+ * @module
+ */
+
+// Core module (namespace with types and functions)
+export * as DistributedMutex from "./DistributedMutex.js";
+// Errors
+export {
+  AcquireTimeoutError,
+  BackingError,
+  DistributedMutexError,
+  LockLostError,
+} from "./Errors.js";
+
+// Redis backing
+export * as RedisBacking from "./RedisBacking.js";

package/tsconfig.json

@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "verbatimModuleSyntax": true,
+
+    // Build output
+    "rootDir": "src",
+    "outDir": "dist",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}