@byline/host-tanstack-start 4.19.0 → 5.1.0

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

@@ -2,7 +2,7 @@
 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 { 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";
@@ -10,11 +10,11 @@ import { hasCommittedDocumentHookFailure } from "../../server-fns/collections/in
 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 { useDocumentMutationState } from "../document-mutation-state.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 }) {
+function SingletonView({ singletonDefinition, adminConfig, document: loadedDocument, initialData, locale, contentLocales, defaultContentLocale }) {
+    const mutation = useDocumentMutationState(loadedDocument);
+    const document = mutation.document ?? null;
     const router = useRouter();
     const navigate = useNavigate();
     const toastManager = useToastManager();
@@ -55,14 +55,20 @@ function SingletonView({ singletonDefinition, adminConfig, document, initialData
     };
     const handleSubmit = async ({ data })=>{
         try {
+            mutation.assertWritable();
             const result = await updateSingleton({
                 data: {
                     singleton: path,
                     data,
                     locale: locale ?? defaultContentLocale,
-                    expectedVersionId: document?.versionId
+                    ...null == document ? {
+                        expectedState: 'empty'
+                    } : {
+                        expectedRevision: mutation.expectedRevision()
+                    }
                 }
             });
+            mutation.adopt(result);
             if (null != document) notifyScheduleSuspended();
             if (hasCommittedDocumentHookFailure(result)) notifyCommittedHookFailure();
             else toast(t('singletons.edit.updateTitle', {
@@ -72,8 +78,14 @@ function SingletonView({ singletonDefinition, adminConfig, document, initialData
             }), '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", {
+            const handled = mutation.report(err);
+            if ('blocked' === handled) throw err;
+            if ('committed' === handled) {
+                notifyCommittedHookFailure();
+                await reload();
+                return;
+            }
+            const description = t("singletons.edit.updateFailedDescription", {
                 label: label.toLowerCase()
             });
             toast(t('singletons.edit.updateTitle', {
@@ -84,12 +96,15 @@ function SingletonView({ singletonDefinition, adminConfig, document, initialData
     };
     const handleStatusChange = async (status)=>{
         try {
-            await changeSingletonStatus({
+            mutation.assertWritable();
+            const result = await changeSingletonStatus({
                 data: {
+                    expectedRevision: mutation.expectedRevision(),
                     singleton: path,
                     status
                 }
             });
+            mutation.adopt(result);
             toast(t('collections.edit.statusUpdateTitle', {
                 label
             }), t("collections.edit.statusChangedDescription", {
@@ -97,44 +112,64 @@ function SingletonView({ singletonDefinition, adminConfig, document, initialData
             }), 'success');
             await reload();
         } catch (err) {
+            const handled = mutation.report(err);
+            if ('blocked' === handled) throw err;
+            if ('committed' === handled) {
+                notifyCommittedHookFailure();
+                await reload();
+                return;
+            }
             toast(t('collections.edit.statusUpdateTitle', {
                 label
             }), t("collections.edit.statusChangeFailedDescription", {
-                message: err.message
+                message: t('documentConcurrency.failed')
             }), 'danger');
             throw err;
         }
     };
     const handleUnpublish = async ()=>{
         try {
-            await unpublishSingleton({
+            mutation.assertWritable();
+            const result = await unpublishSingleton({
                 data: {
+                    expectedRevision: mutation.expectedRevision(),
                     singleton: path
                 }
             });
+            mutation.adopt(result);
             toast(t('collections.edit.unpublishTitle', {
                 label
             }), t("collections.edit.unpublishedDescription"), 'success');
             await reload();
         } catch (err) {
+            const handled = mutation.report(err);
+            if ('blocked' === handled) throw err;
+            if ('committed' === handled) {
+                notifyCommittedHookFailure();
+                await reload();
+                return;
+            }
             toast(t('collections.edit.unpublishTitle', {
                 label
             }), t("collections.edit.unpublishFailedDescription", {
-                message: err.message
+                message: t('documentConcurrency.failed')
             }), 'danger');
             throw err;
         }
     };
     const handleCopyToLocale = async ({ targetLocale, overwrite })=>{
         try {
+            mutation.assertWritable();
             const result = await copySingletonToLocale({
                 data: {
+                    expectedRevision: mutation.expectedRevision(),
                     singleton: path,
                     sourceLocale: locale ?? defaultContentLocale,
                     targetLocale,
                     overwrite
                 }
             });
+            mutation.adopt(result);
             const sourceLocale = locale ?? defaultContentLocale;
             const sourceLabel = contentLocales.find((entry)=>entry.code === sourceLocale)?.label ?? sourceLocale;
             const targetLabel = contentLocales.find((entry)=>entry.code === targetLocale)?.label ?? targetLocale;
@@ -156,62 +191,106 @@ function SingletonView({ singletonDefinition, adminConfig, document, initialData
                 }
             });
         } catch (err) {
+            const handled = mutation.report(err);
+            if ('blocked' === handled) throw err;
+            if ('committed' === handled) {
+                notifyCommittedHookFailure();
+                await reload();
+                return;
+            }
             toast(t('collections.edit.copyToLocaleTitle', {
                 label
             }), t("collections.edit.copyFailedDescription", {
-                message: err.message
+                message: t('documentConcurrency.failed')
             }), 'danger');
             throw err;
         }
     };
     const handleSchedulePublication = async ({ publishAt })=>{
         try {
-            await scheduleSingletonPublish({
+            mutation.assertWritable();
+            const result = await scheduleSingletonPublish({
                 data: {
+                    expectedRevision: mutation.expectedRevision(),
                     singleton: path,
                     publishAt,
                     expectedVersionId: String(document?.versionId)
                 }
             });
+            mutation.adopt(result);
             toast(t('scheduledPublication.toast.scheduledTitle'), t("scheduledPublication.toast.scheduledDescription"), 'success');
             await reload();
         } catch (err) {
-            toast(t('scheduledPublication.toast.failedTitle'), err.message, 'danger');
+            const handled = mutation.report(err);
+            if ('blocked' === handled) throw err;
+            if ('committed' === handled) {
+                notifyCommittedHookFailure();
+                await reload();
+                return;
+            }
+            toast(t('scheduledPublication.toast.failedTitle'), t('documentConcurrency.failed'), 'danger');
             throw err;
         }
     };
     const handleConfirmScheduledPublication = async ()=>{
         try {
-            await confirmSingletonScheduledPublish({
+            mutation.assertWritable();
+            const result = await confirmSingletonScheduledPublish({
                 data: {
+                    expectedRevision: mutation.expectedRevision(),
                     singleton: path,
                     expectedVersionId: String(document?.versionId)
                 }
             });
+            mutation.adopt(result);
             toast(t('scheduledPublication.toast.confirmedTitle'), t("scheduledPublication.toast.confirmedDescription"), 'success');
             await reload();
         } catch (err) {
-            toast(t('scheduledPublication.toast.failedTitle'), err.message, 'danger');
+            const handled = mutation.report(err);
+            if ('blocked' === handled) throw err;
+            if ('committed' === handled) {
+                notifyCommittedHookFailure();
+                await reload();
+                return;
+            }
+            toast(t('scheduledPublication.toast.failedTitle'), t('documentConcurrency.failed'), 'danger');
             throw err;
         }
     };
     const handleCancelScheduledPublication = async ()=>{
         try {
-            await cancelSingletonScheduledPublish({
+            mutation.assertWritable();
+            const result = await cancelSingletonScheduledPublish({
                 data: {
+                    expectedRevision: mutation.expectedRevision(),
                     singleton: path
                 }
             });
+            mutation.adopt({
+                ...result,
+                documentId: String(document?.id)
+            });
             toast(t('scheduledPublication.toast.cancelledTitle'), t("scheduledPublication.toast.cancelledDescription"), 'success');
             await reload();
         } catch (err) {
-            toast(t('scheduledPublication.toast.failedTitle'), err.message, 'danger');
+            const handled = mutation.report(err);
+            if ('blocked' === handled) throw err;
+            if ('committed' === handled) {
+                notifyCommittedHookFailure();
+                await reload();
+                return;
+            }
+            toast(t('scheduledPublication.toast.failedTitle'), t('documentConcurrency.failed'), 'danger');
             throw err;
         }
     };
     return /*#__PURE__*/ jsx(Section, {
         children: /*#__PURE__*/ jsx(Container, {
             children: /*#__PURE__*/ jsx(FormRenderer, {
+                mutationIssue: mutation.issue,
+                mutationsBlocked: mutation.blocked,
+                observedRevision: mutation.revision,
+                onMutationError: mutation.report,
                 mode: null == document ? 'create' : 'edit',
                 fields: fields,
                 onSubmit: handleSubmit,

package/dist/integrations/byline-admin-services.js

@@ -5,13 +5,19 @@ import { createAdminUser, setAdminUserPassword, setUserRoles, updateAdminUser }
 import { adminSignIn } from "../server-fns/auth/index.js";
 import { getCollectionDocumentVersion } from "../server-fns/collections/get.js";
 import { setAdminLocaleFn } from "../server-fns/i18n/index.js";
+import { acceptSession, coordinateAuthAction, notifySessionAction } from "./session-coordination.js";
 const byline_admin_services_getCollectionDocumentVersion = async (collection, documentId, versionId, locale)=>{
     const result = await getCollectionDocumentVersion(collection, documentId, versionId, locale);
     if (null == result) throw new Error(`Document version not found: collection=${collection} document=${documentId} version=${versionId}`);
     return result;
 };
 const bylineAdminServices = {
-    adminSignIn: adminSignIn,
+    adminSignIn: async (args)=>{
+        const result = await coordinateAuthAction(()=>adminSignIn(args));
+        acceptSession(result.sessionId);
+        notifySessionAction();
+        return result;
+    },
     updateAccount: updateAccount,
     changeAccountPassword: changeAccountPassword,
     setAdminLocale: setAdminLocaleFn,

package/dist/integrations/byline-field-services.js

@@ -8,19 +8,12 @@ const byline_field_services_getCollectionDocuments = ({ collection, params })=>g
         }
     });
 const byline_field_services_uploadField = (collection, formData, createDocument)=>uploadField(collection, formData, createDocument);
-const byline_field_services_placeTreeNode = async (input)=>{
-    const { orderKey } = await placeTreeNode({
+const byline_field_services_placeTreeNode = async (input)=>placeTreeNode({
         data: input
     });
-    return {
-        orderKey
-    };
-};
-const byline_field_services_removeFromTree = async (input)=>{
-    await removeFromTree({
+const byline_field_services_removeFromTree = async (input)=>removeFromTree({
         data: input
     });
-};
 const byline_field_services_getTreeAncestors = (input)=>getTreeAncestors({
         data: input
     });

package/dist/integrations/client-ip.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 { ClientIpResolver } from '@byline/auth';
+/** Normalize equivalent IPv6 spellings and IPv4-mapped IPv6 before choosing a rate-limit key. */
+export declare function normalizeClientIp(value: string | null | undefined): string | null;
+/**
+ * Configure either a direct peer resolver or an explicitly trusted proxy header.
+ * Header mode requires the deployment to overwrite that header and block proxy bypass.
+ * Never falls back from a missing/invalid trusted header to another client-supplied header.
+ */
+export declare function createClientIpResolver(options: {
+    trustedProxyHeader?: string;
+    resolvePeerIp: ClientIpResolver;
+}): ClientIpResolver;

package/dist/integrations/client-ip.js

@@ -0,0 +1,34 @@
+import { isIP } from "node:net";
+function normalizeClientIp(value) {
+    if (!value || value.length > 64) return null;
+    const ip = value.trim();
+    if (4 === isIP(ip)) return ip;
+    if (6 !== isIP(ip) || ip.includes('%')) return null;
+    const normalized = new URL(`http://[${ip}]/`).hostname.slice(1, -1);
+    const mapped = /^::ffff:([0-9a-f]+):([0-9a-f]+)$/.exec(normalized);
+    if (mapped) {
+        const high = Number.parseInt(mapped[1], 16);
+        const low = Number.parseInt(mapped[2], 16);
+        return [
+            high >>> 8,
+            255 & high,
+            low >>> 8,
+            255 & low
+        ].join('.');
+    }
+    return normalized;
+}
+function createClientIpResolver(options) {
+    const header = options.trustedProxyHeader;
+    if (void 0 !== header && !/^[a-z0-9-]+$/i.test(header)) throw new Error('Invalid trusted IP header');
+    let lastDiagnostic = -1 / 0;
+    return async (request)=>{
+        const ip = normalizeClientIp(void 0 === header ? await options.resolvePeerIp(request) : request.headers.get(header));
+        if (!ip && performance.now() - lastDiagnostic >= 60000) {
+            lastDiagnostic = performance.now();
+            console.warn('[byline:client-ip] No valid single client IP; check the configured peer resolver or trusted proxy header.');
+        }
+        return ip;
+    };
+}
+export { createClientIpResolver, normalizeClientIp };

package/dist/integrations/session-coordination.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 declare const sessionChangedError: () => Error;
+export declare function expectedSession(): string | null;
+export declare function sessionSnapshot(): {
+    sessionId: string | null;
+    epoch: number;
+};
+export declare function requireUnchanged(snapshot: ReturnType<typeof sessionSnapshot>): void;
+export declare function flagSessionChanged(): void;
+export declare function acceptSession(sessionId: string): void;
+export declare function observeSession(sessionId: string): void;
+export declare function sessionEpoch(): number;
+export declare function sessionIsChanged(): boolean;
+export declare function subscribeSessionChange(listener: () => void): () => void;
+export declare function renewSingleFlight(work: () => Promise<void>): Promise<void>;
+export declare function coordinateAuthAction<T>(work: () => Promise<T>): Promise<T>;
+export declare function startSessionNotifications(): void;
+export declare function notifySessionAction(): void;

package/dist/integrations/session-coordination.js

@@ -0,0 +1,85 @@
+const storageKey = 'byline.expected-login';
+let expected = null;
+let epoch = 0;
+let changed = false;
+let renewal;
+const listeners = new Set();
+const sessionChangedError = ()=>new Error('Session changed. Acknowledge the active account before continuing.');
+function expectedSession() {
+    if ("u" < typeof window) return null;
+    if (!expected) expected = window.sessionStorage.getItem(storageKey);
+    return expected;
+}
+function sessionSnapshot() {
+    return {
+        sessionId: expectedSession(),
+        epoch: epoch
+    };
+}
+function requireUnchanged(snapshot) {
+    if (changed || snapshot.epoch !== epoch || snapshot.sessionId !== expectedSession()) throw sessionChangedError();
+}
+function flagSessionChanged() {
+    changed = true;
+    epoch++;
+    for (const listener of listeners)listener();
+}
+function acceptSession(sessionId) {
+    if ("u" < typeof window) return;
+    if ('string' != typeof sessionId || !sessionId) throw new Error('Provider omitted login identity');
+    window.sessionStorage.setItem(storageKey, sessionId);
+    expected = sessionId;
+    changed = false;
+    epoch++;
+    for (const listener of listeners)listener();
+}
+function observeSession(sessionId) {
+    const old = expectedSession();
+    if (old && old !== sessionId) {
+        flagSessionChanged();
+        throw sessionChangedError();
+    }
+    if (!old) acceptSession(sessionId);
+}
+function sessionEpoch() {
+    return epoch;
+}
+function sessionIsChanged() {
+    return changed;
+}
+function subscribeSessionChange(listener) {
+    listeners.add(listener);
+    return ()=>{
+        listeners.delete(listener);
+    };
+}
+function renewSingleFlight(work) {
+    if (!renewal) renewal = work().finally(()=>{
+        renewal = void 0;
+    });
+    return renewal;
+}
+let authQueue = Promise.resolve();
+function coordinateAuthAction(work) {
+    const run = authQueue.catch(()=>{}).then(async ()=>{
+        if ("u" > typeof navigator && navigator.locks) return navigator.locks.request('byline.auth', work);
+        return work();
+    });
+    authQueue = run;
+    return run;
+}
+let channel;
+function startSessionNotifications() {
+    if ("u" < typeof BroadcastChannel || channel) return;
+    channel = new BroadcastChannel('byline.session');
+    channel.onmessage = ()=>{
+        flagSessionChanged();
+    };
+}
+function notifySessionAction() {
+    startSessionNotifications();
+    channel?.postMessage({
+        type: 'session-changed'
+    });
+}
+export { acceptSession, coordinateAuthAction, expectedSession, flagSessionChanged, notifySessionAction, observeSession, renewSingleFlight, requireUnchanged, sessionChangedError, sessionEpoch, sessionIsChanged, sessionSnapshot, startSessionNotifications, subscribeSessionChange };

package/dist/integrations/session-middleware.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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
+ */
+/** The boundary owns the retry signal; handler errors cannot turn into retryable outcomes. */
+export declare const adminSessionMiddleware: import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>;

package/dist/integrations/session-middleware.js

@@ -0,0 +1,94 @@
+import { createMiddleware } from "@tanstack/react-start";
+import { getRequest, setResponseHeader } from "@tanstack/react-start/server";
+import { AuthError, ERR_ACCESS_EXPIRED, ERR_SESSION_CHANGED, ERR_UNAUTHENTICATED } from "@byline/auth";
+import { getAdminRequestContext } from "@byline/client/server";
+import { renewAdminSession } from "../server-fns/auth/renew.js";
+import { coordinateAuthAction, flagSessionChanged, observeSession, renewSingleFlight, requireUnchanged, sessionSnapshot } from "./session-coordination.js";
+import { sessionRequestKind } from "./session-request-kind.js";
+const outcomeHeader = 'x-byline-auth-boundary';
+const adminSessionMiddleware = createMiddleware({
+    type: 'function'
+}).client(async ({ next })=>{
+    if ("u" < typeof window) return next({
+        sendContext: {
+            bylineExpectedSessionId: null
+        }
+    });
+    const snapshot = sessionSnapshot();
+    requireUnchanged(snapshot);
+    return next({
+        sendContext: {
+            bylineExpectedSessionId: snapshot.sessionId
+        },
+        fetch: async (input, init)=>{
+            const reusable = !(input instanceof Request) && !(init?.body instanceof ReadableStream);
+            let response = await fetch(input, init);
+            if ('changed' === response.headers.get(outcomeHeader)) {
+                flagSessionChanged();
+                throw ERR_SESSION_CHANGED({
+                    message: 'session changed'
+                });
+            }
+            if ('renew' === response.headers.get(outcomeHeader)) {
+                requireUnchanged(snapshot);
+                await renewSingleFlight(()=>coordinateAuthAction(async ()=>{
+                        const result = await renewAdminSession({
+                            data: {
+                                expectedSessionId: snapshot.sessionId ?? void 0
+                            }
+                        }).catch((error)=>{
+                            if (error?.code === 'ERR_SESSION_CHANGED') flagSessionChanged();
+                            throw error;
+                        });
+                        if (snapshot.sessionId && result.sessionId !== snapshot.sessionId) {
+                            flagSessionChanged();
+                            throw ERR_SESSION_CHANGED({
+                                message: 'session changed during renewal'
+                            });
+                        }
+                        observeSession(result.sessionId);
+                    }));
+                requireUnchanged(snapshot);
+                if (!reusable) throw ERR_ACCESS_EXPIRED({
+                    message: 'Session renewed. Please retry the operation.'
+                });
+                response = await fetch(input, init);
+                if ('changed' === response.headers.get(outcomeHeader)) flagSessionChanged();
+            }
+            requireUnchanged(snapshot);
+            return response;
+        }
+    });
+}).server(async ({ next, context, method })=>{
+    const kind = sessionRequestKind(getRequest());
+    if (!kind) throw new Error('sessionRequestMiddleware is not configured');
+    let auth;
+    try {
+        auth = await getAdminRequestContext();
+    } catch (error) {
+        if (error instanceof AuthError && 'ERR_ACCESS_EXPIRED' === error.code) setResponseHeader(outcomeHeader, 'renew');
+        throw error;
+    }
+    const expected = context.bylineExpectedSessionId;
+    if (('serverFn' === kind || 'GET' !== method) && (!expected || expected !== auth.sessionId)) {
+        setResponseHeader(outcomeHeader, 'changed');
+        throw ERR_SESSION_CHANGED({
+            message: 'session changed before operation'
+        });
+    }
+    if (!auth.sessionId) throw ERR_UNAUTHENTICATED({
+        message: 'provider omitted login identity'
+    });
+    try {
+        const result = await next();
+        const response = result.result;
+        if (response instanceof Response) response.headers.delete(outcomeHeader);
+        return result;
+    } catch (error) {
+        if (error instanceof Response) error.headers.delete(outcomeHeader);
+        throw error;
+    } finally{
+        setResponseHeader(outcomeHeader, 'handled');
+    }
+});
+export { adminSessionMiddleware };

package/dist/integrations/session-request-kind.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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 declare function recordSessionRequestKind(request: object, kind: string): void;
+export declare function sessionRequestKind(request: object): string | undefined;

package/dist/integrations/session-request-kind.js

@@ -0,0 +1,10 @@
+const key = Symbol.for('byline.sessionRequestKinds');
+const kinds = globalThis[key] ?? new WeakMap();
+globalThis[key] = kinds;
+function recordSessionRequestKind(request, kind) {
+    kinds.set(request, kind);
+}
+function sessionRequestKind(request) {
+    return kinds.get(request);
+}
+export { recordSessionRequestKind, sessionRequestKind };

package/dist/integrations/session-request-middleware.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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
+ */
+/** Register after CSRF. Classifies SSR separately from remotely invoked business functions. */
+export declare const sessionRequestMiddleware: import("@tanstack/react-start").RequestMiddlewareAfterServer<{}, undefined, undefined>;

package/dist/integrations/session-request-middleware.js

@@ -0,0 +1,7 @@
+import { createMiddleware } from "@tanstack/react-start";
+import { recordSessionRequestKind } from "./session-request-kind.js";
+const sessionRequestMiddleware = createMiddleware().server(async (ctx)=>{
+    recordSessionRequestKind(ctx.request, ctx.handlerType);
+    return ctx.next();
+});
+export { sessionRequestMiddleware };

package/dist/integrations/sign-in-body.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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
+ */
+/** Limit the serialized RPC envelope, not just its eventual credential fields. */
+export declare const SIGN_IN_MAX_BODY_BYTES: number;
+export declare function wasSignInBodyChecked(request: Request): boolean;
+/** Read a bounded clone before Start parses the original. Never await tee cancellation. */
+export declare function checkSignInBody(request: Request): Promise<Response | undefined>;