diff --git a/arch-doc/unload-remote-proposal.md b/arch-doc/unload-remote-proposal.md
new file mode 100644
index 00000000000..1e5ed2cc197
--- /dev/null
+++ b/arch-doc/unload-remote-proposal.md
@@ -0,0 +1,223 @@
+# Proposal: `unloadRemote` API (runtime / runtime-core)
+
+> Scope: **design only** (phase-1). No implementation in this change.
+> Context: https://github.com/module-federation/core/discussions/4566
+
+## Problem
+
+In SSR/Node environments, `registerRemotes(remotes, { force: true })` currently calls an internal `removeRemote`, but it does not fully clean up global/runtime caches and side-effects created by prior remote loads.
+
+Typical symptoms:
+
+- Global caches keep growing across re-registers (e.g. `globalThis.__FEDERATION__.__MANIFEST_LOADING__`, `globalThis.__FEDERATION__.moduleInfo` snapshot entries).
+- Long-lived host processes (SSR servers, Node runtimes) can accumulate stale references and leak memory.
+
+This proposal introduces a dedicated `unloadRemote` API with an explicit contract and coverage list.
+
+## Goals
+
+- Provide a **first-class, observable** remote unload capability.
+- Cover **all** runtime-owned caches and global side-effects that can be safely removed.
+- Define behavior for SSR/Node vs Browser.
+- Provide a migration path from `registerRemotes({ force: true })` and the existing internal `removeRemote`.
+
+Non-goals (phase-1):
+
+- Implementing full unload logic.
+- Solving every possible leak caused by user-land references (e.g. app-level singletons holding onto exposed modules).
+
+## API Shape
+
+### Primary API
+
+Add a new method on `ModuleFederation`:
+
+```ts
+type UnloadRemoteTarget =
+  | string // remote name or alias
+  | { name: string; entry?: string; version?: string; scope?: string };
+
+type UnloadRemoteOptions = {
+  /**
+   * If true, tries to unload even if runtime detects active consumption.
+   * Default: false.
+   */
+  force?: boolean;
+
+  /**
+   * If true, removes global snapshot/manifest records.
+   * Default: true.
+   */
+  purgeSnapshot?: boolean;
+
+  /**
+   * If true, removes global share entries that were contributed by the remote.
+   * Default: "auto" (remove only if not used by other hosts/remotes).
+   */
+  purgeShareScope?: boolean | 'auto';
+
+  /**
+   * For SSR/Node only: attempt to drop Node-module / VM cached artifacts if possible.
+   * Default: false (best-effort only, no hard guarantees).
+   */
+  purgeNodeModuleCache?: boolean;
+
+  /**
+   * Abort ongoing load/unload operations.
+   */
+  signal?: AbortSignal;
+};
+
+type UnloadRemoteResult = {
+  target: { name: string; resolvedEntry?: string; resolvedKey?: string };
+  removed: {
+    // Runtime-owned caches
+    moduleCache: boolean;
+    globalLoading: boolean;
+    manifestCache: boolean;
+    manifestLoading: boolean;
+    snapshot: boolean;
+    instances: boolean;
+    shareScope: boolean;
+    preloadedMap: boolean;
+    globalEntryExport: boolean;
+  };
+  warnings: string[];
+};
+
+unloadRemote(target: UnloadRemoteTarget, options?: UnloadRemoteOptions): Promise<UnloadRemoteResult>;
+```
+
+Rationale (async):
+
+- In Node/SSR, unload may involve waiting on in-flight loads, plugin hooks, or async fetches.
+- Async allows future hooks like `beforeUnloadRemote` / `afterUnloadRemote`.
+
+### Optional convenience API
+
+Provide a static-ish helper for multiple remotes:
+
+```ts
+unloadRemotes(targets: UnloadRemoteTarget[], options?: UnloadRemoteOptions): Promise<UnloadRemoteResult[]>;
+```
+
+## What needs to be unloaded
+
+The list below defines the **minimum** coverage for correctness in long-lived processes.
+
+### Runtime-core / runtime owned caches
+
+- **Host instance remotes list**
+  - Remove the remote entry from `host.options.remotes` (name match, plus alias handling).
+
+- **Per-host module cache**
+  - Remove `host.moduleCache.get(remoteName)`.
+
+- **Global remote-entry loading registry**
+  - Remove `globalThis.__GLOBAL_LOADING_REMOTE_ENTRY__[compose(name, entry)]`.
+  - Also consider cleaning any alias-derived keys if the runtime creates them.
+
+- **Snapshot / Manifest caches**
+  - Per-host manifest cache: `host.snapshotHandler.manifestCache`.
+  - Global manifest loading registry: `globalThis.__FEDERATION__.__MANIFEST_LOADING__`.
+  - Global snapshot registry: `globalThis.__FEDERATION__.moduleInfo` entries for:
+    - `remoteName:remoteEntry` (manifest URL case)
+    - `remoteName:version` (version-based case)
+    - Host snapshot remotesInfo entry pointing to this remote
+
+- **Global instances list**
+  - Remove the remote instance from `globalThis.__FEDERATION__.__INSTANCES__` if it belongs to the unloaded remote.
+
+- **Global share scope map**
+  - Remove shared entries that were **contributed by this remote** and are not used by others.
+  - For `force: true`, allow dropping even if `useIn` indicates usage (with warnings).
+
+- **Preload records**
+  - Clear `globalThis.__FEDERATION__.__PRELOADED_MAP__` entries that are scoped to the remote.
+  - If there is no stable remote-scoped keying, do not over-delete; record warnings.
+
+### Global side-effects created by remote entry
+
+- **Remote entry exports on globalThis**
+  - Remove or nullify `globalThis[remoteInfo.entryGlobalName]` (browser global container pattern).
+  - If not configurable, set `undefined` as a fallback.
+
+### Browser vs Node differences
+
+- Browser
+  - Script/link DOM nodes might have been created and remain attached.
+  - If runtime can track created elements (recommended via loader hook), it can remove them.
+  - Without tracking, **do not** try to scan/remove arbitrary `<script>` tags.
+
+- Node/SSR
+  - Remote entry may be evaluated in a `vm` context or via dynamic import.
+  - Node module cache / ESM module registry is not reliably mutable across all loaders.
+  - Provide only **best-effort** cleanup behind `purgeNodeModuleCache` (default false), and report warnings.
+
+## Hooks (optional but recommended)
+
+Introduce plugin hooks to let integrators clean their own caches:
+
+```ts
+beforeUnloadRemote: AsyncWaterfallHook<{ target; options; origin }>
+afterUnloadRemote: AsyncHook<[ { result; origin } ]>
+```
+
+This avoids hardcoding framework-specific caches in core.
+
+## Relationship with `registerRemotes({ force: true })` and `removeRemote`
+
+### Current behavior
+
+- `registerRemotes(..., { force: true })` calls a private `removeRemote(remote)`.
+- `removeRemote` is currently incomplete for SSR/Node and is not an explicit public contract.
+
+### Proposed migration
+
+1. Introduce public `unloadRemote`.
+2. Refactor internal `removeRemote` to call `unloadRemote` (or share the same internal implementation).
+3. Update `registerRemotes(..., { force: true })` to:
+   - `await unloadRemote(target, { purgeSnapshot: true, purgeShareScope: 'auto', ... })`
+   - then register the new remote.
+4. Keep `force: true` behavior for backward compatibility, but make it **correct** by delegating to `unloadRemote`.
+
+## Risks & Compatibility
+
+### Unloading consumed modules
+
+- If an exposed module has been imported and retained by user code, unloading runtime caches does not revoke those references.
+- For webpack-style module factories, the module may also be cached in the bundler's module cache.
+- Recommendation:
+  - Default `force: false` should be conservative and warn/refuse when it can detect active consumption.
+  - `force: true` should proceed but return warnings.
+
+### Concurrent load/unload
+
+- There can be in-flight `loadRemote`/`getRemoteEntry`/manifest fetch.
+- The unload implementation should guard via:
+  - per-remote mutex/lock in runtime
+  - `AbortSignal` propagation where supported
+  - idempotency (double-unload is OK)
+
+### Share scope state
+
+- Share scope is global; deleting entries can break other remotes/hosts.
+- The default should be `'auto'` cleanup:
+  - Only delete shared entries that:
+    - were contributed by this remote (`from === remoteName`)
+    - and are not used elsewhere (`useIn` empty)
+  - Never delete host-owned share entries.
+
+### Webpack module cache / VM context
+
+- Webpack runtime caches are not uniformly accessible from this library.
+- Node `vm` evaluation can leave references in closures.
+- Provide best-effort optional cleanup, but document that full GC is not guaranteed.
+
+## Acceptance criteria (for future implementation)
+
+- A Node/SSR regression test shows that after `registerRemotes(...,{force:true})` and re-load:
+  - `globalThis.__FEDERATION__.__MANIFEST_LOADING__` does not grow.
+  - `globalThis.__FEDERATION__.moduleInfo` does not retain prior remote snapshot entries.
+  - `host.moduleCache` does not retain the removed remote.
+
diff --git a/packages/runtime-core/__tests__/register-remotes-force-ssr-leak.spec.ts b/packages/runtime-core/__tests__/register-remotes-force-ssr-leak.spec.ts
new file mode 100644
index 00000000000..5909e0a8794
--- /dev/null
+++ b/packages/runtime-core/__tests__/register-remotes-force-ssr-leak.spec.ts
@@ -0,0 +1,193 @@
+// @vitest-environment node
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { ModuleFederation } from '../src/index';
+import { resetFederationGlobalInfo } from '../src/global';
+
+/**
+ * Repro for https://github.com/module-federation/core/discussions/4566
+ *
+ * In Node/SSR, `registerRemotes(..., { force: true })` calls `removeRemote`,
+ * but it does NOT fully clean up global caches (notably
+ * `globalThis.__FEDERATION__.__MANIFEST_LOADING__` and snapshot entries under
+ * `globalThis.__FEDERATION__.moduleInfo`).
+ *
+ * This test asserts on deterministic internal structures instead of
+ * `process.memoryUsage()`.
+ */
+
+type MinimalManifest = {
+  metaData: Record<string, any>;
+  exposes: Array<{ name: string; path: string; assets: Array<any> }>;
+  shared: Array<{ name: string; version: string; assets?: Array<any> }>;
+};
+
+function makeManifest(opts: {
+  name: string;
+  remoteEntryBase: string;
+  ssrRemoteEntryBase?: string;
+}): MinimalManifest {
+  // Minimal shape for `packages/sdk/src/generateSnapshotFromManifest.ts`.
+  // Also satisfies runtime-core's SnapshotHandler assertions:
+  // `metaData`, `exposes`, `shared` must exist.
+  return {
+    metaData: {
+      name: opts.name,
+      globalName: opts.name,
+      buildInfo: { buildVersion: 'test-build' },
+      remoteEntry: {
+        path: opts.remoteEntryBase,
+        name: 'remoteEntry.js',
+        type: 'global',
+      },
+      ...(opts.ssrRemoteEntryBase
+        ? {
+            ssrRemoteEntry: {
+              path: opts.ssrRemoteEntryBase,
+              name: 'remoteEntry.ssr.js',
+              type: 'commonjs-module',
+            },
+          }
+        : {}),
+    },
+    exposes: [
+      {
+        name: './noop',
+        path: './noop',
+        assets: [],
+      },
+    ],
+    shared: [],
+  };
+}
+
+describe('registerRemotes(force:true) SSR/Node leak repro', () => {
+  const hostName = '@register-remotes-force/host';
+  const remoteName = '@register-remotes-force/remote';
+
+  const manifestV1 =
+    'http://localhost:1111/resources/ssr-leak/remote/v1/manifest.json';
+  const manifestV2 =
+    'http://localhost:1111/resources/ssr-leak/remote/v2/manifest.json';
+
+  beforeEach(() => {
+    resetFederationGlobalInfo();
+
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async (input: RequestInfo | URL) => {
+        const url = String(input);
+        if (url === manifestV1) {
+          return new Response(
+            JSON.stringify(
+              makeManifest({
+                name: remoteName,
+                remoteEntryBase:
+                  'http://localhost:1111/resources/ssr-leak/remote/v1/',
+              }),
+            ),
+            {
+              status: 200,
+              headers: { 'content-type': 'application/json' },
+            },
+          );
+        }
+        if (url === manifestV2) {
+          return new Response(
+            JSON.stringify(
+              makeManifest({
+                name: remoteName,
+                remoteEntryBase:
+                  'http://localhost:1111/resources/ssr-leak/remote/v2/',
+              }),
+            ),
+            {
+              status: 200,
+              headers: { 'content-type': 'application/json' },
+            },
+          );
+        }
+        return new Response('not found', { status: 404 });
+      }),
+    );
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('leaks global manifest/snapshot cache entries when re-registering same remote with different manifest entry', async () => {
+    const FM = new ModuleFederation({
+      name: hostName,
+      version: '0.0.0-test',
+      remotes: [
+        {
+          name: remoteName,
+          entry: manifestV1,
+          // Ensure snapshot plugin runs (manifest URL => not a pure remoteEntry).
+          type: 'global',
+        },
+      ],
+    });
+
+    // Ensure `removeRemote` takes the loaded path.
+    FM.initRawContainer(remoteName, manifestV1, {
+      // minimal container shape
+      init: () => void 0,
+      get: () => () => ({}),
+    } as any);
+
+    // 1) First load snapshot (populates global manifest loading + global snapshot entries).
+    await FM.snapshotHandler.loadRemoteSnapshotInfo({
+      moduleInfo: FM.options.remotes[0],
+    });
+
+    const manifestLoading1 = Object.keys(
+      globalThis.__FEDERATION__.__MANIFEST_LOADING__,
+    );
+    const remoteSnapshotKeys1 = Object.keys(
+      globalThis.__FEDERATION__.moduleInfo,
+    )
+      .filter((k) => k.startsWith(`${remoteName}:`))
+      .sort();
+
+    expect(manifestLoading1.sort()).toEqual([manifestV1]);
+    expect(remoteSnapshotKeys1).toEqual([`${remoteName}:${manifestV1}`]);
+
+    // 2) Force re-register same remote name but different manifest URL.
+    FM.registerRemotes(
+      [
+        {
+          name: remoteName,
+          entry: manifestV2,
+          type: 'global',
+        },
+      ],
+      { force: true },
+    );
+
+    // 3) Load snapshot again (creates NEW global entries keyed by manifestV2).
+    const nextRemote = FM.options.remotes.find((r) => r.name === remoteName);
+    expect(nextRemote).toBeTruthy();
+    await FM.snapshotHandler.loadRemoteSnapshotInfo({
+      moduleInfo: nextRemote!,
+    });
+
+    const manifestLoading2 = Object.keys(
+      globalThis.__FEDERATION__.__MANIFEST_LOADING__,
+    ).sort();
+    const remoteSnapshotKeys2 = Object.keys(
+      globalThis.__FEDERATION__.moduleInfo,
+    )
+      .filter((k) => k.startsWith(`${remoteName}:`))
+      .sort();
+
+    // Current (buggy) behavior: old manifest & snapshot entries are retained.
+    // Expected (fixed) behavior: only manifestV2 should remain.
+    expect(manifestLoading2).toEqual([manifestV1, manifestV2]);
+    expect(remoteSnapshotKeys2).toEqual([
+      `${remoteName}:${manifestV1}`,
+      `${remoteName}:${manifestV2}`,
+    ]);
+  });
+});
diff --git a/packages/runtime-core/__tests__/setup.ts b/packages/runtime-core/__tests__/setup.ts
index 4c7f9efcca8..d5196340c8c 100644
--- a/packages/runtime-core/__tests__/setup.ts
+++ b/packages/runtime-core/__tests__/setup.ts
@@ -1,13 +1,18 @@
 import 'whatwg-fetch';
 import { server } from './mock/server';
