@remnic/core 9.69.23 → 9.69.24

package/src/connectors/live/google-drive.ts

@@ -64,6 +64,7 @@ import type {
   SyncIncrementalResult,
 } from "./framework.js";
 import { isTransientHttpError } from "./transient-errors.js";
+import { throwIfAborted } from "../../abort-error.js";
 
 /**
  * Stable connector id. Lives in the registry under this exact string.
@@ -414,10 +415,10 @@ export function createGoogleDriveConnector(
     async syncIncremental(args: SyncIncrementalArgs): Promise<SyncIncrementalResult> {
       // Re-validate on every pass: a JS caller could mutate it between passes.
       const config = validateGoogleDriveConfig(args.config);
-      throwIfAborted(args.abortSignal);
+      throwIfAborted(args.abortSignal, "googleDrive: sync aborted");
 
       const client = await clientFactory(config);
-      throwIfAborted(args.abortSignal);
+      throwIfAborted(args.abortSignal, "googleDrive: sync aborted");
 
       // Cursor bootstrap. On the very first pass (cursor=null) we ask Drive
       // for a page token but DO NOT consume any changes — this aligns with
@@ -455,7 +456,7 @@ export function createGoogleDriveConnector(
       // Page through `changes.list` until we run out, hit the per-pass cap,
       // or get aborted.
       while (true) {
-        throwIfAborted(args.abortSignal);
+        throwIfAborted(args.abortSignal, "googleDrive: sync aborted");
         const remaining = MAX_CHANGES_PER_PASS - consumed;
         if (remaining <= 0) {
           // Hit the cap — persist whatever we have. The next pass resumes
@@ -467,7 +468,7 @@ export function createGoogleDriveConnector(
         const page = await client.listChanges({ pageToken, pageSize });
 
         for (const change of page.changes) {
-          throwIfAborted(args.abortSignal);
+          throwIfAborted(args.abortSignal, "googleDrive: sync aborted");
           consumed++;
           const decision = decideChange(change, folderScope);
           switch (decision.kind) {
@@ -538,7 +539,7 @@ async function fetchDocument(
   fetchedAt: string,
   abortSignal: AbortSignal | undefined,
 ): Promise<ConnectorDocument | null> {
-  throwIfAborted(abortSignal);
+  throwIfAborted(abortSignal, "googleDrive: sync aborted");
   const file = decision.file;
   let body: string;
   try {
@@ -581,14 +582,6 @@ async function fetchDocument(
   };
 }
 
-function throwIfAborted(signal: AbortSignal | undefined): void {
-  if (signal?.aborted) {
-    const err = new Error("googleDrive: sync aborted");
-    err.name = "AbortError";
-    throw err;
-  }
-}
-
 /**
  * Classify a per-file fetch error as "transient" (re-throw to caller so
  * the sync stops without advancing the cursor and the next poll retries)

package/src/connectors/live/notion.ts

@@ -60,6 +60,7 @@ import type {
   SyncIncrementalResult,
 } from "./framework.js";
 import { isTransientHttpError } from "./transient-errors.js";
+import { throwIfAborted } from "../../abort-error.js";
 
 // ---------------------------------------------------------------------------
 // Public constants
@@ -362,17 +363,6 @@ export function isTransientNotionError(err: unknown): boolean {
 const NOTION_BASE_URL = "https://api.notion.com/v1";
 const NOTION_API_VERSION = "2022-06-28";
 
-/**
- * Throw if aborted (cooperative cancellation).
- */
-function throwIfAborted(signal: AbortSignal | undefined): void {
-  if (signal?.aborted) {
-    const err = new Error("notion: sync aborted");
-    err.name = "AbortError";
-    throw err;
-  }
-}
-
 /**
  * Build a Notion API error with the HTTP status attached for classification.
  */
