@bleedingdev/modern-js-federation-runtime 3.9.0-ultramodern.9 → 3.9.3-ultramodern.10

package/dist/esm/module-federation/telemetry.mjs

@@ -0,0 +1,142 @@
+const MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT = 'modernjs:mf-runtime-fallback';
+const MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT = 'modernjs:mf-runtime-recovery';
+const DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = '/_modern/contract-gates/runtime-fallback';
+const DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER = 'x-modernjs-runtime-signal-token';
+class ModuleFederationRemoteLoadTimeoutError extends Error {
+    constructor(remote, timeoutMs){
+        super(`Loading remote "${remote}" timed out after ${timeoutMs}ms`);
+        this.name = 'ModuleFederationRemoteLoadTimeoutError';
+    }
+}
+class ModuleFederationRemoteLoadError extends Error {
+    constructor(remote, attempts, causeError){
+        super(`Unable to load remote "${remote}" after ${attempts} attempt${attempts > 1 ? 's' : ''}: ${causeError.message}`);
+        this.name = 'ModuleFederationRemoteLoadError';
+        this.remote = remote;
+        this.attempts = attempts;
+        this.causeError = causeError;
+    }
+}
+class ModuleFederationRemoteComponentContractError extends Error {
+    constructor(remote, exportName){
+        super(`Remote "${remote}" export "${exportName}" is not a valid React component`);
+        this.name = 'ModuleFederationRemoteComponentContractError';
+    }
+}
+function toError(error) {
+    if (error instanceof Error) return error;
+    return new Error('string' == typeof error ? error : 'Unknown remote load error');
+}
+function classifyModuleFederationFallback(error) {
+    const normalizedError = toError(error);
+    if (normalizedError instanceof ModuleFederationRemoteLoadError) return classifyModuleFederationFallback(normalizedError.causeError);
+    if (normalizedError instanceof ModuleFederationRemoteLoadTimeoutError) return 'timeout';
+    if (normalizedError instanceof ModuleFederationRemoteComponentContractError) return 'contract';
+    const message = normalizedError.message;
+    if (/version|requiredVersion|singleton|share scope|shared module/i.test(message)) return 'version-skew';
+    if (/network|fetch|script|timeout|chunk|loading/i.test(message)) return 'network';
+    return 'remote-unavailable';
+}
+function createModuleFederationFallbackTelemetry(input) {
+    const error = void 0 !== input.error ? toError(input.error) : void 0;
+    const status = input.status ?? 'degraded';
+    const eventName = input.eventName ?? ('recovered' === status ? MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT : MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT);
+    const metadata = {
+        ...input.metadata ?? {},
+        classification: input.classification,
+        remote: input.remote,
+        status
+    };
+    if (void 0 !== input.exportName) metadata.exportName = input.exportName;
+    if (void 0 !== input.runtimeDigest) metadata.runtimeDigest = input.runtimeDigest;
+    if (void 0 !== error) {
+        metadata.errorName = error.name;
+        metadata.errorMessage = error.message;
+    }
+    const payload = {
+        appName: input.appName,
+        eventName,
+        metadata,
+        phase: input.phase,
+        reason: input.classification,
+        schemaVersion: 1
+    };
+    if (void 0 !== input.entry) payload.entry = input.entry;
+    if (void 0 !== input.runtimeDigest) payload.runtimeDigest = input.runtimeDigest;
+    return payload;
+}
+function toModuleFederationFallbackAttributes(payload) {
+    return {
+        'data-mf-fallback-app': payload.appName,
+        'data-mf-fallback-classification': payload.reason,
+        'data-mf-fallback-phase': payload.phase,
+        'data-mf-fallback-remote': String(payload.metadata.remote),
+        'data-mf-fallback-status': String(payload.metadata.status),
+        'data-mf-telemetry-event': payload.eventName
+    };
+}
+function emitModuleFederationFallbackTelemetry(input, options = {}) {
+    return emitModuleFederationFallbackPayload(createModuleFederationFallbackTelemetry(input), options);
+}
+function emitModuleFederationFallbackPayload(payload, options = {}) {
+    const delivery = deliver(payload, options);
+    try {
+        options.observe?.(payload, delivery);
+    } catch  {}
+    return delivery;
+}
+async function deliver(payload, options) {
+    let dispatched = false;
+    let timer;
+    const controller = new AbortController();
+    try {
+        if ("u" > typeof window && 'function' == typeof window.dispatchEvent && "u" > typeof CustomEvent) {
+            window.dispatchEvent(new CustomEvent(payload.eventName, {
+                detail: payload
+            }));
+            dispatched = true;
+        }
+        const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+        if (!(true === options.postSignal || options.endpoint) || 'function' != typeof fetchImpl) return {
+            dispatched,
+            posted: false
+        };
+        const headers = new Headers({
+            'content-type': 'application/json'
+        });
+        if (options.authToken) headers.set(options.authHeaderName ?? DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER, options.authToken);
+        const timeoutMs = Number.isSafeInteger(options.timeoutMs) && (options.timeoutMs ?? 0) > 0 ? options.timeoutMs : 1000;
+        const expired = new Promise((resolve)=>{
+            timer = setTimeout(()=>{
+                controller.abort();
+                resolve(void 0);
+            }, timeoutMs);
+        });
+        const response = await Promise.race([
+            fetchImpl(options.endpoint ?? DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, {
+                body: JSON.stringify(payload),
+                headers,
+                method: 'POST',
+                keepalive: true,
+                signal: controller.signal
+            }),
+            expired
+        ]);
+        return response ? {
+            dispatched,
+            posted: true,
+            postStatus: response.status
+        } : {
+            dispatched,
+            posted: false
+        };
+    } catch  {
+        return {
+            dispatched,
+            posted: false
+        };
+    } finally{
+        if (void 0 !== timer) clearTimeout(timer);
+    }
+}
+export { DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER, DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT, MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT, ModuleFederationRemoteComponentContractError, ModuleFederationRemoteLoadError, ModuleFederationRemoteLoadTimeoutError, classifyModuleFederationFallback, createModuleFederationFallbackTelemetry, emitModuleFederationFallbackPayload, emitModuleFederationFallbackTelemetry, toModuleFederationFallbackAttributes };

