@byline/host-tanstack-start 4.14.0 → 4.15.0

package/dist/admin-shell/scheduled-publications/list_module.css

@@ -0,0 +1,97 @@
+.head-oj4QbV {
+  margin-bottom: var(--spacing-16);
+}
+
+.title-lm1z74 {
+  margin-bottom: var(--spacing-4);
+}
+
+.intro-clPFM7 {
+  color: var(--gray-500);
+  margin: 0;
+}
+
+.health-KAg5x5 {
+  margin-bottom: var(--spacing-16);
+}
+
+.controls-dRon5S {
+  justify-content: space-between;
+  align-items: flex-end;
+  gap: var(--spacing-16);
+  margin-bottom: var(--spacing-4);
+  flex-wrap: wrap;
+  display: flex;
+}
+
+.filters-help-DWQ3Wy {
+  margin: 0 0 var(--spacing-16);
+  color: var(--gray-500);
+  font-size: var(--font-size-sm);
+}
+
+.filters-x7PuG5 {
+  align-items: flex-end;
+  gap: var(--spacing-12);
+  flex-wrap: wrap;
+  display: flex;
+}
+
+.filter-TXeSAI {
+  gap: var(--spacing-4);
+  flex-direction: column;
+  min-width: 12rem;
+  display: flex;
+}
+
+.filter-authorizer-rDbHwh .byline-input-wrapper {
+  min-width: 22rem;
+}
+
+.filter-actions-dbQWCO {
+  align-items: center;
+  gap: var(--spacing-8);
+  padding-bottom: .1rem;
+  display: flex;
+}
+
+.tableWrap-wqdsOy {
+  margin-top: .75rem;
+  overflow-x: auto;
+}
+
+.collection-sBqska, .zone-ikRViN, .error-frhrx4 {
+  margin-top: var(--spacing-4);
+  color: var(--gray-500);
+  font-size: var(--font-size-xs);
+  display: block;
+}
+
+.instant-PTgCBK {
+  white-space: nowrap;
+}
+
+.authorizer-orWXlf {
+  font-family: var(--font-family-mono, monospace);
+  font-size: var(--font-size-xs);
+  overflow-wrap: anywhere;
+}
+
+.error-frhrx4 {
+  max-width: 24rem;
+  color: var(--red-600);
+  white-space: normal;
+}
+
+.empty-K7NcOV {
+  padding: var(--spacing-32) 0;
+  color: var(--gray-500);
+  text-align: center;
+}
+
+.pagerBottom-Sf0_9J {
+  margin-top: var(--spacing-16);
+  justify-content: flex-end;
+  display: flex;
+}
+

package/dist/routes/create-admin-layout-route.js

@@ -19,6 +19,7 @@ import { bylineAdminServices } from "../integrations/byline-admin-services.js";
 import { BylineAiAdminProvider } from "../integrations/byline-ai.js";
 import { bylineFieldServices } from "../integrations/byline-field-services.js";
 import { getCurrentAdminUser } from "../server-fns/auth/index.js";
