@byline/host-tanstack-start 4.19.0 → 5.0.0

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

@@ -1,3 +1,4 @@
+import { withDocumentMutationErrors } from "../document-mutation-errors.js";
 import { createServerFn } from "@tanstack/react-start";
 import { getAdminRequestContext } from "@byline/client/server";
 import { ERR_NOT_FOUND, getLogger, getServerConfig } from "@byline/core";
@@ -5,7 +6,7 @@ import { changeDocumentStatus, unpublishDocument } from "@byline/core/services";
 import { ensureCollection } from "../../integrations/api-utils.js";
 const updateDocumentStatus = createServerFn({
     method: 'POST'
-}).validator((input)=>input).handler(async ({ data: input })=>{
+}).validator((input)=>input).handler(withDocumentMutationErrors(async ({ data: input })=>{
     const { collection: path, id, status: nextStatus } = input;
     const logger = getLogger();
     const config = await ensureCollection(path);
@@ -29,17 +30,20 @@ const updateDocumentStatus = createServerFn({
     };
     const result = await changeDocumentStatus(ctx, {
         documentId: id,
+        expectedRevision: input.expectedRevision,
         nextStatus
     });
     return {
         status: 'ok',
+        documentId: result.documentId,
+        revision: result.revision,
         previousStatus: result.previousStatus,
         newStatus: result.newStatus
     };
-});
+}));
 const status_unpublishDocument = createServerFn({
     method: 'POST'
-}).validator((input)=>input).handler(async ({ data: input })=>{
+}).validator((input)=>input).handler(withDocumentMutationErrors(async ({ data: input })=>{
     const { collection: path, id } = input;
     const logger = getLogger();
     const config = await ensureCollection(path);
@@ -62,18 +66,22 @@ const status_unpublishDocument = createServerFn({
         requestContext: await getAdminRequestContext()
     };
     const result = await unpublishDocument(ctx, {
-        documentId: id
+        documentId: id,
+        expectedRevision: input.expectedRevision
     });
     if (0 === result.archivedCount) throw ERR_NOT_FOUND({
         message: 'No published version found for this document',
         details: {
             documentId: id,
+            expectedRevision: input.expectedRevision,
             collectionPath: path
         }
     }).log(logger);
     return {
         status: 'ok',
+        documentId: result.documentId,
+        revision: result.revision,
         archivedCount: result.archivedCount
     };
-});
+}));
 export { status_unpublishDocument as unpublishDocument, updateDocumentStatus };

package/dist/server-fns/collections/tree-mutation.d.ts

@@ -1,10 +1,12 @@
 import type { CollectionHandle, PlaceTreeNodeOptions, RemoveFromTreeOptions } from '@byline/client';
