@byline/host-tanstack-start 4.14.1 → 4.16.0

package/dist/routes/index.d.ts

@@ -23,11 +23,13 @@ export { getSignInRoutePath } from './sign-in-path.js';
  */
 export { createAdminAccountRoute } from './create-admin-account-route.js';
 export { createAdminActivityRoute } from './create-admin-activity-route.js';
+export { createAdminAnalyticsRoute } from './create-admin-analytics-route.js';
 export { createAdminDashboardRoute } from './create-admin-dashboard-route.js';
 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

@@ -2,11 +2,13 @@ export { getAdminRouteId, getAdminRoutePath, isAdminRoutePathActive, isRoutePath
 export { getSignInRoutePath } from "./sign-in-path.js";
 export { createAdminAccountRoute } from "./create-admin-account-route.js";
 export { createAdminActivityRoute } from "./create-admin-activity-route.js";
+export { createAdminAnalyticsRoute } from "./create-admin-analytics-route.js";
 export { createAdminDashboardRoute } from "./create-admin-dashboard-route.js";
 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/analytics/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+export { type DeleteAnalyticsEventsInput, deleteAnalyticsEvents, rebuildAnalyticsDay, } from './maintenance.js';
+export { type AnalyticsRuntimeState, type AnalyticsTopInput, getAnalyticsCountries, getAnalyticsReferrers, getAnalyticsReportCoverage, getAnalyticsRuntime, getAnalyticsSummary, getAnalyticsTop, } from './queries.js';

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

@@ -0,0 +1,2 @@
+export { deleteAnalyticsEvents, rebuildAnalyticsDay } from "./maintenance.js";
+export { getAnalyticsCountries, getAnalyticsReferrers, getAnalyticsReportCoverage, getAnalyticsRuntime, getAnalyticsSummary, getAnalyticsTop } from "./queries.js";

package/dist/server-fns/analytics/maintenance.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 DeleteAnalyticsEventsInput {
+    from: string;
+    to: string;
+    visitorHash?: string;
+}
+export declare const deleteAnalyticsEvents: import("@tanstack/react-start").RequiredFetcher<undefined, (input: DeleteAnalyticsEventsInput) => DeleteAnalyticsEventsInput, Promise<{
+    deleted: number;
+}>>;
+export declare const rebuildAnalyticsDay: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+    day: string;
+}) => {
+    day: string;
+}, Promise<{
+    rebuilt: string;
+}>>;

package/dist/server-fns/analytics/maintenance.js

@@ -0,0 +1,42 @@
+import { createServerFn } from "@tanstack/react-start";
+import { assertAdminActor } from "@byline/admin";
+import { ANALYTICS_ABILITIES } from "@byline/admin/analytics";
+import { getAdminRequestContext } from "@byline/client/server";
+const deleteAnalyticsEvents = createServerFn({
+    method: 'POST'
+}).validator((input)=>input).handler(async ({ data })=>{
+    await assertAnalyticsMaintenance();
+    const { getAnalytics } = await import("@byline/analytics");
+    const from = parseInstant(data.from, 'from');
+    const to = parseInstant(data.to, 'to');
+    const deleted = await getAnalytics().deleteEvents({
+        from,
+        to,
+        ...null == data.visitorHash ? {} : {
+            visitorHash: data.visitorHash
+        }
+    });
+    return {
+        deleted
+    };
+});
+const rebuildAnalyticsDay = createServerFn({
+    method: 'POST'
+}).validator((input)=>input).handler(async ({ data })=>{
+    await assertAnalyticsMaintenance();
+    const { getAnalytics } = await import("@byline/analytics");
+    await getAnalytics().rebuildDay(data.day);
+    return {
+        rebuilt: data.day
+    };
+});
+async function assertAnalyticsMaintenance() {
+    const context = await getAdminRequestContext();
+    assertAdminActor(context, ANALYTICS_ABILITIES.maintain);
+}
+function parseInstant(value, label) {
+    const date = new Date(value);
+    if (Number.isNaN(date.valueOf())) throw new Error(`analytics ${label} must be an ISO instant`);
+    return date;
+}
+export { deleteAnalyticsEvents, rebuildAnalyticsDay };

