@bleedingdev/modern-js-renderer-core 3.9.3-ultramodern.1 → 3.9.3-ultramodern.11

package/dist/esm-node/worker-federation/handler.mjs

@@ -0,0 +1,160 @@
+import "node:module";
+import { admitWorkerFederationExpose, readWorkerFederationEnvelope, readWorkerFederationPublication, workerFederationEnvelope, workerFederationRecord, workerFederationWireJson } from "./contract.mjs";
+import { WorkerFederationBodyTooLargeError, assertWorkerFederationBodySize, checkWorkerFederationDeadline, readWorkerFederationJsonBody, workerAbortReason, workerAbortable, workerFederationErrorMessage } from "./lease.mjs";
+function createWorkerFederationHandler(options) {
+    if ('function' != typeof options.admitRendererContract || 'function' != typeof options.admitNativeRequest || 'function' != typeof options.releaseNativeRequest || 'function' != typeof options.renderNativeSnapshot) throw new Error('Worker federation requires canonical and native admission callbacks.');
+    const timeout = options.requestTimeout ?? 3000;
+    if (!Number.isFinite(timeout) || timeout <= 0) throw new Error('Worker federation requires a positive request deadline.');
+    const renderer = options.admitRendererContract(options.publication.renderer);
+    const worker = readWorkerFederationPublication(options.publication.worker, renderer.identities);
+    const manifest = JSON.parse(workerFederationWireJson({
+        metaData: {
+            ultramodernRenderer: renderer,
+            ultramodernWorkerFederation: worker
+        }
+    }));
+    const loaders = workerFederationRecord(options.exposes, 'compiled exposes');
+    if (Object.keys(loaders).length !== Object.keys(worker.exposes).length || Object.keys(loaders).some((expose)=>!Object.hasOwn(worker.exposes, expose) || 'function' != typeof loaders[expose])) throw new Error('Worker federation registry conflicts with its own publication.');
+    const pinnedLoaders = {
+        ...options.exposes
+    };
+    const endpoints = new Map();
+    for (const [expose, coordinate] of Object.entries(worker.exposes))for (const locale of Object.keys(coordinate.paths)){
+        const admitted = admitWorkerFederationExpose({
+            manifest,
+            manifestUrl: options.manifestUrl,
+            remote: worker.remote,
+            expose,
+            locale,
+            admitRendererContract: options.admitRendererContract
+        });
+        endpoints.set(admitted.path, admitted);
+    }
+    const admitNativeRequest = options.admitNativeRequest;
+    const releaseNativeRequest = options.releaseNativeRequest;
+    const renderNativeSnapshot = options.renderNativeSnapshot;
+    return async (request)=>{
+        const deadlineAt = performance.now() + timeout;
+        const url = new URL(request.url);
+        const admitted = endpoints.get(url.pathname);
+        if (!admitted) return;
+        if ('POST' !== request.method || url.href !== admitted.endpoint || request.headers.get('content-type')?.split(';')[0].trim().toLowerCase() !== 'application/json') {
+            request.body?.cancel().catch(()=>void 0);
+            return new Response('Worker federation endpoint coordinate conflicts with its publication.', {
+                status: 400
+            });
+        }
+        if (request.signal.aborted) {
+            request.body?.cancel().catch(()=>void 0);
+            throw workerAbortReason(request.signal);
+        }
+        const controller = new AbortController();
+        const signal = AbortSignal.any([
+            request.signal,
+            controller.signal
+        ]);
+        const checkDeadline = ()=>checkWorkerFederationDeadline(deadlineAt, signal, controller);
+        const execution = Object.freeze({
+            admitted,
+            signal
+        });
+        const deadline = setTimeout(()=>{
+            controller.abort(new Error('Worker federation request deadline exceeded.'));
+        }, Math.max(0, deadlineAt - performance.now()));
+        let executing = false;
+        let admittedRequest;
+        let release;
+        let response;
+        let failedRequest;
+        const releaseOnce = (value)=>{
+            if (!release) try {
+                release = Promise.resolve(releaseNativeRequest(value));
+            } catch (error) {
+                release = Promise.reject(error);
+            }
+            return release ?? Promise.resolve();
+        };
+        try {
+            if (!request.body) throw new Error('Worker federation request has no native payload.');
+            const envelope = await readWorkerFederationJsonBody(request.body, signal, request.headers.get('content-length'), checkDeadline);
+            checkDeadline();
+            const payload = readWorkerFederationEnvelope(envelope, 'request', admitted);
+            checkDeadline();
+            const preparing = Promise.resolve().then(()=>{
+                checkDeadline();
+                return admitNativeRequest(payload, execution);
+            });
+            preparing.then((value)=>{
+                if (signal.aborted) releaseOnce(value).catch(()=>void 0);
+            }, ()=>void 0);
+            const nativeRequest = await workerAbortable(preparing, signal);
+            admittedRequest = {
+                value: nativeRequest
+            };
+            checkDeadline();
+            executing = true;
+            const module = await workerAbortable(pinnedLoaders[admitted.expose](), signal);
+            checkDeadline();
+            const snapshot = await workerAbortable(Promise.resolve(renderNativeSnapshot(module, nativeRequest, execution)), signal);
+            checkDeadline();
+            if ('string' == typeof snapshot) assertWorkerFederationBodySize(snapshot);
+            const body = assertWorkerFederationBodySize(workerFederationWireJson(workerFederationEnvelope('response', admitted, snapshot)));
+            checkDeadline();
+            response = new Response(body, {
+                headers: {
+                    'content-type': 'application/json'
+                }
+            });
+        } catch (error) {
+            let failure = error;
+            try {
+                checkDeadline();
+            } catch (deadlineError) {
+                failure = deadlineError;
+            }
+            failedRequest = {
+                error: failure
+            };
+            response = new Response(workerFederationErrorMessage(failure, 'Worker federation request failed.'), {
+                status: signal.aborted ? 504 : executing ? 502 : failure instanceof WorkerFederationBodyTooLargeError ? 413 : 400
+            });
+        } finally{
+            try {
+                if (admittedRequest) {
+                    const releasing = releaseOnce(admittedRequest.value);
+                    if (signal.aborted) releasing.catch(()=>void 0);
+                    else try {
+                        await workerAbortable(releasing, signal);
+                        checkDeadline();
+                    } catch (error) {
+                        response?.body?.cancel().catch(()=>void 0);
+                        let releaseFailure = error;
+                        try {
+                            checkDeadline();
+                        } catch (deadlineError) {
+                            releaseFailure = new AggregateError([
+                                error,
+                                deadlineError
+                            ], `${workerFederationErrorMessage(error, 'Native request release failed.', 384)}; ${workerFederationErrorMessage(deadlineError, 'Worker federation deadline exceeded.', 384)}`);
+                        }
+                        const failure = failedRequest ? new AggregateError([
+                            failedRequest.error,
+                            releaseFailure
+                        ], `${workerFederationErrorMessage(failedRequest.error, 'Worker federation request failed.', 384)}; native request release failed: ${workerFederationErrorMessage(releaseFailure, 'Native request release failed.', 384)}`) : releaseFailure;
+                        response = new Response(workerFederationErrorMessage(failure, 'Worker federation native request release failed.'), {
+                            status: signal.aborted ? 504 : 502
+                        });
+                    }
+                }
+            } finally{
+                clearTimeout(deadline);
+            }
+        }
+        if (request.signal.aborted) {
+            response?.body?.cancel().catch(()=>void 0);
+            throw workerAbortReason(request.signal);
+        }
+        return response;
+    };
+}
+export { createWorkerFederationHandler };

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

