@byline/host-tanstack-start 4.15.0 → 4.17.0

package/dist/admin-shell/singletons/view-menu.js

@@ -0,0 +1,116 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useEffect } from "react";
+import { useTranslation } from "@byline/i18n/react";
+import { Button, HistoryIcon, IconButton, Label, Select } from "@byline/ui/react";
+import clsx from "clsx";
+import { getAdminRoutePath } from "../../routes/admin-path.js";
+import { useNavigate } from "../chrome/loose-router.js";
+import view_menu_module from "../collections/view-menu.module.js";
+import { SingletonPreviewLink } from "./preview-link.js";
+function SingletonViewMenu({ singleton, activeView, locale, contentLocales, defaultContentLocale, adminConfig, doc }) {
+    const navigate = useNavigate();
+    const { t } = useTranslation('byline-admin');
+    useEffect(()=>{
+        if ('edit' === activeView && 'all' === locale) navigate({
+            to: getAdminRoutePath('singletons', '$singleton'),
+            params: {
+                singleton
+            },
+            search: {
+                locale: defaultContentLocale
+            },
+            replace: true
+        });
+    }, [
+        activeView,
+        locale,
+        singleton,
+        defaultContentLocale,
+        navigate
+    ]);
+    const handleLocaleChange = (value)=>{
+        if (null == value) return;
+        navigate({
+            to: 'history' === activeView ? getAdminRoutePath('singletons', '$singleton', 'history') : getAdminRoutePath('singletons', '$singleton'),
+            params: {
+                singleton
+            },
+            search: {
+                locale: value
+            }
+        });
+    };
+    return /*#__PURE__*/ jsxs("div", {
+        className: clsx('byline-view-menu', view_menu_module.root),
+        children: [
+            /*#__PURE__*/ jsx(Label, {
+                className: clsx('muted byline-view-menu-label', view_menu_module.label),
+                id: "contentLocaleLabel",
+                htmlFor: "contentLocale",
+                label: t('collections.viewMenu.contentLocaleLabel')
+            }),
+            /*#__PURE__*/ jsx(Select, {
+                name: "contentLocale",
+                id: "contentLocale",
+                className: clsx('byline-view-menu-locale-select', view_menu_module.localeSelect),
+                size: "xs",
+                variant: "outlined",
+                value: locale ?? defaultContentLocale,
+                items: [
+                    ...'history' === activeView ? [
+                        {
+                            value: 'all',
+                            label: t('collections.viewMenu.localeAll')
+                        }
+                    ] : [],
+                    ...contentLocales.map((entry)=>({
+                            value: entry.code,
+                            label: entry.label
+                        }))
+                ],
+                onValueChange: handleLocaleChange
+            }),
+            adminConfig?.preview != null && null != doc && /*#__PURE__*/ jsx(SingletonPreviewLink, {
+                doc: doc,
+                adminConfig: adminConfig,
+                locale: locale,
+                className: clsx('byline-view-menu-icon-button', view_menu_module.iconButton)
+            }),
+            /*#__PURE__*/ jsx(IconButton, {
+                className: clsx('byline-view-menu-icon-button', view_menu_module.iconButton),
+                size: "xs",
+                variant: 'history' === activeView ? 'filled' : 'text',
+                "aria-label": t('collections.breadcrumbs.history'),
+                onClick: ()=>navigate({
+                        to: getAdminRoutePath('singletons', '$singleton', 'history'),
+                        params: {
+                            singleton
+                        },
+                        search: locale ? {
+                            locale
+                        } : {}
+                    }),
+                children: /*#__PURE__*/ jsx(HistoryIcon, {
+                    className: clsx('byline-view-menu-icon-button-icon', view_menu_module.iconButtonIcon)
+                })
+            }),
+            /*#__PURE__*/ jsx(Button, {
+                size: "xs",
+                variant: 'edit' === activeView ? 'filled' : 'outlined',
+                className: clsx('byline-view-menu-button', view_menu_module.button),
+                onClick: ()=>navigate({
+                        to: getAdminRoutePath('singletons', '$singleton'),
+                        params: {
+                            singleton
+                        },
+                        search: locale ? {
+                            locale
+                        } : {}
+                    }),
+                children: t('common.actions.edit')
+            })
+        ]
+    });
+}
+export { SingletonViewMenu };