package/dist/server-fns/analytics/queries.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 { AnalyticsCountryTotal, AnalyticsDateRange, AnalyticsEventKind, AnalyticsPathTotal, AnalyticsRankedTotals, AnalyticsReferrerTotal, AnalyticsReportCoverage, AnalyticsSummary } from '@byline/analytics';
+export interface AnalyticsTopInput extends AnalyticsDateRange {
+    kind: AnalyticsEventKind;
+    limit?: number;
+}
+export interface AnalyticsRuntimeState {
+    enabled: boolean;
+}
+export declare const getAnalyticsRuntime: import("@tanstack/react-start").OptionalFetcher<undefined, undefined, Promise<AnalyticsRuntimeState>>;
+export declare const getAnalyticsSummary: import("@tanstack/react-start").RequiredFetcher<undefined, (input: AnalyticsDateRange) => AnalyticsDateRange, Promise<AnalyticsSummary>>;
+export declare const getAnalyticsReportCoverage: import("@tanstack/react-start").OptionalFetcher<undefined, undefined, Promise<AnalyticsReportCoverage>>;
+export declare const getAnalyticsTop: import("@tanstack/react-start").RequiredFetcher<undefined, (input: AnalyticsTopInput) => AnalyticsTopInput, Promise<AnalyticsRankedTotals<AnalyticsPathTotal>>>;
+export declare const getAnalyticsReferrers: import("@tanstack/react-start").RequiredFetcher<undefined, (input: AnalyticsDateRange & {
+    limit?: number;
+}) => AnalyticsDateRange & {
+    limit?: number;
+}, Promise<AnalyticsRankedTotals<AnalyticsReferrerTotal>>>;
+export declare const getAnalyticsCountries: import("@tanstack/react-start").RequiredFetcher<undefined, (input: AnalyticsDateRange) => AnalyticsDateRange, Promise<AnalyticsCountryTotal[]>>;

package/dist/server-fns/analytics/queries.js

@@ -0,0 +1,54 @@
+import { createServerFn } from "@tanstack/react-start";
+import { assertAdminActor, requireAdminActor } from "@byline/admin";
+import { ANALYTICS_ABILITIES } from "@byline/admin/analytics";
+import { getAdminRequestContext } from "@byline/client/server";
+const getAnalyticsRuntime = createServerFn({
+    method: 'GET'
+}).handler(async ()=>{
+    const context = await getAdminRequestContext();
+    requireAdminActor(context, 'reading analytics runtime state');
+    const { isAnalyticsRegistered } = await import("@byline/analytics");
+    return {
+        enabled: isAnalyticsRegistered()
+    };
+});
+const getAnalyticsSummary = createServerFn({
+    method: 'GET'
+}).validator((input)=>input).handler(async ({ data })=>{
+    await assertAnalyticsRead();
+    const { getAnalytics } = await import("@byline/analytics");
+    return getAnalytics().getSummary(data);
+});
+const getAnalyticsReportCoverage = createServerFn({
+    method: 'GET'
+}).handler(async ()=>{
+    await assertAnalyticsRead();
+    const { getAnalytics } = await import("@byline/analytics");
+    return getAnalytics().getReportCoverage();
+});
+const getAnalyticsTop = createServerFn({
+    method: 'GET'
+}).validator((input)=>input).handler(async ({ data })=>{
+    await assertAnalyticsRead();
+    const { getAnalytics } = await import("@byline/analytics");
+    return getAnalytics().getTopPaths(data);
+});
+const getAnalyticsReferrers = createServerFn({
+    method: 'GET'
+}).validator((input)=>input).handler(async ({ data })=>{
+    await assertAnalyticsRead();
+    const { getAnalytics } = await import("@byline/analytics");
+    return getAnalytics().getReferrers(data);
+});
+const getAnalyticsCountries = createServerFn({
+    method: 'GET'
+}).validator((input)=>input).handler(async ({ data })=>{
+    await assertAnalyticsRead();
+    const { getAnalytics } = await import("@byline/analytics");
+    return getAnalytics().getCountries(data);
+});
+async function assertAnalyticsRead() {
+    const context = await getAdminRequestContext();
+    assertAdminActor(context, ANALYTICS_ABILITIES.read);
+}
+export { getAnalyticsCountries, getAnalyticsReferrers, getAnalyticsReportCoverage, getAnalyticsRuntime, getAnalyticsSummary, getAnalyticsTop };

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/dist/vite/analytics-dev.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 { Plugin } from 'vite';
+/**
+ * Complete the first-party analytics transport during Vite development.
+ *
+ * Browser script requests carry `Sec-Fetch-Dest: script`, which Vite routes
+ * into its module pipeline before TanStack Start can serve the agent route.
+ * This plugin serves the agent directly. The application event route remains
+ * responsible for its development identity because POST server routes can
+ * bypass Vite's ordinary middleware chain. Production continues to use the
+ * application-owned agent route.
+ */
+export declare function bylineAnalyticsDev(options?: {
+    /** Public path that serves the standalone agent. */
+    agentPath?: string;
+}): Plugin;

