@glw907/cairn-cms 0.58.0 → 0.60.0

package/dist/nav/site-config.d.ts

@@ -34,8 +34,96 @@ export interface SiteConfig {
     menus?: Record<string, unknown>;
     /** Per-concept URL policy: the permalink pattern and date-prefix granularity, keyed by concept id. */
     content?: Record<string, ConceptUrlPolicy>;
+    /** The editor spellcheck settings. The dialect is declared once per site (spec 1.2), so a British
+     *  site loads the British word list and "colour" reads as correct. Today only US English ships, so an
+     *  unset or unknown dialect resolves to it. */
+    spellcheck?: {
+        dialect?: string;
+    };
+    /** The editor tidy (LLM copy-edit) settings. Opt-in at the site level (spec 2.8): tidy is a remote,
+     *  costly model call, so the whole block is optional and `enabled` defaults false. The model is a
+     *  developer-tier fact; the `conventions` block is the editor-tier per-convention config that builds
+     *  the prompt's CONVENTIONS section. The Anthropic API key is a Worker secret, never config. */
+    tidy?: TidyConfig;
     [key: string]: unknown;
 }
+/**
+ * The tidy block on the site config. Every field is optional so the YAML can carry as little as
+ * `tidy: { enabled: true }` and the defaults fill the rest.
+ */
+export interface TidyConfig {
+    /** Master switch. Default false; tidy is opt-in (spec 2.8, decision 1). */
+    enabled?: boolean;
+    /** The model id. Default `claude-sonnet-4-6`; the alternative is `claude-haiku-4-5` (spec 2.2). */
+    model?: string;
+    /** The per-convention toggles that build the prompt's CONVENTIONS section. */
+    conventions?: Partial<TidyConventions>;
+}
+/** The default tidy model when a site sets none: Sonnet, the judgment floor for a light copy-edit. */
+export declare const DEFAULT_TIDY_MODEL = "claude-sonnet-4-6";
+/**
+ * The corrected convention set (spec "The corrected convention set"), the resolved shape the prompt
+ * builder consumes. Every field carries a concrete value; `resolveTidyConventions` fills the defaults
+ * from a partial config. The Fixes group is the objective fixes (default on, governed by the always-on
+ * core); the style tier defaults off (a falsy variant means off); the advanced tier defaults off.
+ * Sentence spacing is dropped on purpose and regional spelling is `spellcheck.dialect`, not a toggle.
+ */
+export interface TidyConventions {
+    /** The objective Fixes group (spelling, grammar, doubled words, whitespace, capitals, terminal
+     *  punctuation). Default on. The always-on core governs it; this toggle lets the screen turn the
+     *  group off. */
+    fixes: boolean;
+    /** Oxford comma position. Off when undefined; `always` | `complex-only` (AP) | `never`. */
+    oxfordComma?: 'always' | 'complex-only' | 'never';
+    /** Number style threshold. Off when undefined; the always-numeral exception sets (ages, dates,
+     *  measurements, percentages) apply at any threshold. */
+    numberStyle?: 'under-ten' | 'under-hundred' | 'always-numerals';
+    /** Measurement notation only (never the system, never the number). Off when undefined. */
+    measurements?: 'abbreviate' | 'spell-out';
+    /** Percent rendering. Off when undefined; `sign` is "%", `word` is "percent". */
+    percent?: 'sign' | 'word';
+    /** Em-dash spacing. Off when undefined. */
+    emDash?: 'spaced' | 'closed';
+    /** Turn a hyphen between two numbers into an en dash. Default off. */
+    enDashRanges: boolean;
+    /** Ellipsis rendering. Off when undefined. */
+    ellipsis?: 'single-char' | 'three-dots';
+    /** Time format. Off when undefined. */
+    timeFormat?: '5 PM' | '5pm' | '5 p.m.';
+    /** Advanced: convert straight quotes to curly with the full apostrophe rule set. Default off. */
+    smartQuotes: boolean;
+    /** Advanced: correct brand and proper-noun capitalization on a curated list only. Default off. */
+    brandCaps: boolean;
+}
+/** The resting tidy convention set: Fixes on, every style and advanced toggle off. */
+export declare function defaultTidyConventions(): TidyConventions;
+/**
+ * Resolve a partial conventions config (from the YAML) into the concrete TidyConventions the prompt
+ * builder consumes. An absent field falls to its default: Fixes on, the style and advanced toggles
+ * off. A multi-position toggle stays undefined (off) unless the config names a variant.
+ */
+export declare function resolveTidyConventions(partial: Partial<TidyConventions> | undefined): TidyConventions;
+export declare class TidyConventionsError extends Error {
+    /** A malformed settings payload maps to the same diagnostic as a malformed config. */
+    readonly conditionId = "config.site-config-invalid";
+    constructor(message: string);
+}
+/**
+ * Validate and normalize an untrusted conventions object (from the settings form) into a concrete
+ * TidyConventions. This input is committed to the repo, so every field is bounded to its known set:
+ * a boolean toggle must be a boolean, and a multi-position toggle must be one of its listed variants
+ * or absent (off). An unknown key is dropped rather than carried, so the committed block can never
+ * grow a junk key. Throws TidyConventionsError on a value outside its allowed set.
+ */
+export declare function validateTidyConventions(value: unknown): TidyConventions;
+/** The dialect string when a site sets none: US English, the only dictionary that ships today. */
+export declare const DEFAULT_DIALECT = "en-US";
+/**
+ * The dictionary asset file for a site's configured dialect, defaulting to US English. The main thread
+ * resolves this filename to a real URL (the spike's out-of-bundle asset) and hands it to the Worker in
+ * the `init` message; the Worker never reads config. An unknown dialect falls back to the default file.
+ */
+export declare function dictionaryFileForDialect(dialect: string | undefined): string;
 export declare class SiteConfigError extends Error {
     /** The registered diagnostic condition a malformed site config maps to (mirrors CairnError). */
     readonly conditionId = "config.site-config-invalid";
@@ -54,3 +142,13 @@ export declare function urlPolicyFrom(config: SiteConfig): Record<string, Concep
  * serializes without `url`/`children` keys.
  */
 export declare function setMenu(raw: string, name: string, tree: NavNode[]): string;
+/**
+ * Write the editor-tier tidy conventions into the YAML site-config text and reserialize, preserving
+ * every other top-level key and the file's comments and key order (parseDocument round-trips both,
+ * the same machinery setMenu uses). Only the `tidy.conventions` block is touched: the developer-tier
+ * `tidy.enabled` and `tidy.model` are read-only in the screen, so this leaves them as they are and a
+ * save can never silently flip the deploy-time facts. A convention whose value is undefined (a
+ * collapsed multi-position toggle, off) is dropped, so the committed block carries only the on
+ * toggles, the same shape `resolveTidyConventions` fills the defaults back from on read.
+ */
+export declare function setTidy(raw: string, conventions: Partial<TidyConventions>): string;

package/dist/nav/site-config.js

@@ -59,6 +59,114 @@ export function validateNavTree(value, maxDepth) {
     }
     return walk(value, 1);
 }
