@byline/host-tanstack-start 4.16.0 → 4.17.0

package/dist/routes/create-singleton-history-route.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 declare function createSingletonHistoryRoute(path: string): any;

package/dist/routes/create-singleton-history-route.js

@@ -0,0 +1,99 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { createFileRoute, notFound } from "@tanstack/react-router";
+import { getSingletonAdminConfig, getWorkflowStatuses } from "@byline/core";
+import { useTranslation } from "@byline/i18n/react";
+import { z } from "zod";
+import { BreadcrumbsClient } from "../admin-shell/chrome/breadcrumbs/breadcrumbs-client.js";
+import { SingletonHistoryView } from "../admin-shell/singletons/history.js";
+import { getSingleton, getSingletonHistory } from "../server-fns/singletons/index.js";
+import { getAdminRoutePath } from "./admin-path.js";
+import { getContentLocaleRouteConfig } from "./get-content-locale-route-config.js";
+import { getSingletonDefinition } from "./get-singleton-definition.js";
+const searchSchema = z.object({
+    page: z.coerce.number().min(1).optional(),
+    page_size: z.coerce.number().max(100).optional(),
+    order: z.string().optional(),
+    desc: z.coerce.boolean().optional(),
+    locale: z.string().optional()
+});
+function createSingletonHistoryRoute(path) {
+    const Route = createFileRoute(path)({
+        validateSearch: searchSchema,
+        loaderDeps: ({ search })=>({
+                page: search.page,
+                page_size: search.page_size,
+                order: search.order,
+                desc: search.desc,
+                locale: search.locale
+            }),
+        loader: async ({ params, deps })=>{
+            if (null == getSingletonDefinition(params.singleton)) throw notFound();
+            const [history, currentDocument] = await Promise.all([
+                getSingletonHistory({
+                    data: {
+                        singleton: params.singleton,
+                        params: {
+                            page: deps.page,
+                            page_size: deps.page_size,
+                            order: deps.order,
+                            desc: deps.desc,
+                            locale: deps.locale
+                        }
+                    }
+                }),
+                getSingleton({
+                    data: {
+                        singleton: params.singleton,
+                        locale: deps.locale ?? 'all'
+                    }
+                })
+            ]);
+            return {
+                history,
+                currentDocument
+            };
+        },
+        staleTime: 0,
+        gcTime: 0,
+        shouldReload: true,
+        component: function() {
+            const { history, currentDocument } = Route.useLoaderData();
+            const { singleton } = Route.useParams();
+            const definition = getSingletonDefinition(singleton);
+            if (null == definition) throw notFound();
+            const { t } = useTranslation('byline-admin');
+            const { contentLocales, defaultContentLocale } = getContentLocaleRouteConfig();
+            return /*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    /*#__PURE__*/ jsx(BreadcrumbsClient, {
+                        breadcrumbs: [
+                            {
+                                label: t('chrome.menu.dashboard'),
+                                href: getAdminRoutePath()
+                            },
+                            {
+                                label: definition.label,
+                                href: getAdminRoutePath('singletons', singleton)
+                            },
+                            {
+                                label: t('collections.breadcrumbs.history'),
+                                href: getAdminRoutePath('singletons', singleton, 'history')
+                            }
+                        ]
+                    }),
+                    /*#__PURE__*/ jsx(SingletonHistoryView, {
+                        singletonDefinition: definition,
+                        adminConfig: getSingletonAdminConfig(singleton) ?? void 0,
+                        data: history,
+                        currentDocument: currentDocument,
+                        contentLocales: contentLocales,
+                        defaultContentLocale: defaultContentLocale,
+                        workflowStatuses: getWorkflowStatuses(definition)
+                    })
+                ]
+            });
+        }
+    });
+    return Route;
+}
+export { createSingletonHistoryRoute };