package/dist/vite/analytics-dev.js

@@ -0,0 +1,28 @@
+import { serveAnalyticsAgent } from "../integrations/serve-analytics-agent.js";
+function bylineAnalyticsDev(options = {}) {
+    const agentPath = options.agentPath ?? '/b.js';
+    return {
+        name: 'byline:analytics-dev',
+        apply: 'serve',
+        configureServer (server) {
+            server.middlewares.use(async (request, response, next)=>{
+                const pathname = request.url?.split('?', 1)[0];
+                if ('GET' === request.method && pathname === agentPath) {
+                    try {
+                        const agentResponse = serveAnalyticsAgent();
+                        response.statusCode = agentResponse.status;
+                        agentResponse.headers.forEach((value, name)=>{
+                            response.setHeader(name, value);
+                        });
+                        response.end(await agentResponse.text());
+                    } catch (error) {
+                        next(error);
+                    }
+                    return;
+                }
+                next();
+            });
+        }
+    };
+}
+export { bylineAnalyticsDev };

package/dist/vite/index.d.ts

@@ -5,4 +5,5 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
+export { bylineAnalyticsDev } from './analytics-dev.js';
 export { bylineClientHookBoundary } from './client-hook-boundary.js';

package/dist/vite/index.js

@@ -1 +1,2 @@
+export { bylineAnalyticsDev } from "./analytics-dev.js";
 export { bylineClientHookBoundary } from "./client-hook-boundary.js";

package/package.json

@@ -3,7 +3,7 @@
   "private": false,
   "type": "module",
   "license": "MPL-2.0",
-  "version": "4.14.1",
+  "version": "4.16.0",
   "engines": {
     "node": ">=20.9.0"
   },
@@ -45,6 +45,10 @@
       "types": "./dist/server-fns/admin-account/index.d.ts",
       "import": "./dist/server-fns/admin-account/index.js"
     },
+    "./server-fns/analytics": {
+      "types": "./dist/server-fns/analytics/index.d.ts",
+      "import": "./dist/server-fns/analytics/index.js"
+    },
     "./server-fns/admin-activity": {
       "types": "./dist/server-fns/admin-activity/index.d.ts",
       "import": "./dist/server-fns/admin-activity/index.js"
@@ -117,13 +121,15 @@
     "react-json-view-lite": "^2.5.0",
     "react-swipeable": "^7.0.2",
     "zod": "^4.4.3",
-    "@byline/auth": "4.14.1",
-    "@byline/admin": "4.14.1",
-    "@byline/ai": "4.14.1",
-    "@byline/i18n": "4.14.1",
-    "@byline/client": "4.14.1",
-    "@byline/core": "4.14.1",
-    "@byline/ui": "4.14.1"
+    "@byline/admin": "4.16.0",
+    "@byline/analytics-agent": "4.16.0",
+    "@byline/ai": "4.16.0",
+    "@byline/analytics": "4.16.0",
+    "@byline/client": "4.16.0",
+    "@byline/core": "4.16.0",
+    "@byline/auth": "4.16.0",
+    "@byline/i18n": "4.16.0",
+    "@byline/ui": "4.16.0"
   },
   "peerDependencies": {
     "@tanstack/react-router": "^1.167.0",