+import { getScheduledPublicationRuntime } from "../server-fns/collections/index.js";
 import { getActiveLocaleFn, setAdminLocaleFn } from "../server-fns/i18n/index.js";
 import { getSignInRoutePath } from "./sign-in-path.js";
 function createAdminLayoutRoute(path) {
@@ -28,9 +29,11 @@ function createAdminLayoutRoute(path) {
             try {
                 const user = await getCurrentAdminUser();
                 const activeLocale = await getActiveLocaleFn();
+                const scheduledPublicationRuntime = await getScheduledPublicationRuntime();
                 return {
                     user,
-                    activeLocale
+                    activeLocale,
+                    scheduledPublicationRuntime
                 };
             } catch  {
                 throw redirect({
@@ -42,7 +45,7 @@ function createAdminLayoutRoute(path) {
             }
         },
         component: function() {
-            const { user, activeLocale } = Route.useRouteContext();
+            const { user, activeLocale, scheduledPublicationRuntime } = Route.useRouteContext();
             const { i18n } = getAdminConfig();
             const localeDefinitions = buildLocaleDefinitions(i18n.admin.locales, i18n.admin.localeDefinitions);
             useEffect(()=>{
@@ -76,7 +79,9 @@ function createAdminLayoutRoute(path) {
                                     /*#__PURE__*/ jsxs("main", {
                                         className: clsx('byline-admin-layout-main', admin_layout_module.main),
                                         children: [
-                                            /*#__PURE__*/ jsx(AdminMenuDrawer, {}),
+                                            /*#__PURE__*/ jsx(AdminMenuDrawer, {
+                                                scheduledPublicationEnabled: scheduledPublicationRuntime.enabled
+                                            }),
                                             /*#__PURE__*/ jsx(Content, {
                                                 children: /*#__PURE__*/ jsx(Outlet, {})
                                             })

package/dist/routes/create-admin-scheduled-publications-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 createAdminScheduledPublicationsRoute(path: string): any;

package/dist/routes/create-admin-scheduled-publications-route.js

@@ -0,0 +1,66 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { createFileRoute, notFound } from "@tanstack/react-router";
+import { useTranslation } from "@byline/i18n/react";
+import { z } from "zod";
+import { BreadcrumbsClient } from "../admin-shell/chrome/breadcrumbs/breadcrumbs-client.js";
+import { ScheduledPublicationsView } from "../admin-shell/scheduled-publications/list.js";
+import { getScheduledPublicationRuntime, listScheduledPublications } from "../server-fns/collections/index.js";
+import { getAdminRoutePath } from "./admin-path.js";
+const searchSchema = z.object({
+    page: z.coerce.number().int().min(1).optional().catch(void 0),
+    page_size: z.coerce.number().int().min(1).max(100).optional().catch(void 0),
+    state: z["enum"]([
+        'armed',
+        'needs_reconfirm'
+    ]).optional().catch(void 0),
+    lastAuthorizedBy: z.string().trim().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i).optional().catch(void 0)
+});
+function createAdminScheduledPublicationsRoute(path) {
+    const Route = createFileRoute(path)({
+        shouldReload: true,
+        validateSearch: searchSchema,
+        loaderDeps: ({ search })=>search,
+        loader: async ({ deps })=>{
+            const runtime = await getScheduledPublicationRuntime();
+            if (!runtime.enabled) throw notFound();
+            const data = await listScheduledPublications({
+                data: {
+                    page: deps.page,
+                    pageSize: deps.page_size,
+                    states: null == deps.state ? void 0 : [
+                        deps.state
+                    ],
+                    lastAuthorizedBy: deps.lastAuthorizedBy
+                }
+            });
+            return {
+                data
+            };
+        },
+        component: function() {
+            const { data } = Route.useLoaderData();
+            const { t } = useTranslation('byline-admin');
+            return /*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    /*#__PURE__*/ jsx(BreadcrumbsClient, {
+                        breadcrumbs: [
+                            {
+                                label: t('chrome.menu.dashboard'),
+                                href: getAdminRoutePath()
+                            },
+                            {
+                                label: t('scheduledPublication.list.title'),
+                                href: getAdminRoutePath('scheduled-publications')
+                            }
+                        ]
+                    }),
+                    /*#__PURE__*/ jsx(ScheduledPublicationsView, {
+                        data: data
+                    })
+                ]
+            });
+        }
+    });
+    return Route;
+}
+export { createAdminScheduledPublicationsRoute };

package/dist/routes/index.d.ts

@@ -28,6 +28,7 @@ export { createAdminLayoutRoute } from './create-admin-layout-route.js';
 export { createAdminPermissionsRoute } from './create-admin-permissions-route.js';
 export { createAdminRoleEditRoute } from './create-admin-role-edit-route.js';
 export { createAdminRolesListRoute } from './create-admin-roles-list-route.js';
+export { createAdminScheduledPublicationsRoute } from './create-admin-scheduled-publications-route.js';
 export { createAdminUserEditRoute } from './create-admin-user-edit-route.js';
 export { createAdminUsersListRoute } from './create-admin-users-list-route.js';
 export { createCollectionApiRoute } from './create-collection-api-route.js';

package/dist/routes/index.js

@@ -7,6 +7,7 @@ export { createAdminLayoutRoute } from "./create-admin-layout-route.js";
 export { createAdminPermissionsRoute } from "./create-admin-permissions-route.js";
 export { createAdminRoleEditRoute } from "./create-admin-role-edit-route.js";
 export { createAdminRolesListRoute } from "./create-admin-roles-list-route.js";
+export { createAdminScheduledPublicationsRoute } from "./create-admin-scheduled-publications-route.js";
 export { createAdminUserEditRoute } from "./create-admin-user-edit-route.js";
 export { createAdminUsersListRoute } from "./create-admin-users-list-route.js";
 export { createCollectionApiRoute } from "./create-collection-api-route.js";

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

@@ -20,6 +20,11 @@ export declare function getCollectionDocument(collection: string, id: string, lo
     _restoreWarnings?: string[] | undefined;
     availableLocales?: string[] | undefined;
     _availableVersionLocales?: string[] | undefined;
+    _scheduledPublicationEnabled: boolean;
+    _canSchedulePublication: boolean;
+    _scheduledPublish: import("@byline/client").DocumentPublishScheduleInfo | null;
+    scheduledPublishAt?: Date | undefined;
+    scheduledPublishVersionId?: string | undefined;
 } | null>;
 /**
  * Fetch a specific historical version of a document. Returns `null` when the

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

@@ -1,6 +1,6 @@
 import { createServerFn } from "@tanstack/react-start";
-import { getAdminBylineClient } from "@byline/client/server";
-import { BylineError, ERR_NOT_FOUND, ErrorCodes, buildRelationSummaryPopulateMap, getCollectionAdminConfig, getCollectionDefinition, getCollectionSchemasForPath, getLogger, getServerConfig } from "@byline/core";
+import { getAdminBylineClient, getAdminRequestContext } from "@byline/client/server";
+import { BylineError, ERR_NOT_FOUND, ErrorCodes, buildRelationSummaryPopulateMap, collectionAbilityKey, getCollectionAdminConfig, getCollectionDefinition, getCollectionSchemasForPath, getLogger, getServerConfig } from "@byline/core";
 import { ensureCollection } from "../../integrations/api-utils.js";
 import { serialise } from "./utils.js";
 const getDocumentFn = createServerFn({
@@ -72,6 +72,15 @@ const getDocumentFn = createServerFn({
     const restoreWarnings = serialised._restoreWarnings;
     const availableLocales = serialised.availableLocales;
     const availableVersionLocales = serialised._availableVersionLocales;
+    const scheduledPublicationEnabled = getServerConfig().scheduledPublication?.enabled === true;
+    let canSchedulePublication = false;
+    let scheduledPublish = null;
+    if (scheduledPublicationEnabled) {
+        const actor = (await getAdminRequestContext()).actor;
+        canSchedulePublication = actor?.hasAbility(collectionAbilityKey(path, 'changeStatus')) === true && actor.hasAbility(collectionAbilityKey(path, 'publish'));
+        if (canSchedulePublication) scheduledPublish = await handle.getScheduledPublish(id);
+    }
+    const serializedSchedule = null == scheduledPublish ? null : serialise(scheduledPublish);
     return {
         ...parsed,
         _publishedVersion: publishedVersion,
@@ -83,7 +92,14 @@ const getDocumentFn = createServerFn({
         } : {},
         ...Array.isArray(availableVersionLocales) ? {
             _availableVersionLocales: availableVersionLocales
-        } : {}
+        } : {},
+        _scheduledPublicationEnabled: scheduledPublicationEnabled,
+        _canSchedulePublication: canSchedulePublication,
+        _scheduledPublish: serializedSchedule,
+        ...null == serializedSchedule ? {} : {
+            scheduledPublishAt: serializedSchedule.publishAt,
+            scheduledPublishVersionId: serializedSchedule.targetVersionId
+        }
     };
 });
 const getDocumentByVersionFn = createServerFn({

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

@@ -17,6 +17,7 @@ export * from './list';
 export * from './reindex';
 export * from './reorder';
 export * from './restore-version';
+export * from './scheduled-publication';
 export * from './set-list-view-preference';
 export * from './stats';
 export * from './status';

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

@@ -11,6 +11,7 @@ export * from "./list.js";
 export * from "./reindex.js";
 export * from "./reorder.js";
 export * from "./restore-version.js";
+export * from "./scheduled-publication.js";
 export * from "./set-list-view-preference.js";
 export * from "./stats.js";
 export * from "./status.js";

package/dist/server-fns/collections/scheduled-publication-response.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
+ */
+import type { DocumentPublishScheduleInfo } from '@byline/client';
+import type { DocumentPublishSchedule } from '@byline/core';
+/** Remove sweep-owned fencing credentials before a schedule crosses a transport boundary. */
+export declare function omitScheduleExecutionState(schedule: DocumentPublishScheduleInfo | DocumentPublishSchedule): DocumentPublishScheduleInfo;

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

@@ -0,0 +1,5 @@
+function omitScheduleExecutionState(schedule) {
+    const { executionToken: _executionToken, executionExpiresAt: _executionExpiresAt, ...editorialSchedule } = schedule;
+    return editorialSchedule;
+}
+export { omitScheduleExecutionState };

package/dist/server-fns/collections/scheduled-publication.d.ts

@@ -0,0 +1,111 @@
+/**
+ * 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';
+import { type DocumentPublishScheduleState, type RecurringTaskHealth } from '@byline/core';
+export interface ScheduledPublicationRuntime {
+    enabled: boolean;
+    health: {
+        status: 'healthy' | 'failed' | 'stale' | 'not_started';
+        task: SerializedRecurringTaskHealth | null;
+    } | null;
+}
+type SerializedRecurringTaskHealth = Omit<RecurringTaskHealth, 'nextRunAt' | 'lastStartedAt' | 'lastSucceededAt' | 'lastFailedAt' | 'databaseNow'> & {
+    nextRunAt: string;
+    lastStartedAt: string | null;
+    lastSucceededAt: string | null;
+    lastFailedAt: string | null;
+    databaseNow: string;
+};
+export type SerializedDocumentPublishSchedule = Omit<DocumentPublishScheduleInfo, 'publishAt' | 'suspendedAt' | 'lastAuthorizedAt' | 'scheduledAt' | 'updatedAt' | 'lastAttemptAt' | 'nextAttemptAt'> & {
+    publishAt: string;
+    suspendedAt: string | null;
+    lastAuthorizedAt: string;
+    scheduledAt: string;
+    updatedAt: string;
+    lastAttemptAt: string | null;
+    nextAttemptAt: string;
+};
+export interface ScheduledPublicationListItem extends SerializedDocumentPublishSchedule {
+    collectionPath: string;
+    collectionLabel: string;
+    documentPath: string | null;
+    /**
+     * Display name for `lastAuthorizedBy` — full name, or email when the account
+     * has no name set. `null` when the account no longer exists, which is a real
+     * state rather than an error: the authorizer column is not a foreign key, so
+     * a schedule outlives the account that authorized it. Callers fall back to
+     * showing the id.
+     */
+    lastAuthorizedByName: string | null;
+}
+export interface ScheduledPublicationListResponse {
+    schedules: ScheduledPublicationListItem[];
+    meta: {
+        page: number;
+        pageSize: number;
+        total: number;
+        totalPages: number;
+    };
+    runtime: ScheduledPublicationRuntime;
+}
+/** Authenticated feature discovery for the admin shell and health warning. */
+export declare const getScheduledPublicationRuntime: import("@tanstack/react-start").OptionalFetcher<undefined, undefined, Promise<ScheduledPublicationRuntime>>;
+export declare const scheduleCollectionDocumentPublish: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+    collection: string;
+    id: string;
+    publishAt: string;
+    expectedVersionId: string;
+}) => {
+    collection: string;
+    id: string;
+    publishAt: string;
+    expectedVersionId: string;
+}, Promise<SerializedDocumentPublishSchedule>>;
+export declare const confirmCollectionDocumentScheduledPublish: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+    collection: string;
+    id: string;
+    expectedVersionId: string;
+}) => {
+    collection: string;
+    id: string;
+    expectedVersionId: string;
+}, Promise<SerializedDocumentPublishSchedule>>;
+export declare const cancelCollectionDocumentScheduledPublish: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+    collection: string;
+    id: string;
+}) => {
+    collection: string;
+    id: string;
+}, Promise<{
+    status: 'not_found';
+    schedule?: undefined;
+} | {
+    status: 'cancelled';
+    schedule: SerializedDocumentPublishSchedule;
+}>>;
+export declare const listScheduledPublications: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+    states?: readonly DocumentPublishScheduleState[];
+    lastAuthorizedBy?: string;
+    page?: number;
+    pageSize?: number;
+}) => {
+    states?: readonly DocumentPublishScheduleState[];
+    lastAuthorizedBy?: string;
+    page?: number;
+    pageSize?: number;
+}, Promise<{
+    schedules: ScheduledPublicationListItem[];
+    meta: {
+        page: number;
+        pageSize: number;
+        total: number;
+        totalPages: number;
+    };
+    runtime: ScheduledPublicationRuntime;
+}>>;
+export {};

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