package/dist/routes/create-singleton-route.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 { DocumentPublishScheduleInfo } from '@byline/client';
+/**
+ * Load the mapped singleton document and attach the admin-only lifecycle
+ * metadata consumed by the editor. Keeping this composition in the route
+ * layer leaves ordinary singleton reads free of publication timing and actor
+ * capability details.
+ */
+export declare const getSingletonRouteDocument: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+    singleton: string;
+    locale?: string;
+}) => {
+    singleton: string;
+    locale?: string;
+}, Promise<{
+    document: null;
+    initialData: Record<string, any>;
+} | {
+    document: {
+        _publishedVersion: Record<string, any> | null;
+        _scheduledPublicationEnabled: boolean;
+        _canSchedulePublication: boolean;
+        _scheduledPublish: DocumentPublishScheduleInfo | null;
+        scheduledPublishAt?: Date | undefined;
+        scheduledPublishVersionId?: string | undefined;
+    };
+    initialData: undefined;
+} | null>>;
+export declare function createSingletonRoute(path: string): any;

package/dist/routes/create-singleton-route.js

@@ -0,0 +1,130 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { createFileRoute, notFound } from "@tanstack/react-router";
+import { createServerFn } from "@tanstack/react-start";
+import { getAdminBylineClient, getAdminRequestContext } from "@byline/client/server";
+import { buildInitialDataFromFields, documentAbilityKey, getServerConfig, getSingletonAdminConfig } from "@byline/core";
+import { useTranslation } from "@byline/i18n/react";
+import { z } from "zod";
+import { BreadcrumbsClient } from "../admin-shell/chrome/breadcrumbs/breadcrumbs-client.js";
+import { SingletonView } from "../admin-shell/singletons/view.js";
+import { bylineCore } from "../integrations/byline-core.js";
+import { serialise } from "../server-fns/serialise.js";
+import { readSingletonDocument } from "../server-fns/singleton-document-read.js";
+import { getAdminRoutePath } from "./admin-path.js";
+import { getContentLocaleRouteConfig } from "./get-content-locale-route-config.js";
+import { getSingletonDefinition } from "./get-singleton-definition.js";
+const searchSchema = z.object({
+    locale: z.string().optional()
+});
+const getSingletonRouteDocument = createServerFn({
+    method: 'GET'
+}).validator((input)=>input).handler(async ({ data })=>{
+    const definition = getSingletonDefinition(data.singleton);
+    if (null == definition) return null;
+    const document = await readSingletonDocument({
+        singleton: data.singleton,
+        locale: data.locale,
+        populateRelations: true
+    });
+    if (null == document) return {
+        document: null,
+        initialData: serialise(await buildInitialDataFromFields(definition.fields, {
+            locale: data.locale ?? getServerConfig().i18n.content.defaultLocale
+        }))
+    };
+    const config = getServerConfig();
+    const record = bylineCore().getCollectionRecord(data.singleton);
+    let publishedVersion = null;
+    if ('published' !== document.status) {
+        const published = await config.db.queries.documents.getPublishedVersion({
+            collection_id: record.collectionId,
+            document_id: String(document.id)
+        });
+        publishedVersion = published ? serialise({
+            id: published.document_id,
+            versionId: published.document_version_id,
+            status: published.status,
+            createdAt: published.created_at,
+            updatedAt: published.updated_at
+        }) : null;
+    }
+    const scheduledPublicationEnabled = config.scheduledPublication?.enabled === true;
+    let canSchedulePublication = false;
+    let scheduledPublish = null;
+    if (scheduledPublicationEnabled) {
+        const actor = (await getAdminRequestContext()).actor;
+        canSchedulePublication = actor?.hasAbility(documentAbilityKey(definition, 'changeStatus')) === true && actor.hasAbility(documentAbilityKey(definition, 'publish'));
+        if (canSchedulePublication) scheduledPublish = await getAdminBylineClient().singleton(data.singleton).getScheduledPublish();
+    }
+    const serializedSchedule = null == scheduledPublish ? null : serialise(scheduledPublish);
+    return {
+        document: {
+            ...document,
+            _publishedVersion: publishedVersion,
+            _scheduledPublicationEnabled: scheduledPublicationEnabled,
+            _canSchedulePublication: canSchedulePublication,
+            _scheduledPublish: serializedSchedule,
+            ...null == serializedSchedule ? {} : {
+                scheduledPublishAt: serializedSchedule.publishAt,
+                scheduledPublishVersionId: serializedSchedule.targetVersionId
+            }
+        },
+        initialData: void 0
+    };
+});
+function createSingletonRoute(path) {
+    const Route = createFileRoute(path)({
+        validateSearch: searchSchema,
+        loaderDeps: ({ search })=>({
+                locale: search.locale
+            }),
+        loader: async ({ params, deps })=>{
+            if (null == getSingletonDefinition(params.singleton)) throw notFound();
+            return getSingletonRouteDocument({
+                data: {
+                    singleton: params.singleton,
+                    locale: deps.locale
+                }
+            });
+        },
+        staleTime: 0,
+        gcTime: 0,
+        shouldReload: true,
+        component: function() {
+            const routeState = Route.useLoaderData();
+            const { singleton } = Route.useParams();
+            const { locale } = Route.useSearch();
+            const definition = getSingletonDefinition(singleton);
+            if (null == definition) throw notFound();
+            const { t } = useTranslation('byline-admin');
+            const { contentLocales, defaultContentLocale } = getContentLocaleRouteConfig();
+            return /*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    /*#__PURE__*/ jsx(BreadcrumbsClient, {
+                        breadcrumbs: [
+                            {
+                                label: t('chrome.menu.dashboard'),
+                                href: getAdminRoutePath()
+                            },
+                            {
+                                label: definition.label,
+                                href: getAdminRoutePath('singletons', singleton)
+                            }
+                        ]
+                    }),
+                    /*#__PURE__*/ jsx(SingletonView, {
+                        singletonDefinition: definition,
+                        adminConfig: getSingletonAdminConfig(singleton) ?? void 0,
+                        document: routeState.document,
+                        initialData: routeState.initialData,
+                        locale: locale,
+                        contentLocales: contentLocales,
+                        defaultContentLocale: defaultContentLocale
+                    })
+                ]
+            });
+        }
+    });
+    return Route;
+}
+export { createSingletonRoute, getSingletonRouteDocument };

