@agentxm/workspace-transactions 0.29.0 → 0.29.2

package/dist/src/transition-lock.js

@@ -60,17 +60,47 @@ const errorCode = (cause) => typeof cause === "object" && cause !== null && "cod
 export const transitionLockPath = (path, workspaceDir) => path.join(workspaceDir, "tmp", TRANSITION_LOCK_FILENAME);
 /**
  * The filesystem handed to `proper-lockfile`. Identical to the platform fs
- * except that removing a transition-lock directory first clears the tool's
- * own holder metadata inside it. The library reclaims a stale lock and
- * releases a held one with a non-recursive `rmdir`; without this, a lock
- * directory left by a crashed process — which always still contains
- * `holder.json` — could never be reclaimed, and every later mutation would
- * wait out its bound and report a false contention. Removal stays
- * non-recursive past that one owned name, so foreign content keeps blocking
- * removal the way it always did.
+ * except for the transition-lock directory itself:
+ *
+ * - acquisition creates an empty holder file before `proper-lockfile` probes
+ *   and records the directory mtime;
+ * - removal clears that owned holder file before the library's non-recursive
+ *   `rmdir`.
+ *
+ * Recording holder metadata therefore overwrites an existing file instead of
+ * adding a directory entry, so it cannot change the lock directory mtime and
+ * compromise the first heartbeat. The empty placeholder is also safe during
+ * the narrow acquisition window: it is unreadable as holder metadata, so an
+ * old finalizer can never mistake a successor's acquisition for its own.
+ * Stale reclamation can remove crashed holders, while foreign content still
+ * blocks removal as it always did.
  */
 const lockDirectoryFs = {
     ...nodeFs,
+    mkdir: (target, callback) => {
+        if (typeof target !== "string" || !target.endsWith(TRANSITION_LOCK_FILENAME)) {
+            nodeFs.mkdir(target, callback);
+            return;
+        }
+        nodeFs.mkdir(target, (directoryError) => {
+            if (directoryError !== null) {
+                callback(directoryError);
+                return;
+            }
+            const holderPath = `${target}/holder.json`;
+            nodeFs.writeFile(holderPath, "", { flag: "wx" }, (holderError) => {
+                if (holderError === null) {
+                    callback(null);
+                    return;
+                }
+                // Surface the original placeholder failure after best-effort cleanup;
+                // leaving a half-created directory would turn it into false contention.
+                nodeFs.unlink(holderPath, () => {
+                    nodeFs.rmdir(target, () => callback(holderError));
+                });
+            });
+        });
+    },
     rmdir: (target, callback) => {
         if (typeof target === "string" && target.endsWith(TRANSITION_LOCK_FILENAME)) {
             nodeFs.unlink(`${target}/holder.json`, () => {
@@ -202,25 +232,9 @@ const acquireWorkspaceTransitionLock = (registry, args) => Effect.gen(function*
             }
             const release = granted.success;
             const token = randomBytes(16).toString("hex");
-            const holderStamped = yield* Effect.gen(function* () {
-                const lockInfo = yield* fs
-                    .stat(lockPath)
-                    .pipe(Effect.mapError((cause) => new TransitionLockError({ path: lockPath, step: "inspect-timestamp", cause })));
-                const lockMtime = yield* Option.match(lockInfo.mtime, {
-                    onNone: () => Effect.fail(new TransitionLockError({ path: lockPath, step: "missing-timestamp" })),
-                    onSome: Effect.succeed,
-                });
-                yield* writeHolder(fs, path, lockPath, {
-                    ...args.holder,
-                    token,
-                });
-                // proper-lockfile proves ownership by comparing the directory's
-                // mtime with the timestamp it recorded at acquisition. Writing
-                // holder.json changes that directory mtime, so restore the exact
-                // acquired value before the first refresh observes it.
-                yield* fs
-                    .utimes(lockPath, lockMtime, lockMtime)
-                    .pipe(Effect.mapError((cause) => new TransitionLockError({ path: lockPath, step: "preserve-timestamp", cause })));
+            const holderStamped = yield* writeHolder(fs, path, lockPath, {
+                ...args.holder,
+                token,
             }).pipe(Effect.result);
             if (holderStamped._tag === "Failure") {
                 // The holder metadata is the only ownership evidence this

package/package.json

@@ -4,17 +4,17 @@
     "url": "https://github.com/agentxm/axm/issues"
   },
   "dependencies": {
-    "effect": "4.0.0-rc.112",
+    "effect": "4.0.0-rc.115",
     "proper-lockfile": "^4.1.2"
   },
   "description": "AXM workspace transactions: the process transition lock, per-closure snapshot ledger, restoration, atomic single-file publication, and footprint observation for the axm CLI. Unstable and unsupported — use the axm.sh CLI.",
   "devDependencies": {
-    "@effect/platform-node": "4.0.0-rc.112",
-    "@effect/vitest": "4.0.0-rc.112",
+    "@effect/platform-node": "4.0.0-rc.115",
+    "@effect/vitest": "4.0.0-rc.115",
     "@types/proper-lockfile": "^4.1.4",
     "@typescript/native": "npm:typescript@^7.0.2",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
-    "vitest": "^4.1.10"
+    "vitest": "^5.0.0"
   },
   "engines": {
     "node": ">=22.19.0"
@@ -51,5 +51,5 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.29.0"
+  "version": "0.29.2"
 }