@byline/core 4.14.1 → 4.15.0

package/dist/services/document-lifecycle/status-transition.test.node.js

@@ -0,0 +1,145 @@
+/**
+ * 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 { describe, expect, it } from 'vitest';
+import { commitDocumentStatusTransition } from './status-transition.js';
+function createTransitionHarness() {
+    const order = [];
+    const auditRows = [];
+    let status = 'draft';
+    let archived = false;
+    const db = {
+        commands: {
+            documents: {
+                setDocumentStatus: async ({ status: nextStatus }) => {
+                    order.push('status-write');
+                    status = nextStatus;
+                },
+                archivePublishedVersions: async () => {
+                    order.push('auto-archive');
+                    archived = true;
+                    return 1;
+                },
+            },
+            audit: {
+                append: async (input) => {
+                    order.push('audit-append');
+                    auditRows.push(input);
+                    return { id: 'audit-1' };
+                },
+            },
+        },
+        withTransaction: async (fn) => {
+            const snapshot = {
+                status,
+                archived,
+                auditLength: auditRows.length,
+            };
+            order.push('transaction-start');
+            try {
+                const result = await fn();
+                order.push('transaction-commit');
+                return result;
+            }
+            catch (error) {
+                status = snapshot.status;
+                archived = snapshot.archived;
+                auditRows.length = snapshot.auditLength;
+                order.push('transaction-rollback');
+                throw error;
+            }
+        },
+    };
+    return {
+        db,
+        order,
+        auditRows,
+        get status() {
+            return status;
+        },
+        get archived() {
+            return archived;
+        },
+    };
+}
+function transitionParams(db) {
+    return {
+        db,
+        documentId: 'doc-1',
+        documentVersionId: 'ver-1',
+        collectionId: 'col-1',
+        previousStatus: 'draft',
+        nextStatus: 'published',
+        actor: {
+            actorId: '01901234-0000-7000-8000-000000000001',
+            actorRealm: 'admin',
+        },
+    };
+}
+describe('commitDocumentStatusTransition', () => {
+    it('runs contributions inside the transaction at the specified boundaries', async () => {
+        const harness = createTransitionHarness();
+        await commitDocumentStatusTransition({
+            ...transitionParams(harness.db),
+            contributions: {
+                beforeStatusWrite: () => {
+                    harness.order.push('before-contribution');
+                },
+                afterAuditAppend: () => {
+                    harness.order.push('after-contribution');
+                },
+            },
+        });
+        expect(harness.order).toEqual([
+            'transaction-start',
+            'before-contribution',
+            'status-write',
+            'auto-archive',
+            'audit-append',
+            'after-contribution',
+            'transaction-commit',
+        ]);
+    });
+    it('aborts before any mutation or audit when the before contribution throws', async () => {
+        const harness = createTransitionHarness();
+        const error = new Error('guard rejected');
+        await expect(commitDocumentStatusTransition({
+            ...transitionParams(harness.db),
+            contributions: {
+                beforeStatusWrite: () => {
+                    throw error;
+                },
+            },
+        })).rejects.toBe(error);
+        expect(harness.status).toBe('draft');
+        expect(harness.archived).toBe(false);
+        expect(harness.auditRows).toEqual([]);
+        expect(harness.order).toEqual(['transaction-start', 'transaction-rollback']);
+    });
+    it('propagates an after-contribution failure so the transaction rolls back', async () => {
+        const harness = createTransitionHarness();
+        const error = new Error('schedule deletion failed');
+        await expect(commitDocumentStatusTransition({
+            ...transitionParams(harness.db),
+            contributions: {
+                afterAuditAppend: () => {
+                    throw error;
+                },
+            },
+        })).rejects.toBe(error);
+        expect(harness.status).toBe('draft');
+        expect(harness.archived).toBe(false);
+        expect(harness.auditRows).toEqual([]);
+        expect(harness.order).toEqual([
+            'transaction-start',
+            'status-write',
+            'auto-archive',
+            'audit-append',
+            'transaction-rollback',
+        ]);
+    });
+});

package/dist/services/document-lifecycle/status.js

@@ -12,6 +12,8 @@ import { withLogContext } from '../../lib/logger.js';
 import { getWorkflow, validateStatusTransition } from '../../workflow/workflow.js';
 import { AUDIT_ACTIONS, auditActor, requireAuditCapability } from './audit.js';
 import { invokeHook } from './internals.js';
+import { appendPublishScheduleCancellationAudit, cancelPublishScheduleInTransaction, } from './publish-schedule-consistency.js';
+import { commitDocumentStatusTransition } from './status-transition.js';
 /**
  * Change a document's workflow status.
  *
@@ -90,29 +92,27 @@ export async function changeDocumentStatus(ctx, params) {
         //      record. Status mutates the version row rather than minting a new
         //      version, so the version stream never captures *who* changed it —
         //      the audit log is its only accountability home (docs/07-auth-and-security/02-auditability.md).
-        const audit = requireAuditCapability(db);
-        const actor = auditActor(ctx);
-        await audit.withTransaction(async () => {
-            await db.commands.documents.setDocumentStatus({
-                document_version_id: documentVersionId,
-                status: params.nextStatus,
-            });
-            if (params.nextStatus === 'published') {
-                await db.commands.documents.archivePublishedVersions({
-                    document_id: params.documentId,
-                    excludeVersionId: documentVersionId,
-                });
-            }
-            await audit.append({
-                documentId: params.documentId,
-                collectionId,
-                actorId: actor.actorId,
-                actorRealm: actor.actorRealm,
-                action: AUDIT_ACTIONS.statusChanged,
-                field: 'status',
-                before: currentStatus,
-                after: params.nextStatus,
-            });
+        const transitionAudit = requireAuditCapability(db);
+        let cancelledSchedule = null;
+        await commitDocumentStatusTransition({
+            db,
+            documentId: params.documentId,
+            documentVersionId,
+            collectionId,
+            previousStatus: currentStatus,
+            nextStatus: params.nextStatus,
+            actor: auditActor(ctx),
+            contributions: {
+                beforeStatusWrite: async () => {
+                    cancelledSchedule = await cancelPublishScheduleInTransaction(ctx, params.documentId);
+                },
+                afterAuditAppend: () => appendPublishScheduleCancellationAudit({
+                    ctx,
+                    audit: transitionAudit,
+                    schedule: cancelledSchedule,
+                    reason: 'status_changed',
+                }),
+            },
         });
         // 6. afterStatusChange hook.
         await invokeHook(hooks?.afterStatusChange, hookCtx);
@@ -156,6 +156,7 @@ export async function unpublishDocument(ctx, params) {
         const audit = requireAuditCapability(db);
         const actor = auditActor(ctx);
         const archivedCount = await audit.withTransaction(async () => {
+            const cancelledSchedule = await cancelPublishScheduleInTransaction(ctx, params.documentId);
             const count = await db.commands.documents.archivePublishedVersions({
                 document_id: params.documentId,
             });
@@ -171,6 +172,12 @@ export async function unpublishDocument(ctx, params) {
                     after: 'archived',
                 });
             }
+            await appendPublishScheduleCancellationAudit({
+                ctx,
+                audit,
+                schedule: cancelledSchedule,
+                reason: 'unpublished',
+            });
             return count;
         });
         await invokeHook(hooks?.afterUnpublish, {

package/dist/services/document-lifecycle/tree.test.node.js

@@ -213,6 +213,9 @@ function createHarness(options = {}) {
     const db = {
         commands: {
             documents: {
+                publishSchedules: {
+                    cancel: vi.fn(async () => null),
+                },
                 placeTreeNode: place,
                 removeFromTree: remove,
                 promoteChildrenAndRemoveFromTree: promote,

package/dist/services/document-lifecycle/update.js

@@ -15,6 +15,7 @@ import { getDefaultStatus } from '../../workflow/workflow.js';
 import { assignCounterValues } from '../assign-counter-values.js';
 import { normalizeNumericFields } from '../normalize-numeric-fields.js';
 import { actorId, applyRichTextEmbed, extractDocumentId, extractVersionId, invokeHook, resolvePathForUpdate, rethrowPathConflict, } from './internals.js';
+import { commitContentVersionWithScheduleSuspension } from './publish-schedule-consistency.js';
 import { selfHealTreePlacement } from './tree.js';
 /**
  * Update a document via full replacement (PUT semantics).
@@ -76,22 +77,24 @@ export async function updateDocument(ctx, params) {
             logger: ctx.logger,
         });
         await applyRichTextEmbed(ctx, data);
-        const result = await db.commands.documents
-            .createDocumentVersion({
+        const result = await commitContentVersionWithScheduleSuspension({
+            ctx,
             documentId: params.documentId,
-            collectionId,
-            collectionVersion: ctx.collectionVersion,
-            collectionConfig: definition,
-            action: 'update',
-            documentData: data,
-            path: pathForCommand,
-            availableLocales: params.availableLocales,
-            status: defaultStatus,
-            locale: requestLocale,
-            previousVersionId: originalData.document_version_id,
-            createdBy: actorId(ctx),
-        })
-            .catch((err) => rethrowPathConflict(db, err, pathForCommand ?? '', sourceLocale, 'update'));
+            write: () => db.commands.documents.createDocumentVersion({
+                documentId: params.documentId,
+                collectionId,
+                collectionVersion: ctx.collectionVersion,
+                collectionConfig: definition,
+                action: 'update',
+                documentData: data,
+                path: pathForCommand,
+                availableLocales: params.availableLocales,
+                status: defaultStatus,
+                locale: requestLocale,
+                previousVersionId: originalData.document_version_id,
+                createdBy: actorId(ctx),
+            }),
+        }).catch((err) => rethrowPathConflict(db, err, pathForCommand ?? '', sourceLocale, 'update'));
         const documentId = extractDocumentId(result.document) || params.documentId;
         const documentVersionId = extractVersionId(result.document);
         // Self-heal: re-root a genuinely-unplaced doc in a tree collection so any
@@ -195,22 +198,24 @@ export async function updateDocumentWithPatches(ctx, params) {
             logger: ctx.logger,
         });
         await applyRichTextEmbed(ctx, nextData);
-        const result = await db.commands.documents
-            .createDocumentVersion({
+        const result = await commitContentVersionWithScheduleSuspension({
+            ctx,
             documentId: params.documentId,
-            collectionId,
-            collectionVersion: ctx.collectionVersion,
-            collectionConfig: definition,
-            action: 'update',
-            documentData: nextData,
-            path: pathForCommand,
-            availableLocales: params.availableLocales,
-            status: defaultStatus,
-            locale: requestLocale,
-            previousVersionId: originalData.document_version_id,
-            createdBy: actorId(ctx),
-        })
-            .catch((err) => rethrowPathConflict(db, err, pathForCommand ?? '', sourceLocale, 'update'));
+            write: () => db.commands.documents.createDocumentVersion({
+                documentId: params.documentId,
+                collectionId,
+                collectionVersion: ctx.collectionVersion,
+                collectionConfig: definition,
+                action: 'update',
+                documentData: nextData,
+                path: pathForCommand,
+                availableLocales: params.availableLocales,
+                status: defaultStatus,
+                locale: requestLocale,
+                previousVersionId: originalData.document_version_id,
+                createdBy: actorId(ctx),
+            }),
+        }).catch((err) => rethrowPathConflict(db, err, pathForCommand ?? '', sourceLocale, 'update'));
         const documentId = extractDocumentId(result.document) || params.documentId;
         const documentVersionId = extractVersionId(result.document);
         // Self-heal: re-root a genuinely-unplaced doc in a tree collection so any

package/dist/services/document-lifecycle.test.node.js

@@ -8,7 +8,7 @@
 import { AdminAuth, AuthError, AuthErrorCodes, createRequestContext, createSuperAdminContext, } from '@byline/auth';
 import { describe, expect, it, vi } from 'vitest';
 import { BylineError, DbErrorCodes, ErrorCodes } from '../lib/errors.js';
-import { changeDocumentStatus, copyToLocale, createDocument, deleteDocument, duplicateDocument, restoreDocumentVersion, unpublishDocument, updateDocument, updateDocumentSystemFields, updateDocumentWithPatches, } from './document-lifecycle/index.js';
+import { cancelDocumentScheduledPublish, changeDocumentStatus, confirmDocumentScheduledPublish, copyToLocale, createDocument, deleteDocument, deleteLocale, duplicateDocument, listDocumentPublishSchedules, restoreDocumentVersion, scheduleDocumentPublish, unpublishDocument, updateDocument, updateDocumentSystemFields, updateDocumentWithPatches, } from './document-lifecycle/index.js';
 // ---------------------------------------------------------------------------
 // Fixtures / Helpers
 // ---------------------------------------------------------------------------
@@ -32,6 +32,30 @@ const numericCollection = {
         { name: 'price', type: 'decimal' },
     ],
 };
+function publishScheduleRow(overrides = {}) {
+    const now = new Date('2026-08-22T12:00:00.000Z');
+    return {
+        documentId: 'doc-1',
+        collectionId: 'col-1',
+        targetVersionId: 'ver-1',
+        publishAt: new Date('2026-08-23T12:00:00.000Z'),
+        state: 'armed',
+        suspendedAt: null,
+        suspendedReason: null,
+        scheduledBy: TEST_ACTOR_ID,
+        lastAuthorizedBy: TEST_ACTOR_ID,
+        lastAuthorizedAt: now,
+        scheduledAt: now,
+        updatedAt: now,
+        executionToken: null,
+        executionExpiresAt: null,
+        lastAttemptAt: null,
+        nextAttemptAt: new Date('2026-08-23T12:00:00.000Z'),
+        attemptCount: 0,
+        lastError: null,
+        ...overrides,
+    };
+}
 /** Build a mock IDbAdapter. Returns the adapter plus individual mock fns. */
 function createMockDb() {
     const createDocumentVersion = vi.fn().mockResolvedValue({
@@ -41,10 +65,22 @@ function createMockDb() {
     const setDocumentStatus = vi.fn().mockResolvedValue(undefined);
     const archivePublishedVersions = vi.fn().mockResolvedValue(0);
     const softDeleteDocument = vi.fn().mockResolvedValue(1);
+    const deleteDocumentLocale = vi.fn().mockResolvedValue({ newVersionId: 'ver-2' });
     const getDocumentById = vi.fn().mockResolvedValue(null);
     const getDocumentSystemFieldsForUpdate = vi.fn().mockResolvedValue(null);
     const getCurrentVersionMetadata = vi.fn().mockResolvedValue(null);
     const getCurrentPath = vi.fn().mockResolvedValue('current-path');
+    const publishSchedule = vi.fn().mockResolvedValue({ status: 'document_not_found' });
+    const confirmPublishSchedule = vi.fn().mockResolvedValue({ status: 'schedule_not_found' });
+    const cancelPublishSchedule = vi.fn().mockResolvedValue(null);
+    const suspendPublishSchedule = vi.fn().mockResolvedValue({ status: 'schedule_not_found' });
+    const claimDuePublishSchedules = vi.fn().mockResolvedValue([]);
+    const lockPublishScheduleClaim = vi.fn().mockResolvedValue(null);
+    const deletePublishScheduleClaim = vi.fn().mockResolvedValue(false);
+    const suspendPublishScheduleClaim = vi.fn().mockResolvedValue(false);
+    const releasePublishScheduleClaim = vi.fn().mockResolvedValue(false);
+    const getPublishSchedule = vi.fn().mockResolvedValue(null);
+    const listPublishSchedules = vi.fn().mockResolvedValue({ schedules: [], total: 0 });
     // Audit capability (docs/07-auth-and-security/02-auditability.md — W2). `withTransaction` is a passthrough
     // in unit tests (runs the unit of work immediately, no real tx); `append`
     // records the calls so write-point tests can assert the audit rows emitted.
@@ -71,6 +107,17 @@ function createMockDb() {
                 delete: vi.fn(),
             },
             documents: {
+                publishSchedules: {
+                    schedule: publishSchedule,
+                    confirm: confirmPublishSchedule,
+                    cancel: cancelPublishSchedule,
+                    suspendForContentEdit: suspendPublishSchedule,
+                    claimDue: claimDuePublishSchedules,
+                    lockClaim: lockPublishScheduleClaim,
+                    deleteClaim: deletePublishScheduleClaim,
+                    suspendClaimForContentEdit: suspendPublishScheduleClaim,
+                    releaseClaim: releasePublishScheduleClaim,
+                },
                 createDocumentVersion,
                 updateDocumentPath: vi.fn().mockResolvedValue(undefined),
                 setDocumentAvailableLocales: vi.fn().mockResolvedValue(undefined),
@@ -78,7 +125,7 @@ function createMockDb() {
                 archivePublishedVersions,
                 softDeleteDocument,
                 restoreSoftDeletedDocument: vi.fn(),
-                deleteDocumentLocale: vi.fn(),
+                deleteDocumentLocale: deleteDocumentLocale,
                 setOrderKey: vi.fn(),
                 placeTreeNode: vi.fn(),
                 removeFromTree: vi.fn(),
@@ -108,6 +155,10 @@ function createMockDb() {
                 getCollectionById: vi.fn(),
             },
             documents: {
+                publishSchedules: {
+                    get: getPublishSchedule,
+                    list: listPublishSchedules,
+                },
                 getDocumentSystemFieldsForUpdate,
                 getDocumentById,
                 getCurrentVersionMetadata,
@@ -147,10 +198,22 @@ function createMockDb() {
         setDocumentStatus,
         archivePublishedVersions,
         softDeleteDocument,
+        deleteDocumentLocale,
         getDocumentById,
         getDocumentSystemFieldsForUpdate,
         getCurrentVersionMetadata,
         getCurrentPath,
+        publishSchedule,
+        confirmPublishSchedule,
+        cancelPublishSchedule,
+        suspendPublishSchedule,
+        claimDuePublishSchedules,
+        lockPublishScheduleClaim,
+        deletePublishScheduleClaim,
+        suspendPublishScheduleClaim,
+        releasePublishScheduleClaim,
+        getPublishSchedule,
+        listPublishSchedules,
         auditAppend,
         withTransaction,
     };
@@ -825,6 +888,203 @@ describe('Document lifecycle service', () => {
         });
     });
     // -----------------------------------------------------------------------
+    // scheduled publication lifecycle
+    // -----------------------------------------------------------------------
+    describe('scheduled publication lifecycle', () => {
+        const metadataRow = {
+            document_version_id: 'ver-1',
+            document_id: 'doc-1',
+            collection_id: 'col-1',
+            status: 'draft',
+            created_at: new Date(),
+            updated_at: new Date(),
+        };
+        it('requires both workflow abilities and records an atomic schedule audit', async () => {
+            const { db, getCurrentVersionMetadata, publishSchedule, auditAppend } = createMockDb();
+            const schedule = publishScheduleRow();
+            getCurrentVersionMetadata.mockResolvedValue(metadataRow);
+            publishSchedule.mockResolvedValue({ status: 'scheduled', schedule, previous: null });
+            const ctx = buildCtx(db);
+            await expect(scheduleDocumentPublish(ctx, {
+                documentId: 'doc-1',
+                expectedVersionId: 'ver-1',
+                publishAt: schedule.publishAt.toISOString(),
+            })).resolves.toEqual(schedule);
+            expect(publishSchedule).toHaveBeenCalledWith(expect.objectContaining({
+                documentId: 'doc-1',
+                collectionId: 'col-1',
+                expectedVersionId: 'ver-1',
+                actorId: TEST_ACTOR_ID,
+                publishAt: schedule.publishAt,
+            }));
+            expect(auditAppend).toHaveBeenCalledWith(expect.objectContaining({ action: 'document.publish.scheduled' }));
+            const restricted = buildCtx(db);
+            restricted.requestContext = createRequestContext({
+                actor: new AdminAuth({
+                    id: TEST_ACTOR_ID,
+                    abilities: ['collections.articles.changeStatus'],
+                }),
+            });
+            await expect(scheduleDocumentPublish(restricted, {
+                documentId: 'doc-1',
+                expectedVersionId: 'ver-1',
+                publishAt: schedule.publishAt.toISOString(),
+            })).rejects.toMatchObject({ code: AuthErrorCodes.FORBIDDEN });
+        });
+        it('maps a database-time past instant and a stale version to domain errors', async () => {
+            const { db, getCurrentVersionMetadata, publishSchedule } = createMockDb();
+            getCurrentVersionMetadata.mockResolvedValue(metadataRow);
+            publishSchedule.mockResolvedValue({ status: 'publish_at_not_future' });
+            await expect(scheduleDocumentPublish(buildCtx(db), {
+                documentId: 'doc-1',
+                expectedVersionId: 'ver-1',
+                publishAt: new Date(Date.now() + 60_000).toISOString(),
+            })).rejects.toMatchObject({ code: ErrorCodes.VALIDATION });
+            getCurrentVersionMetadata.mockResolvedValue({
+                ...metadataRow,
+                document_version_id: 'ver-2',
+            });
+            await expect(scheduleDocumentPublish(buildCtx(db), {
+                documentId: 'doc-1',
+                expectedVersionId: 'ver-1',
+                publishAt: new Date(Date.now() + 60_000).toISOString(),
+            })).rejects.toMatchObject({ code: ErrorCodes.CONFLICT });
+        });
+        it('rejects date strings that are valid to JavaScript but are not ISO instants', async () => {
+            const { db, getCurrentVersionMetadata, publishSchedule } = createMockDb();
+            getCurrentVersionMetadata.mockResolvedValue(metadataRow);
+            await expect(scheduleDocumentPublish(buildCtx(db), {
+                documentId: 'doc-1',
+                expectedVersionId: 'ver-1',
+                publishAt: 'August 23, 2026 12:00:00 UTC',
+            })).rejects.toMatchObject({ code: ErrorCodes.VALIDATION });
+            expect(publishSchedule).not.toHaveBeenCalled();
+        });
+        it('re-confirms and explicitly cancels through audited lifecycle operations', async () => {
+            const { db, getCurrentVersionMetadata, confirmPublishSchedule, cancelPublishSchedule, auditAppend, } = createMockDb();
+            const suspended = publishScheduleRow({
+                state: 'needs_reconfirm',
+                suspendedAt: new Date(),
+                suspendedReason: 'content_edited',
+            });
+            const confirmed = publishScheduleRow();
+            getCurrentVersionMetadata.mockResolvedValue(metadataRow);
+            confirmPublishSchedule.mockResolvedValue({
+                status: 'confirmed',
+                schedule: confirmed,
+                previousTargetVersionId: 'ver-0',
+            });
+            cancelPublishSchedule.mockResolvedValue(confirmed);
+            await expect(confirmDocumentScheduledPublish(buildCtx(db), {
+                documentId: 'doc-1',
+                expectedVersionId: 'ver-1',
+            })).resolves.toEqual(confirmed);
+            await expect(cancelDocumentScheduledPublish(buildCtx(db), { documentId: 'doc-1' })).resolves.toEqual(confirmed);
+            expect(auditAppend).toHaveBeenCalledWith(expect.objectContaining({ action: 'document.publish.reconfirmed' }));
+            expect(auditAppend).toHaveBeenCalledWith(expect.objectContaining({ action: 'document.publish.schedule.cancelled' }));
+            expect(suspended.state).toBe('needs_reconfirm');
+        });
+        it('suspends an armed schedule atomically when an update creates a version', async () => {
+            const { db, getDocumentById, suspendPublishSchedule, auditAppend } = createMockDb();
+            const schedule = publishScheduleRow({
+                state: 'needs_reconfirm',
+                suspendedAt: new Date(),
+                suspendedReason: 'content_edited',
+            });
+            getDocumentById.mockResolvedValue({
+                document_version_id: 'ver-0',
+                document_id: 'doc-1',
+                path: 'current-path',
+                source_locale: 'en',
+                fields: { title: 'Before' },
+            });
+            suspendPublishSchedule.mockResolvedValue({ status: 'suspended', schedule });
+            await updateDocument(buildCtx(db), {
+                documentId: 'doc-1',
+                data: { title: 'After' },
+            });
+            expect(suspendPublishSchedule).toHaveBeenCalledWith({
+                documentId: 'doc-1',
+                collectionId: 'col-1',
+            });
+            expect(auditAppend).toHaveBeenCalledWith(expect.objectContaining({ action: 'document.publish.schedule.suspended' }));
+        });
+        it('treats deleting a locale as a version-creating edit that suspends the schedule', async () => {
+            const { db, deleteDocumentLocale, getDocumentById, suspendPublishSchedule, auditAppend } = createMockDb();
+            getDocumentById.mockResolvedValue({
+                document_version_id: 'ver-1',
+                document_id: 'doc-1',
+                path: 'current-path',
+                _availableVersionLocales: ['en', 'fr'],
+                fields: { title: 'Bonjour' },
+            });
+            suspendPublishSchedule.mockResolvedValue({
+                status: 'suspended',
+                schedule: publishScheduleRow({
+                    state: 'needs_reconfirm',
+                    suspendedAt: new Date(),
+                    suspendedReason: 'content_edited',
+                }),
+            });
+            await deleteLocale(buildCtx(db), { documentId: 'doc-1', locale: 'fr' });
+            expect(deleteDocumentLocale).toHaveBeenCalledOnce();
+            expect(suspendPublishSchedule).toHaveBeenCalledWith({
+                documentId: 'doc-1',
+                collectionId: 'col-1',
+            });
+            expect(auditAppend).toHaveBeenCalledWith(expect.objectContaining({ action: 'document.publish.schedule.suspended' }));
+        });
+        it('cancels an active schedule as an effect of an ordinary status transition', async () => {
+            const { db, getCurrentVersionMetadata, cancelPublishSchedule, auditAppend } = createMockDb();
+            getCurrentVersionMetadata.mockResolvedValue(metadataRow);
+            cancelPublishSchedule.mockResolvedValue(publishScheduleRow());
+            await changeDocumentStatus(buildCtx(db), {
+                documentId: 'doc-1',
+                nextStatus: 'published',
+            });
+            expect(cancelPublishSchedule).toHaveBeenCalledWith({
+                documentId: 'doc-1',
+                collectionId: 'col-1',
+            });
+            expect(auditAppend).toHaveBeenCalledWith(expect.objectContaining({ action: 'document.publish.schedule.cancelled' }));
+        });
+        it('resolves cross-collection visibility above storage into a collection-id allowlist', async () => {
+            const { db, listPublishSchedules } = createMockDb();
+            const secret = {
+                ...minimalCollection,
+                path: 'secret',
+                labels: { singular: 'Secret', plural: 'Secrets' },
+            };
+            const core = {
+                collections: [minimalCollection, secret],
+                db,
+                getCollectionRecord: (path) => ({
+                    collectionId: path === 'articles' ? 'col-1' : 'col-2',
+                    version: 1,
+                    schemaHash: 'test',
+                }),
+            };
+            const requestContext = createRequestContext({
+                actor: new AdminAuth({
+                    id: TEST_ACTOR_ID,
+                    abilities: [
+                        'collections.articles.changeStatus',
+                        'collections.articles.publish',
+                        'collections.secret.changeStatus',
+                    ],
+                }),
+            });
+            await listDocumentPublishSchedules(core, requestContext, { page: 1, pageSize: 20 });
+            expect(listPublishSchedules).toHaveBeenCalledWith({
+                collectionIds: ['col-1'],
+                states: undefined,
+                lastAuthorizedBy: undefined,
+                page: 1,
+                pageSize: 20,
+            });
+        });
+    });
+    // -----------------------------------------------------------------------
     // changeDocumentStatus
     // -----------------------------------------------------------------------
     describe('changeDocumentStatus', () => {

package/dist/services/field-upload.test.node.js

@@ -53,6 +53,7 @@ function createMockDb() {
                 delete: vi.fn(),
             },
             documents: {
+                publishSchedules: {},
                 createDocumentVersion,
                 updateDocumentPath: vi.fn(),
                 setDocumentAvailableLocales: vi.fn(),
@@ -89,6 +90,7 @@ function createMockDb() {
                 getCollectionById: vi.fn(),
             },
             documents: {
+                publishSchedules: {},
                 getDocumentSystemFieldsForUpdate: vi.fn(async () => null),
                 getDocumentById: vi.fn(),
                 getCurrentVersionMetadata: vi.fn(),