package/dist/admin-shell/singletons/view.d.ts

@@ -0,0 +1,18 @@
+import type { SingletonAdminConfig, SingletonDefinition } from '@byline/core';
+import type { ContentLocaleOption } from '../collections/view-menu.js';
+type SingletonDocument = Record<string, any> & {
+    id: string;
+    status: string;
+    fields: Record<string, any>;
+};
+export declare function SingletonView({ singletonDefinition, adminConfig, document, initialData, locale, contentLocales, defaultContentLocale, }: {
+    singletonDefinition: SingletonDefinition;
+    adminConfig?: SingletonAdminConfig;
+    document: SingletonDocument | null;
+    /** Schema defaults resolved by the server-side route loader for an empty slot. */
+    initialData?: Record<string, any>;
+    locale?: string;
+    contentLocales: ReadonlyArray<ContentLocaleOption>;
+    defaultContentLocale: string;
+}): import("react").JSX.Element;
+export {};

package/dist/admin-shell/singletons/view.js

@@ -0,0 +1,259 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useRouter } from "@tanstack/react-router";
+import { FormRenderer } from "@byline/admin/react";
+import { ErrorCodes, getDefaultStatus, getWorkflow, getWorkflowStatuses, validateStatusTransition } from "@byline/core";
+import { useTranslation } from "@byline/i18n/react";
+import { Container, Section, useToastManager } from "@byline/ui/react";
+import { getAdminRoutePath } from "../../routes/admin-path.js";
+import { cancelSingletonScheduledPublish, changeSingletonStatus, confirmSingletonScheduledPublish, copySingletonToLocale, scheduleSingletonPublish, unpublishSingleton, updateSingleton } from "../../server-fns/singletons/index.js";
+import { useNavigate } from "../chrome/loose-router.js";
+import { useTanStackNavigationGuard } from "../collections/tanstack-navigation-guard.js";
+import { SingletonViewMenu } from "./view-menu.js";
+function errorCode(error) {
+    return 'string' == typeof error?.code ? error.code : null;
+}
+function SingletonView({ singletonDefinition, adminConfig, document, initialData, locale, contentLocales, defaultContentLocale }) {
+    const router = useRouter();
+    const navigate = useNavigate();
+    const toastManager = useToastManager();
+    const { t } = useTranslation('byline-admin');
+    const { path, label, fields } = singletonDefinition;
+    const workflowStatuses = getWorkflowStatuses(singletonDefinition);
+    const currentStatus = document?.status ?? getDefaultStatus(singletonDefinition);
+    const currentIndex = workflowStatuses.findIndex((status)=>status.name === currentStatus);
+    const nextStatus = -1 !== currentIndex && currentIndex < workflowStatuses.length - 1 ? workflowStatuses[currentIndex + 1] : void 0;
+    const publishedVersion = document?._publishedVersion ?? null;
+    const restoreWarnings = document?._restoreWarnings;
+    const scheduledPublicationEnabled = document?._scheduledPublicationEnabled === true;
+    const canSchedulePublication = document?._canSchedulePublication === true;
+    const scheduledPublication = document?._scheduledPublish ?? null;
+    const publishTransitionValid = null != document && 'published' !== currentStatus && workflowStatuses.length > 1 && validateStatusTransition(getWorkflow(singletonDefinition), currentStatus, 'published').valid;
+    const canArmSchedule = scheduledPublicationEnabled && canSchedulePublication && publishTransitionValid;
+    const reload = async ()=>{
+        await router.invalidate();
+    };
+    const toast = (title, description, intent)=>{
+        toastManager.add({
+            title,
+            description,
+            data: {
+                intent,
+                iconType: intent,
+                icon: true,
+                close: true
+            }
+        });
+    };
+    const notifyScheduleSuspended = ()=>{
+        if (scheduledPublication?.state !== 'armed') return;
+        toast(t('scheduledPublication.toast.suspendedTitle'), t("scheduledPublication.toast.suspendedDescription"), 'warning');
+    };
+    const handleSubmit = async ({ data })=>{
+        try {
+            await updateSingleton({
+                data: {
+                    singleton: path,
+                    data,
+                    locale: locale ?? defaultContentLocale,
+                    expectedVersionId: document?.versionId
+                }
+            });
+            if (null != document) notifyScheduleSuspended();
+            toast(t('singletons.edit.updateTitle', {
+                label
+            }), t("singletons.edit.updatedDescription", {
+                label: label.toLowerCase()
+            }), 'success');
+            await reload();
+        } catch (err) {
+            const code = errorCode(err);
+            const description = code === ErrorCodes.CONFLICT ? t("singletons.edit.conflictDescription") : code === ErrorCodes.NOT_FOUND ? t("singletons.edit.notConfiguredDescription") : t("singletons.edit.updateFailedDescription", {
+                label: label.toLowerCase()
+            });
+            toast(t('singletons.edit.updateTitle', {
+                label
+            }), description, 'danger');
+            throw err;
+        }
+    };
+    const handleStatusChange = async (status)=>{
+        try {
+            await changeSingletonStatus({
+                data: {
+                    singleton: path,
+                    status
+                }
+            });
+            toast(t('collections.edit.statusUpdateTitle', {
+                label
+            }), t("collections.edit.statusChangedDescription", {
+                status
+            }), 'success');
+            await reload();
+        } catch (err) {
+            toast(t('collections.edit.statusUpdateTitle', {
+                label
+            }), t("collections.edit.statusChangeFailedDescription", {
+                message: err.message
+            }), 'danger');
+            throw err;
+        }
+    };
+    const handleUnpublish = async ()=>{
+        try {
+            await unpublishSingleton({
+                data: {
+                    singleton: path
+                }
+            });
+            toast(t('collections.edit.unpublishTitle', {
+                label
+            }), t("collections.edit.unpublishedDescription"), 'success');
+            await reload();
+        } catch (err) {
+            toast(t('collections.edit.unpublishTitle', {
+                label
+            }), t("collections.edit.unpublishFailedDescription", {
+                message: err.message
+            }), 'danger');
+            throw err;
+        }
+    };
+    const handleCopyToLocale = async ({ targetLocale, overwrite })=>{
+        try {
+            await copySingletonToLocale({
+                data: {
+                    singleton: path,
+                    sourceLocale: locale ?? defaultContentLocale,
+                    targetLocale,
+                    overwrite
+                }
+            });
+            const sourceLocale = locale ?? defaultContentLocale;
+            const sourceLabel = contentLocales.find((entry)=>entry.code === sourceLocale)?.label ?? sourceLocale;
+            const targetLabel = contentLocales.find((entry)=>entry.code === targetLocale)?.label ?? targetLocale;
+            toast(t('collections.edit.copyToLocaleTitle', {
+                label
+            }), t('collections.edit.copiedSuccessMessage', {
+                source: sourceLabel,
+                target: targetLabel
+            }), 'success');
+            notifyScheduleSuspended();
+            navigate({
+                to: getAdminRoutePath('singletons', '$singleton'),
+                params: {
+                    singleton: path
+                },
+                search: {
+                    locale: targetLocale
+                }
+            });
+        } catch (err) {
+            toast(t('collections.edit.copyToLocaleTitle', {
+                label
+            }), t("collections.edit.copyFailedDescription", {
+                message: err.message
+            }), 'danger');
+            throw err;
+        }
+    };
+    const handleSchedulePublication = async ({ publishAt })=>{
+        try {
+            await scheduleSingletonPublish({
+                data: {
+                    singleton: path,
+                    publishAt,
+                    expectedVersionId: String(document?.versionId)
+                }
+            });
+            toast(t('scheduledPublication.toast.scheduledTitle'), t("scheduledPublication.toast.scheduledDescription"), 'success');
+            await reload();
+        } catch (err) {
+            toast(t('scheduledPublication.toast.failedTitle'), err.message, 'danger');
+            throw err;
+        }
+    };
+    const handleConfirmScheduledPublication = async ()=>{
+        try {
+            await confirmSingletonScheduledPublish({
+                data: {
+                    singleton: path,
+                    expectedVersionId: String(document?.versionId)
+                }
+            });
+            toast(t('scheduledPublication.toast.confirmedTitle'), t("scheduledPublication.toast.confirmedDescription"), 'success');
+            await reload();
+        } catch (err) {
+            toast(t('scheduledPublication.toast.failedTitle'), err.message, 'danger');
+            throw err;
+        }
+    };
+    const handleCancelScheduledPublication = async ()=>{
+        try {
+            await cancelSingletonScheduledPublish({
+                data: {
+                    singleton: path
+                }
+            });
+            toast(t('scheduledPublication.toast.cancelledTitle'), t("scheduledPublication.toast.cancelledDescription"), 'success');
+            await reload();
+        } catch (err) {
+            toast(t('scheduledPublication.toast.failedTitle'), err.message, 'danger');
+            throw err;
+        }
+    };
+    return /*#__PURE__*/ jsx(Section, {
+        children: /*#__PURE__*/ jsx(Container, {
+            children: /*#__PURE__*/ jsx(FormRenderer, {
+                mode: null == document ? 'create' : 'edit',
+                fields: fields,
+                onSubmit: handleSubmit,
+                initialData: document ?? (initialData ? {
+                    fields: initialData
+                } : void 0),
+                adminConfig: adminConfig,
+                heading: label,
+                showPath: false,
+                initialLocale: locale,
+                defaultLocale: defaultContentLocale,
+                onLocaleChange: null == document ? void 0 : (nextLocale)=>navigate({
+                        to: getAdminRoutePath('singletons', '$singleton'),
+                        params: {
+                            singleton: path
+                        },
+                        search: {
+                            locale: nextLocale
+                        }
+                    }),
+                useNavigationGuard: useTanStackNavigationGuard,
+                headerSlot: null == document ? void 0 : /*#__PURE__*/ jsx(SingletonViewMenu, {
+                    singleton: path,
+                    activeView: "edit",
+                    locale: locale,
+                    contentLocales: contentLocales,
+                    defaultContentLocale: defaultContentLocale,
+                    adminConfig: adminConfig,
+                    doc: document
+                }),
+                onStatusChange: null == document ? void 0 : handleStatusChange,
+                onUnpublish: null != document && publishedVersion ? handleUnpublish : void 0,
+                scheduledPublication: null == document ? null : scheduledPublication,
+                onSchedulePublication: canArmSchedule ? handleSchedulePublication : void 0,
+                onConfirmScheduledPublication: canArmSchedule && scheduledPublication?.state === 'needs_reconfirm' ? handleConfirmScheduledPublication : void 0,
+                onCancelScheduledPublication: null != document && null != scheduledPublication ? handleCancelScheduledPublication : void 0,
+                onCopyToLocale: null == document ? void 0 : handleCopyToLocale,
+                contentLocales: null == document ? void 0 : contentLocales,
+                publishedVersion: null == document ? null : publishedVersion,
+                restoreWarnings: restoreWarnings,
+                nextStatus: null == document ? void 0 : nextStatus,
+                workflowStatuses: null == document ? void 0 : workflowStatuses,
+                onCancel: ()=>navigate({
+                        to: getAdminRoutePath()
+                    }),
+                collectionPath: path
+            })
+        })
+    });
+}
+export { SingletonView };

