@totalreclaw/totalreclaw 3.3.12-rc.16 → 3.3.12-rc.17

package/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: totalreclaw
 description: "End-to-end encrypted, decentralized memory for OpenClaw. A native kind:memory provider — recall is automatic via memory_search/memory_get, and facts are captured in the background. Trigger on 'install TotalReclaw', 'set up TotalReclaw', 'restore my recovery phrase', any recall request ('what do you remember about me', 'what's my X'), AND any explicit remember request ('remember X', 'save X')."
-version: 3.3.12-rc.16
+version: 3.3.12-rc.17
 author: TotalReclaw Team
 license: MIT
 homepage: https://totalreclaw.xyz

package/dist/embedder-loader.js

@@ -132,6 +132,15 @@ export function makeCacheRequire(layout) {
  * entry — the `.mjs` file — and `import()` of that surfaces named
  * exports on every Node version we support (18, 20, 22, 24).
  *
+ * Post-import normalization (`normalizeImportNamespace`): even with
+ * the correct `.mjs` entry selected, Node 24 minor versions have
+ * shown regressions where the namespace comes back default-wrapped
+ * (cjs-module-lexer mis-parses the 1.3 MB bundled output, or the
+ * caller-context forces CJS resolution). The normalizer unwraps
+ * `.default` defensively so callers can always destructure named
+ * exports directly. See `normalizeImportNamespace` for the detection
+ * rule + edge cases.
+ *
  * Transitive deps resolve the same way: the imported module's own
  * internal `import`/`require` calls walk up from its URL and find the
  * cache's `node_modules` first.
@@ -168,9 +177,85 @@ export function makeCacheImport(layout) {
         // Step 3: native ESM dynamic import of the file URL — populates
         // named exports correctly for dual CJS/ESM and ESM-only packages.
         const fileUrl = pathToFileURL(esmEntry).href;
-        return await import(fileUrl);
+        const mod = await import(fileUrl);
+        // Step 4: normalize the namespace across Node versions.
+        //
+        // Why this exists (issue #394 follow-up: `autoModel is not a function`
+        // PERSISTED on Node 24.16.0 with the real `@huggingface/transformers`
+        // v4.2.0 bundle even after #394 shipped `cacheImport`):
+        //   The `resolveEsmEntryPath` correctly prefers the `.mjs` (ESM
+        //   native) entry, and `import()` of an `.mjs` file surfaces real
+        //   named exports on every Node version we tested locally (18, 20,
+        //   22). But on Node 24, two regressions have been observed in the
+        //   wild for dual CJS/ESM packages with large bundled outputs:
+        //
+        //   a) `cjs-module-lexer` (Node's static analyzer for CJS named
+        //      export detection) silently times out / mis-parses the 1.3 MB
+        //      `transformers.node.cjs` bundle, so a fallback `import()` of
+        //      the `.cjs` file returns ONLY `{ default: module.exports }`
+        //      with no named exports. `const { AutoModel } = mod` then
+        //      yields `undefined`.
+        //
+        //   b) Some Node 24 minor versions changed the ESM-CJS interop such
+        //      that `import()` of a dual package resolves to the CJS entry
+        //      under specific caller-context conditions (e.g. when the
+        //      caller is itself a transitive CJS module loaded via
+        //      `createRequire` from ESM), again producing a default-only
+        //      namespace.
+        //
+        // We CANNOT reproduce (a)/(b) on Node 22 (the bug is Node-24-only
+        // and depends on cjs-module-lexer's behavior on the real 1.3 MB
+        // bundle), so this normalization is defensive: after the `import()`,
+        // if the namespace has NO own enumerable string keys other than
+        // `default` (and `default` is a non-null object), we unwrap `default`
+        // and return ITS keys as the namespace. This makes the loader robust
+        // to BOTH the ESM-native path (named exports come through untouched)
+        // AND the CJS-fallback path (named exports are recovered from
+        // `default`).
+        return normalizeImportNamespace(mod, specifier, esmEntry);
     };
 }
