@totalreclaw/totalreclaw 3.3.2 → 3.3.4-rc.1

package/dist/index.js

@@ -48,7 +48,7 @@
 import { deriveKeys, deriveLshSeed, computeAuthKeyHash, encrypt, decrypt, generateBlindIndices, generateContentFingerprint, } from './crypto.js';
 import { createApiClient } from './api-client.js';
 import { extractFacts, extractDebrief, isValidMemoryType, parseEntity, VALID_MEMORY_TYPES, LEGACY_V0_MEMORY_TYPES, VALID_MEMORY_SOURCES, VALID_MEMORY_SCOPES, EXTRACTION_SYSTEM_PROMPT, extractFactsForCompaction, } from './extractor.js';
-import { initLLMClient, resolveLLMConfig, chatCompletion, generateEmbedding, getEmbeddingDims, getEmbeddingModelId, configureEmbedder, } from './llm-client.js';
+import { initLLMClient, resolveLLMConfig, chatCompletion, generateEmbedding, getEmbeddingDims, getEmbeddingModelId, configureEmbedder, prefetchEmbedderBundle, } from './llm-client.js';
 import { defaultAuthProfilesRoot, readAllProfileKeys, dedupeByProvider, } from './llm-profile-reader.js';
 import { LSHHasher } from './lsh.js';
 import { rerank, cosineSimilarity, detectQueryIntent, INTENT_WEIGHTS } from './reranker.js';
@@ -501,6 +501,36 @@ let firstRunAfterInit = true;
  * skips. A fresh gateway restart resets it back to `false`.
  */
 let firstRunWelcomeShown = false;
