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

package/dist/esm-node/server/dispatch.mjs

@@ -0,0 +1,308 @@
+import "node:module";
+import { untilAborted } from "../abort.mjs";
+import { assertRendererIdentity, identityCacheKey } from "../identity.mjs";
+import { createRequestSession, documentCacheKey, headerMaxAgeSeconds, permitsDocumentCache, policyHeaders, responseHeaders } from "../session/index.mjs";
+function rejectNativeRscRequest(request) {
+    if (request.headers.has('x-rsc-tree') || request.headers.has('x-rsc-action')) return Response.json({
+        code: 'unsupported-renderer-capability',
+        capability: 'rsc'
+    }, {
+        status: 400,
+        headers: {
+            'cache-control': 'no-store'
+        }
+    });
+}
+function permitsCacheLookup(request) {
+    const url = new URL(request.url);
+    const cacheControl = request.headers.get('cache-control') ?? '';
+    return 'GET' === request.method && !request.headers.has('authorization') && !request.headers.has('cookie') && !request.headers.has('range') && !request.headers.has('if-none-match') && !request.headers.has('if-modified-since') && !request.headers.has('if-match') && !request.headers.has('if-unmodified-since') && !/(?:^|,)\s*(?:private|no-store|no-cache)(?:\s|,|=|$)/i.test(cacheControl) && !/(?:^|,)\s*max-age\s*=\s*(?:0+|"0+")\s*(?:,|$)/i.test(cacheControl) && !/(?:^|,)\s*min-fresh(?:\s|,|=|$)/i.test(cacheControl) && (cacheControl.match(/(?:^|,)\s*max-age\s*=/gi)?.length ?? 0) <= 1 && !request.headers.get('pragma')?.split(',').some((directive)=>'no-cache' === directive.trim().toLowerCase()) && !url.searchParams.has('__loader') && !url.searchParams.has('__ssrDirect');
+}
+function requestMaxAgeSeconds(request) {
+    const match = /(?:^|,)\s*max-age\s*=\s*(?:(\d+)|"(\d+)")\s*(?:,|$)/i.exec(request.headers.get('cache-control') ?? '');
+    return match ? Number(match[1] ?? match[2]) : void 0;
+}
+function documentAgeSeconds(document) {
+    return Math.floor((Date.now() - document.storedAt) / 1000);
+}
+function isReusableDocument(document, key, maxAgeSeconds) {
+    return document.identityKey === key && Number.isFinite(document.storedAt) && document.storedAt <= Date.now() && (void 0 === maxAgeSeconds || Date.now() - document.storedAt < 1000 * maxAgeSeconds) && document.expiresAt > Date.now() && 200 === document.status && document.bytes instanceof Uint8Array && permitsDocumentCache({
+        kind: 'document',
+        status: document.status,
+        headers: document.headers,
+        cache: {
+            mode: 'public',
+            maxAgeSeconds: 1
+        }
+    }) && !policyHeaders(document.headers).has('vary');
+}
+function defaultStatusText(status) {
+    return new Response(null, {
+        status
+    }).statusText;
+}
+function normalizeTerminalResponse(response, session) {
+    if (session.committedPolicy) {
+        if (response.status !== session.committedPolicy.status) throw new Error('Native handler changed HTTP status after committing its response policy.');
+        if (response.statusText !== (session.committedPolicy.statusText ?? defaultStatusText(session.committedPolicy.status))) throw new Error('Native handler changed HTTP status text after committing its response policy.');
+        if (!session.ownsResponseBody(response)) throw new Error('Native handler returned a body outside its committed request session.');
+        return response;
+    }
+    session.resolveResponse({
+        kind: 'terminal',
+        status: response.status,
+        statusText: response.statusText,
+        headers: responseHeaders(response.headers),
+        cache: {
+            mode: 'no-store'
+        }
+    });
+    return session.respond(response.body);
+}
+async function chooseCSR(request, manifest, context) {
+    const url = new URL(request.url);
+    if ('GET' !== request.method && 'HEAD' !== request.method || url.searchParams.has('__loader') || url.searchParams.has('__ssrDirect')) return false;
+    const config = context.serverConfig;
+    if (config?.ssr === false || config?.forceCSR) return true;
+    const selectedIds = config?.ssrByRouteIds;
+    if (!selectedIds?.length) return false;
+    if (!manifest.nativeMatchRouteIds) throw new Error('unsupported-renderer-capability: ssrByRouteIds requires native route matching.');
+    const matchedIds = await untilAborted(manifest.nativeMatchRouteIds(request, context), context.session.signal);
+    const leafId = matchedIds.at(-1);
+    return !leafId || !selectedIds.includes(leafId);
+}
+function captureDocument(response, session, options, key, identityKey) {
+    if (!response.body || !options.cache) return response;
+    const reader = response.body.getReader();
+    const chunks = [];
+    const maximum = options.maxCacheBytes ?? 2097152;
+    let total = 0;
+    let canCapture = Number.isSafeInteger(maximum) && maximum > 0;
+    let delivered;
+    const nativeHeaders = responseHeaders(response.headers);
+    const body = new ReadableStream({
+        async pull (controller) {
+            try {
+                const part = await reader.read();
+                if (!part.done) {
+                    if (canCapture) {
+                        total += part.value.byteLength;
+                        if (total <= maximum) chunks.push(part.value.slice());
+                        else {
+                            canCapture = false;
+                            chunks.length = 0;
+                        }
+                    }
+                    controller.enqueue(part.value);
+                    return;
+                }
+                reader.releaseLock();
+                const completion = await session.completion;
+                const policy = session.committedPolicy;
+                if (canCapture && completion.cacheEligible && policy?.cache.mode === 'public' && policy.cache.maxAgeSeconds > 0 && 200 === delivered.status && !delivered.headers.has('vary') && permitsDocumentCache({
+                    ...policy,
+                    status: delivered.status,
+                    headers: responseHeaders(delivered.headers)
+                })) {
+                    const maxAgeSeconds = policy.cache.maxAgeSeconds;
+                    const bytes = new Uint8Array(total);
+                    let offset = 0;
+                    for (const chunk of chunks){
+                        bytes.set(chunk, offset);
+                        offset += chunk.byteLength;
+                    }
+                    const commit = async (headers)=>{
+                        if (!headers || headers.has('vary') || !permitsDocumentCache({
+                            ...policy,
+                            status: delivered.status,
+                            headers: responseHeaders(headers)
+                        })) return;
+                        const lifetimeSeconds = Math.min(maxAgeSeconds, ...headerMaxAgeSeconds(headers));
+                        const age = headers.get('age')?.trim() ?? '0';
+                        const date = Date.parse(headers.get('date') ?? '');
+                        const ageSeconds = Math.max(/^\d+$/u.test(age) ? Number(age) : 0, Number.isFinite(date) ? Math.floor((Date.now() - date) / 1000) : 0);
+                        if (lifetimeSeconds - ageSeconds <= 0) return;
+                        try {
+                            const storedAt = Date.now() - 1000 * ageSeconds;
+                            await options.cache?.set(key, {
+                                identityKey,
+                                storedAt,
+                                expiresAt: storedAt + 1000 * lifetimeSeconds,
+                                status: 200,
+                                statusText: delivered.statusText,
+                                headers: nativeHeaders,
+                                bytes
+                            });
+                        } catch (error) {
+                            options.onCacheError?.(error);
+                        }
+                    };
+                    if (options.confirmDelivery) {
+                        chunks.length = 0;
+                        controller.close();
+                        options.confirmDelivery(delivered).then(commit).catch((error)=>{
+                            options.onCacheError?.(error);
+                        });
+                        return;
+                    }
+                    commit(delivered.headers).catch((error)=>{
+                        options.onCacheError?.(error);
+                    });
+                }
+                chunks.length = 0;
+                controller.close();
+            } catch (error) {
+                chunks.length = 0;
+                session.fail(error);
+                await session.completion;
+                controller.error(error);
+            }
+        },
+        async cancel (reason) {
+            chunks.length = 0;
+            reader.cancel(reason).catch(()=>void 0);
+            session.abort(reason);
+            await session.completion;
+            reader.releaseLock();
+        }
+    }, {
+        highWaterMark: 0
+    });
+    delivered = new Response(body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+    });
+    return delivered;
+}
+function openSession(request, options) {
+    const session = createRequestSession({
+        request,
+        identity: options.identity,
+        platform: {
+            kind: options.platform ?? 'node',
+            bindings: options.context.bindings
+        }
+    });
+    options.executionContext?.waitUntil(session.completion);
+    return session;
+}
+async function dispatchNativeRequest(request, options) {
+    const rscRejection = rejectNativeRscRequest(request);
+    if (rscRejection) return rscRejection;
+    const identityKey = identityCacheKey(options.identity);
+    if ('react' === options.identity.renderer) throw new Error('Native dispatch requires Solid or Octane.');
+    let session = openSession(request, options);
+    const { bindings: _bindings, ...renderContext } = options.context;
+    let context = {
+        ...renderContext,
+        session,
+        entry: session.identity
+    };
+    let handlerStarted = false;
+    try {
+        session.signal.throwIfAborted();
+        const manifest = await untilAborted(options.loadManifest(), session.signal);
+        assertRendererIdentity(manifest.rendererIdentity, options.identity);
+        if ('function' != typeof manifest.nativeRequestHandler) throw new Error('Native renderer manifest has no request handler.');
+        const csr = await chooseCSR(request, manifest, context);
+        session.signal.throwIfAborted();
+        if (csr && !manifest.nativeCSRRequestHandler) throw new Error('unsupported-renderer-capability: selected CSR requires a native document handler.');
+        if (csr) session.markFallback();
+        if (void 0 !== options.hydrationBuildId && ('string' != typeof options.hydrationBuildId || !options.hydrationBuildId.trim())) throw new Error('Native hydration cache identity requires a nonempty build ID.');
+        const cacheKey = documentCacheKey(options.identity, JSON.stringify([
+            request.url,
+            options.hydrationBuildId ?? options.identity.buildId,
+            options.context.assets ?? [],
+            options.context.nonce ?? null
+        ]));
+        const cacheAllowed = !csr && permitsCacheLookup(request);
+        if (cacheAllowed && options.cache) try {
+            const cached = await untilAborted(options.cache.get(cacheKey), session.signal);
+            if (cached && isReusableDocument(cached, identityKey, requestMaxAgeSeconds(request))) {
+                const age = documentAgeSeconds(cached);
+                session.resolveResponse({
+                    kind: 'terminal',
+                    status: cached.status,
+                    statusText: cached.statusText,
+                    headers: [
+                        ...cached.headers.filter(([name])=>'age' !== name.toLowerCase()),
+                        [
+                            'age',
+                            String(age)
+                        ]
+                    ],
+                    cache: {
+                        mode: 'no-store'
+                    }
+                });
+                return session.respond(new ReadableStream({
+                    start (controller) {
+                        controller.enqueue(cached.bytes.slice());
+                        controller.close();
+                    }
+                }));
+            }
+        } catch (error) {
+            if (session.signal.aborted) throw error;
+            options.onCacheError?.(error);
+        }
+        session.signal.throwIfAborted();
+        handlerStarted = true;
+        let response = await untilAborted((csr ? manifest.nativeCSRRequestHandler : manifest.nativeRequestHandler)(request, context), session.signal);
+        if (!(response instanceof Response)) throw new TypeError('Native renderer handler must return a Fetch Response.');
+        response = normalizeTerminalResponse(response, session);
+        if ('HEAD' === request.method && response.body) {
+            response.body.cancel().catch(()=>{});
+            return new Response(null, {
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers
+            });
+        }
+        return cacheAllowed ? captureDocument(response, session, options, cacheKey, identityKey) : response;
+    } catch (error) {
+        const committed = void 0 !== session.committedPolicy;
+        session.fail(error);
+        await session.completion;
+        if (!handlerStarted || committed || request.signal.aborted || !options.onError) throw error;
+        session = openSession(request, options);
+        session.markFallback();
+        context = {
+            ...context,
+            session
+        };
+        try {
+            const response = await untilAborted(options.onError(error, request, context), session.signal);
+            if (!(response instanceof Response)) throw new TypeError('Native fallback must return a Fetch Response.');
+            const owned = normalizeTerminalResponse(response, session);
+            if ('HEAD' === request.method && owned.body) {
+                owned.body.cancel().catch(()=>{});
+                return new Response(null, {
+                    status: owned.status,
+                    statusText: owned.statusText,
+                    headers: owned.headers
+                });
+            }
+            return owned;
+        } catch (fallbackError) {
+            session.fail(fallbackError);
+            await session.completion;
+            throw fallbackError;
+        }
+    }
+}
+function dispatchNativeNodeRequest(request, options) {
+    const fetchRequest = null === request.body ? request : new Request(request.url, {
+        method: request.method,
+        headers: request.headers,
+        body: request.body,
+        signal: request.signal,
+        duplex: 'half'
+    });
+    return dispatchNativeRequest(fetchRequest, {
+        ...options,
+        platform: 'node'
+    });
+}
+export { dispatchNativeNodeRequest, dispatchNativeRequest, rejectNativeRscRequest };