@@ -531,14 +521,14 @@ async function fetchPageText(
   signal: AbortSignal | undefined,
 ): Promise<string> {
   if (depth > MAX_BLOCK_DEPTH) return "";
-  throwIfAborted(signal);
+  throwIfAborted(signal, "notion: sync aborted");
 
   const lines: string[] = [];
   let cursor: string | undefined = undefined;
 
   // Page through block children.
   while (true) {
-    throwIfAborted(signal);
+    throwIfAborted(signal, "notion: sync aborted");
     const pathQuery = cursor
       ? `/blocks/${blockId}/children?page_size=100&start_cursor=${encodeURIComponent(cursor)}`
       : `/blocks/${blockId}/children?page_size=100`;
@@ -552,7 +542,7 @@ async function fetchPageText(
     };
 
     for (const block of page.results ?? []) {
-      throwIfAborted(signal);
+      throwIfAborted(signal, "notion: sync aborted");
       const text = extractBlockText(block);
       if (text.length > 0) lines.push(text);
 
@@ -653,7 +643,7 @@ export function createNotionConnector(
 
     async syncIncremental(args: SyncIncrementalArgs): Promise<SyncIncrementalResult> {
       const config = validateNotionConfig(args.config);
-      throwIfAborted(args.abortSignal);
+      throwIfAborted(args.abortSignal, "notion: sync aborted");
 
       // Short-circuit: if no databases are configured, there is nothing to do.
       // We still return a valid cursor so the framework has something to
@@ -719,12 +709,12 @@ async function seedWatermark(
   const databases = { ...payload.databases };
 
   for (const dbId of config.databaseIds) {
-    throwIfAborted(signal);
+    throwIfAborted(signal, "notion: sync aborted");
     let notionCursor: string | undefined = undefined;
     let latestInDb = "";
 
     while (true) {
-      throwIfAborted(signal);
+      throwIfAborted(signal, "notion: sync aborted");
       const body: Record<string, unknown> = { page_size: 100, sorts: [] };
       if (notionCursor) body.start_cursor = notionCursor;
 
@@ -784,7 +774,7 @@ async function incrementalSync(
   let totalConsumed = 0;
 
   for (const dbId of config.databaseIds) {
-    throwIfAborted(signal);
+    throwIfAborted(signal, "notion: sync aborted");
     if (totalConsumed >= MAX_PAGES_PER_PASS) break;
 
     const dbWatermark = payload.databases[dbId];
@@ -807,7 +797,7 @@ async function incrementalSync(
     let databaseFullyDrained = false;
 
     while (true) {
-      throwIfAborted(signal);
+      throwIfAborted(signal, "notion: sync aborted");
       if (totalConsumed >= MAX_PAGES_PER_PASS) break;
 
       const body: Record<string, unknown> = {
@@ -845,7 +835,7 @@ async function incrementalSync(
 
       let cutoffMidPage = false;
       for (const notionPage of pageResp.results ?? []) {
-        throwIfAborted(signal);
+        throwIfAborted(signal, "notion: sync aborted");
 
         const pageId = notionPage.id;
         const lastEdited = notionPage.last_edited_time;
@@ -970,7 +960,7 @@ async function fetchPageDocument(
   fetchedAt: string,
   signal: AbortSignal | undefined,
 ): Promise<ConnectorDocument | "too-large" | "empty" | null> {
-  throwIfAborted(signal);
+  throwIfAborted(signal, "notion: sync aborted");
 
   let text: string;
   try {

package/src/cue-anchors.ts

@@ -3,6 +3,7 @@ import path from "node:path";
 import { resolveAbstractionNodeStoreDir, validateAbstractionNode, type AbstractionNode } from "./abstraction-nodes.js";
 import { listJsonFilesStrict, readJsonFile, withJsonStoreMutationLock, writeJsonFileAtomic } from "./json-store.js";
 import { compareDeterministicStrings, mergeSortedUniqueStrings } from "./deterministic-order.js";
+import { isNotFoundError } from "./utils/errno.js";
 import {
   assertIsoRecordedAt,
   assertSafePathSegment,
@@ -170,12 +171,6 @@ function mergeSortedValues(existing: string[] | undefined, incoming: string[] |
   return mergeSortedUniqueStrings(existing, incoming);
 }
 
-function isNotFoundError(error: unknown): boolean {
-  return (
-    typeof error === "object" && error !== null && "code" in error && (error as { code?: unknown }).code === "ENOENT"
-  );
-}
-
 function boundNodeRefs(nodeRefs: string[], liveNodes?: Map<string, AbstractionNode>): string[] {
   const uniqueRefs = mergeSortedUniqueStrings(nodeRefs);
   if (!liveNodes) return uniqueRefs.slice(0, 50);

package/src/graph.ts

@@ -30,6 +30,7 @@ import {
   withGraphWriteLock,
   yieldForLockHeartbeat,
 } from "./graph-write-lock.js";
+import { isErrnoCode } from "./utils/errno.js";
 
 export type GraphType = "entity" | "time" | "causal";
 
@@ -143,9 +144,6 @@ export async function appendEdge(memoryDir: string, edge: GraphEdge): Promise<vo
     confidence: typeof edge.confidence === "number" ? edge.confidence : 1.0,
   });
 }
-function isNodeError(err: unknown): err is NodeJS.ErrnoException {
-  return typeof err === "object" && err !== null && "code" in err;
-}
 
 function parseEdgesJsonl(raw: string, expectedType: GraphType): GraphEdge[] {
   const edges: GraphEdge[] = [];
@@ -213,7 +211,7 @@ export async function readEdgesStrict(memoryDir: string, type: GraphType): Promi
     const raw = await readFile(filePath, "utf8");
     return await parseEdgesJsonlYielding(raw, type);
   } catch (err) {
-    if (isNodeError(err) && err.code === "ENOENT") {
+    if (isErrnoCode(err, "ENOENT")) {
       return [];
     }
     throw err;

package/src/json-store.ts

@@ -13,17 +13,14 @@ import {
   type FileHandle,
 } from "node:fs/promises";
 import path from "node:path";
-
-function hasErrorCode(error: unknown, code: string): boolean {
-  return typeof error === "object" && error !== null && "code" in error && (error as { code?: unknown }).code === code;
-}
+import { isErrnoCode } from "./utils/errno.js";
 
 async function listJsonFilesStrictInner(dir: string, allowMissingDirectory: boolean): Promise<string[]> {
   let entries: Dirent[];
   try {
     entries = await readdir(dir, { withFileTypes: true });
   } catch (error) {
-    if (allowMissingDirectory && hasErrorCode(error, "ENOENT")) return [];
+    if (allowMissingDirectory && isErrnoCode(error, "ENOENT")) return [];
     throw error;
   }
   const out: string[] = [];
@@ -107,7 +104,7 @@ function jsonStoreLockTimeoutMs(): number {
 async function closeAndRemoveJsonStoreReclaimGuard(reclaimPath: string, reclaimHandle: FileHandle): Promise<void> {
   await reclaimHandle.close().catch(() => undefined);
   await unlink(reclaimPath).catch((error) => {
-    if (!hasErrorCode(error, "ENOENT")) throw error;
+    if (!isErrnoCode(error, "ENOENT")) throw error;
   });
 }
 
@@ -116,7 +113,7 @@ async function removeStaleJsonStoreReclaimGuard(reclaimPath: string): Promise<vo
   try {
     initial = await readJsonStoreLockState(reclaimPath);
   } catch (error) {
-    if (hasErrorCode(error, "ENOENT")) return;
+    if (isErrnoCode(error, "ENOENT")) return;
     throw error;
   }
   if (Date.now() - initial.mtimeMs <= jsonStoreLockStaleMs()) return;
@@ -134,12 +131,12 @@ async function removeStaleJsonStoreReclaimGuard(reclaimPath: string): Promise<vo
   try {
     confirmed = await readJsonStoreLockState(reclaimPath);
   } catch (error) {
-    if (hasErrorCode(error, "ENOENT")) return;
+    if (isErrnoCode(error, "ENOENT")) return;
     throw error;
   }
   if (!sameJsonStoreLockState(initial, confirmed)) return;
   await unlink(reclaimPath).catch((error) => {
-    if (!hasErrorCode(error, "ENOENT")) throw error;
+    if (!isErrnoCode(error, "ENOENT")) throw error;
   });
 }
 
@@ -147,12 +144,12 @@ async function acquireJsonStoreReclaimGuard(reclaimPath: string): Promise<FileHa
   try {
     return await open(reclaimPath, "wx", 0o600);
   } catch (error) {
-    if (!hasErrorCode(error, "EEXIST")) throw error;
+    if (!isErrnoCode(error, "EEXIST")) throw error;
     await removeStaleJsonStoreReclaimGuard(reclaimPath);
     try {
       return await open(reclaimPath, "wx", 0o600);
     } catch (retryError) {
-      if (hasErrorCode(retryError, "EEXIST")) return undefined;
+      if (isErrnoCode(retryError, "EEXIST")) return undefined;
       throw retryError;
     }
   }
@@ -169,7 +166,7 @@ function processIsRunning(pid: number): boolean {
     process.kill(pid, 0);
     return true;
   } catch (error) {
-    return !hasErrorCode(error, "ESRCH");
+    return !isErrnoCode(error, "ESRCH");
   }
 }
 
@@ -208,7 +205,7 @@ async function removeJsonStoreMutationLockIfOwned(lockPath: string, token: strin
     const metadata = JSON.parse(state.content) as { token?: unknown };
     if (metadata.token === token) await unlink(lockPath);
   } catch (error) {
-    if (!hasErrorCode(error, "ENOENT") && !(error instanceof SyntaxError)) throw error;
+    if (!isErrnoCode(error, "ENOENT") && !(error instanceof SyntaxError)) throw error;
   }
 }
 
@@ -224,7 +221,7 @@ async function removeStaleJsonStoreLock(lockPath: string): Promise<void> {
     try {
       initial = await readJsonStoreLockState(lockPath);
     } catch (error) {
-      if (hasErrorCode(error, "ENOENT")) return;
+      if (isErrnoCode(error, "ENOENT")) return;
       throw error;
     }
     if (Date.now() - initial.mtimeMs <= jsonStoreLockStaleMs()) return;
@@ -241,12 +238,12 @@ async function removeStaleJsonStoreLock(lockPath: string): Promise<void> {
     try {
       confirmed = await readJsonStoreLockState(lockPath);
     } catch (error) {
-      if (hasErrorCode(error, "ENOENT")) return;
+      if (isErrnoCode(error, "ENOENT")) return;
       throw error;
     }
     if (!sameJsonStoreLockState(initial, confirmed)) return;
     await unlink(lockPath).catch((error) => {
-      if (!hasErrorCode(error, "ENOENT")) throw error;
+      if (!isErrnoCode(error, "ENOENT")) throw error;
     });
   } finally {
     await closeAndRemoveJsonStoreReclaimGuard(reclaimPath, reclaimHandle);
@@ -272,7 +269,7 @@ async function confirmJsonStoreMutationLockOwnership(
         const metadata = JSON.parse(state.content) as { token?: unknown };
         return metadata.token === token;
       } catch (error) {
-        if (hasErrorCode(error, "ENOENT") || error instanceof SyntaxError) return false;
+        if (isErrnoCode(error, "ENOENT") || error instanceof SyntaxError) return false;
         throw error;
       }
     } finally {
@@ -291,9 +288,9 @@ async function acquireJsonStoreMutationFileLock(key: string): Promise<() => Prom
     try {
       handle = await open(lockPath, "wx", 0o600);
     } catch (error) {
-      if (!hasErrorCode(error, "EEXIST")) throw error;
+      if (!isErrnoCode(error, "EEXIST")) throw error;
       await removeStaleJsonStoreLock(lockPath).catch((staleError) => {
-        if (!hasErrorCode(staleError, "ENOENT")) throw staleError;
+        if (!isErrnoCode(staleError, "ENOENT")) throw staleError;
       });
       if (Date.now() >= deadline) {
         throw new Error(`Timed out acquiring JSON store mutation lock: ${lockPath}`);
@@ -338,7 +335,7 @@ async function acquireJsonStoreMutationFileLock(key: string): Promise<() => Prom
         const metadata = JSON.parse(await readFile(lockPath, "utf8")) as { token?: unknown };
         if (metadata.token === token) await unlink(lockPath);
       } catch (error) {
-        if (!hasErrorCode(error, "ENOENT")) throw error;
+        if (!isErrnoCode(error, "ENOENT")) throw error;
       }
     };
   }

package/src/live-connectors-runner.ts

@@ -29,6 +29,7 @@ import {
   type ConnectorState,
   type LiveConnector,
 } from "./connectors/live/index.js";
+import { abortError } from "./abort-error.js";
 import type { LiveConnectorsConfig } from "./types.js";
 
 export type LiveConnectorSkipReason =
@@ -428,7 +429,7 @@ function throwIfAborted(signal: AbortSignal | undefined): void {
   if (reason instanceof Error) {
     throw reason;
   }
-  throw new Error(reason === undefined ? "operation aborted" : String(reason));
+  throw abortError(reason === undefined ? "operation aborted" : String(reason));
 }
 
 async function writeConnectorErrorState(options: {

package/src/location/store.ts

@@ -21,6 +21,7 @@ import path from "node:path";
 
 import { writeFileAtomically } from "../maintenance/atomic-file.js";
 import { pathIsInside } from "../utils/path-containment.js";
+import { isErrnoCode } from "../utils/errno.js";
 import { isValidLocationDate, placeDurations } from "./intervals.js";
 import type { LocationSegment } from "./types.js";
 
@@ -376,10 +377,6 @@ export function parseLocationDaySummary(raw: string): LocationDaySummary | null
 
 // ── Containment-checked day-file IO ─────────────────────────────────────────
 
-function isErrnoCode(err: unknown, code: string): boolean {
-  return err instanceof Error && (err as NodeJS.ErrnoException).code === code;
-}
-
 async function assertNotSymlink(target: string, kind: "directory" | "day file"): Promise<void> {
   let stat: { isSymbolicLink(): boolean };
   try {

package/src/maintenance/purge.ts

@@ -25,6 +25,7 @@ import type { StorageManager } from "../storage.js";
 import type { MemoryFile } from "../types.js";
 import { markProjectedMemoryPathInvalid } from "../memory-projection-store.js";
 import type { SearchBackend } from "../search/port.js";
+import { isErrnoCode } from "../utils/errno.js";
 
 export type PurgeTierFilter = "cold" | "all";
 
@@ -87,10 +88,6 @@ export interface PurgeMemoriesResult {
   errors: Array<{ id: string; path: string; error: string }>;
 }
 
-function hasErrorCode(err: unknown, code: string): boolean {
-  return typeof err === "object" && err !== null && "code" in err && (err as { code?: unknown }).code === code;
-}
-
 function resolveTimestamp(memory: MemoryFile): string {
   const fm = memory.frontmatter as unknown as Record<string, unknown>;
   const updated = typeof fm.updated === "string" ? (fm.updated as string) : "";
@@ -247,7 +244,7 @@ export async function purgeMemories(
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      if (hasErrorCode(err, "ENOENT")) {
+      if (isErrnoCode(err, "ENOENT")) {
         alreadyAbsent.push(candidate);
         addCollectionForCandidate(candidate);
         markProjectedMemoryPathInvalid(storage.dir, candidate.id);

package/src/maintenance/rebuild-memory-lifecycle-ledger.ts

@@ -18,6 +18,7 @@ import {
 } from "../memory-lifecycle-ledger-utils.js";
 import { withHeldFileLock, type HeldFileLockOptions, type HeldFileLockController } from "../utils/serialize-mutations.js";
 import { probeEncryptedRegularFileHeader } from "../secure-store/secure-fs.js";
+import { isErrnoCode } from "../utils/errno.js";
 
 
 export interface RebuildMemoryLifecycleLedgerOptions {
@@ -115,10 +116,6 @@ export interface RebuildMemoryLifecycleLedgerResult {
   rewritten?: boolean;
 }
 
-function isNodeError(err: unknown): err is NodeJS.ErrnoException {
-  return typeof err === "object" && err !== null && "code" in err;
-}
-
 /** Serialized on-disk size (bytes, incl. trailing newline) of one ledger row. */
 function lifecycleRowBytes(event: MemoryLifecycleEvent): number {
   return Buffer.byteLength(`${JSON.stringify(event)}\n`, "utf8");
@@ -174,7 +171,7 @@ export async function backupExistingLedger(
   try {
     await stat(outputPath);
   } catch (err) {
-    if (isNodeError(err) && err.code === "ENOENT") {
+    if (isErrnoCode(err, "ENOENT")) {
       return undefined;
     }
     throw err;
@@ -397,7 +394,7 @@ export async function rebuildMemoryLifecycleLedger(
         currentEncrypted = await probeEncryptedRegularFileHeader(outputPath);
         priorRawBuffer = await storage.readMemoryLifecycleLedgerRawBufferForCompaction();
       } catch (err) {
-        if (!isNodeError(err) || err.code !== "ENOENT") throw err;
+        if (!isErrnoCode(err, "ENOENT")) throw err;
       }
       // Preserve encryption at rest (#2033). An already-encrypted ledger (or its
       // encrypted backup) MUST be rewritten encrypted even when the

package/src/maintenance/rebuild-memory-projection.ts

@@ -76,6 +76,7 @@ import type {
   SkippedDuplicateMemory,
   SkippedDuplicateTimelineEvent,
 } from "./projection-support.js";
+import { isErrnoCode } from "../utils/errno.js";
 
 
 export interface RebuildMemoryProjectionResult {
@@ -150,10 +151,6 @@ export interface RepairMemoryProjectionResult {
   rebuild?: RebuildMemoryProjectionResult;
 }
 
-function isNodeError(err: unknown): err is NodeJS.ErrnoException {
-  return typeof err === "object" && err !== null && "code" in err;
-}
-
 export async function backupExistingProjection(
   memoryDir: string,
   outputPath: string,
@@ -162,7 +159,7 @@ export async function backupExistingProjection(
   try {
     await stat(outputPath);
   } catch (err) {
-    if (isNodeError(err) && err.code === "ENOENT") {
+    if (isErrnoCode(err, "ENOENT")) {
       return undefined;
     }
     throw err;

package/src/namespaces/catalog.ts

@@ -22,6 +22,7 @@ import { isSafeRouteNamespace } from "../routing/engine.js";
 import { namespaceIdentityFromToken, namespaceIdentityLegacyToken, namespaceIdentityToken, normalizeNamespaceIdentity } from "./identity.js";
 import { resolveDefaultNamespaceRoot, resolveNamespaceStorageRoot } from "./storage.js";
 import { ALL_CATEGORY_DIRS } from "../utils/category-dir.js";
+import { isNotFoundError } from "../utils/errno.js";
 
 /**
  * Rebuildable namespace catalog (issue #1499).
@@ -191,15 +192,6 @@ type MemoryDataRootStatus = {
   invalidMarker?: string;
 };
 
-function isNotFoundError(err: unknown): boolean {
-  return (
-    typeof err === "object" &&
-    err !== null &&
-    "code" in err &&
-    (err as { code?: string }).code === "ENOENT"
-  );
-}
-
 /**
  * Inspect `child` under `rootDir` as a memory-data marker (NIw0F / PR #1506).
  * Existence alone is not enough: a bogus marker — e.g. `facts` as a symlink or a

package/src/offline-sync-file-io.test.ts

@@ -0,0 +1,39 @@
+import assert from "node:assert/strict";
+import { mkdtemp, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { sha256OfflineSyncFile } from "./offline-sync-file-io.js";
+
+async function tempFile(name: string, content: string): Promise<string> {
+  const dir = await mkdtemp(path.join(os.tmpdir(), `${name}-`));
+  const filePath = path.join(dir, `${name}.txt`);
+  await writeFile(filePath, content);
+  return filePath;
+}
+
+/** The abort guards must surface `name === "AbortError"`, not a plain Error (issue #2795). */
+async function assertRejectsWithAbortError(promise: Promise<unknown>): Promise<void> {
+  await assert.rejects(promise, (err: unknown) => {
+    assert.ok(err instanceof Error, "abort must surface an Error");
+    assert.equal(err.name, "AbortError", "abort must preserve the AbortError name");
+    return true;
+  });
+}
+
+test("sha256OfflineSyncFile rejects with AbortError name via the per-chunk guard", async () => {
+  const filePath = await tempFile("offline-sync-abort", "chunk-of-bytes");
+  const controller = new AbortController();
+  controller.abort();
+  // A non-empty file yields at least one chunk, so the in-loop guard fires first.
+  await assertRejectsWithAbortError(sha256OfflineSyncFile(filePath, controller.signal));
+});
+
+test("sha256OfflineSyncFile rejects with AbortError name via the post-loop guard", async () => {
+  const filePath = await tempFile("offline-sync-abort-empty", "");
+  const controller = new AbortController();
+  controller.abort();
+  // An empty file yields no chunks, so only the trailing guard runs.
+  await assertRejectsWithAbortError(sha256OfflineSyncFile(filePath, controller.signal));
+});

package/src/offline-sync-file-io.ts

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { open } from "node:fs/promises";
+import { throwIfAborted } from "./abort-error.js";
 import { MAGIC_HEADER_SIZE, isEncryptedFile } from "./secure-store/secure-fs.js";
 
 export interface OfflineSyncFileTarget {
@@ -10,11 +11,6 @@ export interface OfflineSyncFileTarget {
 }
 
 export type OfflineSyncExcludeFile = (target: OfflineSyncFileTarget) => boolean | Promise<boolean>;
-
-function throwIfAborted(signal: AbortSignal | undefined): void {
-  if (signal?.aborted) throw new Error("offline sync request aborted");
-}
-
 export async function shouldExcludeOfflineSyncFile(
   excludeFile: OfflineSyncExcludeFile | undefined,
   target: OfflineSyncFileTarget
@@ -29,12 +25,12 @@ export async function sha256OfflineSyncFile(
   const hash = createHash("sha256");
   let bytes = 0;
   for await (const chunk of createReadStream(filePath)) {
-    throwIfAborted(signal);
+    throwIfAborted(signal, "offline sync request aborted");
     const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
     hash.update(buffer);
     bytes += buffer.length;
   }
-  throwIfAborted(signal);
+  throwIfAborted(signal, "offline sync request aborted");
   return { sha256: hash.digest("hex"), bytes };
 }
 

package/src/procedural/procedure-miner.ts

@@ -16,6 +16,7 @@ import { buildProcedurePersistBody, normalizeProcedureSteps, type ProcedureStep
 import { clusterByKey } from "./reinforcement-core.js";
 import { log } from "../logger.js";
 import { composeMemoryEnvelope, STRUCTURED_ATTRIBUTE_LIMITS } from "../write-envelope.js";
+import { isErrnoCode } from "../utils/errno.js";
 
 /** Must match truncation on `procedure_cluster` structured attribute (dedupe + storage). */
 const PROCEDURE_CLUSTER_ATTR_MAX = 500;
@@ -53,15 +54,6 @@ function clusterKeyHash(cluster: string): string {
   return createHash("sha256").update(cluster).digest("hex");
 }
 
-function isErrnoCode(error: unknown, code: string): boolean {
-  return (
-    typeof error === "object" &&
-    error !== null &&
-    "code" in error &&
-    (error as { code?: unknown }).code === code
-  );
-}
-
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/src/search/document-scanner.ts

@@ -2,6 +2,7 @@ import path from "node:path";
 import { lstat, readdir, readFile, realpath } from "node:fs/promises";
 import { RECALL_FALLBACK_DIRS } from "../utils/category-dir.js";
 import { assertPathInsideRoot } from "../utils/path-containment.js";
+import { isErrnoCode } from "../utils/errno.js";
 
 export interface IndexableDocument {
   /** Memory ID from frontmatter or filename stem */
@@ -83,7 +84,7 @@ async function scanDir(dir: string, memoryRootReal: string): Promise<IndexableDo
       }
     }
   } catch (err) {
-    if (isNodeError(err) && err.code === "ENOENT") {
+    if (isErrnoCode(err, "ENOENT")) {
       // Optional category directories may not exist yet.
       return docs;
     }
@@ -92,10 +93,6 @@ async function scanDir(dir: string, memoryRootReal: string): Promise<IndexableDo
   return docs;
 }
 
-function isNodeError(err: unknown): err is NodeJS.ErrnoException {
-  return typeof err === "object" && err !== null && "code" in err;
-}
-
 /**
  * Scan every recall category subdir of memoryDir for indexable markdown
  * documents. The directory set is derived from `RECALL_FALLBACK_DIRS`
@@ -114,7 +111,7 @@ export async function scanMemoryDir(memoryDir: string): Promise<IndexableDocumen
   try {
     memoryRootReal = await realpath(memoryDir);
   } catch (err) {
-    if (isNodeError(err) && err.code === "ENOENT") {
+    if (isErrnoCode(err, "ENOENT")) {
       return [];
     }
     throw err;

package/src/semantic-rule-promotion.ts

@@ -6,6 +6,7 @@ import path from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 import { StorageManager } from "./storage.js";
 import type { MemoryFile, MemoryLink } from "./types.js";
+import { isErrnoCode } from "./utils/errno.js";
 
 export interface SemanticRulePromotionCandidate {
   id: string;
@@ -79,10 +80,6 @@ function promotionLockHeartbeatMs(): number {
   return testHooks?.heartbeatMs ?? PROMOTION_LOCK_HEARTBEAT_MS;
 }
 
-function isErrnoCode(err: unknown, code: string): boolean {
-  return typeof err === "object" && err !== null && "code" in err && (err as { code?: unknown }).code === code;
-}
-
 function promotionLockDir(memoryDir: string, ruleKey: string): string {
   const digest = createHash("sha256").update(ruleKey).digest("hex");
   return path.join(path.resolve(memoryDir), "state", "semantic-rule-promotion-locks", `${digest}.lock`);