@@ -0,0 +1,157 @@
+import { createServerFn } from "@tanstack/react-start";
+import { getAdminBylineClient, getAdminRequestContext } from "@byline/client/server";
+import { ERR_NOT_FOUND, ERR_VALIDATION } from "@byline/core";
+import { listDocumentPublishSchedules } from "@byline/core/services";
+import { bylineCore } from "../../integrations/byline-core.js";
+import { omitScheduleExecutionState } from "./scheduled-publication-response.js";
+import { serialise } from "./utils.js";
+const TASK_NAME = 'documents.publish-scheduled';
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function assertFeatureEnabled() {
+    if (bylineCore().config.scheduledPublication?.enabled === true) return;
+    throw ERR_NOT_FOUND({
+        message: 'Scheduled publication is not enabled for this installation'
+    });
+}
+function serializeSchedule(schedule) {
+    return serialise(omitScheduleExecutionState(schedule));
+}
+async function scheduledPublicationRuntime() {
+    const core = bylineCore();
+    if (core.config.scheduledPublication?.enabled !== true) return {
+        enabled: false,
+        health: null
+    };
+    const scheduler = core.db.scheduler;
+    if (null == scheduler) return {
+        enabled: true,
+        health: {
+            status: 'not_started',
+            task: null
+        }
+    };
+    const [task] = await scheduler.health([
+        TASK_NAME
+    ]);
+    if (null == task) return {
+        enabled: true,
+        health: {
+            status: 'not_started',
+            task: null
+        }
+    };
+    const staleAfter = task.nextRunAt.getTime() + 2 * task.intervalMs;
+    const status = task.leaseExpired ? 'stale' : 'failed' === task.lastStatus ? 'failed' : staleAfter < task.databaseNow.getTime() ? 'stale' : 'healthy';
+    return {
+        enabled: true,
+        health: {
+            status,
+            task: serialise(task)
+        }
+    };
+}
+const getScheduledPublicationRuntime = createServerFn({
+    method: 'GET'
+}).handler(async ()=>{
+    await getAdminRequestContext();
+    return scheduledPublicationRuntime();
+});
+const scheduleCollectionDocumentPublish = createServerFn({
+    method: 'POST'
+}).validator((input)=>input).handler(async ({ data })=>{
+    assertFeatureEnabled();
+    const schedule = await getAdminBylineClient().collection(data.collection).schedulePublish(data.id, {
+        publishAt: data.publishAt,
+        expectedVersionId: data.expectedVersionId
+    });
+    return serializeSchedule(schedule);
+});
+const confirmCollectionDocumentScheduledPublish = createServerFn({
+    method: 'POST'
+}).validator((input)=>input).handler(async ({ data })=>{
+    assertFeatureEnabled();
+    const schedule = await getAdminBylineClient().collection(data.collection).confirmScheduledPublish(data.id, {
+        expectedVersionId: data.expectedVersionId
+    });
+    return serializeSchedule(schedule);
+});
+const cancelCollectionDocumentScheduledPublish = createServerFn({
+    method: 'POST'
+}).validator((input)=>input).handler(async ({ data })=>{
+    assertFeatureEnabled();
+    const schedule = await getAdminBylineClient().collection(data.collection).cancelScheduledPublish(data.id);
+    return null == schedule ? {
+        status: 'not_found'
+    } : {
+        status: 'cancelled',
+        schedule: serializeSchedule(schedule)
+    };
+});
+const listScheduledPublications = createServerFn({
+    method: 'GET'
+}).validator((input)=>input).handler(async ({ data })=>{
+    assertFeatureEnabled();
+    if (data.states?.some((state)=>'armed' !== state && 'needs_reconfirm' !== state) === true) throw ERR_VALIDATION({
+        message: 'state must be armed or needs_reconfirm'
+    });
+    if (null != data.lastAuthorizedBy && !UUID_RE.test(data.lastAuthorizedBy)) throw ERR_VALIDATION({
+        message: 'lastAuthorizedBy must be a UUID'
+    });
+    const core = bylineCore();
+    const page = data.page ?? 1;
+    const pageSize = data.pageSize ?? 25;
+    const requestContext = await getAdminRequestContext();
+    const result = await listDocumentPublishSchedules(core, requestContext, {
+        states: data.states,
+        lastAuthorizedBy: data.lastAuthorizedBy,
+        page,
+        pageSize
+    });
+    const collections = new Map(core.collections.map((definition)=>{
+        const record = core.getCollectionRecord(definition.path);
+        return [
+            record.collectionId,
+            definition
+        ];
+    }));
+    const authorizerIds = [
+        ...new Set(result.schedules.map((schedule)=>schedule.lastAuthorizedBy).filter((id)=>null != id))
+    ];
+    const authorizerNames = new Map();
+    const adminUsers = core.adminStore?.adminUsers;
+    if (authorizerIds.length > 0 && null != adminUsers) {
+        const users = await adminUsers.getByIds(authorizerIds);
+        for (const user of users){
+            const fullName = [
+                user.given_name,
+                user.family_name
+            ].filter(Boolean).join(' ').trim();
+            authorizerNames.set(user.id, fullName.length > 0 ? fullName : user.email);
+        }
+    }
+    const schedules = await Promise.all(result.schedules.map(async (schedule)=>{
+        const definition = collections.get(schedule.collectionId);
+        const documentPath = await core.db.queries.documents.getCurrentPath({
+            collection_id: schedule.collectionId,
+            document_id: schedule.documentId
+        });
+        return {
+            ...serializeSchedule(schedule),
+            collectionPath: definition?.path ?? schedule.collectionId,
+            collectionLabel: definition?.labels.plural ?? definition?.path ?? schedule.collectionId,
+            documentPath,
+            lastAuthorizedByName: null == schedule.lastAuthorizedBy ? null : authorizerNames.get(schedule.lastAuthorizedBy) ?? null
+        };
+    }));
+    return {
+        schedules,
+        meta: {
+            page,
+            pageSize,
+            total: result.total,
+            totalPages: Math.max(1, Math.ceil(result.total / pageSize))
+        },
+        runtime: await scheduledPublicationRuntime()
+    };
+});
+export { cancelCollectionDocumentScheduledPublish, confirmCollectionDocumentScheduledPublish, getScheduledPublicationRuntime, listScheduledPublications, scheduleCollectionDocumentPublish };