package/dist/esm-node/server/index.mjs

@@ -0,0 +1,4 @@
+import "node:module";
+export { RENDERER_ASSET_MANIFEST_FILE, validateNativeClientAssetManifest } from "./assets.mjs";
+export { dispatchNativeNodeRequest, dispatchNativeRequest, rejectNativeRscRequest } from "./dispatch.mjs";
+export { dispatchNativeWorkerRequest } from "./worker.mjs";

package/dist/esm-node/server/types.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/server/worker.mjs

@@ -0,0 +1,36 @@
+import "node:module";
+import { collectDocumentAssets } from "../document.mjs";
+import { assertRendererIdentity } from "../identity.mjs";
+import { dispatchNativeRequest, rejectNativeRscRequest } from "./dispatch.mjs";
+function workerManifest(bundle, identity) {
+    const candidate = bundle && 'object' == typeof bundle && !('rendererIdentity' in bundle) && 'default' in bundle ? bundle.default : bundle;
+    if (!candidate || 'object' != typeof candidate && 'function' != typeof candidate || !('rendererIdentity' in candidate) || !('nativeRequestHandler' in candidate) || 'function' != typeof candidate.nativeRequestHandler) throw new Error('Native worker bundle requires its renderer identity and request handler.');
+    assertRendererIdentity(candidate.rendererIdentity, identity);
+    return candidate;
+}
+function dispatchNativeWorkerRequest(request, options) {
+    const rejection = rejectNativeRscRequest(request);
+    if (rejection) return Promise.resolve(rejection);
+    const { resources } = options;
+    const query = new URL(request.url).searchParams;
+    const forceCSR = Boolean(resources.csrFallbackHeader && (query.get('csr') || request.headers.get(resources.csrFallbackHeader)));
+    const bindings = null !== options.bindings && 'object' == typeof options.bindings ? options.bindings : {};
+    return dispatchNativeRequest(request, {
+        identity: options.identity,
+        platform: 'worker',
+        executionContext: options.executionContext,
+        hydrationBuildId: resources.hydrationBuildId,
+        loadManifest: ()=>workerManifest(options.bundle, options.identity),
+        context: {
+            assets: collectDocumentAssets(resources.assets),
+            nativeManifest: resources.nativeManifest,
+            bindings,
+            serverConfig: {
+                ...resources.serverConfig,
+                forceCSR
+            },
+            nonce: resources.nonce
+        }
+    });
+}
+export { dispatchNativeWorkerRequest };

