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

package/dist/esm/data/server.mjs

@@ -0,0 +1,723 @@
+import { untilAborted } from "../abort.mjs";
+import { identityCacheKey } from "../identity.mjs";
+import { parseCacheControl, responseHeaders } from "../session/cache.mjs";
+import { readBoundedDataText } from "./body.mjs";
+import { DataProtocolError, assertPublicData, serializePublicData } from "./codec.mjs";
+import { createRequestDataPolicy } from "./private.mjs";
+import { DATA_CONTENT_TYPE, DATA_PROTOCOL_VERSION, DATA_STREAM_CONTENT_TYPE, LOADER_ID_PARAM } from "./types.mjs";
+const DEFERRED = Symbol('ultramodern.data.deferred');
+const REDIRECT_STATUSES = new Set([
+    301,
+    302,
+    303,
+    307,
+    308
+]);
+const BODYLESS_STATUSES = new Set([
+    204,
+    205,
+    304
+]);
+const REPRESENTATION_HEADERS = new Set([
+    'content-type',
+    'content-length',
+    'content-encoding',
+    'content-digest',
+    'repr-digest',
+    'digest',
+    'transfer-encoding',
+    'content-range',
+    'accept-ranges',
+    'content-disposition',
+    'content-language',
+    'content-location',
+    'etag',
+    'last-modified',
+    'location'
+]);
+function mergeHeaderFields(primary, secondary) {
+    const primaryNames = new Set(primary.map(([name])=>name.toLowerCase()));
+    return [
+        ...primary.map(([name, value])=>[
+                name,
+                value
+            ]),
+        ...secondary.filter(([name])=>ACCUMULATED_HEADERS.has(name.toLowerCase()) || !primaryNames.has(name.toLowerCase())).map(([name, value])=>[
+                name,
+                value
+            ])
+    ];
+}
+const HOP_BY_HOP_HEADERS = new Set([
+    'connection',
+    'keep-alive',
+    'proxy-connection',
+    'te',
+    'trailer',
+    'upgrade'
+]);
+function projectedHeaderFilter(headers) {
+    const stripped = new Set([
+        ...REPRESENTATION_HEADERS,
+        ...HOP_BY_HOP_HEADERS
+    ]);
+    for (const [name, value] of headers)if ('connection' === name.toLowerCase()) {
+        for (const field of value.split(','))if (field.trim()) stripped.add(field.trim().toLowerCase());
+    }
+    return (name)=>!stripped.has(name.toLowerCase());
+}
+const outcomePolicies = new WeakMap();
+function deferData(critical, deferred, init) {
+    for (const record of [
+        critical,
+        deferred
+    ]){
+        if (null === record || 'object' != typeof record || Object.getPrototypeOf(record) !== Object.prototype && null !== Object.getPrototypeOf(record)) throw new DataProtocolError('Deferred data requires plain critical and deferred records');
+        for (const key of Reflect.ownKeys(record)){
+            const descriptor = Object.getOwnPropertyDescriptor(record, key);
+            if (descriptor.get || descriptor.set) throw new DataProtocolError('Deferred data must not contain accessors');
+            if ('symbol' == typeof key || !descriptor.enumerable) throw new DataProtocolError('Deferred data keys must be enumerable strings');
+        }
+    }
+    assertPublicData(critical);
+    for (const [key, promise] of Object.entries(deferred)){
+        if (Object.hasOwn(critical, key) || !(promise instanceof Promise)) throw new DataProtocolError('Deferred data needs unique keys and Promise values');
+        promise.catch(()=>void 0);
+    }
+    return {
+        [DEFERRED]: true,
+        critical,
+        deferred: Object.fromEntries(Object.entries(deferred)),
+        ...void 0 === init ? {} : {
+            init
+        }
+    };
+}
+function cacheLifetime(cacheControl) {
+    const directives = parseCacheControl(cacheControl);
+    if (!directives) return;
+    const names = new Set();
+    const ages = [];
+    for (const { name, value: raw } of directives){
+        if ('max-age' !== name && 's-maxage' !== name) continue;
+        if (void 0 === raw) return;
+        if (names.has(name) || !/^\d+$/.test(raw)) return;
+        const age = Number(raw);
+        if (!Number.isSafeInteger(age)) return;
+        names.add(name);
+        ages.push(age);
+    }
+    if (!names.has('max-age')) return;
+    return ages.length > 0 ? Math.min(...ages) : void 0;
+}
+const ACCUMULATED_HEADERS = new Set([
+    'set-cookie',
+    'vary',
+    'link',
+    'server-timing',
+    'content-security-policy',
+    'content-security-policy-report-only'
+]);
+function mergeDataResponseMetadata(outcomes, nativeResponse) {
+    const headers = new Headers();
+    let cachePolicy = 'public';
+    for (const outcome of outcomes){
+        for (const [name, value] of outcome.response.headers)if (ACCUMULATED_HEADERS.has(name.toLowerCase())) headers.append(name, value);
+        else headers.set(name, value);
+        if ('success' !== outcome.kind || 'no-store' === outcome.response.cachePolicy) cachePolicy = 'no-store';
+        else if ('private' === outcome.response.cachePolicy && 'public' === cachePolicy) cachePolicy = 'private';
+    }
+    const vary = headers.get('vary');
+    if (null !== vary) {
+        const fields = new Map();
+        for (const field of vary.split(',')){
+            const name = field.trim();
+            const key = name.toLowerCase();
+            if (name && !fields.has(key)) fields.set(key, name);
+        }
+        headers.set('vary', [
+            ...fields.values()
+        ].join(', '));
+    }
+    if (0 === outcomes.length || headers.has('set-cookie') || nativeResponse.status >= 400) cachePolicy = 'no-store';
+    if ('no-store' !== cachePolicy) {
+        const ages = outcomes.map((outcome)=>cacheLifetime(new Headers(outcome.response.headers).get('cache-control') ?? ''));
+        if ('public' === cachePolicy && ages.some((age)=>void 0 === age)) cachePolicy = 'no-store';
+        else {
+            const maxAge = Math.min(...ages.map((age)=>age ?? 0));
+            headers.set('cache-control', 'private' === cachePolicy ? `private, max-age=${maxAge}, must-revalidate` : `public, max-age=${maxAge}`);
+        }
+    }
+    if ('no-store' === cachePolicy) headers.set('cache-control', 'no-store');
+    return {
+        status: nativeResponse.status,
+        statusText: nativeResponse.statusText ?? '',
+        headers: responseHeaders(headers),
+        cachePolicy
+    };
+}
+function dataMetadataToDocumentPolicy(metadata) {
+    const headers = new Headers();
+    const fields = [
+        ...metadata.headers
+    ];
+    const keep = projectedHeaderFilter(fields);
+    for (const [name, value] of fields)if (keep(name)) headers.append(name, value);
+    headers.set('content-type', 'text/html; charset=utf-8');
+    let cache = {
+        mode: 'no-store'
+    };
+    const cacheControl = headers.get('cache-control') ?? '';
+    const directives = cacheDirectiveNames(cacheControl);
+    if ('private' === metadata.cachePolicy) cache = {
+        mode: 'private'
+    };
+    if ('public' === metadata.cachePolicy && 200 === metadata.status && !headers.has('set-cookie') && !directives.has('private') && !directives.has('no-store') && !directives.has('no-cache') && !headers.get('vary')?.split(',').some((value)=>'*' === value.trim())) {
+        const maxAgeSeconds = cacheLifetime(cacheControl);
+        if (void 0 !== maxAgeSeconds) cache = {
+            mode: 'public',
+            maxAgeSeconds
+        };
+    }
+    if (headers.has('set-cookie') || metadata.status >= 400) cache = {
+        mode: 'no-store'
+    };
+    if ('no-store' === cache.mode) headers.set('cache-control', 'no-store');
+    else if ('private' === cache.mode && !directives.has('private')) headers.set('cache-control', 'private');
+    return {
+        kind: 'document',
+        status: metadata.status,
+        headers: responseHeaders(headers),
+        cache
+    };
+}
+function listFieldElements(value) {
+    const elements = [];
+    let current = '';
+    let quoted = false;
+    let bracketed = false;
+    for(let index = 0; index < value.length; index++){
+        const char = value[index];
+        if (quoted) {
+            current += char;
+            if ('\\' === char && index + 1 < value.length) current += value[++index];
+            else if ('"' === char) quoted = false;
+        } else if ('"' === char) {
+            quoted = true;
+            current += char;
+        } else if ('<' === char) {
+            bracketed = true;
+            current += char;
+        } else if ('>' === char) {
+            bracketed = false;
+            current += char;
+        } else if (',' !== char || bracketed) current += char;
+        else {
+            if (current.trim()) elements.push(current.trim());
+            current = '';
+        }
+    }
+    if (current.trim()) elements.push(current.trim());
+    return elements;
+}
+function mergeDataResponseIntoResponse(response, metadata) {
+    const headers = new Headers(response.headers);
+    const nativeCookies = headers.getSetCookie();
+    const metadataHeaders = dataMetadataToDocumentPolicy(metadata).headers;
+    const metadataCookies = [];
+    for (const [name, value] of metadataHeaders){
+        const headerName = name.toLowerCase();
+        if ('set-cookie' === headerName) metadataCookies.push(value);
+        else if (ACCUMULATED_HEADERS.has(headerName) && 'vary' !== headerName) {
+            const present = new Set(listFieldElements(headers.get(name) ?? ''));
+            const missing = listFieldElements(value).filter((item)=>!present.has(item));
+            if (missing.length) headers.append(name, missing.join(', '));
+        } else if ('vary' === headerName) {
+            const fields = new Map();
+            for (const field of `${headers.get('vary') ?? ''},${value}`.split(',')){
+                const item = field.trim();
+                if (item && !fields.has(item.toLowerCase())) fields.set(item.toLowerCase(), item);
+            }
+            headers.set('vary', [
+                ...fields.values()
+            ].join(', '));
+        } else if (!headers.has(name)) headers.set(name, value);
+    }
+    if (metadataCookies.length > 0) {
+        headers.delete('set-cookie');
+        const counts = new Map();
+        for (const cookie of metadataCookies){
+            headers.append('set-cookie', cookie);
+            counts.set(cookie, (counts.get(cookie) ?? 0) + 1);
+        }
+        for (const cookie of nativeCookies){
+            const remaining = counts.get(cookie) ?? 0;
+            if (remaining > 0) counts.set(cookie, remaining - 1);
+            else headers.append('set-cookie', cookie);
+        }
+    }
+    headers.set('cache-control', 'no-store');
+    return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers
+    });
+}
+function cacheDirectiveNames(cacheControl) {
+    const directives = parseCacheControl(cacheControl);
+    return directives ? new Set(directives.map(({ name })=>name)) : new Set([
+        'no-store'
+    ]);
+}
+function responseMetadata(init = {}) {
+    const status = init.status ?? 200;
+    if (!Number.isInteger(status) || status < 200 || status > 599) throw new DataProtocolError('A data response requires a valid HTTP response status');
+    const headers = new Headers(init.headers);
+    const directives = cacheDirectiveNames(headers.get('cache-control') ?? '');
+    return {
+        status,
+        statusText: init.statusText ?? '',
+        headers: responseHeaders(headers),
+        cachePolicy: directives.has('no-store') || directives.has('no-cache') ? 'no-store' : directives.has('private') ? 'private' : directives.has('public') ? 'public' : 'no-store'
+    };
+}
+const DOM_EXCEPTION_FIELDS = {
+    name: Object.getOwnPropertyDescriptor(DOMException.prototype, 'name')?.get,
+    message: Object.getOwnPropertyDescriptor(DOMException.prototype, 'message')?.get
+};
+function publicDataError(error, production = true) {
+    const fallback = {
+        name: 'Error',
+        message: 'Unexpected Server Error'
+    };
+    if (production) return fallback;
+    if (error instanceof Error || error instanceof DOMException) {
+        const field = (key)=>{
+            let object = error;
+            for(let depth = 0; null !== object && depth < 100; depth++){
+                const descriptor = Object.getOwnPropertyDescriptor(object, key);
+                if (descriptor) {
+                    if ('string' == typeof descriptor.value) return descriptor.value;
+                    const intrinsic = object === DOMException.prototype && 'stack' !== key ? DOM_EXCEPTION_FIELDS[key] : void 0;
+                    if (intrinsic && descriptor.get === intrinsic) {
+                        const value = intrinsic.call(error);
+                        return 'string' == typeof value ? value : void 0;
+                    }
+                    break;
+                }
+                object = Object.getPrototypeOf(object);
+            }
+        };
+        try {
+            const name = field('name') ?? fallback.name;
+            const message = field('message') ?? fallback.message;
+            const stack = field('stack');
+            return {
+                name,
+                message,
+                ...stack ? {
+                    stack
+                } : {}
+            };
+        } catch  {}
+    }
+    return fallback;
+}
+async function responseValue(response, signal) {
+    if (BODYLESS_STATUSES.has(response.status) || null === response.body) return;
+    const text = await readBoundedDataText(response, signal);
+    if (/\bapplication\/(?:[^;]+\+)?json\b/i.test(response.headers.get('content-type') ?? '')) try {
+        return JSON.parse(text);
+    } catch  {
+        throw new DataProtocolError('A data Response contains malformed JSON');
+    }
+    return text;
+}
+async function normalizeDataResult(value, options = {}) {
+    const thrown = options.thrown ?? false;
+    const production = options.production ?? true;
+    if (value instanceof Response) {
+        const response = responseMetadata(value);
+        if (REDIRECT_STATUSES.has(value.status)) {
+            const location = value.headers.get('location');
+            if (!location) throw new DataProtocolError('A redirect data Response requires Location');
+            value.body?.cancel().catch(()=>void 0);
+            return {
+                kind: 'redirect',
+                location,
+                response
+            };
+        }
+        const data = await responseValue(value, options.signal);
+        assertPublicData(data);
+        if (404 === value.status) return {
+            kind: 'not-found',
+            value: data,
+            thrown,
+            response
+        };
+        if (thrown || value.status >= 400) return {
+            kind: 'error',
+            error: {
+                name: 'DataResponseError',
+                message: value.status >= 500 && production ? 'Unexpected Server Error' : value.statusText || `Data request failed (${value.status})`
+            },
+            ...value.status >= 500 && production ? {} : {
+                data
+            },
+            thrown,
+            response
+        };
+        return {
+            kind: 'success',
+            value: data,
+            response
+        };
+    }
+    if (thrown) return {
+        kind: 'error',
+        error: publicDataError(value, production),
+        thrown: true,
+        response: responseMetadata({
+            status: 500,
+            headers: {
+                'cache-control': 'no-store'
+            }
+        })
+    };
+    if (value && 'object' == typeof value && DEFERRED in value) {
+        const data = value;
+        const response = responseMetadata(data.init);
+        if (REDIRECT_STATUSES.has(response.status) || response.status >= 400 || BODYLESS_STATUSES.has(response.status)) throw new DataProtocolError('Deferred data must have a successful body-bearing response status');
+        return {
+            kind: 'deferred',
+            critical: data.critical,
+            deferred: data.deferred,
+            response
+        };
+    }
+    assertPublicData(value);
+    return {
+        kind: 'success',
+        value,
+        response: responseMetadata()
+    };
+}
+async function invokeRouteData(handler, input, options = {}) {
+    input.request.signal.throwIfAborted();
+    const policy = createRequestDataPolicy([
+        input.context,
+        input.request,
+        ...options.privateValues ?? []
+    ]);
+    return invokeOwnedRouteData(handler, input, options, policy);
+}
+async function invokeOwnedRouteData(handler, input, options, policy) {
+    input.request.signal.throwIfAborted();
+    let value;
+    let thrown = false;
+    try {
+        value = await untilAborted(handler(input), input.request.signal);
+    } catch (error) {
+        input.request.signal.throwIfAborted();
+        value = error;
+        thrown = true;
+    }
+    if (input.request.signal.aborted) {
+        if (value instanceof Response) value.body?.cancel(input.request.signal.reason).catch(()=>void 0);
+        input.request.signal.throwIfAborted();
+    }
+    policy.assertRoot(value);
+    let outcome = await normalizeDataResult(value, {
+        ...options,
+        thrown,
+        signal: input.request.signal
+    });
+    if ('deferred' === outcome.kind) {
+        policy.assertValue(outcome.critical);
+        outcome = {
+            ...outcome,
+            deferred: Object.fromEntries(Object.entries(outcome.deferred).map(([key, promise])=>{
+                const checked = Promise.prototype.then.call(promise, (value)=>{
+                    policy.assertValue(value);
+                    return value;
+                }, (error)=>{
+                    policy.assertRoot(error);
+                    throw error;
+                });
+                checked.catch(()=>void 0);
+                return [
+                    key,
+                    checked
+                ];
+            }))
+        };
+    } else policy.assertValue(publicOutcome(outcome));
+    outcomePolicies.set(outcome, policy);
+    return outcome;
+}
+function publicOutcome(outcome) {
+    const status = outcome.response.status;
+    switch(outcome.kind){
+        case 'success':
+            return {
+                kind: 'success',
+                value: outcome.value,
+                status
+            };
+        case 'deferred':
+            return {
+                kind: 'success',
+                value: outcome.critical,
+                status
+            };
+        case 'redirect':
+            return {
+                kind: 'redirect',
+                location: outcome.location,
+                status
+            };
+        case 'not-found':
+            return {
+                kind: 'not-found',
+                value: outcome.value,
+                thrown: outcome.thrown,
+                status
+            };
+        case 'error':
+            return {
+                kind: 'error',
+                error: outcome.error,
+                ...Object.hasOwn(outcome, 'data') ? {
+                    data: outcome.data
+                } : {},
+                thrown: outcome.thrown,
+                status
+            };
+    }
+}
+function wireEnvelope(outcome, identity, routeId, operation) {
+    identityCacheKey(identity);
+    return {
+        version: DATA_PROTOCOL_VERSION,
+        identity: {
+            renderer: identity.renderer,
+            appId: identity.appId,
+            entryName: identity.entryName,
+            protocolVersion: identity.protocolVersion,
+            buildId: identity.buildId
+        },
+        routeId,
+        operation,
+        outcome: publicOutcome(outcome),
+        ...'deferred' === outcome.kind ? {
+            deferredKeys: Object.keys(outcome.deferred)
+        } : {}
+    };
+}
+function createDeferredStream(outcome, envelope, signal, production, onCancel, policy) {
+    const encoder = new TextEncoder();
+    const projectError = (error)=>{
+        try {
+            policy?.assertRoot(error);
+        } catch (violation) {
+            error = violation;
+        }
+        return publicDataError(error, production);
+    };
+    policy?.assertValue({
+        type: 'initial',
+        envelope
+    });
+    const initialBytes = encoder.encode(`${serializePublicData({
+        type: 'initial',
+        envelope
+    })}\n`);
+    const transport = new TransformStream();
+    const writer = transport.writable.getWriter();
+    let active = true;
+    let finished = false;
+    let cancelled = false;
+    const stopped = new AbortController();
+    const cancelResources = (reason)=>{
+        if (finished || cancelled) return;
+        cancelled = true;
+        stopped.abort(reason);
+        try {
+            Promise.resolve(onCancel?.(reason)).catch(()=>void 0);
+        } catch  {}
+    };
+    const cleanup = ()=>{
+        if (!active) return;
+        active = false;
+        signal?.removeEventListener('abort', abort);
+    };
+    const abort = ()=>{
+        if (!active) return;
+        const reason = signal?.reason ?? new DOMException('The data request was aborted', 'AbortError');
+        cancelResources(reason);
+        cleanup();
+        writer.abort(reason).catch(()=>void 0);
+    };
+    let writes = Promise.resolve();
+    const write = (frame, encoded)=>{
+        const next = writes.then(async ()=>{
+            if (!active) return;
+            if (encoded) return void await writer.write(encoded);
+            let text;
+            try {
+                policy?.assertValue(frame);
+                text = serializePublicData(frame);
+            } catch (error) {
+                if ('resolve' !== frame.type) throw error;
+                text = serializePublicData({
+                    type: 'reject',
+                    key: frame.key,
+                    error: projectError(error)
+                });
+            }
+            await writer.write(encoder.encode(`${text}\n`));
+        });
+        writes = next;
+        return next;
+    };
+    writer.closed.catch((reason)=>{
+        cancelResources(reason);
+        cleanup();
+    });
+    if (signal?.aborted) abort();
+    else signal?.addEventListener('abort', abort, {
+        once: true
+    });
+    (async ()=>{
+        await write({
+            type: 'initial',
+            envelope
+        }, initialBytes);
+        await Promise.all(Object.entries(outcome.deferred).map(async ([key, promise])=>{
+            let frame;
+            try {
+                const value = await untilAborted(promise, stopped.signal);
+                assertPublicData(value);
+                frame = {
+                    type: 'resolve',
+                    key,
+                    value
+                };
+            } catch (error) {
+                frame = {
+                    type: 'reject',
+                    key,
+                    error: projectError(error)
+                };
+            }
+            await write(frame);
+        }));
+        if (!active) return;
+        await write({
+            type: 'complete'
+        });
+        await writer.close();
+        finished = true;
+        cleanup();
+    })().catch((error)=>{
+        cancelResources(error);
+        cleanup();
+        writer.abort(error).catch(()=>void 0);
+    });
+    return transport.readable;
+}
+function createDataResponse(outcome, identity, options) {
+    const policy = outcomePolicies.get(outcome);
+    policy?.assertValue(publicOutcome(outcome));
+    const envelope = wireEnvelope(outcome, identity, options.routeId, options.operation);
+    const headers = new Headers();
+    const fields = [
+        ...outcome.response.headers
+    ];
+    const keep = projectedHeaderFilter(fields);
+    for (const [name, value] of fields)if (keep(name)) headers.append(name, value);
+    headers.set('x-modernjs-response', 'yes');
+    if (!headers.has('cache-control') || headers.has('set-cookie') || 'success' !== outcome.kind || 'no-store' === outcome.response.cachePolicy) headers.set('cache-control', 'no-store');
+    if ('redirect' === outcome.kind) headers.set('x-modernjs-redirect', outcome.location);
+    headers.set('content-type', `${'deferred' === outcome.kind ? DATA_STREAM_CONTENT_TYPE : DATA_CONTENT_TYPE}; charset=utf-8`);
+    const status = 'redirect' === outcome.kind || 206 === outcome.response.status || BODYLESS_STATUSES.has(outcome.response.status) ? 200 : outcome.response.status;
+    let body;
+    if ('deferred' === outcome.kind) body = createDeferredStream(outcome, envelope, options.signal, options.production ?? true, options.onCancel, policy);
+    else {
+        policy?.assertValue(envelope);
+        body = serializePublicData(envelope);
+    }
+    return new Response(body, {
+        status,
+        headers
+    });
+}
+async function handleDataRequest(options) {
+    const url = new URL(options.request.url);
+    const routeId = url.searchParams.get(LOADER_ID_PARAM);
+    if (!routeId) return;
+    identityCacheKey(options.identity);
+    const context = options.context;
+    const cancellation = new AbortController();
+    const request = new Request(options.request, {
+        signal: AbortSignal.any([
+            options.request.signal,
+            cancellation.signal
+        ])
+    });
+    request.signal.throwIfAborted();
+    const policy = createRequestDataPolicy([
+        context,
+        options.request,
+        request,
+        ...options.privateValues ?? []
+    ]);
+    if (![
+        'GET',
+        'HEAD',
+        'POST',
+        'PUT',
+        'PATCH',
+        'DELETE'
+    ].includes(request.method)) return new Response('Unsupported data method', {
+        status: 405,
+        headers: {
+            allow: 'GET, HEAD, POST, PUT, PATCH, DELETE',
+            'cache-control': 'no-store'
+        }
+    });
+    const operation = 'GET' === request.method || 'HEAD' === request.method ? 'loader' : 'action';
+    const selected = await untilAborted(options.selectRoute(request, routeId, operation), request.signal);
+    if (!selected || selected.routeId !== routeId) return new Response('Data route is not authorized for this URL', {
+        status: 403,
+        headers: {
+            'cache-control': 'no-store'
+        }
+    });
+    const productionOptions = void 0 === options.production ? {} : {
+        production: options.production
+    };
+    const outcome = await invokeOwnedRouteData(selected.handler, {
+        request,
+        routeId,
+        params: selected.params,
+        context
+    }, productionOptions, policy);
+    const response = createDataResponse(outcome, options.identity, {
+        routeId,
+        operation,
+        signal: request.signal,
+        ...productionOptions,
+        onCancel: (reason)=>cancellation.abort(reason)
+    });
+    if ('HEAD' === request.method) {
+        response.body?.cancel().catch(()=>void 0);
+        return new Response(null, {
+            status: response.status,
+            headers: response.headers
+        });
+    }
+    return response;
+}
+export { createDataResponse, dataMetadataToDocumentPolicy, deferData, handleDataRequest, invokeRouteData, mergeDataResponseIntoResponse, mergeDataResponseMetadata, mergeHeaderFields, normalizeDataResult, publicDataError, responseHeaders as collectDataHeaders };