+/** The default tidy model when a site sets none: Sonnet, the judgment floor for a light copy-edit. */
+export const DEFAULT_TIDY_MODEL = 'claude-sonnet-4-6';
+/** The resting tidy convention set: Fixes on, every style and advanced toggle off. */
+export function defaultTidyConventions() {
+    return { fixes: true, enDashRanges: false, smartQuotes: false, brandCaps: false };
+}
+/**
+ * Resolve a partial conventions config (from the YAML) into the concrete TidyConventions the prompt
+ * builder consumes. An absent field falls to its default: Fixes on, the style and advanced toggles
+ * off. A multi-position toggle stays undefined (off) unless the config names a variant.
+ */
+export function resolveTidyConventions(partial) {
+    const base = defaultTidyConventions();
+    if (partial === undefined)
+        return base;
+    return {
+        fixes: partial.fixes ?? base.fixes,
+        oxfordComma: partial.oxfordComma,
+        numberStyle: partial.numberStyle,
+        measurements: partial.measurements,
+        percent: partial.percent,
+        emDash: partial.emDash,
+        enDashRanges: partial.enDashRanges ?? base.enDashRanges,
+        ellipsis: partial.ellipsis,
+        timeFormat: partial.timeFormat,
+        smartQuotes: partial.smartQuotes ?? base.smartQuotes,
+        brandCaps: partial.brandCaps ?? base.brandCaps,
+    };
+}
+// The allowed values for each multi-position style toggle, the single source the validator checks an
+// untrusted settings payload against. A value outside its list is rejected, so the committed YAML can
+// only ever carry a known variant the prompt builder understands.
+const OXFORD_COMMA_VALUES = ['always', 'complex-only', 'never'];
+const NUMBER_STYLE_VALUES = ['under-ten', 'under-hundred', 'always-numerals'];
+const MEASUREMENTS_VALUES = ['abbreviate', 'spell-out'];
+const PERCENT_VALUES = ['sign', 'word'];
+const EM_DASH_VALUES = ['spaced', 'closed'];
+const ELLIPSIS_VALUES = ['single-char', 'three-dots'];
+const TIME_FORMAT_VALUES = ['5 PM', '5pm', '5 p.m.'];
+export class TidyConventionsError extends Error {
+    /** A malformed settings payload maps to the same diagnostic as a malformed config. */
+    conditionId = 'config.site-config-invalid';
+    constructor(message) {
+        super(message);
+        this.name = 'TidyConventionsError';
+    }
+}
+/**
+ * Validate and normalize an untrusted conventions object (from the settings form) into a concrete
+ * TidyConventions. This input is committed to the repo, so every field is bounded to its known set:
+ * a boolean toggle must be a boolean, and a multi-position toggle must be one of its listed variants
+ * or absent (off). An unknown key is dropped rather than carried, so the committed block can never
+ * grow a junk key. Throws TidyConventionsError on a value outside its allowed set.
+ */
+export function validateTidyConventions(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new TidyConventionsError('Tidy conventions must be an object');
+    }
+    const input = value;
+    function bool(key, fallback) {
+        const v = input[key];
+        if (v === undefined)
+            return fallback;
+        if (typeof v !== 'boolean')
+            throw new TidyConventionsError(`${key} must be true or false`);
+        return v;
+    }
+    function variant(key, allowed) {
+        const v = input[key];
+        if (v === undefined || v === null || v === false)
+            return undefined;
+        if (typeof v !== 'string' || !allowed.includes(v)) {
+            throw new TidyConventionsError(`${key} must be one of ${allowed.join(', ')}`);
+        }
+        return v;
+    }
+    return {
+        fixes: bool('fixes', true),
+        oxfordComma: variant('oxfordComma', OXFORD_COMMA_VALUES),
+        numberStyle: variant('numberStyle', NUMBER_STYLE_VALUES),
+        measurements: variant('measurements', MEASUREMENTS_VALUES),
+        percent: variant('percent', PERCENT_VALUES),
+        emDash: variant('emDash', EM_DASH_VALUES),
+        enDashRanges: bool('enDashRanges', false),
+        ellipsis: variant('ellipsis', ELLIPSIS_VALUES),
+        timeFormat: variant('timeFormat', TIME_FORMAT_VALUES),
+        smartQuotes: bool('smartQuotes', false),
+        brandCaps: bool('brandCaps', false),
+    };
+}
+/** The dialect string when a site sets none: US English, the only dictionary that ships today. */
+export const DEFAULT_DIALECT = 'en-US';
+// The dialect-to-dictionary map. Only US English ships now; a new locale adds one entry here and one
+// committed dictionary file under spellcheck-assets, and the rest of the chain (the main-thread URL
+// resolution, the worker fetch) needs no change. An unknown or unset dialect falls back to the default
+// rather than throwing, so a typo or a future-locale config never breaks the editor.
+const DICTIONARY_BY_DIALECT = {
+    'en-US': 'dictionary-en-us.txt',
+};
+/**
+ * The dictionary asset file for a site's configured dialect, defaulting to US English. The main thread
+ * resolves this filename to a real URL (the spike's out-of-bundle asset) and hands it to the Worker in
+ * the `init` message; the Worker never reads config. An unknown dialect falls back to the default file.
+ */
+export function dictionaryFileForDialect(dialect) {
+    const key = dialect ?? DEFAULT_DIALECT;
+    return DICTIONARY_BY_DIALECT[key] ?? DICTIONARY_BY_DIALECT[DEFAULT_DIALECT];
+}
 export class SiteConfigError extends Error {
     /** The registered diagnostic condition a malformed site config maps to (mirrors CairnError). */
     conditionId = 'config.site-config-invalid';
@@ -104,3 +212,27 @@ export function setMenu(raw, name, tree) {
     doc.setIn(['menus', name], tree);
     return doc.toString();
 }
+/**
+ * Write the editor-tier tidy conventions into the YAML site-config text and reserialize, preserving
+ * every other top-level key and the file's comments and key order (parseDocument round-trips both,
+ * the same machinery setMenu uses). Only the `tidy.conventions` block is touched: the developer-tier
+ * `tidy.enabled` and `tidy.model` are read-only in the screen, so this leaves them as they are and a
+ * save can never silently flip the deploy-time facts. A convention whose value is undefined (a
+ * collapsed multi-position toggle, off) is dropped, so the committed block carries only the on
+ * toggles, the same shape `resolveTidyConventions` fills the defaults back from on read.
+ */
+export function setTidy(raw, conventions) {
+    const doc = parseDocument(raw);
+    if (doc.get('siteName') === undefined) {
+        throw new SiteConfigError('Site config must be a mapping with a siteName');
+    }
+    // Drop undefined-valued keys (a collapsed multi-position toggle) so the committed YAML carries only
+    // the enabled conventions; the resolver fills the rest back from defaults on read.
+    const block = {};
+    for (const [key, value] of Object.entries(conventions)) {
+        if (value !== undefined)
+            block[key] = value;
+    }
+    doc.setIn(['tidy', 'conventions'], block);
+    return doc.toString();
+}

package/dist/sveltekit/admin-dispatch.d.ts

@@ -19,6 +19,8 @@ export type AdminView = {
     view: 'nav';
 } | {
     view: 'media';
+} | {
+    view: 'settings';
 };
 /**
  * Parse a raw `URL.pathname` (the caller passes `event.url.pathname`, never a SvelteKit rest

package/dist/sveltekit/admin-dispatch.js

@@ -3,8 +3,8 @@ import { isValidId } from '../content/ids.js';
 /**
  * Fixed first segments that never resolve as concepts. The engine only allows posts and pages
  * today, so no collision is possible, but the parser does not depend on that: a reserved
- * segment wins before concept lookup. `settings` has no view yet; AdminLayout already links
- * the sidebar to /admin/settings, so the URL is spoken for.
+ * segment wins before concept lookup. `settings`, `nav`, and `media` are decided as views below,
+ * so they are not in this no-view set.
  */
 const RESERVED_SEGMENTS = new Set(['login', 'auth', 'editors', 'nav', 'settings']);
 /**
@@ -47,6 +47,10 @@ export function parseAdminPath(pathname, concepts) {
         // concept), which is the correct shape.
         if (head === 'media')
             return { view: 'media' };
+        // settings is its own view, a peer of editors and nav. /admin/settings/<anything> 404s naturally
+        // (the two-segment branch never matches settings), which is the correct shape.
+        if (head === 'settings')
+            return { view: 'settings' };
         if (RESERVED_SEGMENTS.has(head))
             return null;
         const concept = findConcept(concepts, head);

package/dist/sveltekit/cairn-admin.d.ts

@@ -1,4 +1,4 @@
-import { type ContentRoutesDeps, type LayoutData, type ListData, type EditData, type MediaLibraryData } from './content-routes.js';
+import { type ContentRoutesDeps, type LayoutData, type ListData, type EditData, type MediaLibraryData, type SettingsData } from './content-routes.js';
 import { type NavLoadData } from './nav-routes.js';
 import type { AuthBranding, SendMagicLink } from '../email.js';
 import type { AuthEnv, Editor } from '../auth/types.js';
@@ -21,6 +21,11 @@ export interface CairnAdminDeps {
     branding?: AuthBranding;
     send?: SendMagicLink;
     mintToken?: ContentRoutesDeps['mintToken'];
+    /** Build the Anthropic client for the tidy action. Forwarded to the content routes; a site that
+     *  enables tidy injects a stub here to avoid a real network call. Defaults to the real SDK client. */
+    anthropic?: ContentRoutesDeps['anthropic'];
+    /** The tidy action's own request deadline in milliseconds. Forwarded to the content routes. */
+    tidyTimeoutMs?: ContentRoutesDeps['tidyTimeoutMs'];
 }
 /**
  * One admin view's data, discriminated for the admin page component's switch. The public
@@ -65,6 +70,10 @@ export type AdminData = {
     view: 'media';
     layout: LayoutData;
     page: MediaLibraryData;
+} | {
+    view: 'settings';
+    layout: LayoutData;
+    page: SettingsData;
 };
 export declare function createCairnAdmin(runtime: CairnRuntime, deps?: CairnAdminDeps): {
     load: (event: AdminEvent) => Promise<AdminData>;
@@ -74,10 +83,13 @@ export declare function createCairnAdmin(runtime: CairnRuntime, deps?: CairnAdmi
         logout: (event: AdminEvent) => Promise<never>;
         create: (event: AdminEvent) => Promise<never>;
         save: (event: AdminEvent) => Promise<import("@sveltejs/kit").ActionFailure<unknown>>;
+        saveSettings: (event: AdminEvent) => Promise<never>;
         upload: (event: AdminEvent) => Promise<import("./content-routes.js").UploadResult | import("@sveltejs/kit").ActionFailure<unknown>>;
         publish: (event: AdminEvent) => Promise<import("@sveltejs/kit").ActionFailure<unknown>>;
         discard: (event: AdminEvent) => Promise<never>;
         rename: (event: AdminEvent) => Promise<import("@sveltejs/kit").ActionFailure<unknown>>;
+        addDictionaryWord: (event: AdminEvent) => Promise<import("./content-routes.js").DictionaryAddResult | import("@sveltejs/kit").ActionFailure<unknown>>;
+        tidy: (event: AdminEvent) => Promise<import("./content-routes.js").TidyResult | import("@sveltejs/kit").ActionFailure<unknown>>;
         delete: (event: AdminEvent) => Promise<import("@sveltejs/kit").ActionFailure<unknown>>;
         mediaDelete: (event: AdminEvent) => Promise<import("@sveltejs/kit").ActionFailure<unknown>>;
         mediaUpdate: (event: AdminEvent) => Promise<import("@sveltejs/kit").ActionFailure<unknown>>;
@@ -86,6 +98,9 @@ export declare function createCairnAdmin(runtime: CairnRuntime, deps?: CairnAdmi
         mediaReplace: (event: AdminEvent) => Promise<import("@sveltejs/kit").ActionFailure<unknown>>;
         mediaAltPreview: (event: AdminEvent) => Promise<import("./content-routes.js").MediaAltPreviewPlan | import("@sveltejs/kit").ActionFailure<unknown>>;
         mediaAltPropagate: (event: AdminEvent) => Promise<import("@sveltejs/kit").ActionFailure<unknown>>;
+        mediaBulkDelete: (event: AdminEvent) => Promise<import("./content-routes.js").MediaBulkDeleteResult | import("@sveltejs/kit").ActionFailure<unknown>>;
+        mediaOrphanScan: (event: AdminEvent) => Promise<import("../media/orphan-scan.js").OrphanScan | import("@sveltejs/kit").ActionFailure<unknown>>;
+        mediaPurge: (event: AdminEvent) => Promise<import("./content-routes.js").MediaOrphanPurgeResult | import("@sveltejs/kit").ActionFailure<unknown>>;
         publishAll: (event: AdminEvent) => Promise<never>;
         addEditor: (event: AdminEvent) => Promise<import("@sveltejs/kit").ActionFailure<{
             error: string;

package/dist/sveltekit/cairn-admin.js

@@ -19,7 +19,11 @@ export function createCairnAdmin(runtime, deps = {}) {
         replyTo: runtime.sender.replyTo,
     };
     const auth = createAuthRoutes({ branding, send: deps.send });
-    const content = createContentRoutes(runtime, { mintToken: deps.mintToken });
+    const content = createContentRoutes(runtime, {
+        mintToken: deps.mintToken,
+        anthropic: deps.anthropic,
+        tidyTimeoutMs: deps.tidyTimeoutMs,
+    });
     const editors = createEditorRoutes();
     // The nav surface exists only when the site configures a menu; without one its view is a 404.
     const nav = runtime.navMenu ? createNavRoutes(runtime, { mintToken: deps.mintToken }) : null;
@@ -82,6 +86,11 @@ export function createCairnAdmin(runtime, deps = {}) {
                 const [layout, page] = await Promise.all([content.layoutLoad(delegated), content.mediaLibraryLoad(delegated)]);
                 return { view: 'media', layout, page };
             }
+            case 'settings': {
+                const delegated = contentEvent(event, {});
+                const [layout, page] = await Promise.all([content.layoutLoad(delegated), content.settingsLoad(delegated)]);
+                return { view: 'settings', layout, page };
+            }
         }
     }
     /** Wrap a delegate in the parse-and-check every action shares: parse the pathname exactly
@@ -97,9 +106,9 @@ export function createCairnAdmin(runtime, deps = {}) {
         };
     }
     // The topbar posts publishAll from every authed admin page; login and confirm may not.
-    const authedViews = ['list', 'edit', 'editors', 'nav', 'media'];
+    const authedViews = ['list', 'edit', 'editors', 'nav', 'media', 'settings'];
     // An editor signs out from wherever they are, so logout accepts any parsed view.
-    const anyView = ['index', 'login', 'confirm', 'list', 'edit', 'editors', 'nav', 'media'];
+    const anyView = ['index', 'login', 'confirm', 'list', 'edit', 'editors', 'nav', 'media', 'settings'];
     /** The full admin action vocabulary, one named async function per action, so a site's
      *  catch-all route exports `admin.actions` directly. Each wrapper stays thin: parse,
      *  validate the view, synthesize the params the wrapped action reads, delegate. The
@@ -116,10 +125,20 @@ export function createCairnAdmin(runtime, deps = {}) {
                 throw error(404, 'Not found');
             return nav.navSave(contentEvent(event, {}));
         }),
+        // The tidy settings save (spec 2.8, Task 15): the editor commits the per-convention block to the
+        // committed YAML. Gated to the settings view, so it 404s elsewhere; the action itself 404s again
+        // when tidy is off, the server half of the truthful visibility gate.
+        saveSettings: viewAction(['settings'], (event) => content.settingsSave(contentEvent(event, {}))),
         upload: viewAction(['edit'], (event, view) => content.uploadAction(contentEvent(event, { concept: view.concept.id, id: view.id }))),
         publish: viewAction(['edit'], (event, view) => content.publishAction(contentEvent(event, { concept: view.concept.id, id: view.id }))),
         discard: viewAction(['edit'], (event, view) => content.discardAction(contentEvent(event, { concept: view.concept.id, id: view.id }))),
         rename: viewAction(['edit'], (event, view) => content.renameAction(contentEvent(event, { concept: view.concept.id, id: view.id }))),
+        // The personal-dictionary add (spec 1.6): the editor commits its pending add-to-dictionary words at
+        // save time. Gated to the edit view, where the spellcheck surface lives, so it 404s elsewhere.
+        addDictionaryWord: viewAction(['edit'], (event, view) => content.addDictionaryWord(contentEvent(event, { concept: view.concept.id, id: view.id }))),
+        // Tidy (spec 2.1): the editor posts the buffer to `?/tidy` for a light LLM copy-edit. Gated to the
+        // edit view, where the review surface lives, so it 404s elsewhere.
+        tidy: viewAction(['edit'], (event, view) => content.tidyAction(contentEvent(event, { concept: view.concept.id, id: view.id }))),
         delete: viewAction(['edit', 'list'], (event, view) => view.view === 'edit'
             ? content.deleteAction(contentEvent(event, { concept: view.concept.id, id: view.id }))
             : content.listDeleteAction(contentEvent(event, { concept: view.concept.id }))),
@@ -134,6 +153,12 @@ export function createCairnAdmin(runtime, deps = {}) {
         mediaReplace: viewAction(['media'], (event) => content.mediaReplaceApply(contentEvent(event, {}))),
         mediaAltPreview: viewAction(['media'], (event) => content.mediaAltPreview(contentEvent(event, {}))),
         mediaAltPropagate: viewAction(['media'], (event) => content.mediaAltApply(contentEvent(event, {}))),
+        // Pass C library actions: a multi-select bulk delete, the on-demand orphan scan, and the
+        // irreversible byte purge. The component posts to `?/mediaBulkDelete`, `?/mediaOrphanScan`, and
+        // `?/mediaPurge` (the purge key is short of its content method name). All gate on the media view.
+        mediaBulkDelete: viewAction(['media'], (event) => content.mediaBulkDelete(contentEvent(event, {}))),
+        mediaOrphanScan: viewAction(['media'], (event) => content.mediaOrphanScan(contentEvent(event, {}))),
+        mediaPurge: viewAction(['media'], (event) => content.mediaPurgeOrphans(contentEvent(event, {}))),
         publishAll: viewAction(authedViews, (event) => content.publishAllAction(contentEvent(event, {}))),
         addEditor: viewAction(['editors'], (event) => editors.addEditorAction(event)),
         removeEditor: viewAction(['editors'], (event) => editors.removeEditorAction(event)),