@byline/host-tanstack-start 4.19.0 → 5.1.0

package/dist/server-fns/collections/update.js

@@ -1,13 +1,17 @@
 import { createServerFn } from "@tanstack/react-start";
 import { getAdminRequestContext } from "@byline/client/server";
 import { ERR_NOT_FOUND, getLogger, getServerConfig } from "@byline/core";
-import { updateDocumentSystemFields, updateDocumentWithPatches } from "@byline/core/services";
+import { saveDocument, updateDocumentSystemFields } from "@byline/core/services";
 import { ensureCollection } from "../../integrations/api-utils.js";
+import { adminSessionMiddleware } from "../../integrations/session-middleware.js";
+import { withDocumentMutationErrors } from "../document-mutation-errors.js";
 import { toCommittedDocumentHookFailureResponse } from "./save-outcome.js";
 const updateCollectionDocumentWithPatches = createServerFn({
     method: 'POST'
-}).validator((input)=>input).handler(async ({ data: input })=>{
-    const { collection: path, id, patches, versionId, locale } = input;
+}).middleware([
+    adminSessionMiddleware
+]).validator((input)=>input).handler(withDocumentMutationErrors(async ({ data: input })=>{
+    const { collection: path, id, patches, expectedRevision, locale, path: explicitPath, availableLocales } = input;
     const logger = getLogger();
     const config = await ensureCollection(path);
     if (!config) throw ERR_NOT_FOUND({
@@ -30,10 +34,12 @@ const updateCollectionDocumentWithPatches = createServerFn({
     };
     let result;
     try {
-        result = await updateDocumentWithPatches(ctx, {
+        result = await saveDocument(ctx, {
             documentId: id,
             patches,
-            documentVersionId: versionId,
+            expectedRevision,
+            path: explicitPath ?? void 0,
+            availableLocales,
             locale: locale ?? serverConfig.i18n.content.defaultLocale
         });
     } catch (error) {
@@ -44,13 +50,18 @@ const updateCollectionDocumentWithPatches = createServerFn({
     return {
         status: 'ok',
         documentId: result.documentId,
-        documentVersionId: result.documentVersionId
+        ...'documentVersionId' in result ? {
+            documentVersionId: result.documentVersionId
+        } : {},
+        revision: result.revision
     };
-});
+}));
 const updateCollectionDocumentSystemFields = createServerFn({
     method: 'POST'
-}).validator((input)=>input).handler(async ({ data: input })=>{
-    const { collection: path, id, locale, path: explicitPath, availableLocales } = input;
+}).middleware([
+    adminSessionMiddleware
+]).validator((input)=>input).handler(withDocumentMutationErrors(async ({ data: input })=>{
+    const { collection: path, id, expectedRevision, locale, path: explicitPath, availableLocales } = input;
     const logger = getLogger();
     const config = await ensureCollection(path);
     if (!config) throw ERR_NOT_FOUND({
@@ -71,15 +82,23 @@ const updateCollectionDocumentSystemFields = createServerFn({
         slugifier: serverConfig.slugifier,
         requestContext: await getAdminRequestContext()
     };
-    await updateDocumentSystemFields(ctx, {
-        documentId: id,
-        locale: locale ?? serverConfig.i18n.content.defaultLocale,
-        path: explicitPath,
-        availableLocales,
-        reconcile: true
-    });
-    return {
-        status: 'ok'
-    };
-});
+    try {
+        const result = await updateDocumentSystemFields(ctx, {
+            expectedRevision,
+            documentId: id,
+            locale: locale ?? serverConfig.i18n.content.defaultLocale,
+            path: explicitPath,
+            availableLocales,
+            reconcile: true
+        });
+        return {
+            status: 'ok',
+            revision: result.revision
+        };
+    } catch (error) {
+        const committedFailure = toCommittedDocumentHookFailureResponse(error);
+        if (null != committedFailure) return committedFailure;
+        throw error;
+    }
+}));
 export { updateCollectionDocumentSystemFields, updateCollectionDocumentWithPatches };

package/dist/server-fns/collections/upload.d.ts

@@ -1,3 +1,10 @@
+/**
+ * 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 { StoredFileValue } from '@byline/core';
 /**
  * Result of an upload through the host transport. The legacy top-level
@@ -9,6 +16,7 @@ export interface UploadFieldResult {
     /** Present when the upload endpoint created a document (createDocument=true, the default). */
     documentId?: string;
     documentVersionId?: string;
+    revision?: number;
     storedFile: StoredFileValue;
 }
 interface UploadDocumentInput {
@@ -35,7 +43,9 @@ declare function parseUploadFormData(data: FormData): UploadDocumentInput;
  * deployments and external clients can use the identical upload orchestration
  * without depending on TanStack Start server-function transport details.
  */
-export declare const uploadCollectionField: import("@tanstack/react-start").RequiredFetcher<undefined, typeof parseUploadFormData, Promise<import("@byline/core").UploadFieldResult>>;
+export declare const uploadCollectionField: import("@tanstack/react-start").RequiredFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], typeof parseUploadFormData, Promise<import("@byline/core").UploadFieldResult>>;
 /**
  * Upload a file to an upload-enabled collection.
  *

package/dist/server-fns/collections/upload.js

@@ -5,6 +5,8 @@ import { extractImageMeta, generateImageVariants, isBypassMimeType } from "@byli
 import { getLogger, withLogContext } from "@byline/core/logger";
 import { uploadField } from "@byline/core/services";
 import { ensureDocumentResource } from "../../integrations/api-utils.js";
+import { adminSessionMiddleware } from "../../integrations/session-middleware.js";
+import { withDocumentMutationErrors } from "../document-mutation-errors.js";
 function parseUploadFormData(data) {
     if (!(data instanceof FormData)) throw new Error('Expected FormData upload payload.');
     const collectionEntry = data.get('collection');
@@ -56,7 +58,9 @@ function resolveUploadField(definition, collectionPath, requested) {
 }
 const uploadCollectionField = createServerFn({
     method: 'POST'
-}).validator(parseUploadFormData).handler(async ({ data })=>{
+}).middleware([
+    adminSessionMiddleware
+]).validator(parseUploadFormData).handler(withDocumentMutationErrors(async ({ data })=>{
     const { collectionPath, shouldCreateDocument, fieldName, file, fields } = data;
     const logger = getLogger();
     return withLogContext({
@@ -114,7 +118,7 @@ const uploadCollectionField = createServerFn({
             locale: serverConfig.i18n.content.defaultLocale
         });
     });
-});
+}));
 async function upload_uploadField(collection, formData, createDocument = true) {
     const payload = new FormData();
     for (const [key, value] of formData.entries())payload.append(key, value);

package/dist/server-fns/document-mutation-errors.d.ts

@@ -0,0 +1,5 @@
+/** Error subclasses lose custom properties in the server-function serializer.
+ * Throw only validated plain data for document failures; never transport causes,
+ * SQL, hook messages or an unverified current revision. */
+export declare function documentMutationError(error: unknown): unknown;
+export declare function withDocumentMutationErrors<T, R>(handler: (input: T) => Promise<R>): (input: T) => Promise<R>;

package/dist/server-fns/document-mutation-errors.js

@@ -0,0 +1,50 @@
+import { BylineError, ErrorCodes, getDocumentRevisionValidationDetails, getDocumentStaleDetails, getLockConflictDetails } from "@byline/core";
+import { getDocumentHookCommittedDetails } from "@byline/core/services";
+import { committedTreeReceipt } from "./structural-receipt.js";
+function documentMutationError(error) {
+    const stale = getDocumentStaleDetails(error);
+    if (stale) return {
+        code: ErrorCodes.DOCUMENT_STALE,
+        message: 'This document has changed. Reload before making changes.',
+        details: stale
+    };
+    const validation = getDocumentRevisionValidationDetails(error);
+    if (validation) return {
+        code: ErrorCodes.VALIDATION,
+        message: 'Reload this document before making changes.',
+        details: validation
+    };
+    const lock = getLockConflictDetails(error);
+    if (lock) return {
+        code: ErrorCodes.LOCK_CONFLICT,
+        message: 'This change could not be saved because another operation was using the document. Reload before trying again.',
+        details: lock
+    };
+    const tree = committedTreeReceipt(error);
+    if (tree) return {
+        code: ErrorCodes.TREE_HOOK_COMMITTED,
+        message: 'The structure was saved, but a follow-up action failed.',
+        details: tree
+    };
+    const committed = getDocumentHookCommittedDetails(error);
+    if (committed) return {
+        code: ErrorCodes.DOCUMENT_HOOK_COMMITTED,
+        message: 'The document was saved, but a follow-up action failed.',
+        details: committed
+    };
+    if (error instanceof BylineError && error.code === ErrorCodes.NOT_FOUND) return {
+        code: ErrorCodes.NOT_FOUND,
+        message: 'This document is no longer available.'
+    };
+    return error;
+}
+function withDocumentMutationErrors(handler) {
+    return async (input)=>{
+        try {
+            return await handler(input);
+        } catch (error) {
+            throw documentMutationError(error);
+        }
+    };
+}
+export { documentMutationError, withDocumentMutationErrors };

package/dist/server-fns/editable-revision.d.ts

@@ -0,0 +1,9 @@
+/** Restore metadata stripped by schema parsing only onto the exact source version.
+ * Never attach by array position: filtering/reordering must not transfer tokens. */
+export declare function withEditableRevision<T extends object>(document: T, observation: {
+    id: string;
+    versionId: string;
+    revision: number;
+} | undefined): T & {
+    revision: number;
+};

package/dist/server-fns/editable-revision.js

@@ -0,0 +1,11 @@
+import { ERR_DATABASE, isDocumentRevision } from "@byline/core";
+function withEditableRevision(document, observation) {
+    if (!observation || !isDocumentRevision(observation.revision) || Reflect.get(document, 'id') !== observation.id || Reflect.get(document, 'versionId') !== observation.versionId) throw ERR_DATABASE({
+        message: 'Editable response no longer matches its source observation'
+    });
+    return {
+        ...document,
+        revision: observation.revision
+    };
+}
+export { withEditableRevision };

package/dist/server-fns/i18n/set-locale.d.ts

@@ -22,4 +22,6 @@ export interface SetAdminLocaleResult {
      */
     account: AccountResponse | null;
 }
-export declare const setAdminLocaleFn: import("@tanstack/react-start").RequiredFetcher<undefined, (input: SetAdminLocaleInput) => SetAdminLocaleInput, Promise<SetAdminLocaleResult>>;
+export declare const setAdminLocaleFn: import("@tanstack/react-start").RequiredFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterClient<{}, unknown, undefined, {
+    expectedSessionId: string | null;
+}, undefined>], (input: SetAdminLocaleInput) => SetAdminLocaleInput, Promise<SetAdminLocaleResult>>;

package/dist/server-fns/i18n/set-locale.js

@@ -1,12 +1,22 @@
-import { createServerFn } from "@tanstack/react-start";
+import { createMiddleware, createServerFn } from "@tanstack/react-start";
 import { setPreferredLocaleCommand } from "@byline/admin/admin-account";
 import { AuthError, AuthErrorCodes } from "@byline/auth";
 import { getAdminRequestContext } from "@byline/client/server";
 import { clearAdminLocaleCookie, setAdminLocaleCookie } from "../../i18n/locale-cookie.js";
 import { bylineCore } from "../../integrations/byline-core.js";
+import { expectedSession } from "../../integrations/session-coordination.js";
+const localeSession = createMiddleware({
+    type: 'function'
+}).client(({ next })=>next({
+        sendContext: {
+            expectedSessionId: expectedSession()
+        }
+    }));
 const setAdminLocaleFn = createServerFn({
     method: 'POST'
-}).validator((input)=>input).handler(async ({ data })=>{
+}).middleware([
+    localeSession
+]).validator((input)=>input).handler(async ({ data, context: caller })=>{
     const core = bylineCore();
     const locales = core.config.i18n.admin.locales;
     if (null != data.locale && !locales.includes(data.locale)) throw new Error(`[setAdminLocaleFn] locale '${data.locale}' is not in i18n.admin.locales [${locales.join(', ')}].`);
@@ -20,6 +30,11 @@ const setAdminLocaleFn = createServerFn({
     };
     try {
         const context = await getAdminRequestContext();
+        if (!caller.expectedSessionId || caller.expectedSessionId !== context.sessionId) return {
+            ok: true,
+            locale: data.locale,
+            account: null
+        };
         const account = await setPreferredLocaleCommand(context, {
             locale: data.locale
         }, {
@@ -31,7 +46,7 @@ const setAdminLocaleFn = createServerFn({
             account
         };
     } catch (err) {
-        if (err instanceof AuthError && err.code === AuthErrorCodes.UNAUTHENTICATED) return {
+        if (err instanceof AuthError && (err.code === AuthErrorCodes.UNAUTHENTICATED || err.code === AuthErrorCodes.ACCESS_EXPIRED)) return {
             ok: true,
             locale: data.locale,
             account: null

package/dist/server-fns/preview/disable.d.ts

@@ -5,7 +5,9 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
-export declare const disablePreviewModeFn: import("@tanstack/react-start").OptionalFetcher<undefined, undefined, Promise<{
+export declare const disablePreviewModeFn: import("@tanstack/react-start").OptionalFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], undefined, Promise<{
     status: 'ok';
     preview: false;
 }>>;

package/dist/server-fns/preview/disable.js

@@ -1,8 +1,11 @@
 import { createServerFn } from "@tanstack/react-start";
 import { clearPreviewCookie } from "@byline/client/server";
+import { adminSessionMiddleware } from "../../integrations/session-middleware.js";
 const disablePreviewModeFn = createServerFn({
     method: 'POST'
-}).handler(async ()=>{
+}).middleware([
+    adminSessionMiddleware
+]).handler(async ()=>{
     clearPreviewCookie();
     return {
         status: 'ok',

package/dist/server-fns/preview/enable.d.ts

@@ -5,7 +5,9 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
-export declare const enablePreviewModeFn: import("@tanstack/react-start").OptionalFetcher<undefined, undefined, Promise<{
+export declare const enablePreviewModeFn: import("@tanstack/react-start").OptionalFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], undefined, Promise<{
     status: 'ok';
     preview: true;
 }>>;

package/dist/server-fns/preview/enable.js

@@ -1,8 +1,11 @@
 import { createServerFn } from "@tanstack/react-start";
 import { getAdminRequestContext, setPreviewCookie } from "@byline/client/server";
+import { adminSessionMiddleware } from "../../integrations/session-middleware.js";
 const enablePreviewModeFn = createServerFn({
     method: 'POST'
-}).handler(async ()=>{
+}).middleware([
+    adminSessionMiddleware
+]).handler(async ()=>{
     await getAdminRequestContext();
     setPreviewCookie();
     return {

package/dist/server-fns/singleton-document-read.d.ts

@@ -17,4 +17,4 @@ export interface SingletonDocumentReadInput {
  * is deliberately composed one layer up, where host database and actor
  * context are available without widening the singleton transport contract.
  */
-export declare function readSingletonDocument(data: SingletonDocumentReadInput): Promise<import("@byline/client").SingletonDocument<Record<string, any>> | null>;
+export declare function readSingletonDocument(data: SingletonDocumentReadInput): Promise<Omit<import("@byline/client").EditableDocument<Record<string, any>>, "path"> | null>;

package/dist/server-fns/singleton-document-read.js

@@ -1,10 +1,14 @@
 import { getAdminBylineClient } from "@byline/client/server";
-import { getCollectionDefinition } from "@byline/core";
+import { ERR_NOT_FOUND, getCollectionDefinition } from "@byline/core";
 import { resolveAdminDocumentRead } from "./admin-document-presentation.js";
 import { serialise } from "./serialise.js";
 async function readSingletonDocument(data) {
     const handle = getAdminBylineClient().singleton(data.singleton);
-    const { options } = resolveAdminDocumentRead(getCollectionDefinition(data.singleton), data);
-    return serialise(await handle.get(options));
+    const { options: { status: _status, ...options } } = resolveAdminDocumentRead(getCollectionDefinition(data.singleton), data);
+    const snapshot = await handle.getForEdit(options);
+    if (null == snapshot) throw ERR_NOT_FOUND({
+        message: 'Singleton document is unavailable'
+    });
+    return 'empty' === snapshot.state ? null : serialise(snapshot.document);
 }
 export { readSingletonDocument };

package/dist/server-fns/singletons/cancel-scheduled-publish.d.ts

@@ -5,8 +5,15 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
-export declare const cancelSingletonScheduledPublish: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+export declare const cancelSingletonScheduledPublish: import("@tanstack/react-start").RequiredFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], (input: {
+    expectedRevision: number;
     singleton: string;
 }) => {
+    expectedRevision: number;
     singleton: string;
-}, Promise<import("@byline/client").DocumentPublishScheduleInfo | null>>;
+}, Promise<{
+    schedule: import("@byline/client").DocumentPublishScheduleInfo | null;
+    revision: number;
+}>>;

package/dist/server-fns/singletons/cancel-scheduled-publish.js

@@ -1,7 +1,13 @@
 import { createServerFn } from "@tanstack/react-start";
 import { getAdminBylineClient } from "@byline/client/server";
+import { adminSessionMiddleware } from "../../integrations/session-middleware.js";
+import { withDocumentMutationErrors } from "../document-mutation-errors.js";
 import { serialise } from "../serialise.js";
 const cancelSingletonScheduledPublish = createServerFn({
     method: 'POST'
-}).validator((input)=>input).handler(async ({ data })=>serialise(await getAdminBylineClient().singleton(data.singleton).cancelScheduledPublish()));
+}).middleware([
+    adminSessionMiddleware
+]).validator((input)=>input).handler(withDocumentMutationErrors(async ({ data })=>serialise(await getAdminBylineClient().singleton(data.singleton).cancelScheduledPublish({
+        expectedRevision: data.expectedRevision
+    }))));
 export { cancelSingletonScheduledPublish };

package/dist/server-fns/singletons/change-status.d.ts

@@ -5,10 +5,14 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
-export declare const changeSingletonStatus: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+export declare const changeSingletonStatus: import("@tanstack/react-start").RequiredFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], (input: {
+    expectedRevision: number;
     singleton: string;
     status: string;
 }) => {
+    expectedRevision: number;
     singleton: string;
     status: string;
 }, Promise<import("@byline/core").ChangeStatusResult>>;

package/dist/server-fns/singletons/change-status.js

@@ -1,7 +1,13 @@
 import { createServerFn } from "@tanstack/react-start";
 import { getAdminBylineClient } from "@byline/client/server";
+import { adminSessionMiddleware } from "../../integrations/session-middleware.js";
+import { withDocumentMutationErrors } from "../document-mutation-errors.js";
 import { serialise } from "../serialise.js";
 const changeSingletonStatus = createServerFn({
     method: 'POST'
-}).validator((input)=>input).handler(async ({ data })=>serialise(await getAdminBylineClient().singleton(data.singleton).changeStatus(data.status)));
+}).middleware([
+    adminSessionMiddleware
+]).validator((input)=>input).handler(withDocumentMutationErrors(async ({ data })=>serialise(await getAdminBylineClient().singleton(data.singleton).changeStatus(data.status, {
+        expectedRevision: data.expectedRevision
+    }))));
 export { changeSingletonStatus };

package/dist/server-fns/singletons/confirm-scheduled-publish.d.ts

@@ -5,10 +5,16 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
-export declare const confirmSingletonScheduledPublish: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+export declare const confirmSingletonScheduledPublish: import("@tanstack/react-start").RequiredFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], (input: {
+    expectedRevision: number;
     singleton: string;
     expectedVersionId: string;
 }) => {
+    expectedRevision: number;
     singleton: string;
     expectedVersionId: string;
-}, Promise<import("@byline/client").DocumentPublishScheduleInfo>>;
+}, Promise<import("@byline/client").DocumentPublishScheduleInfo & {
+    revision: number;
+}>>;

package/dist/server-fns/singletons/confirm-scheduled-publish.js

@@ -1,9 +1,14 @@
 import { createServerFn } from "@tanstack/react-start";
 import { getAdminBylineClient } from "@byline/client/server";
+import { adminSessionMiddleware } from "../../integrations/session-middleware.js";
+import { withDocumentMutationErrors } from "../document-mutation-errors.js";
 import { serialise } from "../serialise.js";
 const confirmSingletonScheduledPublish = createServerFn({
     method: 'POST'
-}).validator((input)=>input).handler(async ({ data })=>serialise(await getAdminBylineClient().singleton(data.singleton).confirmScheduledPublish({
+}).middleware([
+    adminSessionMiddleware
+]).validator((input)=>input).handler(withDocumentMutationErrors(async ({ data })=>serialise(await getAdminBylineClient().singleton(data.singleton).confirmScheduledPublish({
+        expectedRevision: data.expectedRevision,
         expectedVersionId: data.expectedVersionId
-    })));
+    }))));
 export { confirmSingletonScheduledPublish };

package/dist/server-fns/singletons/copy-to-locale.d.ts

@@ -5,12 +5,16 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
-export declare const copySingletonToLocale: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+export declare const copySingletonToLocale: import("@tanstack/react-start").RequiredFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], (input: {
+    expectedRevision: number;
     singleton: string;
     sourceLocale: string;
     targetLocale: string;
     overwrite?: boolean;
 }) => {
+    expectedRevision: number;
     singleton: string;
     sourceLocale: string;
     targetLocale: string;

package/dist/server-fns/singletons/copy-to-locale.js

@@ -1,12 +1,17 @@
 import { createServerFn } from "@tanstack/react-start";
 import { getAdminBylineClient } from "@byline/client/server";
+import { adminSessionMiddleware } from "../../integrations/session-middleware.js";
 import { toCommittedDocumentHookFailureResponse } from "../collections/save-outcome.js";
+import { withDocumentMutationErrors } from "../document-mutation-errors.js";
 import { serialise } from "../serialise.js";
 const copySingletonToLocale = createServerFn({
     method: 'POST'
-}).validator((input)=>input).handler(async ({ data })=>{
+}).middleware([
+    adminSessionMiddleware
+]).validator((input)=>input).handler(withDocumentMutationErrors(async ({ data })=>{
     try {
         return serialise(await getAdminBylineClient().singleton(data.singleton).copyToLocale({
+            expectedRevision: data.expectedRevision,
             sourceLocale: data.sourceLocale,
             targetLocale: data.targetLocale,
             overwrite: data.overwrite
@@ -16,5 +21,5 @@ const copySingletonToLocale = createServerFn({
         if (null != committedFailure) return committedFailure;
         throw error;
     }
-});
+}));
 export { copySingletonToLocale };

package/dist/server-fns/singletons/find-by-version.d.ts

@@ -5,7 +5,9 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
-export declare const findSingletonByVersion: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+export declare const findSingletonByVersion: import("@tanstack/react-start").RequiredFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], (input: {
     singleton: string;
     versionId: string;
     locale?: string;

package/dist/server-fns/singletons/find-by-version.js

@@ -1,9 +1,12 @@
 import { createServerFn } from "@tanstack/react-start";
 import { getAdminBylineClient } from "@byline/client/server";
+import { adminSessionMiddleware } from "../../integrations/session-middleware.js";
 import { serialise } from "../serialise.js";
 const findSingletonByVersion = createServerFn({
     method: 'GET'
-}).validator((input)=>input).handler(async ({ data })=>serialise(await getAdminBylineClient().singleton(data.singleton).findByVersion(data.versionId, {
+}).middleware([
+    adminSessionMiddleware
+]).validator((input)=>input).handler(async ({ data })=>serialise(await getAdminBylineClient().singleton(data.singleton).findByVersion(data.versionId, {
         locale: data.locale ?? 'all'
     })));
 export { findSingletonByVersion };

package/dist/server-fns/singletons/get-scheduled-publish.d.ts

@@ -5,7 +5,9 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
-export declare const getSingletonScheduledPublish: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+export declare const getSingletonScheduledPublish: import("@tanstack/react-start").RequiredFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], (input: {
     singleton: string;
 }) => {
     singleton: string;

package/dist/server-fns/singletons/get-scheduled-publish.js

@@ -1,7 +1,10 @@
 import { createServerFn } from "@tanstack/react-start";
 import { getAdminBylineClient } from "@byline/client/server";
+import { adminSessionMiddleware } from "../../integrations/session-middleware.js";
 import { serialise } from "../serialise.js";
 const getSingletonScheduledPublish = createServerFn({
     method: 'GET'
-}).validator((input)=>input).handler(async ({ data })=>serialise(await getAdminBylineClient().singleton(data.singleton).getScheduledPublish()));
+}).middleware([
+    adminSessionMiddleware
+]).validator((input)=>input).handler(async ({ data })=>serialise(await getAdminBylineClient().singleton(data.singleton).getScheduledPublish()));
 export { getSingletonScheduledPublish };

package/dist/server-fns/singletons/get.d.ts

@@ -17,8 +17,10 @@ export interface GetSingletonInput {
  * - this shared host layer owns lenient reads, raw missing-locale values,
  *   relation-summary population, transport serialization, and preservation of
  *   restore warnings and locale metadata;
- * - the route loader composes published-version metadata plus scheduled-
- *   publication enablement, capability, and schedule aliases because those
- *   require host-only database and actor context beyond the singleton handle.
+ * - the route loader composes the informational published-version badge, feature
+ *   enablement, capability, and schedule aliases. Schedule state itself comes
+ *   from the same editable snapshot as the source document.
  */
-export declare const getSingleton: import("@tanstack/react-start").RequiredFetcher<undefined, (input: GetSingletonInput) => GetSingletonInput, Promise<import("@byline/client").SingletonDocument<Record<string, any>> | null>>;
+export declare const getSingleton: import("@tanstack/react-start").RequiredFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], (input: GetSingletonInput) => GetSingletonInput, Promise<Omit<import("@byline/client").EditableDocument<Record<string, any>>, "path"> | null>>;

package/dist/server-fns/singletons/get.js

@@ -1,6 +1,9 @@
 import { createServerFn } from "@tanstack/react-start";
+import { adminSessionMiddleware } from "../../integrations/session-middleware.js";
 import { readSingletonDocument } from "../singleton-document-read.js";
 const getSingleton = createServerFn({
     method: 'GET'
-}).validator((input)=>input).handler(async ({ data })=>readSingletonDocument(data));
+}).middleware([
+    adminSessionMiddleware
+]).validator((input)=>input).handler(async ({ data })=>readSingletonDocument(data));
 export { getSingleton };

package/dist/server-fns/singletons/history.d.ts

@@ -13,7 +13,9 @@ export interface SingletonHistorySearchParams {
     desc?: boolean;
     locale?: string;
 }
-export declare const getSingletonHistory: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+export declare const getSingletonHistory: import("@tanstack/react-start").RequiredFetcher<readonly [import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, {
+    bylineExpectedSessionId: string | null;
+}, undefined, undefined>], (input: {
     singleton: string;
     params?: SingletonHistorySearchParams;
 }) => {

package/dist/server-fns/singletons/history.js

@@ -1,10 +1,13 @@
 import { createServerFn } from "@tanstack/react-start";
 import { getAdminBylineClient } from "@byline/client/server";
+import { adminSessionMiddleware } from "../../integrations/session-middleware.js";
 import { resolveActorLabels } from "../actors.js";
 import { serialise } from "../serialise.js";
 const getSingletonHistory = createServerFn({
     method: 'GET'
-}).validator((input)=>input).handler(async ({ data })=>{
+}).middleware([
+    adminSessionMiddleware
+]).validator((input)=>input).handler(async ({ data })=>{
     const params = data.params ?? {};
     const result = await getAdminBylineClient().singleton(data.singleton).history({
         locale: params.locale ?? 'en',