@remnic/core 1.1.31 → 9.3.516

package/src/connectors/live/github.ts

@@ -921,7 +921,10 @@ async function fetchAndFilterComments(
       if (consumed >= remainingBudget) break;
       throwIfAborted(signal);
 
-      const comment = item as GitHubComment;
+      const comment = normalizeGitHubComment(item, kind);
+      if (!comment) {
+        continue;
+      }
 
       // Skip items strictly before the watermark. Items whose `updated_at`
       // equals the watermark second must pass through so the seenIds check
@@ -1005,6 +1008,31 @@ async function fetchAndFilterComments(
   return { docs, skippedOtherAuthor, skippedEmpty, skippedTooLarge, consumed, latestWatermark, newSeenIds };
 }
 
+function normalizeGitHubComment(
+  item: unknown,
+  kind: string,
+): GitHubComment | null {
+  if (typeof item !== "object" || item === null) {
+    return null;
+  }
+  if (kind !== "discussion") {
+    return item as GitHubComment;
+  }
+  const discussion = item as GitHubDiscussionComment;
+  const updatedAt = discussion.updatedAt ?? discussion.createdAt;
+  if (typeof discussion.id !== "number" || typeof updatedAt !== "string") {
+    return null;
+  }
+  return {
+    id: discussion.id,
+    body: discussion.body,
+    user: discussion.author,
+    created_at: discussion.createdAt ?? updatedAt,
+    updated_at: updatedAt,
+    html_url: discussion.url,
+  };
+}
+
 /**
  * Advance a paginated GitHub URL by incrementing the `page` query parameter.
  * GitHub uses 1-based page numbers; if no `page` param is present we assume

package/src/connectors/live/index.ts

@@ -28,8 +28,10 @@ export {
 } from "./registry.js";
 
 export {
+  ConnectorStateLockLostError,
   listConnectorStates,
   readConnectorState,
+  withConnectorStateLock,
   writeConnectorState,
   type ConnectorState,
   type ConnectorSyncStatus,

package/src/connectors/live/live-connectors.test.ts

@@ -6,21 +6,29 @@ import test from "node:test";
 
 import {
   CONNECTOR_ID_PATTERN,
-  isValidConnectorId,
-  LiveConnectorRegistry,
-  LiveConnectorRegistryError,
-  listConnectorStates,
-  readConnectorState,
-  writeConnectorState,
   type ConnectorConfig,
   type ConnectorCursor,
   type ConnectorDocument,
   type ConnectorSyncStatus,
   type LiveConnector,
+  LiveConnectorRegistry,
+  LiveConnectorRegistryError,
   type SyncIncrementalArgs,
   type SyncIncrementalResult,
+  isValidConnectorId,
+  listConnectorStates,
+  readConnectorState,
+  withConnectorStateLock,
+  writeConnectorState,
 } from "./index.js";
-import { _connectorStatePathForTest } from "./state-store.js";
+import {
+  _connectorStatePathForTest,
+  _refreshConnectorLockForTest,
+  _releaseConnectorLockForTest,
+  _tryAcquireConnectorLockForTest,
+  _unlinkStaleConnectorLockForTest,
+  _withConnectorStateLockForTest,
+} from "./state-store.js";
 
 /**
  * Mock `LiveConnector`. Exists primarily as a compile-time assertion that
@@ -94,12 +102,12 @@ test("isValidConnectorId accepts well-formed ids", () => {
 test("isValidConnectorId rejects malformed ids", () => {
   for (const id of [
     "",
-    "Drive",          // uppercase
-    "-leading-dash",  // must start with alphanumeric
+    "Drive", // uppercase
+    "-leading-dash", // must start with alphanumeric
     "trailing-dash-",
     "white space",
     "slash/y",
-    "a".repeat(65),   // > 64
+    "a".repeat(65), // > 64
     null,
     undefined,
     42,
@@ -146,26 +154,14 @@ test("registry: register, get, list, unregister, size", () => {
 test("registry: rejects duplicate ids", () => {
   const reg = new LiveConnectorRegistry();
   reg.register(new MockConnector("dup"));
-  assert.throws(
-    () => reg.register(new MockConnector("dup")),
-    LiveConnectorRegistryError,
-  );
+  assert.throws(() => reg.register(new MockConnector("dup")), LiveConnectorRegistryError);
 });
 
 test("registry: rejects invalid ids", () => {
   const reg = new LiveConnectorRegistry();
-  assert.throws(
-    () => reg.register(new MockConnector("Bad-Caps")),
-    LiveConnectorRegistryError,
-  );
-  assert.throws(
-    () => reg.register(new MockConnector("-leading-dash")),
-    LiveConnectorRegistryError,
-  );
-  assert.throws(
-    () => reg.register(new MockConnector("a".repeat(65))),
-    LiveConnectorRegistryError,
-  );
+  assert.throws(() => reg.register(new MockConnector("Bad-Caps")), LiveConnectorRegistryError);
+  assert.throws(() => reg.register(new MockConnector("-leading-dash")), LiveConnectorRegistryError);
+  assert.throws(() => reg.register(new MockConnector("a".repeat(65))), LiveConnectorRegistryError);
 });
 
 test("registry: rejects connectors missing required fields", () => {
@@ -182,7 +178,7 @@ test("registry: rejects connectors missing required fields", () => {
           nextCursor: { kind: "x", value: "0", updatedAt: new Date().toISOString() },
         }),
       } as unknown as LiveConnector),
-    LiveConnectorRegistryError,
+    LiveConnectorRegistryError
   );
 
   assert.throws(
@@ -193,13 +189,10 @@ test("registry: rejects connectors missing required fields", () => {
         validateConfig: () => ({}),
         // missing syncIncremental
       } as unknown as LiveConnector),
-    LiveConnectorRegistryError,
+    LiveConnectorRegistryError
   );
 
-  assert.throws(
-    () => reg.register(null as unknown as LiveConnector),
-    LiveConnectorRegistryError,
-  );
+  assert.throws(() => reg.register(null as unknown as LiveConnector), LiveConnectorRegistryError);
 });
 
 // ───────────────────────────────────────────────────────────────────────────
@@ -294,7 +287,10 @@ test("state store: listConnectorStates enumerates and is sorted", async (t) => {
   });
 
   const states = await listConnectorStates(memoryDir);
-  assert.deepEqual(states.map((s) => s.id), ["alpha", "mike", "zeta"]);
+  assert.deepEqual(
+    states.map((s) => s.id),
+    ["alpha", "mike", "zeta"]
+  );
 });
 
 test("state store: listConnectorStates returns [] for missing dir", async (t) => {
@@ -321,7 +317,10 @@ test("state store: listConnectorStates skips non-matching files", async (t) => {
   fs.writeFileSync(path.join(dir, "corrupt.json"), "{ not valid");
 
   const states = await listConnectorStates(memoryDir);
-  assert.deepEqual(states.map((s) => s.id), ["real"]);
+  assert.deepEqual(
+    states.map((s) => s.id),
+    ["real"]
+  );
 });
 
 // ───────────────────────────────────────────────────────────────────────────
@@ -373,7 +372,7 @@ test("state store: previous good state is preserved when a new write fails", asy
       lastSyncStatus: "never",
       totalDocsImported: 0,
     }),
-    /does not match/,
+    /does not match/
   );
 
   // The good file must still be readable and unchanged.
@@ -385,10 +384,7 @@ test("state store: previous good state is preserved when a new write fails", asy
 
 test("state store: rejects invalid id at boundary", async (t) => {
   const memoryDir = makeMemoryDir(t);
-  await assert.rejects(
-    () => readConnectorState(memoryDir, "Bad-Caps"),
-    /invalid connector id/,
-  );
+  await assert.rejects(() => readConnectorState(memoryDir, "Bad-Caps"), /invalid connector id/);
   await assert.rejects(
     () =>
       writeConnectorState(memoryDir, "../escape" as string, {
@@ -398,7 +394,7 @@ test("state store: rejects invalid id at boundary", async (t) => {
         lastSyncStatus: "never",
         totalDocsImported: 0,
       }),
-    /invalid connector id/,
+    /invalid connector id/
   );
 });
 
@@ -418,7 +414,7 @@ test("state store: rejects invalid lastSyncStatus at boundary (PR #724 review)",
         lastSyncStatus: "BOGUS" as unknown as ConnectorSyncStatus,
         totalDocsImported: 0,
       } as unknown as Parameters<typeof writeConnectorState>[2]),
-    /lastSyncStatus must be one of/,
+    /lastSyncStatus must be one of/
   );
   // And the file must NOT have been written.
   const after = await readConnectorState(memoryDir, "drive");
@@ -437,7 +433,7 @@ test("state store: rejects malformed cursor at boundary (PR #724 review)", async
         lastSyncStatus: "success",
         totalDocsImported: 0,
       }),
-    /cursor must have string/,
+    /cursor must have string/
   );
 });
 
@@ -458,7 +454,10 @@ test("state store: listConnectorStates skips corrupt files but rethrows EACCES (
   fs.writeFileSync(path.join(dir, "corrupt.json"), "{ not valid json");
   // Listing succeeds, returning only the good record.
   const states = await listConnectorStates(memoryDir);
-  assert.deepEqual(states.map((s) => s.id), ["good"]);
+  assert.deepEqual(
+    states.map((s) => s.id),
+    ["good"]
+  );
 
   // Now make one of the files unreadable (EACCES). On platforms that respect
   // chmod for the current user (POSIX, when not running as root), this
@@ -477,7 +476,7 @@ test("state store: listConnectorStates skips corrupt files but rethrows EACCES (
     });
     await assert.rejects(
       () => listConnectorStates(memoryDir),
-      (err: NodeJS.ErrnoException) => err.code === "EACCES" || err.code === "EPERM",
+      (err: NodeJS.ErrnoException) => err.code === "EACCES" || err.code === "EPERM"
     );
   }
 });
@@ -493,7 +492,7 @@ test("state store: rejects negative totalDocsImported", async (t) => {
         lastSyncStatus: "never",
         totalDocsImported: -1,
       }),
-    /non-negative integer/,
+    /non-negative integer/
   );
 });
 
@@ -510,7 +509,7 @@ test("state store: rejects fractional totalDocsImported (PR #724 review)", async
         lastSyncStatus: "never",
         totalDocsImported: 3.7,
       }),
-    /non-negative integer/,
+    /non-negative integer/
   );
   // And the read-shape check must reject a hand-crafted file with a float.
   const dir = path.join(memoryDir, "state", "connectors");
@@ -524,12 +523,9 @@ test("state store: rejects fractional totalDocsImported (PR #724 review)", async
       lastSyncStatus: "never",
       totalDocsImported: 3.7,
       updatedAt: new Date().toISOString(),
-    }),
-  );
-  await assert.rejects(
-    () => readConnectorState(memoryDir, "drive"),
-    /does not match ConnectorState shape/,
+    })
   );
+  await assert.rejects(() => readConnectorState(memoryDir, "drive"), /does not match ConnectorState shape/);
 });
 
 test("state store: refuses symlinked state file (PR #724 review)", async (t) => {
@@ -558,7 +554,7 @@ test("state store: refuses symlinked state file (PR #724 review)", async (t) =>
       lastSyncStatus: "never",
       totalDocsImported: 999,
       updatedAt: new Date().toISOString(),
-    }),
+    })
   );
   // Plant the symlink where the connector state would live.
   const dir = path.join(memoryDir, "state", "connectors");
@@ -566,10 +562,7 @@ test("state store: refuses symlinked state file (PR #724 review)", async (t) =>
   const linkPath = path.join(dir, "drive.json");
   fs.symlinkSync(outsideFile, linkPath);
 
-  await assert.rejects(
-    () => readConnectorState(memoryDir, "drive"),
-    /symlink/,
-  );
+  await assert.rejects(() => readConnectorState(memoryDir, "drive"), /symlink/);
   await assert.rejects(
     () =>
       writeConnectorState(memoryDir, "drive", {
@@ -579,7 +572,7 @@ test("state store: refuses symlinked state file (PR #724 review)", async (t) =>
         lastSyncStatus: "never",
         totalDocsImported: 0,
       }),
-    /symlink/,
+    /symlink/
   );
 });
 
@@ -598,14 +591,8 @@ test("state store: refuses symlinked state directory (PR #724 review)", async (t
   fs.mkdirSync(path.join(memoryDir, "state"), { recursive: true });
   fs.symlinkSync(outside, path.join(memoryDir, "state", "connectors"));
 
-  await assert.rejects(
-    () => listConnectorStates(memoryDir),
-    /symlink/,
-  );
-  await assert.rejects(
-    () => readConnectorState(memoryDir, "drive"),
-    /symlink/,
-  );
+  await assert.rejects(() => listConnectorStates(memoryDir), /symlink/);
+  await assert.rejects(() => readConnectorState(memoryDir, "drive"), /symlink/);
 });
 
 test("state store: truncates oversized lastSyncError", async (t) => {
@@ -623,15 +610,317 @@ test("state store: truncates oversized lastSyncError", async (t) => {
   assert.ok(written.lastSyncError!.length <= 1024);
 });
 
+test("state store: serializes connector state locks for one connector", async (t) => {
+  const memoryDir = makeMemoryDir(t);
+  const events: string[] = [];
+  let releaseFirst!: () => void;
+  const firstCanFinish = new Promise<void>((resolve) => {
+    releaseFirst = resolve;
+  });
+
+  const first = withConnectorStateLock(memoryDir, "drive", async () => {
+    events.push("first:start");
+    await firstCanFinish;
+    events.push("first:end");
+    return "first";
+  });
+
+  await waitForTest(() => events.includes("first:start"));
+
+  const second = withConnectorStateLock(memoryDir, "drive", async () => {
+    events.push("second:start");
+    return "second";
+  });
+
+  await new Promise<void>((resolve) => setTimeout(resolve, 25));
+  assert.deepEqual(events, ["first:start"]);
+  releaseFirst();
+
+  assert.deepEqual(await Promise.all([first, second]), ["first", "second"]);
+  assert.deepEqual(events, ["first:start", "first:end", "second:start"]);
+  assert.equal(fs.existsSync(path.join(memoryDir, "state", "connector-locks", "drive.lock")), false);
+});
+
+test("state store: treats already-removed stale locks as benign", async (t) => {
+  const memoryDir = makeMemoryDir(t);
+  const lockDir = path.join(memoryDir, "state", "connector-locks");
+  const lockPath = path.join(lockDir, "drive.lock");
+  fs.mkdirSync(lockDir, { recursive: true });
+
+  await _unlinkStaleConnectorLockForTest(lockPath);
+});
+
+test("state store: does not evict a freshly refreshed lock held by a live process", async (t) => {
+  const memoryDir = makeMemoryDir(t);
+  const lockDir = path.join(memoryDir, "state", "connector-locks");
+  const lockPath = path.join(lockDir, "drive.lock");
+  fs.mkdirSync(lockDir, { recursive: true });
+  const freshDate = new Date();
+  fs.writeFileSync(
+    lockPath,
+    `${JSON.stringify({
+      pid: process.pid,
+      token: "live-lock",
+      createdAt: freshDate.toISOString(),
+      refreshedAt: freshDate.toISOString(),
+    })}\n`
+  );
+  fs.utimesSync(lockPath, freshDate, freshDate);
+
+  assert.equal(await _tryAcquireConnectorLockForTest(memoryDir, "drive"), null);
+  assert.equal(JSON.parse(fs.readFileSync(lockPath, "utf8")).token, "live-lock");
+});
+
+test("state store: evicts an unrefreshed stale lock even when the pid is live", async (t) => {
+  const memoryDir = makeMemoryDir(t);
+  const lockDir = path.join(memoryDir, "state", "connector-locks");
+  const lockPath = path.join(lockDir, "drive.lock");
+  fs.mkdirSync(lockDir, { recursive: true });
+  const staleDate = new Date(Date.now() - 11 * 60 * 1000);
+  fs.writeFileSync(
+    lockPath,
+    `${JSON.stringify({
+      pid: process.pid,
+      token: "reused-pid-lock",
+      createdAt: staleDate.toISOString(),
+      refreshedAt: staleDate.toISOString(),
+    })}\n`
+  );
+  fs.utimesSync(lockPath, staleDate, staleDate);
+
+  assert.equal(await _tryAcquireConnectorLockForTest(memoryDir, "drive"), null);
+  assert.equal(fs.existsSync(lockPath), false);
+});
+
+test("state store: stale cleanup does not race another reclaim holder", async (t) => {
+  const memoryDir = makeMemoryDir(t);
+  const lockDir = path.join(memoryDir, "state", "connector-locks");
+  const lockPath = path.join(lockDir, "drive.lock");
+  const reclaimPath = `${lockPath}.reclaim`;
+  fs.mkdirSync(lockDir, { recursive: true });
+  const staleDate = new Date(Date.now() - 11 * 60 * 1000);
+  fs.writeFileSync(
+    lockPath,
+    `${JSON.stringify({
+      pid: process.pid,
+      token: "stale-lock",
+      createdAt: staleDate.toISOString(),
+      refreshedAt: staleDate.toISOString(),
+    })}\n`
+  );
+  fs.utimesSync(lockPath, staleDate, staleDate);
+  fs.writeFileSync(reclaimPath, "other-reclaimer");
+
+  await _unlinkStaleConnectorLockForTest(lockPath);
+
+  assert.equal(JSON.parse(fs.readFileSync(lockPath, "utf8")).token, "stale-lock");
+});
+
+test("state store: stale cleanup preserves a lock refreshed by its owner", async (t) => {
+  const memoryDir = makeMemoryDir(t);
+  const lockDir = path.join(memoryDir, "state", "connector-locks");
+  const lockPath = path.join(lockDir, "drive.lock");
+  fs.mkdirSync(lockDir, { recursive: true });
+  const staleDate = new Date(Date.now() - 11 * 60 * 1000);
+  const lease = { path: lockPath, token: "owner-lock" };
+  fs.writeFileSync(
+    lockPath,
+    `${JSON.stringify({
+      pid: process.pid,
+      token: lease.token,
+      createdAt: staleDate.toISOString(),
+      refreshedAt: staleDate.toISOString(),
+    })}\n`
+  );
+  fs.utimesSync(lockPath, staleDate, staleDate);
+
+  assert.equal(await _refreshConnectorLockForTest(lease), true);
+  await _unlinkStaleConnectorLockForTest(lockPath);
+
+  assert.equal(JSON.parse(fs.readFileSync(lockPath, "utf8")).token, lease.token);
+});
+
+test("state store: release only removes the matching connector lock token", async (t) => {
+  const memoryDir = makeMemoryDir(t);
+  const lease = await _tryAcquireConnectorLockForTest(memoryDir, "drive");
+  assert.ok(lease);
+  const replacement = {
+    pid: process.pid,
+    token: "replacement-lock",
+    createdAt: new Date().toISOString(),
+    refreshedAt: new Date().toISOString(),
+  };
+  fs.writeFileSync(lease.path, `${JSON.stringify(replacement)}\n`);
+
+  await _releaseConnectorLockForTest(lease);
+
+  assert.equal(JSON.parse(fs.readFileSync(lease.path, "utf8")).token, "replacement-lock");
+});
+
+test("state store: aborts scoped work when heartbeat loses the connector lock", async (t) => {
+  const memoryDir = makeMemoryDir(t);
+  const lockPath = path.join(memoryDir, "state", "connector-locks", "drive.lock");
+  let scopedSignal: AbortSignal | undefined;
+  let scopedWorkSettled = false;
+  let resolveStarted!: () => void;
+  const started = new Promise<void>((resolve) => {
+    resolveStarted = resolve;
+  });
+
+  const lockedWork = _withConnectorStateLockForTest(
+    memoryDir,
+    "drive",
+    async (abortSignal) => {
+      scopedSignal = abortSignal;
+      resolveStarted();
+      await new Promise<never>((_resolve, reject) => {
+        abortSignal.addEventListener(
+          "abort",
+          () => {
+            setTimeout(() => {
+              scopedWorkSettled = true;
+              reject(abortSignal.reason);
+            }, 20);
+          },
+          { once: true },
+        );
+      });
+    },
+    { heartbeatMs: 5, unrefHeartbeat: false },
+  );
+
+  await started;
+  await waitForTest(() => fs.existsSync(lockPath));
+  const replacement = {
+    pid: process.pid,
+    token: "replacement-lock",
+    createdAt: new Date().toISOString(),
+    refreshedAt: new Date().toISOString(),
+  };
+  fs.writeFileSync(lockPath, `${JSON.stringify(replacement)}\n`);
+
+  await assert.rejects(lockedWork, /lost connector "drive" state lock/);
+  assert.equal(scopedWorkSettled, true);
+  assert.equal(scopedSignal?.aborted, true);
+  assert.equal(JSON.parse(fs.readFileSync(lockPath, "utf8")).token, "replacement-lock");
+});
+
+test("state store: refreshing an unlinked stale lease reports a newer lock owner", async (t) => {
+  const memoryDir = makeMemoryDir(t);
+  const lease = await _tryAcquireConnectorLockForTest(memoryDir, "drive");
+  assert.ok(lease);
+  const probeHandle = await fs.promises.open(lease.path, "r");
+  const fileHandlePrototype = Object.getPrototypeOf(probeHandle) as {
+    readFile: (...args: unknown[]) => Promise<unknown>;
+  };
+  const originalReadFile = fileHandlePrototype.readFile;
+  await probeHandle.close();
+  const replacement = {
+    pid: process.pid,
+    token: "replacement-lock",
+    createdAt: new Date().toISOString(),
+    refreshedAt: new Date().toISOString(),
+  };
+  let replaced = false;
+
+  fileHandlePrototype.readFile = async function readFileAndReplace(...args: unknown[]) {
+    const result = await originalReadFile.apply(this, args);
+    if (!replaced) {
+      replaced = true;
+      fs.unlinkSync(lease.path);
+      fs.writeFileSync(lease.path, `${JSON.stringify(replacement)}\n`);
+    }
+    return result;
+  };
+
+  try {
+    assert.equal(await _refreshConnectorLockForTest(lease), false);
+  } finally {
+    fileHandlePrototype.readFile = originalReadFile;
+  }
+
+  assert.equal(JSON.parse(fs.readFileSync(lease.path, "utf8")).token, "replacement-lock");
+});
+
+test("state store: release does not unlink a lock path replaced after ownership read", async (t) => {
+  const memoryDir = makeMemoryDir(t);
+  const lease = await _tryAcquireConnectorLockForTest(memoryDir, "drive");
+  assert.ok(lease);
+  const probeHandle = await fs.promises.open(lease.path, "r");
+  const fileHandlePrototype = Object.getPrototypeOf(probeHandle) as {
+    readFile: (...args: unknown[]) => Promise<unknown>;
+  };
+  const originalReadFile = fileHandlePrototype.readFile;
+  await probeHandle.close();
+  const replacement = {
+    pid: process.pid,
+    token: "replacement-lock",
+    createdAt: new Date().toISOString(),
+    refreshedAt: new Date().toISOString(),
+  };
+  let replaced = false;
+
+  fileHandlePrototype.readFile = async function readFileAndReplace(...args: unknown[]) {
+    const result = await originalReadFile.apply(this, args);
+    if (!replaced) {
+      replaced = true;
+      fs.unlinkSync(lease.path);
+      fs.writeFileSync(lease.path, `${JSON.stringify(replacement)}\n`);
+    }
+    return result;
+  };
+
+  try {
+    await _releaseConnectorLockForTest(lease);
+  } finally {
+    fileHandlePrototype.readFile = originalReadFile;
+  }
+
+  assert.equal(JSON.parse(fs.readFileSync(lease.path, "utf8")).token, "replacement-lock");
+});
+
+test("state store: removes connector lock when lock metadata write fails", async (t) => {
+  const memoryDir = makeMemoryDir(t);
+  const probePath = path.join(memoryDir, "probe.lock");
+  const probeHandle = await fs.promises.open(probePath, "w");
+  const fileHandlePrototype = Object.getPrototypeOf(probeHandle) as {
+    writeFile: typeof probeHandle.writeFile;
+  };
+  const originalWriteFile = fileHandlePrototype.writeFile;
+  await probeHandle.close();
+
+  fileHandlePrototype.writeFile = async function writeFileFailure() {
+    throw Object.assign(new Error("simulated lock write failure"), { code: "EIO" });
+  };
+
+  try {
+    await assert.rejects(
+      () => withConnectorStateLock(memoryDir, "drive", async () => "unreachable"),
+      /simulated lock write failure/
+    );
+  } finally {
+    fileHandlePrototype.writeFile = originalWriteFile;
+  }
+
+  assert.equal(fs.existsSync(path.join(memoryDir, "state", "connector-locks", "drive.lock")), false);
+});
+
+async function waitForTest(predicate: () => boolean): Promise<void> {
+  const deadline = Date.now() + 1_000;
+  while (!predicate()) {
+    if (Date.now() >= deadline) {
+      throw new Error("timed out waiting for test condition");
+    }
+    await new Promise<void>((resolve) => setTimeout(resolve, 5));
+  }
+}
+
 test("state store: rejects corrupt JSON loudly via readConnectorState", async (t) => {
   const memoryDir = makeMemoryDir(t);
   const dir = path.join(memoryDir, "state", "connectors");
   fs.mkdirSync(dir, { recursive: true });
   fs.writeFileSync(path.join(dir, "drive.json"), "{ not valid json");
-  await assert.rejects(
-    () => readConnectorState(memoryDir, "drive"),
-    /not valid JSON/,
-  );
+  await assert.rejects(() => readConnectorState(memoryDir, "drive"), /not valid JSON/);
 });
 
 test("state store: rejects null parsed result", async (t) => {
@@ -640,10 +929,7 @@ test("state store: rejects null parsed result", async (t) => {
   const dir = path.join(memoryDir, "state", "connectors");
   fs.mkdirSync(dir, { recursive: true });
   fs.writeFileSync(path.join(dir, "drive.json"), "null");
-  await assert.rejects(
-    () => readConnectorState(memoryDir, "drive"),
-    /does not match ConnectorState shape/,
-  );
+  await assert.rejects(() => readConnectorState(memoryDir, "drive"), /does not match ConnectorState shape/);
 });
 
 // ───────────────────────────────────────────────────────────────────────────