package/dist/routes/get-multi-collection-definition.d.ts

@@ -0,0 +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 { MultiCollectionDefinition } from '@byline/core';
+/** Resolve only the resource kind supported by the collection route family. */
+export declare function getMultiCollectionDefinition(path: string): MultiCollectionDefinition | null;

package/dist/routes/get-multi-collection-definition.js

@@ -0,0 +1,6 @@
+import { getCollectionDefinition, isSingleton } from "@byline/core";
+function getMultiCollectionDefinition(path) {
+    const definition = getCollectionDefinition(path);
+    return null == definition || isSingleton(definition) ? null : definition;
+}
+export { getMultiCollectionDefinition };

package/dist/routes/get-singleton-definition.d.ts

@@ -0,0 +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 { SingletonDefinition } from '@byline/core';
+/** Resolve only the resource kind supported by the singleton route family. */
+export declare function getSingletonDefinition(path: string): SingletonDefinition | null;

package/dist/routes/get-singleton-definition.js

@@ -0,0 +1,6 @@
+import { getCollectionDefinition, isSingleton } from "@byline/core";
+function getSingletonDefinition(path) {
+    const definition = getCollectionDefinition(path);
+    return null != definition && isSingleton(definition) ? definition : null;
+}
+export { getSingletonDefinition };

package/dist/routes/index.d.ts

@@ -38,3 +38,5 @@ export { createCollectionEditRoute } from './create-collection-edit-route.js';
 export { createCollectionHistoryRoute } from './create-collection-history-route.js';
 export { createCollectionListRoute } from './create-collection-list-route.js';
 export { type CreateSignInRouteOptions, createSignInRoute, } from './create-sign-in-route.js';
+export { createSingletonHistoryRoute } from './create-singleton-history-route.js';
+export { createSingletonRoute } from './create-singleton-route.js';

package/dist/routes/index.js

@@ -17,3 +17,5 @@ export { createCollectionEditRoute } from "./create-collection-edit-route.js";
 export { createCollectionHistoryRoute } from "./create-collection-history-route.js";
 export { createCollectionListRoute } from "./create-collection-list-route.js";
 export { createSignInRoute } from "./create-sign-in-route.js";
+export { createSingletonHistoryRoute } from "./create-singleton-history-route.js";
+export { createSingletonRoute } from "./create-singleton-route.js";

