@forumone/throughline 0.0.0 → 1.0.0-next.0

package/dist/publishing/hooks/block-status-writes.js

@@ -0,0 +1,242 @@
+import { APIError } from 'payload';
+import { isDraftWrite } from './draft-writes.js';
+/**
+ * The trust boundary. This `beforeChange` hook rejects every update that
+ * changes whether a document is live, unless the request explicitly carries
+ * the `bypassPublishingServer` context flag (set by the pipeline's
+ * `executeStep`).
+ *
+ * Without this hook, the Payload MCP could let Claude flip a document to
+ * `published` directly, sidestepping every check the publishing server
+ * exists to enforce. With it, the only sanctioned path is the pipeline.
+ *
+ * Three details of Payload's update pipeline shape this:
+ *
+ * 1. `data` is the existing document merged with the incoming changes, so
+ *    `_status` is present on essentially every update — an ordinary field
+ *    edit on a published document arrives carrying `_status: 'published'`.
+ *    The presence of `_status` therefore means nothing on its own.
+ *
+ * 2. Payload injects `data._status = 'draft'` into every `draft: true`
+ *    update before this hook runs, so a draft save of a published document
+ *    arrives looking like an unpublish. `createRecordDraftWritesHook`
+ *    captures the operation's real `draft` flag to tell them apart; both
+ *    hooks must be installed together.
+ *
+ * 3. `originalDoc` is the *latest version*, not the live document. Once any
+ *    draft version exists on a published document, `originalDoc._status` is
+ *    `'draft'` while the document is still live — so comparing against it
+ *    reads a genuine unpublish as a harmless no-op.
+ *
+ * So the question asked here is narrow and concrete: **would this write
+ * change what the public sees?** A draft write never does. A non-draft
+ * write does when it takes a live document down, or when it puts content
+ * live — including promoting a pending draft, which leaves `_status` on
+ * `published` throughout and so cannot be caught by comparing statuses
+ * alone.
+ *
+ * One non-draft `published` write over a pending draft is harmless: one
+ * whose content is exactly what is already live. That is Payload's own
+ * "Revert to published", which reads the live document and writes it back
+ * unchanged to discard the draft — the public sees nothing new, so there is
+ * nothing for the pipeline to check.
+ *
+ * Moving a document to the trash is the same question asked a different way.
+ * On a collection with `trash: true` it is an update that sets `deletedAt`,
+ * and every read then leaves the document out — so trashing a live document
+ * takes it off the site. `_status` stays `published` throughout, so without
+ * its own check it passed as an ordinary edit, and the page came down with no
+ * policy check, no `unpublished` event and nothing to drop the cached copy.
+ * It is refused while the document is live: unpublish, then trash.
+ */
+export function createBlockStatusWritesHook() {
+    return async ({ collection, data, originalDoc, operation, context, req }) => {
+        if (operation !== 'update')
+            return data;
+        if (!carriesStatus(data))
+            return data;
+        if (isBypassed(context) || isBypassed(req?.context))
+            return data;
+        const nextStatus = data['_status'];
+        const previousStatus = originalDoc?.['_status'];
+        const id = originalDoc?.id;
+        if (movesToTrash(data, originalDoc)) {
+            const liveStatus = await resolveLiveStatus(req, collection?.slug, id, previousStatus);
+            if (liveStatus !== undefined && liveStatus !== 'published')
+                return data;
+            throw new APIError('This document is published. Unpublish it first, then move it to the trash.', 400);
+        }
+        // A draft save writes a version and leaves the live document alone.
+        //
+        // Mirror Payload's own `isSavingDraft`, which excludes `published`: a
+        // request asking for `draft: true` while setting `_status: 'published'`
+        // is a real publish, so `draft` cannot become a way around the pipeline.
+        if (nextStatus !== 'published' && isDraftWrite(req, collection?.slug, id)) {
+            return data;
+        }
+        if (nextStatus === 'published') {
+            // This puts content live. Allowed only when the document is already
+            // live *and* nothing is pending: a latest version of `published`
+            // means there is no newer draft for this write to promote. When a
+            // draft is pending, this is the publish and it belongs in the
+            // pipeline — even though the live status does not change.
+            if (previousStatus === 'published')
+                return data;
+            if (await restatesLiveContent(req, collection?.slug, id, data))
+                return data;
+        }
+        else {
+            // This takes the live document down. Harmless only if nothing is
+            // live: a document that was never published, or is already down.
+            const liveStatus = await resolveLiveStatus(req, collection?.slug, id, previousStatus);
+            if (liveStatus !== undefined && liveStatus !== 'published')
+                return data;
+        }
+        // Payload's restore dialog offers "restore as published". Refusing it is
+        // right — it is a publish — but the generic message below is written for
+        // a developer, and this is the one refusal an editor reaches from the
+        // admin's own controls. Same decision, words they can act on.
+        if (nextStatus === 'published' && restoresFromTrash(data, originalDoc)) {
+            throw new APIError('Restore it as a draft, then publish it. Publishing is what runs the checks a live page needs.', 400);
+        }
+        throw new APIError('Direct writes to `_status` are not allowed. Use the publishing server (publish / unpublish / rollback) so the policy pipeline runs.', 400);
+    };
+}
+/**
+ * The live document's current `_status`, or `undefined` when it cannot be
+ * established — in which case the caller blocks the write.
+ *
+ * `originalDoc` is the latest version. A latest version of `published`
+ * means the live document is published, so that answer is taken directly.
+ * A latest version of `draft` is ambiguous — the document may still be live
+ * with a newer draft sitting on top of it — and only then is the published
+ * row read. Draft writes return before reaching this, so the admin's
+ * publish flow never pays for the query.
+ */
+async function resolveLiveStatus(req, collectionSlug, id, previousStatus) {
+    if (previousStatus === 'published')
+        return 'published';
+    if (!req?.payload || !collectionSlug || id === undefined || id === null)
+        return undefined;
+    try {
+        const live = await req.payload.findByID({
+            collection: collectionSlug,
+            id: id,
+            depth: 0,
+            overrideAccess: true,
+            // A trashed document is still the live row, and restoring one is a
+            // write about it. Without this every read leaves it out, the lookup
+            // throws, and "Restore as draft" was refused. Ignored where the
+            // collection has no trash.
+            trash: true,
+            // Share the request so this reads inside the open transaction.
+            req,
+        });
+        const status = live?.['_status'];
+        return typeof status === 'string' ? status : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Fields that differ between two writes of the same content: the row's
+ * identity, its timestamps, and the status this hook is already judging.
+ */
+const NOT_CONTENT = new Set(['id', 'createdAt', 'updatedAt', '_status']);
+/**
+ * Whether `data` is the live document's content, unchanged — so writing it
+ * would leave the public site exactly as it is.
+ *
+ * Compared as JSON so a `Date` and its ISO string agree, ignoring key order,
+ * and with a missing key equal to `null`, which is how Payload stores an
+ * empty field. Anything
+ * it cannot read counts as a change, and the caller blocks.
+ */
+async function restatesLiveContent(req, collectionSlug, id, data) {
+    if (!req?.payload || !collectionSlug || id === undefined || id === null)
+        return false;
+    let live;
+    try {
+        live = await req.payload.findByID({
+            collection: collectionSlug,
+            id: id,
+            depth: 0,
+            draft: false,
+            overrideAccess: true,
+            req,
+        });
+    }
+    catch {
+        return false;
+    }
+    if (!live || typeof live !== 'object')
+        return false;
+    if (live['_status'] !== 'published')
+        return false;
+    const next = asJSON(data);
+    const current = asJSON(live);
+    const keys = new Set([...Object.keys(next), ...Object.keys(current)]);
+    for (const key of keys) {
+        if (NOT_CONTENT.has(key))
+            continue;
+        if (!sameContent(next[key], current[key]))
+            return false;
+    }
+    return true;
+}
+function asJSON(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+/** Deep equality over JSON values, ignoring object key order. */
+function sameContent(a, b) {
+    a = a ?? null;
+    b = b ?? null;
+    if (a === b)
+        return true;
+    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
+        return false;
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    if (Array.isArray(a)) {
+        const other = b;
+        return a.length === other.length && a.every((item, i) => sameContent(item, other[i]));
+    }
+    const left = a;
+    const right = b;
+    const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
+    for (const key of keys)
+        if (!sameContent(left[key], right[key]))
+            return false;
+    return true;
+}
+/**
+ * Whether `_status` is present at all. Payload merges the stored document
+ * into `data`, so this is true for nearly every update — it only filters
+ * out collections without drafts.
+ */
+function carriesStatus(data) {
+    return typeof data === 'object' && data !== null && '_status' in data;
+}
+/**
+ * Whether this write puts the document in the trash: `deletedAt` set now and
+ * not before. Restoring clears it, and is judged by the status rules above
+ * like any other write.
+ */
+function movesToTrash(data, originalDoc) {
+    const next = data?.['deletedAt'];
+    const previous = originalDoc?.['deletedAt'];
+    return next != null && previous == null;
+}
+/** Whether this write takes the document out of the trash: `deletedAt` cleared. */
+function restoresFromTrash(data, originalDoc) {
+    const next = data?.['deletedAt'];
+    const previous = originalDoc?.['deletedAt'];
+    return next == null && previous != null;
+}
+function isBypassed(context) {
+    if (!context || typeof context !== 'object')
+        return false;
+    return context['bypassPublishingServer'] === true;
+}
+//# sourceMappingURL=block-status-writes.js.map

package/dist/publishing/hooks/block-status-writes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-status-writes.js","sourceRoot":"","sources":["../../../src/publishing/hooks/block-status-writes.ts"],"names":[],"mappings":"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"}

package/dist/publishing/hooks/draft-writes.d.ts

@@ -0,0 +1,32 @@
+import type { CollectionBeforeOperationHook, PayloadRequest } from 'payload';
+/**
+ * Records whether the update in flight is a draft write, so the
+ * status-write hook can tell a draft save apart from an unpublish.
+ *
+ * It has to be recorded here because `beforeChange` cannot work it out:
+ * Payload sets `data._status = 'draft'` for any `draft: true` update
+ * *before* calling the hook, whether or not the caller supplied it —
+ *
+ *     const isSavingDraft = Boolean(draftArg && hasDraftsEnabled(config))
+ *       && data._status !== 'published' && !publishAllLocales
+ *     if (isSavingDraft) { data._status = 'draft' }
+ *
+ * so by the time `beforeChange` runs, saving a draft of a published
+ * document and unpublishing it look identical: `data._status` is `'draft'`
+ * and `originalDoc._status` is `'published'` in both cases.
+ *
+ * `beforeOperation` is the one place that sees the operation's own `draft`
+ * argument, and it sees it identically on the Local API, REST and GraphQL —
+ * unlike `req.query.draft`, which is only populated on the REST path.
+ * `beforeOperation` shares `req.context` with `beforeChange`, which is how
+ * the flag gets across.
+ */
+export declare function createRecordDraftWritesHook(): CollectionBeforeOperationHook;
+/**
+ * Whether the update in flight on this document is a draft write.
+ *
+ * Defaults to `false` when nothing was recorded, so a caller that installs
+ * the status-write hook without this one keeps the stricter behaviour.
+ */
+export declare function isDraftWrite(req: Pick<PayloadRequest, 'context'> | undefined, collectionSlug: string | undefined, id: unknown): boolean;
+//# sourceMappingURL=draft-writes.d.ts.map

package/dist/publishing/hooks/draft-writes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"draft-writes.d.ts","sourceRoot":"","sources":["../../../src/publishing/hooks/draft-writes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAM5E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,2BAA2B,IAAI,6BAA6B,CAW3E;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,IAAI,CAAC,cAAc,EAAE,SAAS,CAAC,GAAG,SAAS,EAChD,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,EAAE,EAAE,OAAO,GACV,OAAO,CAcT"}

package/dist/publishing/hooks/draft-writes.js

@@ -0,0 +1,76 @@
+const DRAFT_WRITES_KEY = '__throughlinePublishingDraftWrites';
+/**
+ * Records whether the update in flight is a draft write, so the
+ * status-write hook can tell a draft save apart from an unpublish.
+ *
+ * It has to be recorded here because `beforeChange` cannot work it out:
+ * Payload sets `data._status = 'draft'` for any `draft: true` update
+ * *before* calling the hook, whether or not the caller supplied it —
+ *
+ *     const isSavingDraft = Boolean(draftArg && hasDraftsEnabled(config))
+ *       && data._status !== 'published' && !publishAllLocales
+ *     if (isSavingDraft) { data._status = 'draft' }
+ *
+ * so by the time `beforeChange` runs, saving a draft of a published
+ * document and unpublishing it look identical: `data._status` is `'draft'`
+ * and `originalDoc._status` is `'published'` in both cases.
+ *
+ * `beforeOperation` is the one place that sees the operation's own `draft`
+ * argument, and it sees it identically on the Local API, REST and GraphQL —
+ * unlike `req.query.draft`, which is only populated on the REST path.
+ * `beforeOperation` shares `req.context` with `beforeChange`, which is how
+ * the flag gets across.
+ */
+export function createRecordDraftWritesHook() {
+    return ({ args, operation, req }) => {
+        // `update` and `updateByID` both arrive as the `update` hook operation.
+        if (operation !== 'update')
+            return;
+        const updateArgs = args;
+        const slug = collectionSlug(args);
+        if (!slug)
+            return;
+        registry(req)[draftWriteKey(slug, updateArgs.id)] = updateArgs.draft === true;
+    };
+}
+/**
+ * Whether the update in flight on this document is a draft write.
+ *
+ * Defaults to `false` when nothing was recorded, so a caller that installs
+ * the status-write hook without this one keeps the stricter behaviour.
+ */
+export function isDraftWrite(req, collectionSlug, id) {
+    if (!req || !collectionSlug)
+        return false;
+    const entries = req.context?.[DRAFT_WRITES_KEY];
+    if (!entries)
+        return false;
+    // Keyed per document so a nested write to a different document during the
+    // same request cannot be mistaken for this one.
+    const scoped = entries[draftWriteKey(collectionSlug, id)];
+    if (scoped !== undefined)
+        return scoped;
+    // Bulk updates match by `where` and carry no id.
+    return entries[draftWriteKey(collectionSlug, undefined)] === true;
+}
+function draftWriteKey(collectionSlug, id) {
+    return `${collectionSlug}:${id === undefined || id === null ? '*' : String(id)}`;
+}
+function collectionSlug(args) {
+    const slug = args?.collection?.config
+        ?.slug;
+    return typeof slug === 'string' ? slug : undefined;
+}
+function registry(req) {
+    // Payload always assigns `req.context`, but attach it if absent rather
+    // than writing the flag to an object nothing else can see.
+    if (!req.context) {
+        req.context = {};
+    }
+    const context = req.context;
+    if (!context[DRAFT_WRITES_KEY]) {
+        context[DRAFT_WRITES_KEY] = {};
+    }
+    return context[DRAFT_WRITES_KEY];
+}
+//# sourceMappingURL=draft-writes.js.map

package/dist/publishing/hooks/draft-writes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"draft-writes.js","sourceRoot":"","sources":["../../../src/publishing/hooks/draft-writes.ts"],"names":[],"mappings":"AAEA,MAAM,gBAAgB,GAAG,oCAAoC,CAAA;AAI7D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,2BAA2B;IACzC,OAAO,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,EAAE,EAAE;QAClC,wEAAwE;QACxE,IAAI,SAAS,KAAK,QAAQ;YAAE,OAAM;QAElC,MAAM,UAAU,GAAG,IAAiD,CAAA;QACpE,MAAM,IAAI,GAAG,cAAc,CAAC,IAAI,CAAC,CAAA;QACjC,IAAI,CAAC,IAAI;YAAE,OAAM;QAEjB,QAAQ,CAAC,GAAG,CAAC,CAAC,aAAa,CAAC,IAAI,EAAE,UAAU,CAAC,EAAE,CAAC,CAAC,GAAG,UAAU,CAAC,KAAK,KAAK,IAAI,CAAA;IAC/E,CAAC,CAAA;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAC1B,GAAgD,EAChD,cAAkC,EAClC,EAAW;IAEX,IAAI,CAAC,GAAG,IAAI,CAAC,cAAc;QAAE,OAAO,KAAK,CAAA;IACzC,MAAM,OAAO,GAAI,GAAG,CAAC,OAA+C,EAAE,CACpE,gBAAgB,CACiB,CAAA;IACnC,IAAI,CAAC,OAAO;QAAE,OAAO,KAAK,CAAA;IAE1B,0EAA0E;IAC1E,gDAAgD;IAChD,MAAM,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC,CAAA;IACzD,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,MAAM,CAAA;IAEvC,iDAAiD;IACjD,OAAO,OAAO,CAAC,aAAa,CAAC,cAAc,EAAE,SAAS,CAAC,CAAC,KAAK,IAAI,CAAA;AACnE,CAAC;AAED,SAAS,aAAa,CAAC,cAAsB,EAAE,EAAW;IACxD,OAAO,GAAG,cAAc,IAAI,EAAE,KAAK,SAAS,IAAI,EAAE,KAAK,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAA;AAClF,CAAC;AAED,SAAS,cAAc,CAAC,IAAa;IACnC,MAAM,IAAI,GAAI,IAAyD,EAAE,UAAU,EAAE,MAAM;QACzF,EAAE,IAAI,CAAA;IACR,OAAO,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAA;AACpD,CAAC;AAED,SAAS,QAAQ,CAAC,GAAmB;IACnC,uEAAuE;IACvE,2DAA2D;IAC3D,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;QACjB,GAAG,CAAC,OAAO,GAAG,EAA+B,CAAA;IAC/C,CAAC;IACD,MAAM,OAAO,GAAG,GAAG,CAAC,OAA6C,CAAA;IACjE,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAE,CAAC;QAC/B,OAAO,CAAC,gBAAgB,CAAC,GAAG,EAA+B,CAAA;IAC7D,CAAC;IACD,OAAO,OAAO,CAAC,gBAAgB,CAAuB,CAAA;AACxD,CAAC"}

package/dist/publishing/hooks/schedule-events.d.ts

@@ -0,0 +1,26 @@
+import type { CollectionAfterChangeHook } from 'payload';
+import type { Inngest } from 'inngest';
+/**
+ * Sends `content/page.scheduled` when a document's scheduled publish time is
+ * set to a new value, by whatever route — the admin's Schedule control, the
+ * `schedule_publish` MCP tool, a REST write.
+ *
+ * On the collection rather than in the service because the field is the
+ * source of truth and the service is only one way to write it. A schedule that
+ * could be stored without the event would be a date nothing wakes up for,
+ * which is the defect this replaces.
+ *
+ * Nothing is sent for a cleared or unchanged time. The run sleeping on a
+ * schedule re-reads the document when it wakes and publishes only if the
+ * stored time is still the one it was started for, so a cancellation needs no
+ * event of its own — and an event sent from a transaction that then rolls back
+ * wakes a run that finds nothing to do.
+ *
+ * `previousDoc` is the latest version, not the live document, which is the
+ * right comparison here: a schedule lives on the latest version.
+ */
+export declare function createSendScheduledEventHook(args: {
+    inngest: Inngest;
+    scheduledPublishField: string;
+}): CollectionAfterChangeHook;
+//# sourceMappingURL=schedule-events.d.ts.map

package/dist/publishing/hooks/schedule-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule-events.d.ts","sourceRoot":"","sources":["../../../src/publishing/hooks/schedule-events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAA;AACxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAGtC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE;IACjD,OAAO,EAAE,OAAO,CAAA;IAChB,qBAAqB,EAAE,MAAM,CAAA;CAC9B,GAAG,yBAAyB,CA0B5B"}

package/dist/publishing/hooks/schedule-events.js

@@ -0,0 +1,54 @@
+import { sendEventSafely } from '../events.js';
+/**
+ * Sends `content/page.scheduled` when a document's scheduled publish time is
+ * set to a new value, by whatever route — the admin's Schedule control, the
+ * `schedule_publish` MCP tool, a REST write.
+ *
+ * On the collection rather than in the service because the field is the
+ * source of truth and the service is only one way to write it. A schedule that
+ * could be stored without the event would be a date nothing wakes up for,
+ * which is the defect this replaces.
+ *
+ * Nothing is sent for a cleared or unchanged time. The run sleeping on a
+ * schedule re-reads the document when it wakes and publishes only if the
+ * stored time is still the one it was started for, so a cancellation needs no
+ * event of its own — and an event sent from a transaction that then rolls back
+ * wakes a run that finds nothing to do.
+ *
+ * `previousDoc` is the latest version, not the live document, which is the
+ * right comparison here: a schedule lives on the latest version.
+ */
+export function createSendScheduledEventHook(args) {
+    const field = args.scheduledPublishField;
+    return async ({ collection, doc, previousDoc, req }) => {
+        const next = instant(doc?.[field]);
+        if (next === null)
+            return doc;
+        if (next === instant(previousDoc?.[field]))
+            return doc;
+        const id = doc.id;
+        if (id === undefined || id === null)
+            return doc;
+        const warning = await sendEventSafely(args.inngest, {
+            name: 'content/page.scheduled',
+            data: {
+                collection: collection.slug,
+                id: String(id),
+                scheduledFor: new Date(next).toISOString(),
+            },
+        });
+        if (warning) {
+            // The schedule is saved; only the on-time wake-up is lost. The daily
+            // backstop still finds the document once it is overdue.
+            req.payload.logger.warn({ collection: collection.slug, id }, `[publishing] ${warning}`);
+        }
+        return doc;
+    };
+}
+function instant(value) {
+    if (typeof value !== 'string')
+        return null;
+    const ms = Date.parse(value);
+    return Number.isNaN(ms) ? null : ms;
+}
+//# sourceMappingURL=schedule-events.js.map

package/dist/publishing/hooks/schedule-events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule-events.js","sourceRoot":"","sources":["../../../src/publishing/hooks/schedule-events.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAE9C;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,4BAA4B,CAAC,IAG5C;IACC,MAAM,KAAK,GAAG,IAAI,CAAC,qBAAqB,CAAA;IAExC,OAAO,KAAK,EAAE,EAAE,UAAU,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE,EAAE,EAAE;QACrD,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAA;QAClC,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,GAAG,CAAA;QAC7B,IAAI,IAAI,KAAK,OAAO,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC;YAAE,OAAO,GAAG,CAAA;QAEtD,MAAM,EAAE,GAAI,GAAwB,CAAC,EAAE,CAAA;QACvC,IAAI,EAAE,KAAK,SAAS,IAAI,EAAE,KAAK,IAAI;YAAE,OAAO,GAAG,CAAA;QAE/C,MAAM,OAAO,GAAG,MAAM,eAAe,CAAC,IAAI,CAAC,OAAO,EAAE;YAClD,IAAI,EAAE,wBAAwB;YAC9B,IAAI,EAAE;gBACJ,UAAU,EAAE,UAAU,CAAC,IAAI;gBAC3B,EAAE,EAAE,MAAM,CAAC,EAAE,CAAC;gBACd,YAAY,EAAE,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE;aAC3C;SACF,CAAC,CAAA;QACF,IAAI,OAAO,EAAE,CAAC;YACZ,qEAAqE;YACrE,wDAAwD;YACxD,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,gBAAgB,OAAO,EAAE,CAAC,CAAA;QACzF,CAAC;QACD,OAAO,GAAG,CAAA;IACZ,CAAC,CAAA;AACH,CAAC;AAED,SAAS,OAAO,CAAC,KAAc;IAC7B,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAA;IAC1C,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;IAC5B,OAAO,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAA;AACrC,CAAC"}

package/dist/publishing/index.d.ts

@@ -0,0 +1,35 @@
+export { publishingPlugin } from './plugin.js';
+export type { AccessibilityCheck, AccessibilityIssue, ActiveApproval, ApprovalResolver, PublishableCollection, PublishingPluginOptions, ResolvedCollection, } from './options.js';
+export type { PipelineContext, PipelineResult, PipelineStep, PipelineStepResult, } from './pipeline/index.js';
+/**
+ * Server-side publishing API. Use these from host code — a custom endpoint,
+ * a scheduled job, a Server Action — to run the full policy pipeline as a
+ * given user, with no API key and correct audit attribution.
+ */
+export { getPublishStatus, getPublishingService, publishDocument, scheduleDocument, unpublishDocument, unscheduleDocument, } from './service.js';
+export type { DocumentActionArgs, PublishOutcome, PublishRequest, PublishStatusOutcome, PublishingActor, PublishingService, ScheduleOutcome, ScheduleRequest, UnpublishOutcome, UnscheduleOutcome, } from './service.js';
+/**
+ * Whether the update in flight on this document is a draft write — a "Save
+ * draft", or a tick of autosave — rather than one that changes what the
+ * public sees.
+ *
+ * `afterChange` cannot work this out for itself. Payload sets
+ * `data._status = 'draft'` on any `draft: true` update before the hooks
+ * run, and `previousDoc` is the latest *version* rather than the live
+ * document, so a draft save of a published page and an unpublish of it look
+ * the same from inside the hook. The publishing plugin already records the
+ * operation's real `draft` argument in `beforeOperation` for its own trust
+ * boundary; this exposes the same answer to host hooks.
+ *
+ * With autosave on, a host `afterChange` that drops a cache or sends a
+ * notification fires every few seconds of typing unless it asks this first.
+ */
+export { isDraftWrite } from './hooks/draft-writes.js';
+export { BUILT_IN_ACCESSIBILITY_CHECKS, altTextCheck, headingHierarchyCheck, linkLabelsCheck, } from './checks/index.js';
+export { revalidateOnPublishJob } from './jobs/revalidate-on-publish.js';
+export { executeScheduledPublishesJob } from './jobs/execute-scheduled-publishes.js';
+export { publishAtScheduledTimeJob } from './jobs/publish-at-scheduled-time.js';
+export { createTagRevalidationHooks } from './jobs/revalidate-tag-hooks.js';
+export type { CollectionTagHookOptions, GlobalTagHookOptions, RevalidateTagFn, TagRevalidationHooks, TagRevalidationOptions, TagSelector, } from './jobs/revalidate-tag-hooks.js';
+export type { ExecuteScheduledPublishesOptions, PublishAtScheduledTimeOptions, RevalidateFn, RevalidateOnPublishOptions, RevalidatePathsInput, ScheduledCollectionConfig, ScheduledPublishRequest, ScheduledPublishResult, } from '../jobs/workflow-types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/publishing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/publishing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAE9C,YAAY,EACV,kBAAkB,EAClB,kBAAkB,EAClB,cAAc,EACd,gBAAgB,EAChB,qBAAqB,EACrB,uBAAuB,EACvB,kBAAkB,GACnB,MAAM,cAAc,CAAA;AAErB,YAAY,EACV,eAAe,EACf,cAAc,EACd,YAAY,EACZ,kBAAkB,GACnB,MAAM,qBAAqB,CAAA;AAE5B;;;;GAIG;AACH,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,cAAc,CAAA;AAErB,YAAY,EACV,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,eAAe,EACf,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,cAAc,CAAA;AAErB;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAGtD,OAAO,EACL,6BAA6B,EAC7B,YAAY,EACZ,qBAAqB,EACrB,eAAe,GAChB,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAA;AACxE,OAAO,EAAE,4BAA4B,EAAE,MAAM,uCAAuC,CAAA;AACpF,OAAO,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAA;AAC/E,OAAO,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAA;AAC3E,YAAY,EACV,wBAAwB,EACxB,oBAAoB,EACpB,eAAe,EACf,oBAAoB,EACpB,sBAAsB,EACtB,WAAW,GACZ,MAAM,gCAAgC,CAAA;AACvC,YAAY,EACV,gCAAgC,EAChC,6BAA6B,EAC7B,YAAY,EACZ,0BAA0B,EAC1B,oBAAoB,EACpB,yBAAyB,EACzB,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,2BAA2B,CAAA"}

package/dist/publishing/index.js

@@ -0,0 +1,32 @@
+export { publishingPlugin } from './plugin.js';
+/**
+ * Server-side publishing API. Use these from host code — a custom endpoint,
+ * a scheduled job, a Server Action — to run the full policy pipeline as a
+ * given user, with no API key and correct audit attribution.
+ */
+export { getPublishStatus, getPublishingService, publishDocument, scheduleDocument, unpublishDocument, unscheduleDocument, } from './service.js';
+/**
+ * Whether the update in flight on this document is a draft write — a "Save
+ * draft", or a tick of autosave — rather than one that changes what the
+ * public sees.
+ *
+ * `afterChange` cannot work this out for itself. Payload sets
+ * `data._status = 'draft'` on any `draft: true` update before the hooks
+ * run, and `previousDoc` is the latest *version* rather than the live
+ * document, so a draft save of a published page and an unpublish of it look
+ * the same from inside the hook. The publishing plugin already records the
+ * operation's real `draft` argument in `beforeOperation` for its own trust
+ * boundary; this exposes the same answer to host hooks.
+ *
+ * With autosave on, a host `afterChange` that drops a cache or sends a
+ * notification fires every few seconds of typing unless it asks this first.
+ */
+export { isDraftWrite } from './hooks/draft-writes.js';
+// Built-in accessibility checks, which were `@forumone/throughline-publishing/checks`.
+export { BUILT_IN_ACCESSIBILITY_CHECKS, altTextCheck, headingHierarchyCheck, linkLabelsCheck, } from './checks/index.js';
+// Revalidation and scheduled publishing, as jobs for either adapter in `/jobs`.
+export { revalidateOnPublishJob } from './jobs/revalidate-on-publish.js';
+export { executeScheduledPublishesJob } from './jobs/execute-scheduled-publishes.js';
+export { publishAtScheduledTimeJob } from './jobs/publish-at-scheduled-time.js';
+export { createTagRevalidationHooks } from './jobs/revalidate-tag-hooks.js';
+//# sourceMappingURL=index.js.map

package/dist/publishing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/publishing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAmB9C;;;;GAIG;AACH,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,cAAc,CAAA;AAerB;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAEtD,uFAAuF;AACvF,OAAO,EACL,6BAA6B,EAC7B,YAAY,EACZ,qBAAqB,EACrB,eAAe,GAChB,MAAM,mBAAmB,CAAA;AAE1B,gFAAgF;AAChF,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAA;AACxE,OAAO,EAAE,4BAA4B,EAAE,MAAM,uCAAuC,CAAA;AACpF,OAAO,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAA;AAC/E,OAAO,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAA"}

package/dist/publishing/jobs/execute-scheduled-publishes.d.ts

@@ -0,0 +1,24 @@
+import type { Job } from '../../jobs/types.js';
+import { type JobOptions } from '../../jobs/options.js';
+import type { ExecuteScheduledPublishesOptions } from '../../jobs/workflow-types.js';
+/**
+ * Cron-driven scheduled publish executor. Every tick (default: every 5
+ * minutes) the function looks for documents in any of the configured
+ * collections whose latest version is still a draft and whose
+ * `scheduledPublishAt` has passed, and calls `options.publish` for each.
+ *
+ * `publishAtScheduledTimeJob` does the same job on time and without
+ * polling. Run alongside it, this is the backstop — set `overdueByMs` and a
+ * slow schedule, and it only ever finds a document whose event went missing.
+ *
+ * `publish` must go through the publishing pipeline — see the option's own
+ * documentation for the wiring. That is what makes a scheduled publish get the
+ * same composition / accessibility / approval checks as an interactive one.
+ *
+ * A refusal is logged and does not throw; the document stays at
+ * `_status: draft` until an admin intervenes or a later tick succeeds.
+ * Throwing would retry indefinitely on a permanent error (a composition
+ * failure, say), which is wrong for cron-style work.
+ */
+export declare function executeScheduledPublishesJob(options: JobOptions<ExecuteScheduledPublishesOptions>): Job;
+//# sourceMappingURL=execute-scheduled-publishes.d.ts.map

package/dist/publishing/jobs/execute-scheduled-publishes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute-scheduled-publishes.d.ts","sourceRoot":"","sources":["../../../src/publishing/jobs/execute-scheduled-publishes.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAA;AAC9C,OAAO,EAAc,KAAK,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACnE,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,8BAA8B,CAAA;AAWpF;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,UAAU,CAAC,gCAAgC,CAAC,GACpD,GAAG,CAyGL"}