package/package.json

@@ -3,7 +3,7 @@
   "private": false,
   "type": "module",
   "license": "MPL-2.0",
-  "version": "4.14.0",
+  "version": "4.15.0",
   "engines": {
     "node": ">=20.9.0"
   },
@@ -117,13 +117,13 @@
     "react-json-view-lite": "^2.5.0",
     "react-swipeable": "^7.0.2",
     "zod": "^4.4.3",
-    "@byline/admin": "4.14.0",
-    "@byline/auth": "4.14.0",
-    "@byline/ai": "4.14.0",
-    "@byline/client": "4.14.0",
-    "@byline/core": "4.14.0",
-    "@byline/i18n": "4.14.0",
-    "@byline/ui": "4.14.0"
+    "@byline/admin": "4.15.0",
+    "@byline/auth": "4.15.0",
+    "@byline/ai": "4.15.0",
+    "@byline/ui": "4.15.0",
+    "@byline/core": "4.15.0",
+    "@byline/client": "4.15.0",
+    "@byline/i18n": "4.15.0"
   },
   "peerDependencies": {
     "@tanstack/react-router": "^1.167.0",

package/src/admin-shell/chrome/admin-layout.module.css

@@ -6,10 +6,15 @@
  * Override handle: .byline-admin-layout-main
  */
 
+/* `min-height`, not `height`: the document is the scroll container, so with a
+   fixed 100vh height the flex row ends at the fold and the sticky menu drawer
+   inside it has nothing left to stick to — it scrolls away as soon as the
+   route content runs past one viewport. Growing with the content gives the
+   drawer a containing block tall enough to stay pinned all the way down. */
 .main,
 :global(.byline-admin-layout-main) {
   display: flex;
-  height: 100vh;
+  min-height: 100vh;
   width: 100%;
   max-width: 100%;
   padding-top: 45px;