package/dist/server-fns/actors.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 type ActorLabelMap = Record<string, {
+    label: string;
+}>;
+/**
+ * Batch-resolve admin-user ids to display labels. The admin server-fn layer
+ * owns this presentation concern so both collection and singleton history
+ * can share it without teaching document storage about admin-realm tables.
+ */
+export declare function resolveActorLabels(ids: Iterable<string | null | undefined>): Promise<ActorLabelMap>;

package/dist/server-fns/actors.js

@@ -0,0 +1,25 @@
+import { bylineCore } from "../integrations/byline-core.js";
+function labelFor(row) {
+    const name = [
+        row.given_name,
+        row.family_name
+    ].filter(Boolean).join(' ');
+    return name || row.username || row.email;
+}
+async function resolveActorLabels(ids) {
+    const unique = [
+        ...new Set([
+            ...ids
+        ].filter((id)=>'string' == typeof id && id.length > 0))
+    ];
+    if (0 === unique.length) return {};
+    const store = bylineCore().adminStore;
+    if (null == store) return {};
+    const rows = await store.adminUsers.getByIds(unique);
+    const map = {};
+    for (const row of rows)map[row.id] = {
+        label: labelFor(row)
+    };
+    return map;
+}
+export { resolveActorLabels };

package/dist/server-fns/admin-document-presentation.d.ts

@@ -0,0 +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 CollectionDefinition, type PopulateSpec } from '@byline/core';
+export interface AdminDocumentReadInput {
+    locale?: string;
+    depth?: number;
+    populateRelations?: boolean;
+}
+export interface AdminDocumentReadOptions {
+    locale: string;
+    populate?: PopulateSpec;
+    depth?: number;
+    status: 'any';
+    onMissingLocale: 'empty';
+    lenient: true;
+}
+/**
+ * Resolve the shared read controls used by collection and singleton editors.
+ * Explicit depth is the API-preview mode; otherwise relation-summary mode
+ * projects only each target's picker/title fields for first-paint tiles.
+ */
+export declare function resolveAdminDocumentRead(definition: CollectionDefinition | null, input: AdminDocumentReadInput): {
+    options: AdminDocumentReadOptions;
+    populatedTree: boolean;
+};

package/dist/server-fns/admin-document-presentation.js

@@ -0,0 +1,32 @@
+import { buildRelationSummaryPopulateMap, getCollectionAdminConfig, getCollectionDefinition } from "@byline/core";
+function resolveAdminDocumentRead(definition, input) {
+    const populateRequested = 'number' == typeof input.depth && input.depth > 0;
+    const autoRelationsActive = !populateRequested && true === input.populateRelations;
+    let populate;
+    let depth;
+    if (populateRequested) {
+        populate = '*';
+        depth = input.depth;
+    } else if (autoRelationsActive && null != definition) {
+        const populateMap = buildRelationSummaryPopulateMap(definition.fields, (targetPath)=>({
+                def: getCollectionDefinition(targetPath),
+                admin: getCollectionAdminConfig(targetPath)
+            }));
+        if (Object.keys(populateMap).length > 0) {
+            populate = populateMap;
+            depth = 1;
+        }
+    }
+    return {
+        options: {
+            locale: input.locale ?? 'en',
+            populate,
+            depth,
+            status: 'any',
+            onMissingLocale: 'empty',
+            lenient: true
+        },
+        populatedTree: populateRequested || autoRelationsActive
+    };
+}
+export { resolveAdminDocumentRead };

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

@@ -5,13 +5,4 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
-export type ActorLabelMap = Record<string, {
-    label: string;
-}>;
-/**
- * Batch-resolve admin-user ids to display labels. Accepts the raw
- * `createdBy` values straight off a page of shaped documents — nullish
- * and duplicate entries are tolerated and deduplicated. Returns `{}`
- * when there is nothing to resolve or no admin store is configured.
- */
-export declare function resolveActorLabels(ids: Iterable<string | null | undefined>): Promise<ActorLabelMap>;
+export { type ActorLabelMap, resolveActorLabels } from '../actors.js';

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

