@bleedingdev/modern-js-renderer-core 3.9.3-ultramodern.7 → 3.9.3-ultramodern.9

package/dist/esm/worker-federation/contract.mjs

@@ -0,0 +1,227 @@
+import { identityCacheKey, readRendererIdentity } from "../identity.mjs";
+const WORKER_FEDERATION_METADATA_KEY = 'ultramodernWorkerFederation';
+const WORKER_FEDERATION_SCHEMA = 'ultramodern.worker-federation';
+const WORKER_FEDERATION_VERSION = 1;
+function workerFederationRecord(value, label) {
+    if (!value || 'object' != typeof value || ![
+        Object.prototype,
+        null
+    ].includes(Object.getPrototypeOf(value))) throw new Error(`Worker federation ${label} must be a plain record.`);
+    return value;
+}
+function exactFields(value, fields, label) {
+    if (Object.keys(value).length !== fields.length || Object.keys(value).some((key)=>!fields.includes(key))) throw new Error(`Worker federation ${label} has unsupported fields.`);
+}
+function requiredString(value, label) {
+    if ('string' != typeof value || 0 === value.length || value.trim() !== value || /[\u0000-\u001f\u007f]/u.test(value)) throw new Error(`Worker federation requires ${label}.`);
+    return value;
+}
+function readWorkerFederationPath(value) {
+    const path = requiredString(value, 'an endpoint path');
+    let decoded;
+    try {
+        decoded = decodeURIComponent(path);
+    } catch  {
+        throw new Error('Worker federation endpoint path has invalid encoding.');
+    }
+    if (!path.startsWith('/') || path.startsWith('//') || /[\\?#\s\u0000-\u001f\u007f]/u.test(decoded) || /%[0-9a-f]{2}/iu.test(decoded) || decoded.split('/').some((segment)=>'.' === segment || '..' === segment) || new URL(path, 'https://worker.invalid').pathname !== path) throw new Error('Worker federation endpoint must be an exact root path.');
+    return path;
+}
+function readWorkerFederationManifestUrl(value) {
+    const url = new URL(value);
+    if (![
+        'http:',
+        'https:'
+    ].includes(url.protocol) || url.username || url.password || url.hash) throw new Error('Worker federation manifest requires an HTTP(S) publication URL.');
+    return url;
+}
+function readWorkerFederationPublication(value, identities) {
+    const record = workerFederationRecord(value, 'publication');
+    exactFields(record, [
+        'schema',
+        'schemaVersion',
+        'remote',
+        'exposes'
+    ], 'publication');
+    if (record.schema !== WORKER_FEDERATION_SCHEMA || record.schemaVersion !== WORKER_FEDERATION_VERSION) throw new Error('Unsupported Worker federation publication protocol.');
+    const remote = requiredString(record.remote, 'a remote');
+    const entries = workerFederationRecord(record.exposes, 'exposes');
+    if (0 === Object.keys(entries).length) throw new Error('Worker federation publication has no exposes.');
+    const paths = new Set();
+    const exposes = Object.fromEntries(Object.entries(entries).map(([expose, raw])=>{
+        if (!/^\.\/[A-Za-z0-9_$@.-]+(?:\/[A-Za-z0-9_$@.-]+)*$/u.test(expose) || expose.slice(2).split('/').some((segment)=>'.' === segment || '..' === segment)) throw new Error(`Unsupported Worker federation expose ${expose}.`);
+        const coordinate = workerFederationRecord(raw, 'expose coordinate');
+        exactFields(coordinate, [
+            'entryName',
+            'boundaryId',
+            'paths',
+            'native'
+        ], 'expose coordinate');
+        const entryName = requiredString(coordinate.entryName, 'an entry name');
+        if (!Object.hasOwn(identities, entryName)) throw new Error(`Worker federation expose ${expose} has no built entry.`);
+        const identity = identities[entryName];
+        identityCacheKey(identity);
+        if (identity.entryName !== entryName) throw new Error('Worker federation entry identity conflicts with its key.');
+        const rawPaths = workerFederationRecord(coordinate.paths, 'locale paths');
+        const native = workerFederationRecord(coordinate.native, 'native authority');
+        exactFields(native, [
+            'publisherBuildId',
+            'runtimeABI'
+        ], 'native authority');
+        if (1 !== native.runtimeABI) throw new Error('Unsupported native Worker federation runtime ABI.');
+        if (0 === Object.keys(rawPaths).length) throw new Error('Worker federation expose has no locale endpoints.');
+        const locales = Object.keys(rawPaths);
+        if (new Set(locales.map((locale)=>locale.toLowerCase())).size !== locales.length || locales.includes('default') && 1 !== locales.length) throw new Error('Worker federation requires unique locales or only default.');
+        const localePaths = Object.fromEntries(Object.entries(rawPaths).map(([locale, rawPath])=>{
+            if (!/^[a-zA-Z0-9]+(?:[-_][a-zA-Z0-9]+)*$/u.test(locale)) throw new Error('Worker federation endpoint has an invalid locale.');
+            const path = readWorkerFederationPath(rawPath);
+            if (paths.has(path)) throw new Error('Worker federation exposes have conflicting endpoint paths.');
+            paths.add(path);
+            return [
+                locale,
+                path
+            ];
+        }));
+        return [
+            expose,
+            Object.freeze({
+                entryName,
+                boundaryId: requiredString(coordinate.boundaryId, 'a boundary ID'),
+                paths: Object.freeze(localePaths),
+                native: Object.freeze({
+                    publisherBuildId: requiredString(native.publisherBuildId, 'a native publisher build ID'),
+                    runtimeABI: 1
+                })
+            })
+        ];
+    }));
+    return Object.freeze({
+        schema: WORKER_FEDERATION_SCHEMA,
+        schemaVersion: WORKER_FEDERATION_VERSION,
+        remote,
+        exposes: Object.freeze(exposes)
+    });
+}
+function workerFederationWireJson(value) {
+    const encode = (input)=>{
+        if (null === input || 'string' == typeof input || 'boolean' == typeof input) return input;
+        if ('number' == typeof input && Number.isFinite(input)) return input;
+        if (Array.isArray(input)) return input.map(encode);
+        const record = workerFederationRecord(input, 'wire value');
+        return Object.fromEntries(Object.keys(record).toSorted().map((key)=>[
+                key,
+                encode(record[key])
+            ]));
+    };
+    return JSON.stringify(encode(value));
+}
+function freezeWireValue(value) {
+    const copy = JSON.parse(workerFederationWireJson(value));
+    const freeze = (input)=>{
+        if (input && 'object' == typeof input) {
+            Object.values(input).forEach(freeze);
+            Object.freeze(input);
+        }
+    };
+    freeze(copy);
+    return copy;
+}
+function readWorkerFederationStyles(options) {
+    const manifest = workerFederationRecord(options.manifest, 'manifest');
+    const metadata = workerFederationRecord(manifest.metaData, 'manifest metadata');
+    const manifestUrl = readWorkerFederationManifestUrl(options.manifestUrl);
+    if (!Array.isArray(manifest.exposes)) throw new Error('Worker federation manifest exposes must be an array.');
+    const selected = manifest.exposes.map((value)=>workerFederationRecord(value, 'manifest expose')).filter((value)=>value.path === options.expose);
+    if (1 !== selected.length) throw new Error('Worker federation styles require one exact manifest expose.');
+    if (void 0 === selected[0].assets) return Object.freeze([]);
+    const assets = workerFederationRecord(selected[0].assets, 'expose assets');
+    if (void 0 === assets.css) return Object.freeze([]);
+    const css = workerFederationRecord(assets.css, 'expose CSS assets');
+    const files = [
+        'sync',
+        'async'
+    ].flatMap((kind)=>{
+        const values = css[kind];
+        if (void 0 === values) return [];
+        if (!Array.isArray(values)) throw new Error('Worker federation CSS assets must be string arrays.');
+        return values.map((value)=>requiredString(value, 'a CSS asset URL'));
+    });
+    if (0 === files.length) return Object.freeze([]);
+    if (void 0 === metadata.publicPath || 'auto' === metadata.publicPath) throw new Error('Worker federation CSS requires a completed static publicPath; auto and getPublicPath cannot resolve styles in a Worker.');
+    const publicPath = requiredString(metadata.publicPath, 'a completed public path');
+    const explicitScheme = /^[a-z][a-z0-9+.-]*:/iu;
+    const isHttpScheme = /^https?:/iu;
+    const assertScheme = (value)=>{
+        if (explicitScheme.test(value) && !isHttpScheme.test(value)) throw new Error('Worker federation styles require an HTTP(S) publication URL.');
+    };
+    assertScheme(publicPath);
+    const publicUrl = new URL(publicPath, manifestUrl);
+    if (![
+        'http:',
+        'https:'
+    ].includes(publicUrl.protocol) || publicUrl.username || publicUrl.password || publicUrl.hash) throw new Error('Worker federation styles require an HTTP(S) publication URL.');
+    const styles = files.map((file)=>{
+        assertScheme(file);
+        const resolved = /^(?:https?:)?\/\//iu.test(file) ? file : `${publicPath.replace(/\/$/u, '')}/${file.replace(/^\//u, '')}`;
+        const url = new URL(resolved, manifestUrl);
+        if (![
+            'http:',
+            'https:'
+        ].includes(url.protocol) || url.username || url.password || url.hash) throw new Error('Worker federation styles require an HTTP(S) publication URL.');
+        return resolved;
+    });
+    return Object.freeze([
+        ...new Set(styles)
+    ]);
+}
+function admitWorkerFederationExpose(options) {
+    const url = readWorkerFederationManifestUrl(options.manifestUrl);
+    const manifest = workerFederationRecord(options.manifest, 'manifest');
+    const metadata = workerFederationRecord(manifest.metaData, 'manifest metadata');
+    const renderer = freezeWireValue(options.admitRendererContract(metadata.ultramodernRenderer));
+    const worker = readWorkerFederationPublication(metadata[WORKER_FEDERATION_METADATA_KEY], renderer.identities);
+    if (worker.remote !== options.remote) throw new Error('Worker federation publication names another remote.');
+    if (!Object.hasOwn(worker.exposes, options.expose)) throw new Error(`Worker federation expose ${options.expose} is not published.`);
+    const coordinate = worker.exposes[options.expose];
+    if (!Object.hasOwn(coordinate.paths, options.locale)) throw new Error('Worker federation locale has no published endpoint.');
+    const path = coordinate.paths[options.locale];
+    const identity = readRendererIdentity(renderer.identities[coordinate.entryName], renderer.identities[coordinate.entryName]);
+    return Object.freeze({
+        authority: Object.freeze({
+            origin: url.origin,
+            renderer,
+            worker
+        }),
+        expose: options.expose,
+        locale: options.locale,
+        coordinate,
+        path,
+        identity,
+        endpoint: new URL(path, url.origin).href,
+        styles: Object.freeze([])
+    });
+}
+function workerFederationEnvelope(kind, admitted, payload) {
+    return {
+        schema: `ultramodern.worker-federation-${kind}`,
+        schemaVersion: 1,
+        authority: admitted.authority,
+        expose: admitted.expose,
+        locale: admitted.locale,
+        payload
+    };
+}
+function readWorkerFederationEnvelope(value, kind, admitted) {
+    const record = workerFederationRecord(value, `${kind} envelope`);
+    exactFields(record, [
+        'schema',
+        'schemaVersion',
+        'authority',
+        'expose',
+        'locale',
+        'payload'
+    ], `${kind} envelope`);
+    if (record.schema !== `ultramodern.worker-federation-${kind}` || 1 !== record.schemaVersion || record.expose !== admitted.expose || record.locale !== admitted.locale || workerFederationWireJson(record.authority) !== workerFederationWireJson(admitted.authority)) throw new Error(`Worker federation ${kind} conflicts with the admitted publication.`);
+    return record.payload;
+}
+export { WORKER_FEDERATION_METADATA_KEY, WORKER_FEDERATION_SCHEMA, WORKER_FEDERATION_VERSION, admitWorkerFederationExpose, readWorkerFederationEnvelope, readWorkerFederationManifestUrl, readWorkerFederationPath, readWorkerFederationPublication, readWorkerFederationStyles, workerFederationEnvelope, workerFederationRecord, workerFederationWireJson };

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

@@ -0,0 +1,159 @@
+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/worker-federation/index.mjs

@@ -0,0 +1,3 @@
+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/worker-federation/lease.mjs

@@ -0,0 +1,107 @@
+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 };