package/dist/admin-shell/singletons/view.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+export {};

package/dist/integrations/analytics-agent.d.ts

@@ -0,0 +1,20 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import type React from 'react';
+export interface AnalyticsAgentProps {
+    /** Application-owned same-origin route that receives browser events. */
+    endpoint: string;
+    src?: string;
+    cdnHosts?: readonly string[];
+    downloadExtensions?: readonly string[];
+    ignoredPathPrefixes?: readonly string[];
+    countSearchChanges?: boolean;
+    countHashChanges?: boolean;
+}
+/** Render the standalone script and bridge only committed router locations into it. */
+export declare function AnalyticsAgent({ endpoint, src, cdnHosts, downloadExtensions, ignoredPathPrefixes, countSearchChanges, countHashChanges, }: AnalyticsAgentProps): React.JSX.Element;

package/dist/integrations/analytics-agent.js

@@ -0,0 +1,57 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useRef } from "react";
+import { useRouterState } from "@tanstack/react-router";
+import { ANALYTICS_NAVIGATION_EVENT, ANALYTICS_STOP_EVENT } from "@byline/analytics-agent";
+let pendingStopTimer;
+function AnalyticsAgent({ endpoint, src = '/b.js', cdnHosts, downloadExtensions, ignoredPathPrefixes, countSearchChanges = false, countHashChanges = false }) {
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx("script", {
+                defer: true,
+                src: src,
+                "data-endpoint": endpoint,
+                "data-cdn-hosts": boundedAttribute(cdnHosts),
+                "data-download-extensions": boundedAttribute(downloadExtensions),
+                "data-ignore-prefixes": boundedAttribute(ignoredPathPrefixes),
+                "data-count-search": countSearchChanges ? 'true' : void 0,
+                "data-count-hash": countHashChanges ? 'true' : void 0
+            }),
+            /*#__PURE__*/ jsx(AnalyticsNavigationBridge, {})
+        ]
+    });
+}
+function AnalyticsNavigationBridge() {
+    const href = useRouterState({
+        select: (state)=>state.location.href
+    });
+    const previousHref = useRef(void 0);
+    useEffect(()=>{
+        const previous = previousHref.current;
+        previousHref.current = href;
+        if (null == previous || previous === href) return;
+        document.dispatchEvent(new CustomEvent(ANALYTICS_NAVIGATION_EVENT, {
+            detail: href
+        }));
+    }, [
+        href
+    ]);
+    useEffect(()=>{
+        if (void 0 !== pendingStopTimer) {
+            window.clearTimeout(pendingStopTimer);
+            pendingStopTimer = void 0;
+        }
+        return ()=>{
+            pendingStopTimer = window.setTimeout(()=>{
+                pendingStopTimer = void 0;
+                document.dispatchEvent(new Event(ANALYTICS_STOP_EVENT));
+            }, 0);
+        };
+    }, []);
+    return null;
+}
+function boundedAttribute(values) {
+    if (null == values || 0 === values.length) return;
+    return values.slice(0, 64).join(',').slice(0, 2048);
+}
+export { AnalyticsAgent };