@@ -1,25 +1 @@
-import { bylineCore } from "../../integrations/byline-core.js";
-function labelFor(row) {
-    const name = [
-        row.given_name,
-        row.family_name
-    ].filter(Boolean).join(' ');
-    return name || row.username || row.email;
-}
-async function resolveActorLabels(ids) {
-    const unique = [
-        ...new Set([
-            ...ids
-        ].filter((id)=>'string' == typeof id && id.length > 0))
-    ];
-    if (0 === unique.length) return {};
-    const store = bylineCore().adminStore;
-    if (null == store) return {};
-    const rows = await store.adminUsers.getByIds(unique);
-    const map = {};
-    for (const row of rows)map[row.id] = {
-        label: labelFor(row)
-    };
-    return map;
-}
-export { resolveActorLabels };
+export { resolveActorLabels } from "../actors.js";

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

@@ -1,7 +1,8 @@
 import { createServerFn } from "@tanstack/react-start";
 import { getAdminBylineClient, getAdminRequestContext } from "@byline/client/server";
-import { BylineError, ERR_NOT_FOUND, ErrorCodes, buildRelationSummaryPopulateMap, collectionAbilityKey, getCollectionAdminConfig, getCollectionDefinition, getCollectionSchemasForPath, getLogger, getServerConfig } from "@byline/core";
+import { BylineError, ERR_NOT_FOUND, ErrorCodes, documentAbilityKey, getCollectionSchemasForPath, getLogger, getServerConfig } from "@byline/core";
 import { ensureCollection } from "../../integrations/api-utils.js";