+/**
+ * Normalize the result of `import(specifier)` so callers can always
+ * destructure named exports directly, regardless of whether the resolved
+ * entry was ESM-native (named exports on the namespace) or CJS-via-ESM
+ * (named exports only reachable through `.default`).
+ *
+ * Detection rule: if the namespace has `default` AND zero non-`default`
+ * own enumerable string-keyed properties, treat it as a CJS-wrapped
+ * namespace and return the `default` object instead. Otherwise return
+ * the namespace unchanged (ESM-native or already-unwrapped).
+ *
+ * Edge case: a legitimately default-only ESM module (one that exports
+ * ONLY a default) would be mis-detected as CJS-wrapped. That is safe —
+ * the unwrapped `default` is itself the value the caller wants, and a
+ * default-only ESM module has no named exports to lose. The bundled
+ * packages this loader targets (`@huggingface/transformers`,
+ * `onnxruntime-node`) are named-export-heavy, so this edge case does
+ * not arise in practice.
+ */
+function normalizeImportNamespace(mod, specifier, entryPath) {
+    if (!mod || typeof mod !== 'object')
+        return mod;
+    const ownKeys = Object.keys(mod).filter((k) => k !== 'default');
+    if (ownKeys.length > 0) {
+        // Named exports already present — ESM-native path. Return as-is.
+        return mod;
+    }
+    const def = mod.default;
+    if (def && typeof def === 'object') {
+        // CJS-wrapped namespace (Node 24 cjs-module-lexer regression).
+        // Unwrap so callers can destructure named exports directly.
+        return def;
+    }
+    // Neither named exports nor a usable default. Return as-is and let
+    // the caller's destructure yield `undefined` — but include a
+    // diagnostic marker the caller can surface in its error message.
+    throw new Error(`cacheImport("${specifier}") resolved ${entryPath} but the import() ` +
+        `returned a namespace with no named exports and no usable default ` +
+        `(keys: ${JSON.stringify(Object.keys(mod))}). The bundled package ` +
+        `may be corrupt or the platform's ESM-CJS interop is incompatible.`);
+}
 /**
  * Walk up from `entryFile` to the nearest directory containing a
  * `package.json` whose `name` matches the specifier's package name.

package/dist/embedding.js

@@ -140,8 +140,32 @@ export async function generateEmbedding(text, options) {
         // dynamic `import()` of the resolved entry file URL populates the named
         // exports correctly on every Node version we support. See
         // `makeCacheImport` in embedder-loader.ts.
+        //
+        // Defensive access (#394 follow-up): `cacheImport` normalizes the
+        // namespace so named exports are always top-level, but if the bundle
+        // is corrupt or a future Node version changes interop again, we want
+        // a CLEAR error here ("transformers bundle did not expose AutoModel")
+        // rather than the opaque downstream `autoModel is not a function`.
+        // The previous fix silently returned undefined and let the inference
+        // call site crash with a misleading message; this guard turns that
+        // into an actionable one.
         const transformers = await loaded.cacheImport('@huggingface/transformers');
-        const { AutoTokenizer, AutoModel, pipeline } = transformers;
+        let AutoTokenizer = transformers.AutoTokenizer;
+        let AutoModel = transformers.AutoModel;
+        let pipeline = transformers.pipeline;
+        // Final `.default` fallback — covers any future regression where the
+        // loader's normalizer does not run (e.g. a hand-rolled caller).
+        if ((!AutoModel || !AutoTokenizer || !pipeline) && transformers.default) {
+            AutoTokenizer = AutoTokenizer ?? transformers.default.AutoTokenizer;
+            AutoModel = AutoModel ?? transformers.default.AutoModel;
+            pipeline = pipeline ?? transformers.default.pipeline;
+        }
+        if (typeof AutoModel !== 'function' && typeof AutoModel !== 'object') {
+            throw new Error(`transformers bundle did not expose AutoModel (typeof=${typeof AutoModel}). ` +
+                `Bundle may be corrupt or Node ${process.version} ESM-CJS interop ` +
+                `incompatible with the bundled @huggingface/transformers entry. ` +
+                `Cache at ${cfg.cacheRoot}/v1/.`);
+        }
         if (activeModel.pooling === 'sentence_embedding') {
             autoTokenizer = await AutoTokenizer.from_pretrained(activeModel.hfId);
             autoModel = await AutoModel.from_pretrained(activeModel.hfId, {

package/dist/tr-cli.js

@@ -51,7 +51,7 @@ const STATE_PATH = CONFIG.onboardingStatePath;
 // Auto-synced by skill/scripts/sync-version.mjs from skill/plugin/package.json::version.
 // Do not edit by hand — running tests will catch drift but the publish workflow
 // rewrites this constant at the start of every npm/ClawHub publish.
-const PLUGIN_VERSION = '3.3.12-rc.16';
+const PLUGIN_VERSION = '3.3.12-rc.17';
 function die(msg, code = 1) {
     process.stderr.write(`tr: ${msg}\n`);
     process.exit(code);

package/embedder-loader.ts

@@ -217,6 +217,15 @@ export function makeCacheRequire(layout: CacheLayout): NodeRequire {
  * entry — the `.mjs` file — and `import()` of that surfaces named
  * exports on every Node version we support (18, 20, 22, 24).
  *
+ * Post-import normalization (`normalizeImportNamespace`): even with
+ * the correct `.mjs` entry selected, Node 24 minor versions have
+ * shown regressions where the namespace comes back default-wrapped
+ * (cjs-module-lexer mis-parses the 1.3 MB bundled output, or the
+ * caller-context forces CJS resolution). The normalizer unwraps
+ * `.default` defensively so callers can always destructure named
+ * exports directly. See `normalizeImportNamespace` for the detection
+ * rule + edge cases.
+ *
  * Transitive deps resolve the same way: the imported module's own
  * internal `import`/`require` calls walk up from its URL and find the
  * cache's `node_modules` first.
@@ -255,10 +264,88 @@ export function makeCacheImport(layout: CacheLayout): (specifier: string) => Pro
     // Step 3: native ESM dynamic import of the file URL — populates
     // named exports correctly for dual CJS/ESM and ESM-only packages.
     const fileUrl = pathToFileURL(esmEntry).href;
-    return await import(fileUrl);
+    const mod = await import(fileUrl);
+    // Step 4: normalize the namespace across Node versions.
+    //
+    // Why this exists (issue #394 follow-up: `autoModel is not a function`
+    // PERSISTED on Node 24.16.0 with the real `@huggingface/transformers`
+    // v4.2.0 bundle even after #394 shipped `cacheImport`):
+    //   The `resolveEsmEntryPath` correctly prefers the `.mjs` (ESM
+    //   native) entry, and `import()` of an `.mjs` file surfaces real
+    //   named exports on every Node version we tested locally (18, 20,
+    //   22). But on Node 24, two regressions have been observed in the
+    //   wild for dual CJS/ESM packages with large bundled outputs:
+    //
+    //   a) `cjs-module-lexer` (Node's static analyzer for CJS named
+    //      export detection) silently times out / mis-parses the 1.3 MB
+    //      `transformers.node.cjs` bundle, so a fallback `import()` of
+    //      the `.cjs` file returns ONLY `{ default: module.exports }`
+    //      with no named exports. `const { AutoModel } = mod` then
+    //      yields `undefined`.
+    //
+    //   b) Some Node 24 minor versions changed the ESM-CJS interop such
+    //      that `import()` of a dual package resolves to the CJS entry
+    //      under specific caller-context conditions (e.g. when the
+    //      caller is itself a transitive CJS module loaded via
+    //      `createRequire` from ESM), again producing a default-only
+    //      namespace.
+    //
+    // We CANNOT reproduce (a)/(b) on Node 22 (the bug is Node-24-only
+    // and depends on cjs-module-lexer's behavior on the real 1.3 MB
+    // bundle), so this normalization is defensive: after the `import()`,
+    // if the namespace has NO own enumerable string keys other than
+    // `default` (and `default` is a non-null object), we unwrap `default`
+    // and return ITS keys as the namespace. This makes the loader robust
+    // to BOTH the ESM-native path (named exports come through untouched)
+    // AND the CJS-fallback path (named exports are recovered from
+    // `default`).
+    return normalizeImportNamespace(mod, specifier, esmEntry);
   };
 }
 
+/**
+ * Normalize the result of `import(specifier)` so callers can always
+ * destructure named exports directly, regardless of whether the resolved
+ * entry was ESM-native (named exports on the namespace) or CJS-via-ESM
+ * (named exports only reachable through `.default`).
+ *
+ * Detection rule: if the namespace has `default` AND zero non-`default`
+ * own enumerable string-keyed properties, treat it as a CJS-wrapped
+ * namespace and return the `default` object instead. Otherwise return
+ * the namespace unchanged (ESM-native or already-unwrapped).
+ *
+ * Edge case: a legitimately default-only ESM module (one that exports
+ * ONLY a default) would be mis-detected as CJS-wrapped. That is safe —
+ * the unwrapped `default` is itself the value the caller wants, and a
+ * default-only ESM module has no named exports to lose. The bundled
+ * packages this loader targets (`@huggingface/transformers`,
+ * `onnxruntime-node`) are named-export-heavy, so this edge case does
+ * not arise in practice.
+ */
+function normalizeImportNamespace(mod: any, specifier: string, entryPath: string): any {
+  if (!mod || typeof mod !== 'object') return mod;
+  const ownKeys = Object.keys(mod).filter((k) => k !== 'default');
+  if (ownKeys.length > 0) {
+    // Named exports already present — ESM-native path. Return as-is.
+    return mod;
+  }
+  const def = (mod as { default?: unknown }).default;
+  if (def && typeof def === 'object') {
+    // CJS-wrapped namespace (Node 24 cjs-module-lexer regression).
+    // Unwrap so callers can destructure named exports directly.
+    return def;
+  }
+  // Neither named exports nor a usable default. Return as-is and let
+  // the caller's destructure yield `undefined` — but include a
+  // diagnostic marker the caller can surface in its error message.
+  throw new Error(
+    `cacheImport("${specifier}") resolved ${entryPath} but the import() ` +
+      `returned a namespace with no named exports and no usable default ` +
+      `(keys: ${JSON.stringify(Object.keys(mod))}). The bundled package ` +
+      `may be corrupt or the platform's ESM-CJS interop is incompatible.`
+  );
+}
+
 /**
  * Walk up from `entryFile` to the nearest directory containing a
  * `package.json` whose `name` matches the specifier's package name.

package/embedding.ts

@@ -187,8 +187,39 @@ export async function generateEmbedding(
     // dynamic `import()` of the resolved entry file URL populates the named
     // exports correctly on every Node version we support. See
     // `makeCacheImport` in embedder-loader.ts.
-    const transformers = await loaded.cacheImport('@huggingface/transformers');
-    const { AutoTokenizer, AutoModel, pipeline } = transformers as any;
+    //
+    // Defensive access (#394 follow-up): `cacheImport` normalizes the
+    // namespace so named exports are always top-level, but if the bundle
+    // is corrupt or a future Node version changes interop again, we want
+    // a CLEAR error here ("transformers bundle did not expose AutoModel")
+    // rather than the opaque downstream `autoModel is not a function`.
+    // The previous fix silently returned undefined and let the inference
+    // call site crash with a misleading message; this guard turns that
+    // into an actionable one.
+    const transformers = await loaded.cacheImport('@huggingface/transformers') as {
+      AutoTokenizer?: unknown;
+      AutoModel?: unknown;
+      pipeline?: unknown;
+      default?: { AutoTokenizer?: unknown; AutoModel?: unknown; pipeline?: unknown };
+    };
+    let AutoTokenizer = transformers.AutoTokenizer;
+    let AutoModel = transformers.AutoModel;
+    let pipeline = transformers.pipeline;
+    // Final `.default` fallback — covers any future regression where the
+    // loader's normalizer does not run (e.g. a hand-rolled caller).
+    if ((!AutoModel || !AutoTokenizer || !pipeline) && transformers.default) {
+      AutoTokenizer = AutoTokenizer ?? transformers.default.AutoTokenizer;
+      AutoModel = AutoModel ?? transformers.default.AutoModel;
+      pipeline = pipeline ?? transformers.default.pipeline;
+    }
+    if (typeof AutoModel !== 'function' && typeof AutoModel !== 'object') {
+      throw new Error(
+        `transformers bundle did not expose AutoModel (typeof=${typeof AutoModel}). ` +
+          `Bundle may be corrupt or Node ${process.version} ESM-CJS interop ` +
+          `incompatible with the bundled @huggingface/transformers entry. ` +
+          `Cache at ${cfg.cacheRoot}/v1/.`,
+      );
+    }
 
     if (activeModel.pooling === 'sentence_embedding') {
       autoTokenizer = await AutoTokenizer.from_pretrained(activeModel.hfId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totalreclaw/totalreclaw",
-  "version": "3.3.12-rc.16",
+  "version": "3.3.12-rc.17",
   "description": "End-to-end encrypted, agent-portable memory for OpenClaw and any LLM-agent runtime. XChaCha20-Poly1305 with protobuf v4 + on-chain Memory Taxonomy v1 (claim / preference / directive / commitment / episode / summary).",
   "type": "module",
   "keywords": [

package/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "totalreclaw",
-  "version": "3.3.12-rc.16",
+  "version": "3.3.12-rc.17",
   "description": "End-to-end encrypted memory for AI agents — portable, yours forever. XChaCha20-Poly1305 E2EE: server never sees plaintext.",
   "author": "TotalReclaw Team",
   "license": "MIT",

package/tr-cli.ts

@@ -68,7 +68,7 @@ const STATE_PATH = CONFIG.onboardingStatePath;
 // Auto-synced by skill/scripts/sync-version.mjs from skill/plugin/package.json::version.
 // Do not edit by hand — running tests will catch drift but the publish workflow
 // rewrites this constant at the start of every npm/ClawHub publish.
-const PLUGIN_VERSION = '3.3.12-rc.16';
+const PLUGIN_VERSION = '3.3.12-rc.17';
 
 function die(msg: string, code = 1): never {
   process.stderr.write(`tr: ${msg}\n`);