package/dist/integrations/analytics-events.d.ts

@@ -0,0 +1,51 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import { type Analytics } from '@byline/analytics';
+import { type BylineLogger } from '@byline/core';
+export interface AnalyticsEventHandlerOptions {
+    /** Host-owned resolver for deployment-specific, request-scoped network facts. */
+    resolveRequestContext: AnalyticsRequestContextResolver;
+    /** Test/embedding seam; production resolves the registered installation runtime. */
+    analytics?: () => Pick<Analytics, 'ingest'>;
+    /** Test/embedding seam; production resolves the initialized application logger. */
+    logger?: () => Pick<BylineLogger, 'error'>;
+}
+export interface AnalyticsRequestContext {
+    clientIp?: string | null;
+    country?: string | null;
+}
+export type AnalyticsRequestContextResolver = (request: Request) => AnalyticsRequestContext | Promise<AnalyticsRequestContext>;
+export interface LocalAnalyticsRequestContextOptions {
+    /** Resolve the direct peer address from the host runtime, without forwarded headers. */
+    resolveClientIp: (request: Request) => string | null | undefined | Promise<string | null | undefined>;
+    /** Explicit development-only identity for runtimes that expose no peer address. */
+    developmentFallbackClientIp?: string;
+}
+export interface TrustedAnalyticsHeadersOptions {
+    /** Header overwritten by the trusted reverse proxy with the normalized client address. */
+    clientIpHeader: string;
+    /** Optional header overwritten by the trusted edge with an ISO country code. */
+    countryHeader?: string;
+    /** Explicit context or resolver used only when a trusted header is absent. */
+    fallback?: AnalyticsRequestContext | AnalyticsRequestContextResolver;
+}
+/**
+ * Resolve an identity for a server reached directly through a loopback URL.
+ * Both the URL and the direct peer address must be loopback. This is safe for
+ * a directly reached local server. A same-host reverse proxy also appears as
+ * a loopback peer, however, so do not expose this fallback through a public
+ * proxy where a client can select the Host header.
+ */
+export declare function localAnalyticsRequestContext(options: LocalAnalyticsRequestContextOptions): AnalyticsRequestContextResolver;
+/**
+ * Resolve network facts from headers owned and overwritten by a trusted proxy.
+ * This helper does not establish that trust: the deployment must prevent a
+ * client from selecting the configured header values or bypassing the proxy.
+ */
+export declare function trustedAnalyticsHeaders(options: TrustedAnalyticsHeadersOptions): AnalyticsRequestContextResolver;
+export declare function createAnalyticsEventHandler(options: AnalyticsEventHandlerOptions): (request: Request) => Promise<Response>;