package/dist/esm-node/module-federation/consume-surface.mjs

@@ -1,6 +1,6 @@
 import "node:module";
-import { classifyModuleFederationFallback, createModuleFederationFallbackTelemetry, emitModuleFederationFallbackTelemetry } from "./index.mjs";
 import { createDiscoveryError, formatSurfaceRef, parseSurfaceRef, validateSurfaceRef } from "./surface-resolution-types.mjs";
+import { classifyModuleFederationFallback, createModuleFederationFallbackTelemetry, emitModuleFederationFallbackPayload, emitModuleFederationFallbackTelemetry } from "./telemetry.mjs";
 function classifyDiscoveryError(code) {
     switch(code){
         case 'major-not-published':
@@ -39,17 +39,7 @@ async function reportFailure(options, ref, base) {
         remote,
         status: 'degraded'
     });
-    try {
-        await emitModuleFederationFallbackTelemetry({
-            appName: options.appName,
-            classification: base.classification,
-            error: base.error ?? base.discoveryError,
-            metadata: telemetry.metadata,
-            phase: base.phase,
-            remote,
-            status: 'degraded'
-        }, options.telemetry ?? {});
-    } catch  {}
+    emitModuleFederationFallbackPayload(telemetry, options.telemetry);
     const failure = {
         ref,
         env: options.env,
@@ -69,7 +59,7 @@ async function reportFailure(options, ref, base) {
         degradedValue = await options.degraded(failure);
     } catch (handlerError) {
         try {
-            await emitModuleFederationFallbackTelemetry({
+            emitModuleFederationFallbackTelemetry({
                 appName: options.appName,
                 classification: base.classification,
                 error: handlerError,

package/dist/esm-node/module-federation/distributed-ssr.mjs

@@ -63,7 +63,12 @@ function DistributedSsrBoundary({ children, expose, fallback, fragmentProps, rem
 function createDistributedSsrComponent({ createComponent, expose, fallback, remote }) {
     let RemoteComponent;
     function DeferredRemoteComponent(props) {
-        RemoteComponent ??= createComponent();
+        RemoteComponent ??= createComponent({
+            export: 'default',
+            fallback,
+            injectLink: false,
+            loading: null
+        });
         return /*#__PURE__*/ jsx(RemoteComponent, {
             ...props
         });

package/dist/esm-node/module-federation/index.mjs

@@ -1,116 +1,6 @@
 import "node:module";
 export * from "./consume-surface.mjs";
-export * from "./distributed-ssr.mjs";
 export * from "./last-known-good.mjs";
 export * from "./manifest-recovery-runtime-plugin.mjs";
 export * from "./surface-resolution-types.mjs";
-const MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT = 'modernjs:mf-runtime-fallback';
-const MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT = 'modernjs:mf-runtime-recovery';
-const DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = '/_modern/contract-gates/runtime-fallback';
-const DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER = 'x-modernjs-runtime-signal-token';
-class ModuleFederationRemoteLoadTimeoutError extends Error {
-    constructor(remote, timeoutMs){
-        super(`Loading remote "${remote}" timed out after ${timeoutMs}ms`);
-        this.name = 'ModuleFederationRemoteLoadTimeoutError';
-    }
-}
-class ModuleFederationRemoteLoadError extends Error {
-    constructor(remote, attempts, causeError){
-        super(`Unable to load remote "${remote}" after ${attempts} attempt${attempts > 1 ? 's' : ''}: ${causeError.message}`);
-        this.name = 'ModuleFederationRemoteLoadError';
-        this.remote = remote;
-        this.attempts = attempts;
-        this.causeError = causeError;
-    }
-}
-class ModuleFederationRemoteComponentContractError extends Error {
-    constructor(remote, exportName){
-        super(`Remote "${remote}" export "${exportName}" is not a valid React component`);
-        this.name = 'ModuleFederationRemoteComponentContractError';
-    }
-}
-function toError(error) {
-    if (error instanceof Error) return error;
-    return new Error('string' == typeof error ? error : 'Unknown remote load error');
-}
-function classifyModuleFederationFallback(error) {
-    const normalizedError = toError(error);
-    if (normalizedError instanceof ModuleFederationRemoteLoadError) return classifyModuleFederationFallback(normalizedError.causeError);
-    if (normalizedError instanceof ModuleFederationRemoteLoadTimeoutError) return 'timeout';
-    if (normalizedError instanceof ModuleFederationRemoteComponentContractError) return 'contract';
-    const message = normalizedError.message;
-    if (/version|requiredVersion|singleton|share scope|shared module/i.test(message)) return 'version-skew';
-    if (/network|fetch|script|timeout|chunk|loading/i.test(message)) return 'network';
-    return 'remote-unavailable';
-}
-function createModuleFederationFallbackTelemetry(input) {
-    const error = void 0 !== input.error ? toError(input.error) : void 0;
-    const status = input.status ?? 'degraded';
-    const eventName = input.eventName ?? ('recovered' === status ? MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT : MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT);
-    const metadata = {
-        ...input.metadata ?? {},
-        classification: input.classification,
-        remote: input.remote,
-        status
-    };
-    if (void 0 !== input.exportName) metadata.exportName = input.exportName;
-    if (void 0 !== input.runtimeDigest) metadata.runtimeDigest = input.runtimeDigest;
-    if (void 0 !== error) {
-        metadata.errorName = error.name;
-        metadata.errorMessage = error.message;
-    }
-    const payload = {
-        appName: input.appName,
-        eventName,
-        metadata,
-        phase: input.phase,
-        reason: input.classification,
-        schemaVersion: 1
-    };
-    if (void 0 !== input.entry) payload.entry = input.entry;
-    if (void 0 !== input.runtimeDigest) payload.runtimeDigest = input.runtimeDigest;
-    return payload;
-}
-function toModuleFederationFallbackAttributes(payload) {
-    return {
-        'data-mf-fallback-app': payload.appName,
-        'data-mf-fallback-classification': payload.reason,
-        'data-mf-fallback-phase': payload.phase,
-        'data-mf-fallback-remote': String(payload.metadata.remote),
-        'data-mf-fallback-status': String(payload.metadata.status),
-        'data-mf-telemetry-event': payload.eventName
-    };
-}
-async function emitModuleFederationFallbackTelemetry(input, options = {}) {
-    const payload = createModuleFederationFallbackTelemetry(input);
-    if ("u" > typeof window && 'function' == typeof window.dispatchEvent && "u" > typeof CustomEvent) window.dispatchEvent(new CustomEvent(payload.eventName, {
-        detail: payload
-    }));
-    const shouldPost = true === options.postSignal || Boolean(options.endpoint);
-    if (!shouldPost) return {
-        dispatched: true,
-        posted: false
-    };
-    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
-    if ('function' != typeof fetchImpl) return {
-        dispatched: true,
-        posted: false
-    };
-    const headers = new Headers({
-        'content-type': 'application/json'
-    });
-    if (void 0 !== options.authToken && options.authToken.length > 0) headers.set(options.authHeaderName ?? DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER, options.authToken);
-    const response = await fetchImpl(options.endpoint ?? DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, {
-        body: JSON.stringify(payload),
-        headers,
-        method: 'POST',
-        keepalive: true
-    });
-    return {
-        dispatched: true,
-        posted: true,
-        postStatus: response.status
-    };
-}
-export { DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY, useDistributedSsrFragmentProps } from "./distributed-ssr.mjs";
-export { DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER, DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT, MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT, ModuleFederationRemoteComponentContractError, ModuleFederationRemoteLoadError, ModuleFederationRemoteLoadTimeoutError, classifyModuleFederationFallback, createModuleFederationFallbackTelemetry, emitModuleFederationFallbackTelemetry, toModuleFederationFallbackAttributes };
+export * from "./telemetry.mjs";

package/dist/esm-node/module-federation/manifest-recovery-runtime-plugin.mjs

@@ -32,7 +32,7 @@ const getErrorStatus = (error)=>{
     if ('object' == typeof error && null !== error && 'status' in error && 'number' == typeof error.status) return error.status;
 };
 const isRetryableError = (error)=>{
-    if (error instanceof SyntaxError) return false;
+    if (error instanceof SyntaxError) return true;
     const message = getErrorMessage(error);
     if (NON_RETRYABLE_ERROR_PATTERNS.some((pattern)=>pattern.test(message))) return false;
     const status = getErrorStatus(error);

package/dist/esm-node/module-federation/native-browser-dev-client.mjs

@@ -0,0 +1,277 @@
+import "node:module";
+import { isNativeBrowserDevCommitError } from "./native-browser-dev-refresh.mjs";
+import { hasNativeBrowserDevPublisher, readNativeBrowserDevPublication, replaceNativeBrowserDevRemote } from "./native-browser-dev-runtime-plugin.mjs";
+const CLIENTS = Symbol.for('ultramodern.federation.browser-dev-clients.v1');
+const clients = ()=>{
+    const root = globalThis;
+    if (!root[CLIENTS]) Object.defineProperty(root, CLIENTS, {
+        value: new Map()
+    });
+    return root[CLIENTS];
+};
+function commitClient(remoteName, graph) {
+    const state = clients().get(remoteName);
+    const next = state?.candidates.get(graph.runtimeHash)?.deref();
+    if (!state || !next) throw new Error('Accepted native graph has no matching fresh HMR runtime.');
+    if (state.active === next) return;
+    state.active?.stop();
+    state.active = next;
+    next.start();
+}
+function prepareNativeBrowserDevClient(remoteName, manifest) {
+    const hash = /\/__ultramodern_mf__\/([a-f0-9]+)\//u.exec(new URL(manifest).pathname)?.[1];
+    const candidate = hash && clients().get(remoteName)?.candidates.get(hash)?.deref();
+    if (!candidate) throw new Error('Native graph has no loaded standby HMR runtime.');
+    return candidate.lease();
+}
+function releaseNativeBrowserDevClient(remoteName, manifest) {
+    const hash = /\/__ultramodern_mf__\/([a-f0-9]+)\//u.exec(new URL(manifest).pathname)?.[1];
+    if (!hash) return;
+    const state = clients().get(remoteName);
+    const candidate = state?.candidates.get(hash)?.deref();
+    if (!state || !candidate) return;
+    candidate.releaseStandby();
+}
+function startNativeBrowserDevClient(options) {
+    const state = clients().get(options.remoteName) ?? {
+        candidates: new Map()
+    };
+    clients().set(options.remoteName, state);
+    const initialHash = options.hash();
+    let socket;
+    let ping;
+    let reconnect;
+    let reconnectCount = 0;
+    let lastHash;
+    let running = false;
+    let applying;
+    let lifetime;
+    let removeCustom;
+    const custom = new Map();
+    const queued = [];
+    const leases = new Set();
+    const base = options.serverBase.endsWith('/') ? options.serverBase : `${options.serverBase}/`;
+    const report = (error)=>{
+        console.error('[ultramodern] Native federation development update failed:', error);
+        if (false !== options.config.overlay && ('object' != typeof options.config.overlay || false !== options.config.overlay.errors)) options.overlay()?.create('Native federation update failed', String(error));
+    };
+    const send = (message)=>{
+        if (socket?.readyState === WebSocket.OPEN) socket.send(JSON.stringify(message));
+        else queued.push(message);
+    };
+    const errorMessage = (error)=>error instanceof Error ? error.message : String(error);
+    const onError = (event)=>send({
+            type: 'client-error',
+            id: crypto.randomUUID(),
+            message: event.message,
+            name: event.error?.name,
+            stack: event.error?.stack
+        });
+    const onRejected = (event)=>send({
+            type: 'client-error',
+            id: crypto.randomUUID(),
+            message: `Uncaught (in promise) ${errorMessage(event.reason)}`,
+            name: event.reason?.name,
+            stack: event.reason?.stack
+        });
+    const fullReload = (data)=>{
+        if (!options.liveReload) return;
+        if (data?.path?.endsWith('.html')) {
+            const pathname = decodeURI(location.pathname);
+            const target = base + data.path.slice(1);
+            if (pathname !== target && pathname !== target.slice(0, -5) && !(pathname.endsWith('/') && `${pathname}index.html` === target)) return;
+        }
+        location.reload();
+    };
+    const apply = ()=>{
+        if (!running || applying || !lastHash || lastHash === options.hash()) return;
+        const signal = lifetime.signal;
+        const targetHash = lastHash;
+        applying = (async ()=>{
+            if (hasNativeBrowserDevPublisher(options.remoteName)) {
+                const graph = await readNativeBrowserDevPublication(options.remoteName, {
+                    signal: AbortSignal.any([
+                        signal,
+                        AbortSignal.timeout(3000)
+                    ]),
+                    revisionHeader: options.revisionHeader
+                });
+                if (signal.aborted) throw signal.reason;
+                if (graph.buildId !== options.buildId) {
+                    try {
+                        await replaceNativeBrowserDevRemote(graph);
+                    } catch (error) {
+                        if (running && !signal.aborted && hasNativeBrowserDevPublisher(options.remoteName) && isNativeBrowserDevCommitError(error, graph.revision)) {
+                            state.failure = {
+                                runtimeHash: graph.runtimeHash,
+                                error
+                            };
+                            report(error);
+                            commitClient(options.remoteName, graph);
+                        }
+                        throw error;
+                    }
+                    if (!running || signal.aborted || !hasNativeBrowserDevPublisher(options.remoteName)) return;
+                    commitClient(options.remoteName, graph);
+                    return;
+                }
+            }
+            if (!options.hot) return fullReload();
+            if ('idle' !== options.hot.status()) return;
+            try {
+                const updated = await options.hot.check(true);
+                if (!updated) fullReload();
+            } catch (error) {
+                console.error('[rsbuild] HMR update failed, performing full reload:', error);
+                fullReload();
+            }
+        })().catch((error)=>{
+            if (!signal.aborted) report(error);
+        }).finally(()=>{
+            applying = void 0;
+            if (running && !signal.aborted && lastHash !== targetHash) apply();
+        });
+    };
+    const clearOverlayForBuild = ()=>{
+        if (state.failure) {
+            if (!lastHash || lastHash === state.failure.runtimeHash) return;
+            state.failure = void 0;
+        }
+        options.overlay()?.clear();
+    };
+    const message = (event)=>{
+        let value;
+        try {
+            value = JSON.parse(event.data);
+        } catch (error) {
+            report(error);
+            return;
+        }
+        switch(value.type){
+            case 'hash':
+                lastHash = value.data;
+                break;
+            case 'ok':
+                clearOverlayForBuild();
+                apply();
+                break;
+            case 'warnings':
+                for (const warning of value.data?.text ?? [])console.warn(warning);
+                clearOverlayForBuild();
+                apply();
+                break;
+            case 'errors':
+                for (const error of value.data?.text ?? [])console.error(error);
+                if (value.data?.html) options.overlay()?.create('Build failed', value.data.html);
+                break;
+            case 'full-reload':
+                fullReload(value.data);
+                break;
+            case 'static-changed':
+                fullReload();
+                break;
+            case 'custom':
+                for (const listener of custom.get(value.data?.event) ?? [])listener(value.data.data);
+                break;
+            case 'resolved-client-error':
+                options.overlay()?.create('Runtime errors', String(value.data?.message ?? ''));
+                break;
+        }
+    };
+    const socketUrl = (fallback)=>{
+        const url = new URL('http://localhost');
+        url.hostname = (fallback ? options.serverHost : options.config.host) || location.hostname;
+        url.port = String((fallback ? options.serverPort : options.config.port) || location.port);
+        url.protocol = options.config.protocol || ('https:' === location.protocol ? 'wss:' : 'ws:');
+        url.pathname = options.config.path;
+        url.searchParams.set('token', options.token);
+        return options.resolveWebSocketUrl?.(url.href) ?? url.href;
+    };
+    const detachSocket = ()=>{
+        clearInterval(ping);
+        ping = void 0;
+        const previous = socket;
+        socket = void 0;
+        if (!previous) return;
+        previous.onopen = previous.onclose = previous.onmessage = previous.onerror = null;
+        previous.close();
+    };
+    const connect = (fallback = false)=>{
+        if (!running) return;
+        socket = new WebSocket(socketUrl(fallback));
+        socket.onopen = ()=>{
+            reconnectCount = 0;
+            ping = setInterval(()=>send({
+                    type: 'ping'
+                }), 30000);
+            for (const item of queued.splice(0))send(item);
+        };
+        socket.onmessage = message;
+        socket.onclose = ()=>{
+            detachSocket();
+            if (!running || reconnectCount >= options.config.reconnect) return;
+            reconnectCount++;
+            reconnect = setTimeout(()=>connect(), 1000 * 1.5 ** reconnectCount);
+        };
+        socket.onerror = ()=>{
+            if (options.resolveWebSocketUrl || fallback || socketUrl(false) === socketUrl(true)) return;
+            detachSocket();
+            connect(true);
+        };
+    };
+    const client = {
+        arm () {
+            removeCustom ??= options.installCustomListeners(custom);
+        },
+        lease () {
+            const lease = {};
+            leases.add(lease);
+            client.arm();
+            return ()=>{
+                if (!leases.delete(lease)) return;
+                client.releaseStandby();
+            };
+        },
+        releaseStandby () {
+            if (state.active !== client && !leases.size) client.stop();
+        },
+        start () {
+            if (running) return;
+            running = true;
+            lifetime = new AbortController();
+            client.arm();
+            if (options.browserLogs) {
+                window.addEventListener('error', onError);
+                window.addEventListener('unhandledrejection', onRejected);
+            }
+            connect();
+        },
+        stop () {
+            if (!running && !removeCustom) return;
+            running = false;
+            lifetime?.abort(new Error('Native browser HMR runtime retired.'));
+            clearTimeout(reconnect);
+            reconnect = void 0;
+            detachSocket();
+            window.removeEventListener('error', onError);
+            window.removeEventListener('unhandledrejection', onRejected);
+            removeCustom?.();
+            removeCustom = void 0;
+            custom.clear();
+            queued.length = 0;
+        }
+    };
+    client.arm();
+    state.candidates.set(initialHash, new WeakRef(client));
+    if (!state.active) {
+        state.active = client;
+        client.start();
+    }
+    return ()=>{
+        client.stop();
+        if (state.active === client) state.active = void 0;
+        if (state.candidates.get(initialHash)?.deref() === client) state.candidates.delete(initialHash);
+        if (!state.active && !state.candidates.size) clients().delete(options.remoteName);
+    };
+}
+export { prepareNativeBrowserDevClient, releaseNativeBrowserDevClient, startNativeBrowserDevClient };