@@ -0,0 +1,4 @@
+import "node:module";
+export { WORKER_FEDERATION_METADATA_KEY, WORKER_FEDERATION_SCHEMA, WORKER_FEDERATION_VERSION, readWorkerFederationManifestUrl, readWorkerFederationPath, readWorkerFederationPublication } from "./contract.mjs";
+export { createWorkerFederationHandler } from "./handler.mjs";
+export { createWorkerFederationTransport } from "./transport.mjs";

package/dist/esm-node/worker-federation/lease.mjs

@@ -0,0 +1,108 @@
+import "node:module";
+function checkWorkerFederationDeadline(deadlineAt, signal, controller) {
+    if (signal?.aborted) throw workerAbortReason(signal);
+    if (performance.now() >= deadlineAt) {
+        const error = new Error('Worker federation request deadline exceeded.');
+        controller?.abort(error);
+        throw error;
+    }
+}
+function workerFederationErrorMessage(error, fallback, maxLength = 1024) {
+    return error instanceof Error && error.message.length <= maxLength ? error.message : fallback;
+}
+function workerAbortReason(signal) {
+    return signal.reason ?? new DOMException('Worker federation request aborted.', 'AbortError');
+}
+function workerAbortable(operation, signal) {
+    if (signal.aborted) {
+        operation.catch(()=>void 0);
+        return Promise.reject(workerAbortReason(signal));
+    }
+    return new Promise((resolve, reject)=>{
+        const onAbort = ()=>reject(workerAbortReason(signal));
+        signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+        operation.then(resolve, reject).finally(()=>signal.removeEventListener('abort', onAbort));
+    });
+}
+async function readWorkerFederationJsonBody(body, signal, contentLength, checkDeadline) {
+    if (signal.aborted) {
+        body.cancel().catch(()=>void 0);
+        throw workerAbortReason(signal);
+    }
+    try {
+        checkDeadline?.();
+        if (null != contentLength) {
+            if (!/^\d+$/u.test(contentLength)) throw new Error('Worker federation body has an invalid Content-Length.');
+            if (Number(contentLength) > WORKER_FEDERATION_MAX_BODY_BYTES) throw new WorkerFederationBodyTooLargeError();
+        }
+    } catch (error) {
+        body.cancel(error).catch(()=>void 0);
+        throw error;
+    }
+    const reader = body.getReader();
+    const onAbort = ()=>{
+        reader.cancel(workerAbortReason(signal)).catch(()=>void 0);
+    };
+    signal.addEventListener('abort', onAbort, {
+        once: true
+    });
+    try {
+        const chunks = [];
+        let length = 0;
+        while(true){
+            checkDeadline?.();
+            const chunk = await workerAbortable(reader.read(), signal);
+            checkDeadline?.();
+            if (chunk.done) break;
+            if (chunk.value.byteLength > WORKER_FEDERATION_MAX_BODY_BYTES - length) throw new WorkerFederationBodyTooLargeError();
+            chunks.push(new Uint8Array(chunk.value));
+            length += chunk.value.byteLength;
+        }
+        checkDeadline?.();
+        const bytes = new Uint8Array(length);
+        let offset = 0;
+        for (const chunk of chunks){
+            bytes.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        if (signal.aborted) throw workerAbortReason(signal);
+        const decoded = new TextDecoder('utf-8', {
+            fatal: true
+        }).decode(bytes);
+        checkDeadline?.();
+        const result = JSON.parse(decoded);
+        checkDeadline?.();
+        return result;
+    } catch (error) {
+        reader.cancel(error).catch(()=>void 0);
+        throw error;
+    } finally{
+        signal.removeEventListener('abort', onAbort);
+        reader.releaseLock();
+    }
+}
+const WORKER_FEDERATION_MAX_BODY_BYTES = 8388608;
+class WorkerFederationBodyTooLargeError extends Error {
+    constructor(){
+        super('Worker federation body exceeds 8 MiB.');
+        this.name = 'WorkerFederationBodyTooLargeError';
+    }
+}
+function assertWorkerFederationBodySize(value) {
+    if (value.length > WORKER_FEDERATION_MAX_BODY_BYTES) throw new WorkerFederationBodyTooLargeError();
+    let bytes = 0;
+    for(let index = 0; index < value.length; index++){
+        const code = value.charCodeAt(index);
+        if (code <= 0x7f) bytes++;
+        else if (code <= 0x7ff) bytes += 2;
+        else if (code >= 0xd800 && code <= 0xdbff && value.charCodeAt(index + 1) >= 0xdc00 && value.charCodeAt(index + 1) <= 0xdfff) {
+            bytes += 4;
+            index++;
+        } else bytes += 3;
+        if (bytes > WORKER_FEDERATION_MAX_BODY_BYTES) throw new WorkerFederationBodyTooLargeError();
+    }
+    return value;
+}
+export { WORKER_FEDERATION_MAX_BODY_BYTES, WorkerFederationBodyTooLargeError, assertWorkerFederationBodySize, checkWorkerFederationDeadline, readWorkerFederationJsonBody, workerAbortReason, workerAbortable, workerFederationErrorMessage };

package/dist/esm-node/worker-federation/transport.mjs

@@ -0,0 +1,235 @@
+import "node:module";
+import { admitWorkerFederationExpose, readWorkerFederationEnvelope, readWorkerFederationManifestUrl, readWorkerFederationPath, readWorkerFederationStyles, workerFederationEnvelope, workerFederationWireJson } from "./contract.mjs";
+import { assertWorkerFederationBodySize, checkWorkerFederationDeadline, readWorkerFederationJsonBody, workerAbortReason, workerAbortable } from "./lease.mjs";
+async function readResponseJson(response, expectedUrl, signal, checkDeadline) {
+    const cancelBody = ()=>{
+        response.body?.cancel().catch(()=>void 0);
+    };
+    if (signal.aborted) {
+        cancelBody();
+        throw workerAbortReason(signal);
+    }
+    try {
+        checkDeadline();
+    } catch (error) {
+        cancelBody();
+        throw error;
+    }
+    if (!response.ok || response.redirected || response.url && response.url !== expectedUrl) {
+        cancelBody();
+        throw new Error(`Worker federation publication request failed (${response.status}).`);
+    }
+    if (!response.body) throw new Error('Worker federation response has no body.');
+    return readWorkerFederationJsonBody(response.body, signal, response.headers.get('content-length'), checkDeadline);
+}
+async function fetchJson(fetchResponse, request, signal, checkDeadline) {
+    checkDeadline();
+    if (signal.aborted) throw workerAbortReason(signal);
+    const pending = fetchResponse(request);
+    pending.then((response)=>{
+        if (signal.aborted) response.body?.cancel().catch(()=>void 0);
+    }, ()=>void 0);
+    return readResponseJson(await workerAbortable(pending, signal), request.url, signal, checkDeadline);
+}
+function createWorkerFederationTransport(options) {
+    const timeout = options.requestTimeout ?? 3000;
+    const admitRendererContract = options.admitRendererContract;
+    if ('function' != typeof admitRendererContract) throw new Error('Worker federation requires canonical renderer admission.');
+    if (!Number.isFinite(timeout) || timeout <= 0) throw new Error('Worker federation requires a positive request deadline.');
+    const services = new Map();
+    for (const service of options.services){
+        if (!service.remote || services.has(service.remote)) throw new Error('Worker federation service remotes must be unique.');
+        const exposes = new Set();
+        for (const fragment of service.fragments){
+            Object.values(fragment.paths).forEach(readWorkerFederationPath);
+            if (!fragment.boundaryId || exposes.has(fragment.expose)) throw new Error('Worker federation service exposes must be explicit and unique.');
+            exposes.add(fragment.expose);
+        }
+        const captured = {
+            ...service,
+            manifestUrl: readWorkerFederationManifestUrl(service.manifestUrl).href,
+            fetch: service.fetch.bind(service),
+            fragments: service.fragments.map((fragment)=>Object.freeze({
+                    ...fragment,
+                    paths: Object.freeze({
+                        ...fragment.paths
+                    })
+                }))
+        };
+        services.set(service.remote, captured);
+        if (service.alias && service.alias !== service.remote) {
+            if (services.has(service.alias)) throw new Error('Worker federation service aliases must be unique.');
+            services.set(service.alias, captured);
+        }
+    }
+    const snapshots = new Map();
+    const admissions = new Map();
+    const fetchManifest = options.fetchManifest;
+    let retired;
+    const onOwnerAbort = ()=>dispose(workerAbortReason(options.signal));
+    function checkDocumentLiveness() {
+        if (retired) throw retired.reason;
+    }
+    function dispose(reason = new DOMException('The Worker federation document was disposed', 'AbortError')) {
+        if (retired) return;
+        retired = {
+            reason
+        };
+        options.signal?.removeEventListener('abort', onOwnerAbort);
+        for (const pending of [
+            ...snapshots.values(),
+            ...admissions.values()
+        ])pending.controller.abort(reason);
+        snapshots.clear();
+        admissions.clear();
+    }
+    if (options.signal?.aborted) onOwnerAbort();
+    else options.signal?.addEventListener('abort', onOwnerAbort, {
+        once: true
+    });
+    function serviceCoordinate(remote, expose, locale) {
+        const service = services.get(remote);
+        const fragment = service?.fragments.find((value)=>value.expose === expose);
+        if (!service || !fragment || !Object.hasOwn(fragment.paths, locale)) throw new Error('Worker federation remote/expose has no configured service binding.');
+        return {
+            service,
+            fragment
+        };
+    }
+    async function shared(cache, key, operation, signal, deadlineAt = performance.now() + timeout, retainFulfilled = true) {
+        checkDocumentLiveness();
+        if (signal?.aborted) throw workerAbortReason(signal);
+        let pending = cache.get(key);
+        if (!pending) {
+            const controller = new AbortController();
+            const checkDeadline = ()=>checkWorkerFederationDeadline(deadlineAt, controller.signal, controller);
+            const deadline = setTimeout(()=>controller.abort(new Error('Worker federation request deadline exceeded.')), Math.max(0, deadlineAt - performance.now()));
+            const promise = operation(controller.signal, checkDeadline);
+            pending = {
+                controller,
+                promise,
+                waiters: 0,
+                settled: false
+            };
+            const captured = pending;
+            cache.set(key, captured);
+            promise.then(()=>{
+                captured.settled = true;
+                clearTimeout(deadline);
+                if (!retainFulfilled && cache.get(key) === captured) cache.delete(key);
+            }, ()=>{
+                captured.settled = true;
+                clearTimeout(deadline);
+                if (cache.get(key) === captured) cache.delete(key);
+            });
+        }
+        const captured = pending;
+        captured.waiters++;
+        try {
+            const value = await (signal ? workerAbortable(captured.promise, signal) : captured.promise);
+            checkDocumentLiveness();
+            checkWorkerFederationDeadline(deadlineAt, signal);
+            return value;
+        } finally{
+            captured.waiters--;
+            if (!captured.settled && 0 === captured.waiters) {
+                captured.controller.abort(new Error('Worker federation request has no active consumers.'));
+                if (cache.get(key) === captured) cache.delete(key);
+            }
+        }
+    }
+    function admitWithin({ remote, expose, locale, signal }, deadlineAt = performance.now() + timeout) {
+        const { service, fragment } = serviceCoordinate(remote, expose, locale);
+        const key = workerFederationWireJson([
+            service.remote,
+            expose,
+            locale
+        ]);
+        const promise = shared(admissions, key, async (signal, checkDeadline)=>{
+            checkDeadline();
+            const request = new Request(service.manifestUrl, {
+                redirect: 'manual',
+                signal
+            });
+            const manifest = await fetchJson(fetchManifest ?? service.fetch, request, signal, checkDeadline);
+            const styles = readWorkerFederationStyles({
+                manifest,
+                manifestUrl: request.url,
+                expose
+            });
+            const admitted = admitWorkerFederationExpose({
+                manifest,
+                manifestUrl: request.url,
+                remote: service.remote,
+                expose,
+                locale,
+                admitRendererContract
+            });
+            checkDeadline();
+            if (admitted.coordinate.boundaryId !== fragment.boundaryId || admitted.path !== fragment.paths[locale]) throw new Error('Worker federation publication conflicts with its service coordinate.');
+            return Object.freeze({
+                ...admitted,
+                styles
+            });
+        }, signal, deadlineAt);
+        return {
+            promise,
+            key,
+            pending: admissions.get(key)
+        };
+    }
+    return {
+        dispose,
+        admit: (options)=>admitWithin(options).promise,
+        async request ({ remote, expose, locale, payload, signal }) {
+            const deadlineAt = performance.now() + timeout;
+            checkDocumentLiveness();
+            if (signal?.aborted) throw workerAbortReason(signal);
+            const { service } = serviceCoordinate(remote, expose, locale);
+            if ('string' == typeof payload) assertWorkerFederationBodySize(payload);
+            const encodedPayload = assertWorkerFederationBodySize(workerFederationWireJson(payload));
+            const key = workerFederationWireJson([
+                service.remote,
+                expose,
+                locale,
+                encodedPayload
+            ]);
+            checkWorkerFederationDeadline(deadlineAt, signal);
+            return shared(snapshots, key, async (signal, checkDeadline)=>{
+                checkDeadline();
+                const admission = admitWithin({
+                    remote,
+                    expose,
+                    locale,
+                    signal
+                }, deadlineAt);
+                const admitted = await admission.promise;
+                checkDeadline();
+                try {
+                    const body = assertWorkerFederationBodySize(workerFederationWireJson(workerFederationEnvelope('request', admitted, JSON.parse(encodedPayload))));
+                    checkDeadline();
+                    const response = await fetchJson(service.fetch, new Request(admitted.endpoint, {
+                        method: 'POST',
+                        headers: {
+                            'content-type': 'application/json'
+                        },
+                        body,
+                        redirect: 'manual',
+                        signal
+                    }), signal, checkDeadline);
+                    checkDeadline();
+                    const decodedPayload = readWorkerFederationEnvelope(response, 'response', admitted);
+                    checkDeadline();
+                    return {
+                        admitted,
+                        payload: decodedPayload
+                    };
+                } catch (error) {
+                    if (!signal.aborted && admissions.get(admission.key) === admission.pending) admissions.delete(admission.key);
+                    throw error;
+                }
+            }, signal, deadlineAt, false);
+        }
+    };
+}
+export { createWorkerFederationTransport };

package/dist/types/adapter.d.ts

@@ -10,7 +10,7 @@ export interface RendererBuildProfile<TRenderer extends Renderer = Renderer> {
     renderer: TRenderer;
     status: 'stable' | 'preview';
     protocolVersion: 1;
-    minimumNode: '26.10.0';
+    minimumNode: '26.12.0';
     hmr: {
         editedBoundary: 'may-reset';
         unaffectedComponents: 'preserved';

package/dist/types/data/codec.d.ts

@@ -1,4 +1,4 @@
-export declare const DATA_CODEC: 'seroval-json@1.6.8';
+export declare const DATA_CODEC: 'seroval-json@1.6.9';
 export declare const MAX_DATA_BYTES: number;
 export declare class DataProtocolError extends Error {
     constructor(message: string);

package/dist/types/entry-client.d.ts

@@ -40,6 +40,8 @@ export interface NativeClientStart<Bootstrap extends DocumentBootstrap, Router,
 export interface NativeClientAdapter<Bootstrap extends DocumentBootstrap, Router extends object, Instance extends NativeI18nInstance, LocalisedUrls> {
     readBootstrap(document: Document, identity: Readonly<RendererIdentity>): Bootstrap;
     createRouter(application: NativeRoutedApplication, options: NativeRouterOptions): Router;
+    /** Release the router and browser history created for this entry. */
+    disposeRouter(router: Router): void;
     /** Load a fresh router, or adopt the server's matches when hydrating. */
     prepareRouter(router: Router, hydrating: boolean, signal: AbortSignal): Promise<void>;
     /** Mount or hydrate the root; resolves its disposal. */

package/dist/types/federation.d.ts

@@ -1,8 +1,14 @@
+/** The Node dev runtime captures assets before releasing a container load. */
+declare const LOAD_WITH_CAPTURE: unique symbol;
 /** The application compiler's native Module Federation runtime. */
 export interface FederationInstance {
     /** The application's federation name, unique among this realm's instances. */
     readonly name?: string;
     loadRemote<T>(id: string): Promise<T | null>;
+    [LOAD_WITH_CAPTURE]?: <T, Captured>(id: string, capture: (module: T | null, resolution?: LoadResolution) => Captured) => Promise<{
+        module: T | null;
+        captured: Captured | undefined;
+    }>;
     readonly remoteHandler?: {
         readonly idToRemoteMap?: Record<string, {
             name: string;
@@ -34,6 +40,10 @@ interface RemoteSnapshot {
         };
     }[];
 }
+interface LoadResolution {
+    readonly remoteSnapshot: unknown;
+    readonly expose: string;
+}
 /** Generated entries retain their own compiler's host, including on the server. */
 export interface NativeFederationBinding {
     readonly instance: () => FederationInstance;
@@ -50,7 +60,10 @@ export interface FederatedAssets {
 /** Capture the host before importing application modules or remote containers. */
 export declare function getFederationHost(binding: NativeFederationBinding | undefined): FederationInstance | undefined;
 /** Load through the selected application's runtime, never another app's host. */
-export declare function loadFederatedModule<T>(instance: FederationInstance | undefined, id: string): Promise<T>;
+export declare function loadFederatedModule<T>(instance: FederationInstance | undefined, id: string): Promise<{
+    module: T;
+    assets: FederatedAssets | undefined;
+}>;
 /** Browser assets from the native snapshot that admitted and loaded this remote. */
-export declare function remoteBrowserAssets(instance: FederationInstance, id: string): FederatedAssets | undefined;
+export declare function remoteBrowserAssets(instance: FederationInstance, id: string, resolution?: LoadResolution): FederatedAssets | undefined;
 export {};

package/dist/types/server/types.d.ts

@@ -1,6 +1,7 @@
 import type { DocumentAsset } from '../document.js';
 import type { RendererIdentity } from '../identity.js';
 import type { RequestPlatform, RequestSession } from '../session/index.js';
+import type { WorkerFederationTransport } from '../worker-federation/index.js';
 /** Native route matching remains with the selected router adapter. */
 export interface NativeServerConfig {
     readonly ssr?: boolean | 'stream';
@@ -15,6 +16,8 @@ export interface NativeRequestContext<Bindings extends object = object> {
     readonly nativeManifest?: unknown;
     readonly serverConfig?: NativeServerConfig;
     readonly entry: Readonly<RendererIdentity>;
+    /** Request-owned service transport for native Worker snapshot boundaries. */
+    readonly workerFederation?: WorkerFederationTransport;
 }
 export type NativeRequestHandler<Bindings extends object = object> = (request: Request, context: NativeRequestContext<Bindings>) => Response | Promise<Response>;
 /** Identity is generated with the bundle, never inferred from its filename. */

package/dist/types/server/worker.d.ts

@@ -1,5 +1,6 @@
 import { type DocumentAsset } from '../document.js';
 import { type RendererIdentity } from '../identity.js';
+import type { WorkerFederationPublication, WorkerFederationTransport } from '../worker-federation/index.js';
 import type { NativeExecutionContext, NativeServerConfig } from './types.js';
 /** Build-validated per-entry inputs a worker bundle cannot read from disk. */
 export interface NativeWorkerEntryResources {
@@ -11,6 +12,22 @@ export interface NativeWorkerEntryResources {
     /** Present only when the entry admits a CSR fallback request. */
     readonly csrFallbackHeader?: string;
     readonly nonce?: string;
+    readonly workerFederation?: {
+        readonly renderer: unknown;
+        readonly worker: WorkerFederationPublication;
+    };
+    readonly workerFederationManifestUrl?: string;
+    readonly workerFederationServices?: readonly {
+        readonly remote: string;
+        readonly alias?: string;
+        readonly manifestUrl: string;
+        readonly binding: string;
+        readonly fragments: readonly {
+            readonly expose: string;
+            readonly boundaryId: string;
+            readonly paths: Readonly<Record<string, string>>;
+        }[];
+    }[];
 }
 export interface NativeWorkerDispatchOptions<Bindings extends object> {
     readonly identity: RendererIdentity;
@@ -20,6 +37,8 @@ export interface NativeWorkerDispatchOptions<Bindings extends object> {
     /** The module worker `env`, forwarded unchanged as the platform binding. */
     readonly bindings: Bindings | undefined;
     readonly executionContext?: NativeExecutionContext;
+    /** Constructed by this compiled renderer entry for this document only. */
+    readonly workerFederation?: WorkerFederationTransport;
 }
 /** Worker Fetch dispatch over the same native handler the Node host loads. */
 export declare function dispatchNativeWorkerRequest<Bindings extends object>(request: Request, options: NativeWorkerDispatchOptions<Bindings>): Promise<Response>;