@fluado/enmetu 0.2.0 → 0.3.0

package/dist/quarantine/pathQuarantine.js

@@ -70,7 +70,13 @@ export class PathQuarantine {
         // --- Step 5: a file written since step 3 is stored again (Decision 114) ---
         await this.storeAgainIfWritten(entries, []);
         // --- Step 6: the held paths now match the index, so the rebase may run ---
-        await this.writer.restoreFromIndex(paths);
+        try {
+            await this.writer.restoreFromIndex(paths);
+        }
+        catch (error) {
+            await this.forgetUnheld(0);
+            throw error;
+        }
         return { kind: 'held', count: entries.length };
     }
     async extend(paths) {
@@ -102,9 +108,45 @@ export class PathQuarantine {
         // --- Step 6: a file written since step 4 is stored again (Decision 114) ---
         await this.storeAgainIfWritten(entries, earlier);
         // --- Step 7: the captured paths now match the index ---
-        await this.writer.restoreFromIndex(paths);
+        try {
+            await this.writer.restoreFromIndex(paths);
+        }
+        catch (error) {
+            await this.forgetUnheld(earlier.length);
+            throw error;
+        }
         return { kind: 'held', count: entries.length };
     }
+    /**
+     * git refused the checkout (a person's merge left a held path unmerged,
+     * design 14.20): an entry whose file still holds the bytes stored for it was
+     * never set aside, and restoring it later would write those bytes over the
+     * person's newer work, conflict markers included. Such entries leave the
+     * memento (the memento goes when none is left); an entry whose file changed
+     * stays, so no write goes unrecorded. Entries before `from` (an earlier
+     * hold that extend added to) stay as they are.
+     */
+    async forgetUnheld(from) {
+        const text = await this.fs.readText(this.mementoPath());
+        const memento = text === null ? null : parseQuarantineMemento(text);
+        if (memento === null) {
+            return;
+        }
+        const kept = memento.entries.slice(0, from);
+        for (const entry of memento.entries.slice(from)) {
+            const target = join(this.paths.root, entry.path);
+            const seen = await this.observe(entry.path, target);
+            if (seen !== (entry.blobId ?? OBSERVED_ABSENT)) {
+                kept.push(entry);
+            }
+        }
+        if (kept.length === 0) {
+            await this.fs.remove(this.mementoPath());
+        }
+        else {
+            await this.writeMemento({ version: 1, entries: kept });
+        }
+    }
     /**
      * git's checkout writes the index's version over a file whatever the file
      * holds, so a write that landed after storeEntries read it would be gone

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluado/enmetu",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Keeps one git working tree committed and in sync with its upstream.",
   "license": "MIT",
   "author": "fluado UG (haftungsbeschränkt)",