+/**
+ * 3.3.3-rc.1 — RC-mode staging-only banner (PR #165 implementation).
+ *
+ * Fires ONCE per gateway process when:
+ *   - the bundled-default `serverUrl` resolves to `api-staging.totalreclaw.xyz`
+ *     (RC artifact, not stable), AND
+ *   - the user has NOT overridden via `TOTALRECLAW_SERVER_URL=...` env.
+ *
+ * Goal: a fresh QA tester can't accidentally use an RC build for real data
+ * without seeing a clear "RC = staging, no SLA, may be wiped" warning.
+ * One-shot at the first `before_agent_start` whose `prependContext` actually
+ * lands on the LLM (3.3.4-rc.1 — see fix below). A fresh gateway restart
+ * re-fires it once.
+ *
+ * 3.3.4-rc.1 fix: through 3.3.3-rc.1 this flag was set to true as soon as
+ * the banner BLOCK was built — but multiple hook return paths returned
+ * `undefined` (zero-match cases), so the banner block was silently dropped
+ * AND the flag was flipped, suppressing all subsequent attempts. Now the
+ * flag flips ONLY when a return path actually includes the block in its
+ * `prependContext`, via the `markBannerDelivered()` closure.
+ */
+let stagingBannerShown = false;
+/**
+ * 3.3.4-rc.1 — operator-facing "this is an RC build" log fires once per
+ * gateway process, independent of whether the user-facing banner has
+ * been delivered yet. Without this split, the warn-log was tied to the
+ * same flag as the user-facing banner and got dropped together when
+ * the hook returned `undefined`.
+ */
+let stagingBannerLogged = false;
 /**
  * Derive keys from the recovery phrase, load credentials, and register with
  * the server if this is the first run.
@@ -514,7 +544,9 @@ let firstRunWelcomeShown = false;
  * directs the caller to `openclaw totalreclaw onboard`.
  */
 async function initialize(logger) {
-    const serverUrl = CONFIG.serverUrl || 'https://api.totalreclaw.xyz';
+    // 3.3.3-rc.1: staging is the source default per #165. Stable build-time
+    // sed-replace flips `api-staging` -> `api` in dist/.
+    const serverUrl = CONFIG.serverUrl || 'https://api-staging.totalreclaw.xyz';
     let masterPassword = CONFIG.recoveryPhrase;
     // 3.2.0: if the env var is unset, probe credentials.json for a
     // pre-existing mnemonic (written either by the CLI wizard on this machine
@@ -2394,26 +2426,63 @@ const plugin = {
                 }
                 // 3.3.1-rc.22 — wire the lazy-embedder runtime config so the first
                 // `generateEmbedding()` call knows where to cache the bundle and
-                // which RC's GitHub Release to fetch from. `pluginVersion` may be
-                // `null` if package.json is unreadable; the embedder defaults to
-                // a "0.0.0-dev" tag in that case.
-                try {
-                    configureEmbedder({
-                        cacheRoot: CONFIG.embedderCachePath,
-                        rcTag: pluginVersion ?? '0.0.0-dev',
-                    });
+                // which RC's GitHub Release to fetch from.
+                //
+                // 3.3.4-rc.1 — when readPluginVersion() returns null (rare, but
+                // possible if package.json is unreadable inside the OpenClaw
+                // sandbox), we previously passed the literal `'0.0.0-dev'` which
+                // resolves to a 404 GitHub Release URL. Now we let `embedding.ts`
+                // fall back to its `LAST_KNOWN_GOOD_RC_TAG` constant by SKIPPING
+                // the configure call entirely in the null case — the
+                // `activeRuntimeConfig()` helper picks the constant up. This way
+                // the constant lives in one place (embedding.ts) and the orch-
+                // estrator just doesn't fight it.
+                if (pluginVersion) {
+                    try {
+                        configureEmbedder({
+                            cacheRoot: CONFIG.embedderCachePath,
+                            rcTag: pluginVersion,
+                        });
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        api.logger.warn(`TotalReclaw: configureEmbedder failed (will use defaults): ${msg}`);
+                    }
                 }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    api.logger.warn(`TotalReclaw: configureEmbedder failed (will use defaults): ${msg}`);
+                else {
+                    api.logger.warn('TotalReclaw: pluginVersion unresolved — embedder will fall back to LAST_KNOWN_GOOD_RC_TAG. ' +
+                        'Investigate package.json resolution; see fs-helpers.readPluginVersion docs.');
+                }
+                // 3.3.3-rc.1 (issue #187 — ONNX decouple): kick off a non-blocking
+                // bundle prefetch so the ~700 MB embedder tarball starts streaming
+                // as soon as the gateway boots, BEFORE the user completes
+                // `totalreclaw_pair`. Decouples the model download from the
+                // pair-completion gate the previous flow imposed via
+                // `requireFullSetup()` -> first `generateEmbedding()` call.
+                // Fire-and-forget — never awaits, never throws on failure (the next
+                // `generateEmbedding()` call retries via the same idempotent path).
+                // Disabled when `TOTALRECLAW_DISABLE_EMBEDDER_PREFETCH=1` (CI / tests
+                // where the network is sandboxed away). The env read lives in
+                // config.ts; we read the resolved CONFIG flag here so this file
+                // stays scanner-clean (no env lookups in index.ts).
+                if (!CONFIG.embedderPrefetchDisabled) {
+                    prefetchEmbedderBundle({ log: (msg) => api.logger.info(msg) })
+                        .then((result) => {
+                        api.logger.info(`TotalReclaw: embedder prefetch ${result === 'fetched' ? 'completed (downloaded bundle)' : 'cache hit'}`);
+                    })
+                        .catch((err) => {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        api.logger.warn(`TotalReclaw: embedder prefetch failed (non-fatal — will retry on first generateEmbedding): ${msg}`);
+                    });
                 }
                 // 3.3.1-rc.22 (rc.21 finding #5): self-heal partial-install marker.
-                // The `preinstall` npm script writes `.tr-partial-install`; the
-                // `postinstall` script removes it on a successful install. If we
-                // have gotten this far the loader did register us — meaning the
-                // install succeeded enough to be useful — so any lingering marker
-                // (e.g. npm ran preinstall but postinstall misfired) is stale.
-                // Clear it so the next retry's detector does not see a false positive.
+                // The `preinstall` npm script writes `.tr-partial-install`; clearing
+                // it has been the runtime's job since 3.3.3-rc.1 dropped postinstall.mjs
+                // (OpenClaw scanner blocked the install on the subprocess-spawn import
+                // — see 3.3.3-rc.1 PR). If we have gotten this far the loader did
+                // register us — meaning the install succeeded enough to be useful —
+                // so any lingering marker is stale. Clear it so the next retry's
+                // detector does not see a false positive.
                 //
                 // 3.3.1-rc.22 (rc.21 finding #6) — gateway/reload upstream caveat:
                 // OpenClaw's config-watcher fires `gateway/reload` when
@@ -2537,11 +2606,36 @@ const plugin = {
                     });
                     // 3.3.0 — `openclaw totalreclaw pair [generate|import]` attaches
                     // alongside the existing `onboard` + `status` subcommands.
+                    //
+                    // 3.3.4-rc.1 — wire `runRelayPairCli` so the CLI defaults to the
+                    // same relay-brokered URL surface the agent tool uses. The local
+                    // (gateway-loopback) flow is still available via `--local`. See
+                    // pair-cli.ts header for the rationale.
                     const { registerPairCli } = await import('./pair-cli.js');
                     registerPairCli(program, {
                         sessionsPath: CONFIG.pairSessionsPath,
                         renderPairingUrl: (session) => buildPairingUrl(api, session),
                         logger: api.logger,
+                        runRelayPairCli: async (cliMode, runOpts) => {
+                            const { runRelayPairCli } = await import('./pair-cli-relay.js');
+                            return runRelayPairCli(cliMode, {
+                                relayBaseUrl: CONFIG.pairRelayUrl,
+                                credentialsPath: CREDENTIALS_PATH,
+                                onboardingStatePath: CONFIG.onboardingStatePath,
+                                logger: api.logger,
+                                pluginVersion: pluginVersion ?? '3.3.4-rc.1',
+                                deriveScopeAddress: async (mnemonic) => {
+                                    try {
+                                        return await deriveSmartAccountAddress(mnemonic, CONFIG.chainId);
+                                    }
+                                    catch (err) {
+                                        api.logger.warn(`relay pair-cli: scope-address derivation failed (will retry lazily): ${err instanceof Error ? err.message : String(err)}`);
+                                        return undefined;
+                                    }
+                                },
+                                ...runOpts,
+                            });
+                        },
                     });
                 }, { commands: ['totalreclaw'] });
             }