+import { structuralReceipt } from '../structural-receipt.js';
 /** Prefer the code; the marker survives transports that reconstruct a code-less Error. */
 export declare function isTreeMutationConflict(error: unknown): boolean;
 /** Detect when tree/audit committed even if transport reconstruction dropped the code. */
 export declare function isCommittedTreeHookFailure(error: unknown): boolean;
 export type AdminTreeMoveOutcome = {
     status: 'ok';
+    receipt?: ReturnType<typeof structuralReceipt>;
 } | {
     status: 'suppressed';
 } | {
@@ -18,6 +20,7 @@ export type AdminTreeMoveOutcome = {
 } | {
     status: 'refresh-failed';
     error: unknown;
+    receipt?: ReturnType<typeof structuralReceipt>;
 };
 export interface AdminTreeMoveUiEffects {
     rollback: boolean;
@@ -38,9 +41,7 @@ export interface AdminTreeMoveController {
 }
 /** Single-flight controller shared by pointer and keyboard tree moves. */
 export declare function createAdminTreeMoveController(): AdminTreeMoveController;
-/** Admin retries reconcile post-commit tree hooks unless explicitly disabled. */
-export declare function placeAdminTreeNode(handle: Pick<CollectionHandle, 'placeTreeNode'>, documentId: string, options: PlaceTreeNodeOptions): Promise<{
-    orderKey: string;
-}>;
-/** Admin retries reconcile post-commit tree hooks unless explicitly disabled. */
-export declare function removeAdminTreeNode(handle: Pick<CollectionHandle, 'removeFromTree'>, documentId: string, options?: RemoveFromTreeOptions): Promise<void>;
+/** Request reconciliation for explicit caller actions; never retry or replace their revision. */
+export declare function placeAdminTreeNode(handle: Pick<CollectionHandle, 'placeTreeNode'>, documentId: string, options: PlaceTreeNodeOptions): ReturnType<CollectionHandle['placeTreeNode']>;
+/** Request reconciliation for explicit caller actions; never retry or replace their revision. */
+export declare function removeAdminTreeNode(handle: Pick<CollectionHandle, 'removeFromTree'>, documentId: string, options: RemoveFromTreeOptions): ReturnType<CollectionHandle['removeFromTree']>;

package/dist/server-fns/collections/tree-mutation.js

@@ -1,4 +1,5 @@
-import { ErrorCodes, TREE_HOOK_COMMITTED_MARKER, TREE_PLACEMENT_STALE_MARKER } from "@byline/core";
+import { ErrorCodes, TREE_HOOK_COMMITTED_MARKER, TREE_PLACEMENT_STALE_MARKER, getDocumentRevisionValidationDetails, getDocumentStaleDetails, getLockConflictDetails } from "@byline/core";
+import { structuralReceipt } from "../structural-receipt.js";
 function hasErrorCode(error, code) {
     return 'object' == typeof error && null != error && 'code' in error && error.code === code;
 }
@@ -47,9 +48,14 @@ function shouldSyncAdminTreeRows(rows, preservedRows, isMoving) {
     return !isMoving && rows !== preservedRows;
 }
 async function executeAdminTreeMove(mutate, refresh) {
+    let receipt;
     try {
-        await mutate();
+        receipt = structuralReceipt(await mutate());
     } catch (error) {
+        if (getDocumentStaleDetails(error) || getDocumentRevisionValidationDetails(error) || getLockConflictDetails(error) || hasErrorCode(error, ErrorCodes.NOT_FOUND)) return {
+            status: 'mutation-failed',
+            error
+        };
         const status = isCommittedTreeHookFailure(error) ? 'committed-hook-failed' : 'mutation-failed';
         try {
             await refresh();
@@ -68,12 +74,18 @@ async function executeAdminTreeMove(mutate, refresh) {
     try {
         await refresh();
         return {
-            status: 'ok'
+            status: 'ok',
+            ...receipt ? {
+                receipt
+            } : {}
         };
     } catch (error) {
         return {
             status: 'refresh-failed',
-            error
+            error,
+            ...receipt ? {
+                receipt
+            } : {}
         };
     }
 }
@@ -100,7 +112,7 @@ function placeAdminTreeNode(handle, documentId, options) {
         reconcile: options.reconcile ?? true
     });
 }
-function removeAdminTreeNode(handle, documentId, options = {}) {
+function removeAdminTreeNode(handle, documentId, options) {
     return handle.removeFromTree(documentId, {
         ...options,
         reconcile: options.reconcile ?? true

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

@@ -1,11 +1,5 @@
-/**
- * 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 placeTreeNode: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+    expectedRevision: number;
     collection: string;
     documentId: string;
     parentDocumentId: string | null;
@@ -13,6 +7,7 @@ export declare const placeTreeNode: import("@tanstack/react-start").RequiredFetc
     afterDocumentId?: string | null;
     reconcile?: boolean;
 }) => {
+    expectedRevision: number;
     collection: string;
     documentId: string;
     parentDocumentId: string | null;
@@ -20,18 +15,28 @@ export declare const placeTreeNode: import("@tanstack/react-start").RequiredFetc
     afterDocumentId?: string | null;
     reconcile?: boolean;
 }, Promise<{
-    status: 'ok';
+    documentId: string;
+    revision: number;
+    affectedDocuments: import("@byline/core").DocumentRevisionReceipt[];
+    scheduledPublicationsNeedReconfirmation: boolean;
     orderKey: string;
+    status: 'ok';
 }>>;
 export declare const removeFromTree: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+    expectedRevision: number;
     collection: string;
     documentId: string;
     reconcile?: boolean;
 }) => {
+    expectedRevision: number;
     collection: string;
     documentId: string;
     reconcile?: boolean;
 }, Promise<{
+    documentId: string;
+    revision: number;
+    affectedDocuments: import("@byline/core").DocumentRevisionReceipt[];
+    scheduledPublicationsNeedReconfirmation: boolean;
     status: 'ok';
 }>>;
 export declare const getTreeAncestors: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
@@ -53,6 +58,7 @@ export declare const getTreeParent: import("@tanstack/react-start").RequiredFetc
     documentId: string;
 }, Promise<import("@byline/client").TreeParentResult>>;
 export interface CollectionTreeRow {
+    revision: number;
     id: string;
     /** Parent document id, or `null` for a root or unplaced node. Drives the
      * client-side tree reconstruction for drag-to-reorder / re-parent. */

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

@@ -1,12 +1,13 @@
+import { withDocumentMutationErrors } from "../document-mutation-errors.js";
 import { createServerFn } from "@tanstack/react-start";
 import { getAdminBylineClient } from "@byline/client/server";
 import { ERR_NOT_FOUND, createReadContext, getLogger } from "@byline/core";
 import { ensureCollection } from "../../integrations/api-utils.js";
 import { placeAdminTreeNode, removeAdminTreeNode } from "./tree-mutation.js";
-import { getAdminTreeParent, getAdminUnplacedTreeDocuments } from "./tree-read.js";
+import { getAdminTreeParent } from "./tree-read.js";
 const placeTreeNode = createServerFn({
     method: 'POST'
-}).validator((input)=>input).handler(async ({ data })=>{
+}).validator((input)=>input).handler(withDocumentMutationErrors(async ({ data })=>{
     const { collection: path, documentId } = data;
     const config = await ensureCollection(path);
     if (!config) throw ERR_NOT_FOUND({
@@ -17,6 +18,7 @@ const placeTreeNode = createServerFn({
     }).log(getLogger());
     const handle = getAdminBylineClient().collection(path);
     const result = await placeAdminTreeNode(handle, documentId, {
+        expectedRevision: data.expectedRevision,
         parentDocumentId: data.parentDocumentId,
         beforeDocumentId: data.beforeDocumentId ?? null,
         afterDocumentId: data.afterDocumentId ?? null,
@@ -24,12 +26,12 @@ const placeTreeNode = createServerFn({
     });
     return {
         status: 'ok',
-        orderKey: result.orderKey
+        ...result
     };
-});
+}));
 const removeFromTree = createServerFn({
     method: 'POST'
-}).validator((input)=>input).handler(async ({ data })=>{
+}).validator((input)=>input).handler(withDocumentMutationErrors(async ({ data })=>{
     const { collection: path, documentId } = data;
     const config = await ensureCollection(path);
     if (!config) throw ERR_NOT_FOUND({
@@ -38,16 +40,18 @@ const removeFromTree = createServerFn({
             collectionPath: path
         }
     }).log(getLogger());
-    await removeAdminTreeNode(getAdminBylineClient().collection(path), documentId, {
+    const result = await removeAdminTreeNode(getAdminBylineClient().collection(path), documentId, {
+        expectedRevision: data.expectedRevision,
         reconcile: data.reconcile
     });
     return {
-        status: 'ok'
+        status: 'ok',
+        ...result
     };
-});
+}));
 const getTreeAncestors = createServerFn({
     method: 'GET'
-}).validator((input)=>input).handler(async ({ data })=>{
+}).validator((input)=>input).handler(withDocumentMutationErrors(async ({ data })=>{
     const { collection: path, documentId } = data;
     const config = await ensureCollection(path);
     if (!config) throw ERR_NOT_FOUND({
@@ -69,10 +73,10 @@ const getTreeAncestors = createServerFn({
             path: doc.path
         };
     });
-});
+}));
 const getTreeParent = createServerFn({
     method: 'GET'
-}).validator((input)=>input).handler(async ({ data })=>{
+}).validator((input)=>input).handler(withDocumentMutationErrors(async ({ data })=>{
     const { collection: path, documentId } = data;
     const config = await ensureCollection(path);
     if (!config) throw ERR_NOT_FOUND({
@@ -82,10 +86,10 @@ const getTreeParent = createServerFn({
         }
     }).log(getLogger());
     return getAdminTreeParent(getAdminBylineClient().collection(path), documentId);
-});
+}));
 const getCollectionTree = createServerFn({
     method: 'GET'
-}).validator((input)=>input).handler(async ({ data })=>{
+}).validator((input)=>input).handler(withDocumentMutationErrors(async ({ data })=>{
     const { collection: path } = data;
     const config = await ensureCollection(path);
     if (!config) throw ERR_NOT_FOUND({
@@ -96,8 +100,7 @@ const getCollectionTree = createServerFn({
     }).log(getLogger());
     const handle = getAdminBylineClient().collection(path);
     const readContext = createReadContext();
-    const forest = await handle.getSubtree({
-        status: 'any',
+    const { forest, unplaced } = await handle.getTreeForEdit({
         locale: data.locale,
         _readContext: readContext
     });
@@ -108,6 +111,7 @@ const getCollectionTree = createServerFn({
             const doc = node.document;
             rows.push({
                 id: doc.id,
+                revision: doc.revision,
                 parentId,
                 depth,
                 unplaced: false,
@@ -122,9 +126,9 @@ const getCollectionTree = createServerFn({
         }
     };
     walk(forest, 0, null);
-    const unplaced = await getAdminUnplacedTreeDocuments(handle, placed, readContext, data.locale);
     for (const doc of unplaced)rows.push({
         id: doc.id,
+        revision: doc.revision,
         parentId: null,
         depth: 0,
         unplaced: true,
@@ -143,5 +147,5 @@ const getCollectionTree = createServerFn({
             }
         }
     };
-});
+}));
 export { getCollectionTree, getTreeAncestors, getTreeParent, placeTreeNode, removeFromTree };

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

@@ -1,31 +1,30 @@
-/**
- * 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 { DocumentPatch } from '@byline/core/patches';
 export declare const updateCollectionDocumentWithPatches: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
     collection: string;
     id: string;
     patches: DocumentPatch[];
-    versionId?: string;
+    expectedRevision: number;
+    path?: string | null;
+    availableLocales?: string[];
     locale?: string;
 }) => {
     collection: string;
     id: string;
     patches: DocumentPatch[];
-    versionId?: string;
+    expectedRevision: number;
+    path?: string | null;
+    availableLocales?: string[];
     locale?: string;
 }, Promise<import("./save-outcome.js").CollectionDocumentCommittedHookFailureResponse | {
     status: 'ok';
     documentId: string;
-    documentVersionId: string;
+    documentVersionId?: string | undefined;
+    revision: number;
 }>>;
 export declare const updateCollectionDocumentSystemFields: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
     collection: string;
     id: string;
+    expectedRevision: number;
     locale?: string;
     /** Path override; `null`/omitted means no path write. */
     path?: string | null;
@@ -34,11 +33,13 @@ export declare const updateCollectionDocumentSystemFields: import("@tanstack/rea
 }) => {
     collection: string;
     id: string;
+    expectedRevision: number;
     locale?: string;
     /** Path override; `null`/omitted means no path write. */
     path?: string | null;
     /** Editorial advertised-locale set; omitted means no advertised-locale write. */
     availableLocales?: string[];
-}, Promise<{
+}, Promise<import("./save-outcome.js").CollectionDocumentCommittedHookFailureResponse | {
     status: 'ok';
+    revision: number;
 }>>;

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

@@ -1,13 +1,14 @@
+import { withDocumentMutationErrors } from "../document-mutation-errors.js";
 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 { 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;
+}).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 +31,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 +47,16 @@ 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;
+}).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 +77,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

@@ -9,6 +9,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 {

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

@@ -5,6 +5,7 @@ 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 { 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 +57,7 @@ function resolveUploadField(definition, collectionPath, requested) {
 }
 const uploadCollectionField = createServerFn({
     method: 'POST'
-}).validator(parseUploadFormData).handler(async ({ data })=>{
+}).validator(parseUploadFormData).handler(withDocumentMutationErrors(async ({ data })=>{
     const { collectionPath, shouldCreateDocument, fieldName, file, fields } = data;
     const logger = getLogger();
     return withLogContext({
@@ -114,7 +115,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/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

@@ -1,12 +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
- */
 export declare const cancelSingletonScheduledPublish: import("@tanstack/react-start").RequiredFetcher<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,10 @@
+import { withDocumentMutationErrors } from "../document-mutation-errors.js";
 import { createServerFn } from "@tanstack/react-start";
 import { getAdminBylineClient } from "@byline/client/server";
 import { serialise } from "../serialise.js";
 const cancelSingletonScheduledPublish = createServerFn({
     method: 'POST'
-}).validator((input)=>input).handler(async ({ data })=>serialise(await getAdminBylineClient().singleton(data.singleton).cancelScheduledPublish()));
+}).validator((input)=>input).handler(withDocumentMutationErrors(async ({ data })=>serialise(await getAdminBylineClient().singleton(data.singleton).cancelScheduledPublish({
+        expectedRevision: data.expectedRevision
+    }))));
 export { cancelSingletonScheduledPublish };