+import { resolveAdminDocumentRead } from "../admin-document-presentation.js";
 import { serialise } from "./utils.js";
 const getDocumentFn = createServerFn({
     method: 'GET'
@@ -17,30 +18,13 @@ const getDocumentFn = createServerFn({
     }).log(logger);
     const client = getAdminBylineClient();
     const handle = client.collection(path);
-    const populateRequested = 'number' == typeof depth && depth > 0;
-    const autoRelationsActive = !populateRequested && true === populateRelations;
-    let populate;
-    let resolvedDepth;
-    if (populateRequested) {
-        populate = '*';
-        resolvedDepth = depth;
-    } else if (autoRelationsActive) {
-        const populateMap = buildRelationSummaryPopulateMap(config.definition.fields, (targetPath)=>({
-                def: getCollectionDefinition(targetPath),
-                admin: getCollectionAdminConfig(targetPath)
-            }));
-        if (Object.keys(populateMap).length > 0) {
-            populate = populateMap;
-            resolvedDepth = 1;
-        }
-    }
+    const { options: readOptions, populatedTree } = resolveAdminDocumentRead(config.definition, {
+        locale,
+        depth,
+        populateRelations
+    });
     const document = await handle.findById(id, {
-        locale: locale ?? 'en',
-        populate,
-        depth: resolvedDepth,
-        status: 'any',
-        onMissingLocale: 'empty',
-        lenient: true
+        ...readOptions
     });
     if (!document) throw ERR_NOT_FOUND({
         message: 'Document not found',
@@ -50,7 +34,6 @@ const getDocumentFn = createServerFn({
         }
     }).log(logger);
     const serialised = serialise(document);
-    const populatedTree = populateRequested || autoRelationsActive;
     const parsed = 'all' === locale || populatedTree ? serialised : (()=>{
         const { get } = getCollectionSchemasForPath(path);
         return get.parse(serialised);
@@ -77,7 +60,7 @@ const getDocumentFn = createServerFn({
     let scheduledPublish = null;
     if (scheduledPublicationEnabled) {
         const actor = (await getAdminRequestContext()).actor;
-        canSchedulePublication = actor?.hasAbility(collectionAbilityKey(path, 'changeStatus')) === true && actor.hasAbility(collectionAbilityKey(path, 'publish'));
+        canSchedulePublication = actor?.hasAbility(documentAbilityKey(config.definition, 'changeStatus')) === true && actor.hasAbility(documentAbilityKey(config.definition, 'publish'));
         if (canSchedulePublication) scheduledPublish = await handle.getScheduledPublish(id);
     }
     const serializedSchedule = null == scheduledPublish ? null : serialise(scheduledPublish);

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

@@ -21,7 +21,7 @@ const reorderCollectionDocument = createServerFn({
         }
     }).log(logger);
     const requestContext = await getAdminRequestContext();
-    assertActorCanPerform(requestContext, path, 'update');
+    assertActorCanPerform(requestContext, config.definition, 'update');
     const serverConfig = getServerConfig();
     const collectionId = config.collection.id;
     const canonical = await serverConfig.db.queries.documents.getCanonicalDocumentOrder({

package/dist/server-fns/collections/scheduled-publication.js

@@ -1,6 +1,6 @@
 import { createServerFn } from "@tanstack/react-start";
 import { getAdminBylineClient, getAdminRequestContext } from "@byline/client/server";
-import { ERR_NOT_FOUND, ERR_VALIDATION } from "@byline/core";
+import { ERR_NOT_FOUND, ERR_VALIDATION, isSingleton } from "@byline/core";
 import { listDocumentPublishSchedules } from "@byline/core/services";
 import { bylineCore } from "../../integrations/byline-core.js";
 import { omitScheduleExecutionState } from "./scheduled-publication-response.js";
@@ -138,7 +138,7 @@ const listScheduledPublications = createServerFn({
         return {
             ...serializeSchedule(schedule),
             collectionPath: definition?.path ?? schedule.collectionId,
-            collectionLabel: definition?.labels.plural ?? definition?.path ?? schedule.collectionId,
+            collectionLabel: null == definition ? schedule.collectionId : isSingleton(definition) ? definition.label : definition.labels.plural,
             documentPath,
             lastAuthorizedByName: null == schedule.lastAuthorizedBy ? null : authorizerNames.get(schedule.lastAuthorizedBy) ?? null
         };

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

@@ -4,7 +4,7 @@ import { ERR_NOT_FOUND, ERR_VALIDATION, getServerConfig, getUploadFields } from
 import { extractImageMeta, generateImageVariants, isBypassMimeType } from "@byline/core/image";
 import { getLogger, withLogContext } from "@byline/core/logger";
 import { uploadField } from "@byline/core/services";
-import { ensureCollection } from "../../integrations/api-utils.js";
+import { ensureDocumentResource } from "../../integrations/api-utils.js";
 function parseUploadFormData(data) {
     if (!(data instanceof FormData)) throw new Error('Expected FormData upload payload.');
     const collectionEntry = data.get('collection');
@@ -64,9 +64,9 @@ const uploadCollectionField = createServerFn({
         module: 'upload',
         function: 'uploadCollectionField'
     }, async ()=>{
-        const config = await ensureCollection(collectionPath);
+        const config = await ensureDocumentResource(collectionPath);
         if (null == config) throw ERR_NOT_FOUND({
-            message: 'Collection not found.',
+            message: 'Document resource not found.',
             details: {
                 collectionPath
             }

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

@@ -5,10 +5,4 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
-/**
- * Deep-serialise a value through JSON to convert Date objects to ISO strings.
- * TanStack Start server functions pass return values directly during SSR
- * (no automatic JSON round-trip), so Date instances from the DB driver would
- * fail downstream Zod z.string() checks without this explicit step.
- */
-export declare function serialise<T>(value: T): T;
+export { serialise } from '../serialise.js';

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

@@ -1,4 +1 @@
-function serialise(value) {
-    return JSON.parse(JSON.stringify(value));
-}
-export { serialise };
+export { serialise } from "../serialise.js";

package/dist/server-fns/serialise.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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
+ */
+/**
+ * Deep-serialise a value through JSON to convert Date objects to ISO strings.
+ * TanStack Start server functions pass return values directly during SSR
+ * (no automatic JSON round-trip), so Date instances from the DB driver would
+ * fail downstream string checks without this explicit step.
+ */
+export declare function serialise<T>(value: T): T;

package/dist/server-fns/serialise.js

@@ -0,0 +1,4 @@
+function serialise(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+export { serialise };

package/dist/server-fns/singleton-document-read.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
+ */
+export interface SingletonDocumentReadInput {
+    singleton: string;
+    locale?: string;
+    depth?: number;
+    populateRelations?: boolean;
+}
+/**
+ * Read the singleton document with the presentation controls shared by the
+ * editor route and the public server function. Route-only lifecycle metadata
+ * 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>;