@@ -3509,6 +3603,114 @@ const plugin = {
                 },
             }, { name: 'totalreclaw_status' });
             // ---------------------------------------------------------------
+            // Tool: totalreclaw_preload_embedder (3.3.3-rc.1 — issue #187)
+            // ---------------------------------------------------------------
+            //
+            // Decouples the ~700 MB embedder bundle download from the pair-
+            // completion gate. The agent can call this BEFORE
+            // `totalreclaw_pair` to pre-flight disk space, kick off the
+            // download, and surface the completion state. The non-blocking
+            // prefetch in `register()` already starts the download
+            // unconditionally; this tool is an explicit on-demand hook for
+            // agents that want to confirm completion (or trigger a retry on
+            // network failure) without first completing pair.
+            //
+            // Behavior:
+            //   - Disk-space pre-flight: refuses if free disk < 500 MB on the
+            //     embedder cache mount. Surfaces the path + free bytes so the
+            //     user can clear space.
+            //   - Triggers `prefetchEmbedderBundle()` (idempotent — cache hit
+            //     returns immediately).
+            //   - Returns a structured success message with status:
+            //     `cache_hit | fetched | failed`.
+            //
+            // Phrase-safety: this tool does NOT touch credentials.json,
+            // mnemonics, or keys. It only touches `~/.totalreclaw/embedder/`
+            // and the GitHub Releases CDN.
+            api.registerTool({
+                name: 'totalreclaw_preload_embedder',
+                label: 'Preload Embedder',
+                description: 'Download the local-embedding model bundle ahead of pair completion. Use this when the user wants to set up TotalReclaw on a slow connection or run an offline-after-setup workflow. Returns success once the ~700 MB bundle is cached at ~/.totalreclaw/embedder/.',
+                parameters: {
+                    type: 'object',
+                    properties: {},
+                    additionalProperties: false,
+                },
+                async execute() {
+                    try {
+                        // Disk-space pre-flight: refuse if < 500 MB free on the
+                        // embedder cache mount. Best-effort — if statfs fails, we
+                        // proceed without the pre-flight rather than blocking.
+                        const fsModule = await import('node:fs');
+                        const cacheRoot = CONFIG.embedderCachePath;
+                        const REQUIRED_BYTES = 500 * 1024 * 1024;
+                        try {
+                            // Find the deepest existing parent so statfs has a real
+                            // mount to measure (loadEmbedder will mkdir under it
+                            // anyway).
+                            let probeDir = cacheRoot;
+                            while (true) {
+                                try {
+                                    fsModule.statSync(probeDir);
+                                    break;
+                                }
+                                catch {
+                                    const parent = nodePath.dirname(probeDir);
+                                    if (parent === probeDir)
+                                        break;
+                                    probeDir = parent;
+                                }
+                            }
+                            const stats = fsModule.statfsSync?.(probeDir);
+                            if (stats) {
+                                const bavail = typeof stats.bavail === 'bigint' ? Number(stats.bavail) : stats.bavail;
+                                const bsize = typeof stats.bsize === 'bigint' ? Number(stats.bsize) : stats.bsize;
+                                const freeBytes = bavail * bsize;
+                                if (freeBytes > 0 && freeBytes < REQUIRED_BYTES) {
+                                    const freeMb = Math.round(freeBytes / (1024 * 1024));
+                                    return {
+                                        content: [{
+                                                type: 'text',
+                                                text: `Insufficient free disk space for embedder bundle. Required: 500 MB. Available at ${probeDir}: ${freeMb} MB. Free up space and retry.`,
+                                            }],
+                                        details: { status: 'failed', reason: 'disk_space', free_mb: freeMb, required_mb: 500, cache_root: cacheRoot },
+                                    };
+                                }
+                            }
+                        }
+                        catch {
+                            // statfs probe failed — surface a soft warning in logs
+                            // but proceed with the download anyway.
+                            api.logger.info('totalreclaw_preload_embedder: disk-space probe unavailable, proceeding without pre-flight');
+                        }
+                        // Trigger the prefetch. This is idempotent (cache hit returns
+                        // immediately) so it's safe to invoke even when the
+                        // background prefetch from register() already completed.
+                        const result = await prefetchEmbedderBundle({
+                            log: (msg) => api.logger.info(msg),
+                        });
+                        const human = result === 'fetched'
+                            ? `Embedder bundle downloaded and cached at ${cacheRoot}. Subsequent embedding calls run in-memory.`
+                            : `Embedder bundle already cached at ${cacheRoot} — no download needed.`;
+                        return {
+                            content: [{ type: 'text', text: human }],
+                            details: { status: result, cache_root: cacheRoot },
+                        };
+                    }
+                    catch (err) {
+                        const message = err instanceof Error ? err.message : String(err);
+                        api.logger.error(`totalreclaw_preload_embedder failed: ${message}`);
+                        return {
+                            content: [{
+                                    type: 'text',
+                                    text: `Embedder bundle preload failed: ${humanizeError(message)}. The plugin will retry on first embedding call.`,
+                                }],
+                            details: { status: 'failed', reason: 'fetch_error', message },
+                        };
+                    }
+                },
+            }, { name: 'totalreclaw_preload_embedder' });
+            // ---------------------------------------------------------------
             // Tool: totalreclaw_consolidate
             // ---------------------------------------------------------------
             api.registerTool({
@@ -4840,6 +5042,84 @@ const plugin = {
                     if (!evt?.prompt || evt.prompt.length < 5) {
                         return undefined;
                     }
+                    // 3.3.3-rc.1 — RC-staging banner (PR #165 implementation).
+                    // Build a one-shot prefix when the bundled default points at staging
+                    // AND the user hasn't overridden via env. This prefix is prepended
+                    // to whichever context block the rest of the hook produces.
+                    //
+                    // 3.3.4-rc.1 — fix: previously `stagingBannerShown` was set to
+                    // `true` AS SOON AS the block was built. If the rest of the hook
+                    // then returned `undefined` (e.g. zero memory matches on the first
+                    // turn — multiple paths around lines 6103-6325 do this), the
+                    // banner block was silently discarded AND the flag was already
+                    // flipped, so subsequent before_agent_start invocations never
+                    // reconstructed it. Net effect: QA on 3.3.3-rc.1 (Pedro
+                    // 2026-04-30) saw NO banner emitted across an entire conversation
+                    // even though the build was bound to staging.
+                    //
+                    // Fix: build the block on every call until it is actually
+                    // delivered (i.e., until at least one return path included it
+                    // in `prependContext`). The flag flips at the bottom of this
+                    // hook in `markBannerDelivered()` once we know the prependContext
+                    // path was taken.
+                    let stagingBannerBlock = '';
+                    let stagingBannerSuppressed = false;
+                    if (!stagingBannerShown) {
+                        try {
+                            const usingStagingDefault = CONFIG.serverUrl.includes('api-staging.totalreclaw.xyz');
+                            const userOverrode = CONFIG.serverUrlEnvOverridden;
+                            if (usingStagingDefault && !userOverrode) {
+                                stagingBannerBlock =
+                                    '## ⚠️ TotalReclaw is running in RC / staging mode\n\n' +
+                                        'This build is bound to `api-staging.totalreclaw.xyz`. Staging has **no SLA** ' +
+                                        'and may be wiped between QA cycles. Do **NOT** use this build for real data.\n\n' +
+                                        'For production, install the stable release: `openclaw plugins install ' +
+                                        '@totalreclaw/totalreclaw` (no `@rc` suffix). To pin a custom server, set ' +
+                                        '`TOTALRECLAW_SERVER_URL=https://api.totalreclaw.xyz` in your env.\n\n';
+                                // Do NOT set stagingBannerShown=true here — see comment above.
+                                // Logger emits once per gateway process; this is fine to
+                                // gate on the same flag because the logger is operator-
+                                // facing, not user-facing.
+                                stagingBannerSuppressed = true;
+                            }
+                            else {
+                                // Non-RC artifact OR user override — never fire the banner this
+                                // gateway-process lifetime.
+                                stagingBannerShown = true;
+                            }
+                        }
+                        catch {
+                            // Best-effort; never block session start on banner derivation.
+                            stagingBannerShown = true;
+                        }
+                    }
+                    // Operator-facing log: once per process, when we DETECT the
+                    // staging build (banner-shown semantics are about user
+                    // delivery; this log is independent).
+                    if (stagingBannerSuppressed && !stagingBannerLogged) {
+                        stagingBannerLogged = true;
+                        api.logger.warn('TotalReclaw: RC/staging build active (api-staging.totalreclaw.xyz). ' +
+                            'See docs/guides/release-process.md for the RC=staging / stable=production rule.');
+                    }
+                    /**
+                     * Helper — invoked inline at any `prependContext` site that
+                     * wants to lead with the staging banner. Returns the banner
+                     * string AND atomically marks the banner as delivered, so
+                     * subsequent hook calls in the same gateway-process lifetime
+                     * skip re-emission. Returns '' (empty) when no banner is due
+                     * (stable build, user override, or already delivered).
+                     *
+                     * Use this at every prependContext callsite that takes the
+                     * banner; do NOT inline `stagingBannerBlock` on its own — the
+                     * 3.3.4-rc.1 bug fix requires the marker flip to be coupled
+                     * to the actual delivery.
+                     */
+                    const consumeBannerForPrepend = () => {
+                        if (stagingBannerBlock === '')
+                            return '';
+                        stagingBannerShown = true;
+                        return stagingBannerBlock;
+                    };
                     await ensureInitialized(api.logger);
                     // 3.2.0 onboarding pending: emit a non-secret guidance banner so
                     // the LLM knows how to respond when the user asks about setup.
@@ -4868,7 +5148,8 @@ const plugin = {
                             api.logger.warn(`First-run welcome check failed: ${msg}`);
                         }
                         return {
-                            prependContext: welcomeBlock +
+                            prependContext: consumeBannerForPrepend() +
+                                welcomeBlock +
                                 '## TotalReclaw setup pending\n\n' +
                                 'TotalReclaw encrypted memory is installed but not yet set up on this machine. ' +
                                 'If the user asks about memory features or wants to configure TotalReclaw, ' +
@@ -4966,7 +5247,8 @@ const plugin = {
                                 if (injectResult.promptText) {
                                     api.logger.info(`Digest injection: state=${injectResult.state}`);
                                     return {
-                                        prependContext: `## Your Memory\n\n${injectResult.promptText}` + welcomeBack + billingWarning,
+                                        prependContext: consumeBannerForPrepend() +
+                                            `## Your Memory\n\n${injectResult.promptText}` + welcomeBack + billingWarning,
                                     };
                                 }
                             }
@@ -5007,7 +5289,7 @@ const plugin = {
                             const querySimilarity = cosineSimilarity(queryEmbedding, lastQueryEmbedding);
                             if (querySimilarity > SEMANTIC_SKIP_THRESHOLD) {
                                 const lines = cachedFacts.slice(0, 8).map((f, i) => `${i + 1}. ${f.text} (importance: ${f.importance}/10, cached)`);
-                                return { prependContext: `## Relevant Memories\n\n${lines.join('\n')}` + welcomeBack + billingWarning };
+                                return { prependContext: consumeBannerForPrepend() + `## Relevant Memories\n\n${lines.join('\n')}` + welcomeBack + billingWarning };
                             }
                         }
                         // 3. Merge trapdoors — always include word trapdoors for small-dataset coverage.
@@ -5016,7 +5298,7 @@ const plugin = {
                         // If we have cached facts and no trapdoors, return cached facts.
                         if (allTrapdoors.length === 0 && cachedFacts.length > 0) {
                             const lines = cachedFacts.slice(0, 8).map((f, i) => `${i + 1}. ${f.text} (importance: ${f.importance}/10, cached)`);
-                            return { prependContext: `## Relevant Memories\n\n${lines.join('\n')}` + welcomeBack + billingWarning };
+                            return { prependContext: consumeBannerForPrepend() + `## Relevant Memories\n\n${lines.join('\n')}` + welcomeBack + billingWarning };
                         }
                         if (allTrapdoors.length === 0)
                             return undefined;
@@ -5031,7 +5313,7 @@ const plugin = {
                             // Subgraph query failed -- fall back to cached facts if available.
                             if (cachedFacts.length > 0) {
                                 const lines = cachedFacts.slice(0, 8).map((f, i) => `${i + 1}. ${f.text} (importance: ${f.importance}/10, cached)`);
-                                return { prependContext: `## Relevant Memories\n\n${lines.join('\n')}` + welcomeBack + billingWarning };
+                                return { prependContext: consumeBannerForPrepend() + `## Relevant Memories\n\n${lines.join('\n')}` + welcomeBack + billingWarning };
                             }
                             return undefined;
                         }
@@ -5055,7 +5337,7 @@ const plugin = {
                         // If subgraph returned no results but we have cache, use cache.
                         if (subgraphResults.length === 0) {
                             const lines = cachedFacts.slice(0, 8).map((f, i) => `${i + 1}. ${f.text} (importance: ${f.importance}/10, cached)`);
-                            return { prependContext: `## Relevant Memories\n\n${lines.join('\n')}` + welcomeBack + billingWarning };
+                            return { prependContext: consumeBannerForPrepend() + `## Relevant Memories\n\n${lines.join('\n')}` + welcomeBack + billingWarning };
                         }
                         // 5. Decrypt subgraph results and build reranker input.
                         const rerankerCandidates = [];
@@ -5130,7 +5412,7 @@ const plugin = {
                             return `${i + 1}. ${typeTag}${m.text} (importance: ${importance}/10, ${age})`;
                         });
                         const contextString = `## Relevant Memories\n\n${lines.join('\n')}`;
-                        return { prependContext: contextString + welcomeBack + billingWarning };
+                        return { prependContext: consumeBannerForPrepend() + contextString + welcomeBack + billingWarning };
                     }
                     // --- Server mode (existing behavior) ---
                     // 1. Generate word trapdoors from the user prompt.
@@ -5212,7 +5494,7 @@ const plugin = {
                         return `${i + 1}. ${m.text} (importance: ${importance}/10, ${age})`;
                     });
                     const contextString = `## Relevant Memories\n\n${lines.join('\n')}`;
-                    return { prependContext: contextString + welcomeBack + billingWarning };
+                    return { prependContext: consumeBannerForPrepend() + contextString + welcomeBack + billingWarning };
                 }
                 catch (err) {
                     // The hook must NEVER throw -- log and return undefined.

package/dist/llm-client.js

@@ -684,4 +684,6 @@ async function chatCompletionAnthropic(config, messages, maxTokens, temperature,
 // (Harrier-OSS-v1-270M ONNX model). No API key needed. The native deps +
 // model are lazy-fetched from a pinned GitHub Release on first call —
 // see embedding.ts + embedder-loader.ts.
-export { generateEmbedding, getEmbeddingDims, getEmbeddingModelId, configureEmbedder } from './embedding.js';
+export { generateEmbedding, getEmbeddingDims, getEmbeddingModelId, configureEmbedder, 
+// 3.3.3-rc.1 (#187): pre-pair bundle prefetch
+prefetchEmbedderBundle, } from './embedding.js';