package/dist/esm-node/session/cache.mjs

@@ -0,0 +1,117 @@
+import "node:module";
+import { identityCacheKey } from "../identity.mjs";
+function documentCacheKey(identity, requestKey) {
+    if ('string' != typeof requestKey || 0 === requestKey.length) throw new TypeError('A document cache request key must be nonempty.');
+    return JSON.stringify([
+        identityCacheKey(identity),
+        requestKey
+    ]);
+}
+function responseHeaders(headers) {
+    const fields = [];
+    headers.forEach((value, name)=>{
+        if ('set-cookie' !== name) fields.push([
+            name,
+            value
+        ]);
+    });
+    for (const cookie of headers.getSetCookie())fields.push([
+        'set-cookie',
+        cookie
+    ]);
+    return fields;
+}
+function policyHeaders(headers) {
+    const result = new Headers();
+    for (const [name, value] of headers)result.append(name, value);
+    return result;
+}
+const NO_STORE = {
+    mode: 'no-store',
+    ages: []
+};
+const CACHE_DIRECTIVE = /\s*([!#$%&'*+.^_`|~\w-]+)\s*(?:=\s*([!#$%&'*+.^_`|~\w-]+|"(?:[^"\\]|\\.)*"))?\s*(?:,|$)/uy;
+function parseCacheControl(value) {
+    const directives = [];
+    let index = 0;
+    while(index < value.length){
+        CACHE_DIRECTIVE.lastIndex = index;
+        const match = CACHE_DIRECTIVE.exec(value);
+        if (!match || CACHE_DIRECTIVE.lastIndex === index) return;
+        directives.push({
+            name: match[1].toLowerCase(),
+            value: match[2]
+        });
+        index = CACHE_DIRECTIVE.lastIndex;
+    }
+    return directives;
+}
+function cacheDirectives(value) {
+    let mode = 'public';
+    const ages = [];
+    const ageNames = new Set();
+    const parsed = parseCacheControl(value ?? '');
+    if (!parsed) return NO_STORE;
+    for (const { name, value: raw } of parsed){
+        if ('no-store' === name || 'no-cache' === name) mode = 'no-store';
+        else if ('private' === name && 'no-store' !== mode) mode = 'private';
+        if ('max-age' === name || 's-maxage' === name) {
+            const age = Number(raw);
+            if (ageNames.has(name) || !/^\d+$/u.test(raw ?? '') || !Number.isSafeInteger(age)) return NO_STORE;
+            ageNames.add(name);
+            ages.push(age);
+        }
+    }
+    return {
+        mode,
+        ages
+    };
+}
+function headerMaxAgeSeconds(headers) {
+    return cacheDirectives(headers.get('cache-control')).ages;
+}
+function headerCacheMode(headers, ages) {
+    const control = cacheDirectives(headers.get('cache-control'));
+    ages.push(...control.ages);
+    if (headers.has('set-cookie') || headers.get('vary')?.split(',').some((value)=>'*' === value.trim())) return 'no-store';
+    return control.mode;
+}
+function isSingleHtmlContentType(headers) {
+    const type = headers.get('content-type');
+    return !type?.includes(',') && type?.split(';')[0].trim().toLowerCase() === 'text/html';
+}
+function permitsDocumentCache(policy) {
+    if ('document' !== policy.kind || 200 !== policy.status || 'public' !== policy.cache.mode) return false;
+    const headers = policyHeaders(policy.headers);
+    return 'public' === headerCacheMode(headers, []) && isSingleHtmlContentType(headers);
+}
+function restrictDocumentCache(policy, sources, outgoing) {
+    const original = policyHeaders(policy.headers);
+    let mode = policy.cache.mode;
+    const ages = 'public' === policy.cache.mode ? [
+        policy.cache.maxAgeSeconds
+    ] : [];
+    for (const headers of [
+        original,
+        ...sources,
+        outgoing
+    ]){
+        const restricted = headerCacheMode(headers, ages);
+        if ('no-store' === restricted) mode = 'no-store';
+        else if ('private' === restricted && 'public' === mode) mode = 'private';
+    }
+    if ('document' !== policy.kind || 200 !== policy.status || !isSingleHtmlContentType(original) || !isSingleHtmlContentType(outgoing)) mode = 'no-store';
+    if ('public' === mode) {
+        const maxAgeSeconds = Math.min(...ages);
+        outgoing.set('cache-control', `public, max-age=${maxAgeSeconds}, s-maxage=${maxAgeSeconds}, must-revalidate`);
+        return {
+            mode,
+            maxAgeSeconds
+        };
+    }
+    outgoing.set('cache-control', 'private' === mode ? 'private, max-age=0, must-revalidate' : 'no-store');
+    return {
+        mode
+    };
+}
+export { documentCacheKey, headerMaxAgeSeconds, parseCacheControl, permitsDocumentCache, policyHeaders, responseHeaders, restrictDocumentCache };

package/dist/esm-node/session/index.mjs

@@ -0,0 +1,4 @@
+import "node:module";
+export { untilAborted } from "../abort.mjs";
+export { documentCacheKey, headerMaxAgeSeconds, permitsDocumentCache, policyHeaders, responseHeaders, restrictDocumentCache } from "./cache.mjs";
+export { createRequestSession } from "./request.mjs";