-import { mockScriptDomResponse } from './mock/mock-script';
 import { requestList } from './mock/env';
 import { resetFederationGlobalInfo } from '../src/global';
 
-mockScriptDomResponse({
-  baseDir: __dirname,
-  baseUrl: 'http://localhost:1111/',
-});
+// Note: runtime-core tests may run in both `jsdom` and `node` environments.
+// The script-DOM mocking module touches `window` at import-time, so we must
+// only import it when a DOM is available.
+if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+  const { mockScriptDomResponse } = await import('./mock/mock-script');
+  mockScriptDomResponse({
+    baseDir: __dirname,
+    baseUrl: 'http://localhost:1111/',
+  });
+}
 
 beforeAll(() => server.listen({ onUnhandledRequest: 'bypass' }));
 afterAll(() => server.close());
diff --git a/packages/runtime-core/scripts/ssr-memory-leak-profile.ts b/packages/runtime-core/scripts/ssr-memory-leak-profile.ts
new file mode 100644
index 00000000000..3598b1603d8
--- /dev/null
+++ b/packages/runtime-core/scripts/ssr-memory-leak-profile.ts
@@ -0,0 +1,239 @@
+/*
+ * Standalone heap profiling script for SSR `registerRemotes({ force: true })`
+ * leak discussed in https://github.com/module-federation/core/discussions/4566.
+ *
+ * This script intentionally bypasses test runners and measures real
+ * `process.memoryUsage().heapUsed` in a Node.js process.
+ *
+ * Usage (from repo root, after building `@module-federation/runtime-core`):
+ *
+ *   # 1) Build runtime-core to generate dist/index.js
+ *   pnpm --filter @module-federation/runtime-core run build
+ *
+ *   # 2) Run this script with Node.js exposed GC (recommended: Node 20)
+ *   NODE_OPTIONS=--expose-gc node \
+ *     packages/runtime-core/scripts/ssr-memory-leak-profile.js
+ */
+
+/* eslint-disable no-console */
+
+// Note: we intentionally import from the built entry so this script can be
+// executed against a regular `pnpm build` output without relying on the
+// package's internal TS sources. This minimizes coupling to ts-node/TS
+// config while still living close to runtime-core.
+//
+// The script itself is not part of the published package exports.
+import { ModuleFederation, resetFederationGlobalInfo } from '../dist/index.js';
+
+type MinimalManifest = {
+  metaData: Record<string, any>;
+  exposes: Array<{ name: string; path: string; assets: Array<any> }>;
+  shared: Array<{ name: string; version: string; assets?: Array<any> }>;
+};
+
+function makeManifestFromUrl(url: string): MinimalManifest {
+  const base = url.replace(/manifest\.json$/, '');
+
+  return {
+    metaData: {
+      name: '@register-remotes-force/remote',
+      globalName: '@register-remotes-force/remote',
+      buildInfo: { buildVersion: 'ssr-memory-leak-profile' },
+      remoteEntry: {
+        path: base,
+        name: 'remoteEntry.js',
+        type: 'global',
+      },
+      ssrRemoteEntry: {
+        path: base,
+        name: 'remoteEntry.ssr.js',
+        type: 'commonjs-module',
+      },
+    },
+    exposes: [
+      {
+        name: './noop',
+        path: './noop',
+        assets: [],
+      },
+    ],
+    shared: [],
+  };
+}
+
+function makeManifestUrl(iteration: number): string {
+  // Each iteration uses a distinct manifest URL so that buggy
+  // `registerRemotes(..., { force: true })` behavior will accumulate
+  // entries under `globalThis.__FEDERATION__.__MANIFEST_LOADING__` and
+  // snapshot keys `globalThis.__FEDERATION__.moduleInfo`.
+  return `http://localhost:1111/resources/ssr-leak/remote/v${iteration}/manifest.json`;
+}
+
+function ensureGC(): void {
+  if (typeof global.gc !== 'function') {
+    // eslint-disable-next-line no-console
+    console.error(
+      '[ssr-memory-leak-profile] global.gc 不可用。请使用 `node --expose-gc`（或设置 NODE_OPTIONS=--expose-gc）运行此脚本。',
+    );
+    throw new Error('global.gc is not available. Run with `node --expose-gc`.');
+  }
+}
+
+function formatMB(bytes: number): string {
+  return (bytes / 1024 / 1024).toFixed(2);
+}
+
+async function runProfile(iterations = 1000): Promise<void> {
+  ensureGC();
+
+  // Reset federation globals so the measurement starts from a clean state.
+  resetFederationGlobalInfo();
+
+  const originalFetch = globalThis.fetch;
+
+  // In Node 20, `fetch` and `Response` are available on the global scope.
+  // We override `fetch` with an in-memory manifest responder so that no
+  // actual HTTP traffic is performed during profiling.
+  globalThis.fetch = (async (input: RequestInfo | URL) => {
+    const url = String(input);
+    const body = JSON.stringify(makeManifestFromUrl(url));
+
+    return new Response(body, {
+      status: 200,
+      headers: { 'content-type': 'application/json' },
+    });
+  }) as typeof fetch;
+
+  try {
+    global.gc();
+    const startHeap = process.memoryUsage().heapUsed;
+
+    const hostName = '@register-remotes-force/host';
+    const remoteName = '@register-remotes-force/remote';
+
+    const initialManifest = makeManifestUrl(0);
+
+    const fm = new ModuleFederation({
+      name: hostName,
+      version: '0.0.0-ssr-memory-leak-profile',
+      remotes: [
+        {
+          name: remoteName,
+          entry: initialManifest,
+          // Ensure snapshot plugin runs (manifest URL => not a pure remoteEntry).
+          type: 'global',
+        },
+      ],
+    });
+
+    // Minimal container to satisfy `initRawContainer` in Node env.
+    fm.initRawContainer(remoteName, initialManifest, {
+      init: () => void 0,
+      get: () => () => ({}),
+    } as any);
+
+    // Seed snapshot / manifest cache for the initial manifest.
+    await fm.snapshotHandler.loadRemoteSnapshotInfo({
+      moduleInfo: fm.options.remotes[0],
+    });
+
+    for (let i = 1; i <= iterations; i += 1) {
+      const manifestUrl = makeManifestUrl(i);
+
+      // 1) Force re-register same remote name but with a new manifest URL.
+      fm.registerRemotes(
+        [
+          {
+            name: remoteName,
+            entry: manifestUrl,
+            type: 'global',
+          },
+        ],
+        { force: true },
+      );
+
+      const nextRemote = fm.options.remotes.find(
+        (r) => r.name === remoteName && r.entry === manifestUrl,
+      );
+
+      if (!nextRemote) {
+        throw new Error(
+          `[ssr-memory-leak-profile] Failed to find remote config for ${manifestUrl} after registerRemotes().`,
+        );
+      }
+
+      // 2) Load snapshot again for the new manifest URL. Under the bug,
+      //    this populates new entries in global manifest/snapshot caches
+      //    without fully cleaning old ones.
+      //
+      //    This is effectively the same pattern as
+      //    `register-remotes-force-ssr-leak.spec.ts`, repeated many times.
+      // eslint-disable-next-line no-await-in-loop
+      await fm.snapshotHandler.loadRemoteSnapshotInfo({
+        moduleInfo: nextRemote,
+      });
+
+      if (i % 100 === 0) {
+        // Provide coarse-grained progress for long runs.
+        // eslint-disable-next-line no-console
+        console.log(
+          `[ssr-memory-leak-profile] Completed ${i}/${iterations} iterations...`,
+        );
+      }
+    }
+
+    global.gc();
+    const endHeap = process.memoryUsage().heapUsed;
+
+    const startMB = formatMB(startHeap);
+    const endMB = formatMB(endHeap);
+    const deltaMB = (endHeap - startHeap) / 1024 / 1024;
+
+    // eslint-disable-next-line no-console
+    console.log('--- SSR registerRemotes({ force: true }) heap profile ---');
+    // eslint-disable-next-line no-console
+    console.log(`Iterations   : ${iterations}`);
+    // eslint-disable-next-line no-console
+    console.log(`Heap before  : ${startMB} MB`);
+    // eslint-disable-next-line no-console
+    console.log(`Heap after   : ${endMB} MB`);
+    // eslint-disable-next-line no-console
+    console.log(`Heap delta   : ${deltaMB.toFixed(2)} MB`);
+
+    const thresholdMB = 5;
+    if (deltaMB > thresholdMB) {
+      throw new Error(
+        `[ssr-memory-leak-profile] Suspected memory leak: heap grew by ${deltaMB.toFixed(
+          2,
+        )} MB (> ${thresholdMB} MB) after forced GC.`,
+      );
+    }
+
+    // eslint-disable-next-line no-console
+    console.log(
+      `[ssr-memory-leak-profile] Heap growth (${deltaMB.toFixed(
+        2,
+      )} MB) is within threshold (${thresholdMB} MB).`,
+    );
+  } finally {
+    // Restore original fetch implementation to avoid polluting the environment
+    // if this script is ever imported (even though it is intended to be
+    // executed as a standalone entrypoint).
+    globalThis.fetch = originalFetch;
+  }
+}
+
+// Allow overriding iteration count via env for quick experiments, e.g.
+//   RUNTIME_CORE_SSR_LEAK_ITERATIONS=200 NODE_OPTIONS=--expose-gc node ...
+const iterationsFromEnv = Number.parseInt(
+  process.env.RUNTIME_CORE_SSR_LEAK_ITERATIONS || '',
+  10,
+);
+
+runProfile(Number.isFinite(iterationsFromEnv) ? iterationsFromEnv : 1000).catch(
+  (err) => {
+    // eslint-disable-next-line no-console
+    console.error('[ssr-memory-leak-profile] Profiling failed:', err);
+    process.exitCode = 1;
+  },
+);