@remnic/core 9.69.23 → 9.69.25

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`);

package/src/utils/errno.test.ts

@@ -0,0 +1,31 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { isErrnoCode, isNotFoundError } from "./errno.js";
+
+/** Shapes accepted by every local helper this module replaced (issue #2795). */
+test("isErrnoCode matches code-carrying errors and rejects everything else", () => {
+  const enoent = Object.assign(new Error("no such file"), { code: "ENOENT" });
+  assert.equal(isErrnoCode(enoent, "ENOENT"), true);
+  assert.equal(isErrnoCode({ code: "ENOENT" }, "ENOENT"), true, "plain objects with a code match");
+  assert.equal(isErrnoCode(enoent, "EEXIST"), false, "different code does not match");
+  assert.equal(isErrnoCode(new Error("no code"), "ENOENT"), false);
+  assert.equal(isErrnoCode(null, "ENOENT"), false);
+  assert.equal(isErrnoCode(undefined, "ENOENT"), false);
+  assert.equal(isErrnoCode("ENOENT", "ENOENT"), false);
+  assert.equal(isErrnoCode({}, "ENOENT"), false);
+});
+
+test("isNotFoundError is equivalent to isErrnoCode(error, \"ENOENT\")", () => {
+  const enoent = Object.assign(new Error("no such file"), { code: "ENOENT" });
+  const eexist = Object.assign(new Error("file exists"), { code: "EEXIST" });
+  for (const candidate of [enoent, eexist, { code: "ENOENT" }, {}, null, undefined, "ENOENT", 42]) {
+    assert.equal(
+      isNotFoundError(candidate),
+      isErrnoCode(candidate, "ENOENT"),
+      `isNotFoundError must agree with isErrnoCode(_, "ENOENT") for ${JSON.stringify(candidate) ?? String(candidate)}`,
+    );
+  }
+  assert.equal(isNotFoundError(enoent), true);
+  assert.equal(isNotFoundError(eexist), false);
+});

package/src/utils/errno.ts

@@ -4,3 +4,8 @@ export function isErrnoCode(error: unknown, code: string): boolean {
     && "code" in error
     && (error as { code?: unknown }).code === code;
 }
+
+/** True iff `error` carries Node's `ENOENT` code (missing file or directory). */
+export function isNotFoundError(error: unknown): boolean {
+  return isErrnoCode(error, "ENOENT");
+}

package/src/wearables/index.ts

@@ -18,6 +18,7 @@ export {
 export {
   builtInConnectorPackageSpecifier,
   registerWearableConnector,
+  selfRegisterWearableConnector,
   getWearableConnector,
   listWearableConnectors,
   clearWearableConnectors,

package/src/wearables/registry.ts

@@ -64,6 +64,29 @@ export function getWearableConnector(
   return registrations.get(key);
 }
 
+/**
+ * Register a connector package with this registry immediately (idempotent)
+ * and return its `ensure*Registered()` companion.
+ *
+ * Connector packages call this once at module scope with their registration
+ * record, so importing the module registers the connector as a side effect.
+ * The returned companion re-checks the live registry on every call — so it
+ * also re-registers after a test-only registry reset — and returns false
+ * while the connector stays registered. `registerWearableConnector` throws
+ * on duplicate ids, which is why the registry is checked before each call.
+ */
+export function selfRegisterWearableConnector(
+  registration: WearableConnectorRegistration,
+): () => boolean {
+  const ensureRegistered = (): boolean => {
+    if (getWearableConnector(registration.id) !== undefined) return false;
+    registerWearableConnector(registration);
+    return true;
+  };
+  ensureRegistered();
+  return ensureRegistered;
+}
+
 export function listWearableConnectors(): string[] {
   return [...registrations.keys()];
 }