package/dist/integrations/analytics-events.js

@@ -0,0 +1,129 @@
+import { ANALYTICS_MAX_BODY_BYTES, getAnalytics } from "@byline/analytics";
+import { getLogger } from "@byline/core";
+function localAnalyticsRequestContext(options) {
+    const developmentFallbackClientIp = null == options.developmentFallbackClientIp ? void 0 : validateFact(options.developmentFallbackClientIp, 'developmentFallbackClientIp', 255);
+    return async (request)=>{
+        const clientIp = await options.resolveClientIp(request);
+        if (isLoopbackHostname(new URL(request.url).hostname) && isLoopbackAddress(clientIp)) return {
+            clientIp: validateFact(clientIp, 'resolved clientIp', 255)
+        };
+        return null == developmentFallbackClientIp ? {} : {
+            clientIp: developmentFallbackClientIp
+        };
+    };
+}
+function trustedAnalyticsHeaders(options) {
+    const clientIpHeader = validateHeaderName(options.clientIpHeader, 'clientIpHeader');
+    const countryHeader = null == options.countryHeader ? void 0 : validateHeaderName(options.countryHeader, 'countryHeader');
+    const fallback = 'function' == typeof options.fallback ? options.fallback : validateFallback(options.fallback);
+    return async (request)=>{
+        const fallbackContext = 'function' == typeof fallback ? validateFallback(await fallback(request)) : fallback;
+        return {
+            clientIp: request.headers.get(clientIpHeader)?.trim() || fallbackContext?.clientIp,
+            country: (null == countryHeader ? null : request.headers.get(countryHeader)?.trim()) || fallbackContext?.country
+        };
+    };
+}
+function createAnalyticsEventHandler(options) {
+    const resolveAnalytics = options.analytics ?? getAnalytics;
+    return async (request)=>{
+        const body = await readBoundedBody(request, ANALYTICS_MAX_BODY_BYTES);
+        try {
+            const requestContext = await options.resolveRequestContext(request);
+            const result = await resolveAnalytics().ingest({
+                method: request.method,
+                body: body ?? new Uint8Array(ANALYTICS_MAX_BODY_BYTES + 1),
+                origin: request.headers.get('origin'),
+                referer: request.headers.get('referer'),
+                userAgent: request.headers.get('user-agent'),
+                secPurpose: request.headers.get('sec-purpose'),
+                xPurpose: request.headers.get('x-purpose'),
+                clientIp: requestContext.clientIp,
+                country: requestContext.country
+            });
+            return analyticsResponse(result.status);
+        } catch (error) {
+            const logger = options.logger?.() ?? getLogger();
+            logger.error({
+                errorCode: safeErrorCode(error)
+            }, '[analytics] event persistence failed');
+            return analyticsResponse(503);
+        }
+    };
+}
+function safeErrorCode(error) {
+    if (null == error || 'object' != typeof error || !('code' in error)) return 'UNKNOWN';
+    const code = error.code;
+    return 'string' == typeof code && /^[a-z0-9_-]{1,64}$/iu.test(code) ? code : 'UNKNOWN';
+}
+function analyticsResponse(status) {
+    return new Response(null, {
+        status,
+        headers: {
+            'cache-control': 'no-store'
+        }
+    });
+}
+async function readBoundedBody(request, limit) {
+    const declaredLength = Number(request.headers.get('content-length'));
+    if (Number.isFinite(declaredLength) && declaredLength > limit) return null;
+    if (null == request.body) return new Uint8Array();
+    const reader = request.body.getReader();
+    const chunks = [];
+    let length = 0;
+    try {
+        while(true){
+            const { done, value } = await reader.read();
+            if (done) break;
+            length += value.byteLength;
+            if (length > limit) {
+                await reader.cancel();
+                return null;
+            }
+            chunks.push(value);
+        }
+    } finally{
+        reader.releaseLock();
+    }
+    const body = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks){
+        body.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return body;
+}
+function validateHeaderName(value, label) {
+    const normalized = value.trim().toLowerCase();
+    if (!/^[!#$%&'*+.^_`|~0-9a-z-]+$/u.test(normalized)) throw new Error(`analytics ${label} must be a valid HTTP header name`);
+    return normalized;
+}
+function validateFallback(value) {
+    if (null == value) return;
+    return {
+        ...null == value.clientIp ? {} : {
+            clientIp: validateFact(value.clientIp, 'fallback.clientIp', 255)
+        },
+        ...null == value.country ? {} : {
+            country: validateFact(value.country, 'fallback.country', 16)
+        }
+    };
+}
+function validateFact(value, label, maxLength) {
+    const normalized = value.trim();
+    if (0 === normalized.length || normalized.length > maxLength) throw new Error(`analytics ${label} must contain 1 to ${maxLength} characters`);
+    return normalized;
+}
+function isLoopbackHostname(value) {
+    const normalized = stripIpv6Brackets(value.toLowerCase());
+    return 'localhost' === normalized || normalized.endsWith('.localhost') || isLoopbackAddress(normalized);
+}
+function isLoopbackAddress(value) {
+    if (null == value) return false;
+    const normalized = stripIpv6Brackets(value.trim().toLowerCase());
+    return '::1' === normalized || /^127(?:\.\d{1,3}){3}$/u.test(normalized) || /^::ffff:127(?:\.\d{1,3}){3}$/u.test(normalized);
+}
+function stripIpv6Brackets(value) {
+    return value.startsWith('[') && value.endsWith(']') ? value.slice(1, -1) : value;
+}
+export { createAnalyticsEventHandler, localAnalyticsRequestContext, trustedAnalyticsHeaders };