@herbertgao/pi-extensions 2026.9.2 → 2026.9.3

package/node_modules/pi-lens/dist/clients/lsp/diagnostic-binding.js

@@ -73,6 +73,27 @@ export function touchCoverageGap(result) {
 export function touchCompletedConfirmationPolicy(result) {
     return result?.confirmation !== undefined;
 }
+/**
+ * #2878: one publication-evidence predicate for auxiliary coverage. A
+ * content-hash binding proves that the stored publication describes these
+ * bytes. For a version-less publisher, an advanced per-path publication stamp
+ * proves that the auxiliary published after this touch's pre-notify baseline;
+ * the stamp alone cannot prove that the bytes matched. The pre-notify boolean
+ * passed as `bindingMatchesContent` preserves a binding that the notify
+ * cleared, while the live stamp covers a publication that landed after the
+ * wait began. This predicate is the union. Four callers use it; only the
+ * demoted row's `publishedThisContent` takes the union — the sibling and
+ * aggregate rows compute that field from `auxCoversThisContent` directly
+ * (#2914), while their `outcome` field still reads the stamp through this
+ * predicate. Absent evidence fails closed.
+ */
+export function auxiliaryPublicationEvidence({ bindingMatchesContent, baseline, currentPathVersion, raced = true, }) {
+    return (bindingMatchesContent ||
+        (raced &&
+            Number.isFinite(baseline) &&
+            currentPathVersion !== undefined &&
+            currentPathVersion > baseline));
+}
 /**
  * #1493: the single policy deciding which auxiliaries a touch carries NO
  * evidence from. Both no-answer shapes belong here, because they are the same
@@ -106,7 +127,9 @@ export function touchCompletedConfirmationPolicy(result) {
  * irrelevant once a verified publication for them exists. Exempting `silent` but
  * not `cut_off` on identical evidence would report the same coverage two ways
  * depending on which timer happened to win. This stays fail-closed — it
- * un-narrows only against a content-hash match, never against a timer.
+ * un-narrows only against publication evidence (content-hash match, or an
+ * advanced per-path publication stamp for version-less publishers), never
+ * against a timer.
  */
 export function auxiliaryCoverageGap(evidence) {
     return evidence

package/node_modules/pi-lens/dist/clients/lsp/document-drift.js

@@ -106,6 +106,8 @@ export function driftCheckIntervalMs() {
 export class DocumentDriftTracker {
     /** Insertion-ordered; the sweep cursor walks it round-robin. */
     synced = new Map();
+    /** Git/external recovery targets waiting for the same paced resync budget. */
+    pendingResync = new Set();
     lastSweepAt = 0;
     cursor = 0;
     /**
@@ -123,6 +125,15 @@ export class DocumentDriftTracker {
     peek(filePath) {
         return this.synced.get(normalizeMapKey(filePath));
     }
+    /** Queue known-open targets for the next ordinary paced drift pass. */
+    enqueueResync(filePaths) {
+        for (const filePath of filePaths) {
+            this.pendingResync.add(normalizeMapKey(filePath));
+        }
+    }
+    get pendingResyncCount() {
+        return this.pendingResync.size;
+    }
     /**
      * Record content that landed on EVERY server holding this document.
      *
@@ -154,6 +165,7 @@ export class DocumentDriftTracker {
     /** Drop every record. Used on shutdown/session reset, where the server's view dies with it. */
     clear() {
         this.synced.clear();
+        this.pendingResync.clear();
         this.cursor = 0;
         this.lastSweepAt = 0;
         this.flight.clear();
@@ -270,11 +282,77 @@ export class DocumentDriftTracker {
                 mtimeMs: entry.stat.mtimeMs,
             });
         }
+        const queued = [...this.pendingResync];
+        for (const key of queued) {
+            if (deps.holdsDocument && !deps.holdsDocument(key)) {
+                this.pendingResync.delete(key);
+                unheld += 1;
+                continue;
+            }
+        }
         let resynced = 0;
         let failed = 0;
         let unchanged = 0;
         let deferred = 0;
+        const resyncedKeys = new Set();
+        for (const key of queued) {
+            if (!this.pendingResync.has(key))
+                continue;
+            if (resynced >= DRIFT_RESYNC_BATCH) {
+                deferred += 1;
+                deps.onDrift?.({
+                    filePath: key,
+                    driftAgeMs: 0,
+                    disposition: "deferred",
+                    syncedSize: this.synced.get(key)?.size ?? 0,
+                    diskSize: -1,
+                });
+                continue;
+            }
+            let content;
+            try {
+                content = await read(key);
+            }
+            catch {
+                this.pendingResync.delete(key);
+                vanished += 1;
+                continue;
+            }
+            let landed = false;
+            try {
+                landed = await deps.resync(key, content, 0);
+            }
+            catch {
+                landed = false;
+            }
+            if (!landed) {
+                failed += 1;
+                deps.onDrift?.({
+                    filePath: key,
+                    driftAgeMs: 0,
+                    disposition: "failed",
+                    syncedSize: this.synced.get(key)?.size ?? 0,
+                    diskSize: Buffer.byteLength(content, "utf8"),
+                });
+                continue;
+            }
+            this.pendingResync.delete(key);
+            resynced += 1;
+            resyncedKeys.add(key);
+            deps.onDrift?.({
+                filePath: key,
+                driftAgeMs: 0,
+                disposition: "resynced",
+                syncedSize: this.synced.get(key)?.size ?? 0,
+                diskSize: Buffer.byteLength(content, "utf8"),
+            });
+        }
         for (const { key, record, mtimeMs } of drifted) {
+            // A Git recovery target and the ordinary stat backstop can identify the
+            // same file in one pass. One event gets one resync opportunity; otherwise
+            // folding Git recovery onto this scheduler double-counts the same write.
+            if (resyncedKeys.has(key))
+                continue;
             const driftAgeMs = Math.max(0, now() - record.syncedAt);
             if (resynced >= DRIFT_RESYNC_BATCH) {
                 // Paced, not dropped: the cursor already advanced past this file, but