@o-a/cms-agent 0.1.0

package/dist/services/batch.js

@@ -0,0 +1,136 @@
+import { DraftError, prepareDiscardDraft, prepareSaveDraft } from "./drafts.js";
+import { DeleteContentError, prepareDeleteContent } from "./delete-content.js";
+import { commitPaths } from "./git.js";
+import { MoveError, prepareMovePage } from "./move.js";
+import { PublishError, preparePublishDrafts } from "./publish.js";
+import { enqueue } from "./write-queue.js";
+export class BatchError extends Error {
+    reason;
+    // Which part of the batch failed. operationIndex indexes into the
+    // operations array; the trailing publish step is a distinct stage,
+    // not folded into that same index space (index 3 could otherwise
+    // ambiguously mean "the 4th operation" or "there were only 3
+    // operations, so this must be publish").
+    stage;
+    operationIndex;
+    constructor(reason, message, options) {
+        super(message, { cause: options?.cause });
+        this.name = 'BatchError';
+        this.reason = reason;
+        this.stage = options?.stage;
+        this.operationIndex = options?.operationIndex;
+    }
+}
+// No whole-batch duplicate-path pre-check: rejected in design review.
+// publishDrafts's own internal duplicate check exists because its
+// rollback restores multiple snapshots in *forward* order within a
+// single call - a real hazard specific to that shape. Undo across
+// batch *operations* runs in *reverse* chronological order instead
+// (see batchJob below), which composes correctly even when multiple
+// operations touch the same path (e.g. move A->B then content-delete
+// B in the same batch unwinds correctly: undo delete restores B to
+// what move wrote, then undo move renames B back to A). Genuine
+// conflicts (two moves to the same destination, etc.) are already
+// caught fresh by each sub-service's own real-time validation when it
+// runs, precisely because processing is sequential.
+async function runOperation(config, themeSchemas, operation) {
+    switch (operation.type) {
+        case 'draft-write':
+            return prepareSaveDraft(config, themeSchemas, operation.path, operation.content, operation.expectedEtag);
+        case 'draft-discard':
+            return prepareDiscardDraft(config, operation.path);
+        case 'content-delete':
+            return prepareDeleteContent(config, operation.path, operation.redirectTo);
+        case 'move':
+            return prepareMovePage(config, operation.from, operation.to);
+    }
+}
+function reasonFromError(error) {
+    if (error instanceof DraftError ||
+        error instanceof DeleteContentError ||
+        error instanceof MoveError ||
+        error instanceof PublishError) {
+        return error.reason;
+    }
+    return undefined;
+}
+async function batchJob(config, themeSchemas, operations, publish, message, author) {
+    const allPaths = [];
+    const undoStack = [];
+    // Sequential, not two-phase validate-then-write: operations can be
+    // order-dependent within a single batch (e.g. write a draft, then
+    // publish that same draft, in one call) - a later step's validation
+    // may depend on an earlier step's write having already happened.
+    for (let index = 0; index < operations.length; index++) {
+        const operation = operations[index];
+        try {
+            const prepared = await runOperation(config, themeSchemas, operation);
+            allPaths.push(...prepared.paths);
+            undoStack.push(prepared.undo);
+        }
+        catch (error) {
+            await rollbackAndThrow(undoStack, error, { stage: 'operation', operationIndex: index });
+        }
+    }
+    if (publish) {
+        try {
+            const prepared = preparePublishDrafts(config, themeSchemas, publish.relativePaths);
+            allPaths.push(...prepared.paths);
+            undoStack.push(prepared.undo);
+        }
+        catch (error) {
+            await rollbackAndThrow(undoStack, error, { stage: 'publish' });
+        }
+    }
+    // A batch of pure draft-write/draft-discard operations legitimately
+    // produces zero git-tracked paths (drafts are never git-tracked).
+    // git commit with nothing staged exits non-zero ("nothing to
+    // commit") - verified empirically - which would otherwise produce a
+    // spurious commit-failed (or a spurious full rollback) for a batch
+    // that did nothing wrong. Skip the commit entirely when there is
+    // nothing to stage.
+    if (allPaths.length === 0) {
+        return;
+    }
+    try {
+        commitPaths(config.siteRoot, allPaths, message, author);
+    }
+    catch (error) {
+        await rollbackAndThrow(undoStack, error, {});
+    }
+}
+// Runs every already-succeeded operation's undo, in reverse order,
+// then throws. Never returns normally - always throws either
+// BatchError('rollback-failed') (if any undo itself failed) or a
+// BatchError carrying the original failure's own reason.
+async function rollbackAndThrow(undoStack, cause, context) {
+    const failures = [];
+    for (const undo of [...undoStack].reverse()) {
+        failures.push(...undo());
+    }
+    if (failures.length > 0) {
+        throw new BatchError('rollback-failed', 'Batch failed and rolling back afterwards also failed; the working tree may be inconsistent and needs manual inspection', { cause, ...context });
+    }
+    const reason = reasonFromError(cause);
+    if (reason) {
+        const detail = cause instanceof Error ? cause.message : String(cause);
+        throw new BatchError(reason, `Batch failed: ${detail}`, { cause, ...context });
+    }
+    // context.stage is only ever set when this was called from the
+    // operations/publish loop, never from the post-loop commitPaths call
+    // below - so a non-domain error reaching here (e.g. PathSafetyError
+    // thrown by sanitisePath deep inside a prepareX function) came from
+    // there too. Rethrow it as-is rather than mislabelling it
+    // 'commit-failed': callers up the stack (the route's own
+    // PathSafetyError check) need to see the original error type.
+    if (context.stage) {
+        throw cause;
+    }
+    // No stage means this can only have come from the commitPaths call
+    // just above, which only ever throws GitOperationError.
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    throw new BatchError('commit-failed', `Batch failed: ${detail}`, { cause, ...context });
+}
+export function runBatch(config, themeSchemas, operations, publish, message, author) {
+    return enqueue(() => batchJob(config, themeSchemas, operations, publish, message, author));
+}

package/dist/services/checkpoint.d.ts

@@ -0,0 +1,4 @@
+import type { SiteConfig } from '../config.ts';
+import type { CommitAuthor } from './git.ts';
+export declare const CHECKPOINT_AUTHOR: CommitAuthor;
+export declare function runCheckpoint(config: SiteConfig, author: CommitAuthor): Promise<'committed' | 'clean'>;

package/dist/services/checkpoint.js

@@ -0,0 +1,45 @@
+import { execFileSync } from 'node:child_process';
+import { relative } from 'node:path';
+import { CHECKPOINT_MESSAGE } from "./git-history.js";
+import { commitPaths } from "./git.js";
+import { enqueue } from "./write-queue.js";
+// Resolves the checklist's own carried-forward open question 3: the
+// same shape of question boot.ts already declined to answer for
+// boot-time migrations. A fixed, hardcoded in-code identity - not
+// configurable per-site - so this never depends on host config
+// (matching the Phase 1 sign-off that commits never fall back to
+// ~/.gitconfig), and there's zero possibility of a site operator
+// misconfiguring or omitting it.
+export const CHECKPOINT_AUTHOR = { name: 'CMS Agent', email: 'agent@localhost' };
+async function checkpointJob(config, author) {
+    // Derived from config.draftsRoot, never a hardcoded literal - Group N
+    // nested draftsRoot inside contentRoot (content/drafts), so a fixed
+    // 'drafts' pathspec would silently match nothing there, making this
+    // checkpoint a permanent no-op with zero error output. Always
+    // relative to siteRoot, matching commitPaths'/git status's own
+    // pathspec convention below.
+    const draftsPathspec = relative(config.siteRoot, config.draftsRoot);
+    // "When drafts have changed" (checklist H4) - checked before ever
+    // staging/committing, matching the empty-commit lesson batch.ts and
+    // git-revert.ts already learned: git commit with nothing staged
+    // exits non-zero, which must not surface as a spurious failure for
+    // a checkpoint tick that legitimately had nothing to do.
+    const status = execFileSync('git', ['status', '--porcelain', '--', draftsPathspec], {
+        cwd: config.siteRoot,
+    }).toString('utf-8');
+    if (status.trim().length === 0) {
+        return 'clean';
+    }
+    // Reuses commitPaths (not commitWorkingTree, which stages the
+    // *entire* working tree) - scoped to a single drafts-directory
+    // pathspec. Verified empirically that a bare pathspec (no -A flag)
+    // correctly stages both modifications and deletions under that
+    // directory, essential since a discarded draft (a pure fs removal
+    // today, no git call) must be captured by the next checkpoint as a
+    // real change, not silently missed.
+    commitPaths(config.siteRoot, [draftsPathspec], CHECKPOINT_MESSAGE, author);
+    return 'committed';
+}
+export function runCheckpoint(config, author) {
+    return enqueue(() => checkpointJob(config, author));
+}

package/dist/services/content-read.d.ts

@@ -0,0 +1,27 @@
+import type { SiteConfig } from '../config.ts';
+export type ContentReadReason = 'not-found';
+export declare class ContentReadError extends Error {
+    readonly reason: ContentReadReason;
+    constructor(reason: ContentReadReason, message: string);
+}
+export interface ReadResult {
+    bytes: Buffer;
+    etag: string;
+}
+export declare function readContentFile(root: string, relativePath: string): ReadResult;
+export interface ContentListFilters {
+    type?: string;
+    prefix?: string;
+    draftStatus?: 'has-draft' | 'no-draft';
+}
+export interface ContentListEntry {
+    path: string;
+    name: string;
+    title: string;
+    type: string;
+    published: boolean;
+    hasDraft: boolean;
+    url: string | null;
+    changedAt: string | null;
+}
+export declare function listContent(config: SiteConfig, filters: ContentListFilters): ContentListEntry[];

package/dist/services/content-read.js

@@ -0,0 +1,156 @@
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { computeEtag } from "./etag.js";
+import { listFilesRecursively } from "./fs-walk.js";
+import { sanitisePath } from "./path-safety.js";
+import { pagePathToUrl } from "./urls.js";
+import { postPathToUrl } from "./post-urls.js";
+export class ContentReadError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.name = 'ContentReadError';
+        this.reason = reason;
+    }
+}
+// Shared by both content.ts (root = config.contentRoot) and drafts.ts
+// (root = config.draftsRoot) - identical read+hash logic, just a
+// different root. sanitisePath's PathSafetyError is left to propagate
+// uncaught: the route handlers catch it explicitly and map it to 404,
+// the same precedent preview.ts already established (PathSafetyError
+// has no .statusCode, so left uncaught it would fall through to the
+// global handler's generic sanitised 500).
+export function readContentFile(root, relativePath) {
+    const fullPath = sanitisePath(root, relativePath);
+    if (!existsSync(fullPath)) {
+        throw new ContentReadError('not-found', `No file at "${relativePath}"`);
+    }
+    const bytes = readFileSync(fullPath);
+    return { bytes, etag: computeEtag(bytes) };
+}
+// Both contentRoot-relative live paths and draftsRoot-relative draft
+// paths share the identical pages/posts/menus subroot prefix shape
+// (content/drafts/ mirrors content/'s own layout), so one function
+// handles both with no branching on which root an entry came from.
+// Menus have no public URL - there is no preview route for them.
+function computeContentUrl(relativePath) {
+    if (relativePath.startsWith('pages/')) {
+        return pagePathToUrl(relativePath.slice('pages/'.length));
+    }
+    if (relativePath.startsWith('posts/')) {
+        return postPathToUrl(relativePath.slice('posts/'.length));
+    }
+    return null;
+}
+// The later of the live file's and the draft's own mtime, whichever
+// exist - a page with a pending draft edit should show that edit's
+// recency, not just whichever file readSummary happened to prefer.
+// File mtime, not a git commit date: a per-path git-log call for
+// every entry in a listing that can run to hundreds of pages isn't
+// viable, and mtime is a reasonable proxy for "last touched" - a
+// known, accepted imprecision (e.g. a fresh git clone/checkout can
+// reset it), not a claim of exact publish history (that's what the
+// page history view's own real git log is for).
+function latestMtime(candidatePaths) {
+    let latest = null;
+    for (const fullPath of candidatePaths) {
+        try {
+            const { mtime } = statSync(fullPath);
+            if (latest === null || mtime > latest) {
+                latest = mtime;
+            }
+        }
+        catch {
+            // A path that vanished between the directory walk and this stat
+            // (e.g. a concurrent delete) just doesn't contribute - not fatal
+            // to the rest of the listing.
+        }
+    }
+    return latest ? latest.toISOString() : null;
+}
+// Defensive, not the strict PageContent shape from render-page.ts:
+// boot.ts deliberately never auto-migrates content at startup, so a
+// file sitting at an old schemaVersion (and therefore missing a field
+// as new as "type") is a real, persistent possibility, not a
+// hypothetical - matching rebuild-index.ts's PageForIndex precedent.
+function readSummary(fullPath) {
+    try {
+        return JSON.parse(readFileSync(fullPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+// GET /v1/content lists the union of contentRoot and draftsRoot paths,
+// not live content alone: Group D's own checklist heading is "content
+// AND draft reads", and there is no separate "list drafts" endpoint
+// anywhere in the build plan - this is the only place a draft-only
+// page (never yet published) is discoverable at all.
+//
+// Deliberately three named walks (pages/posts/menus), not one broad
+// walk of contentRoot: since Group N nested draftsRoot and redirectsPath
+// inside contentRoot (content/drafts/, content/redirects.json), a
+// single broad contentRoot walk would descend into content/drafts/
+// too, double-listing draft files under two different relative-path
+// keys, and would pick up redirects.json as if it were a page. An
+// inclusion-based walk sidesteps both problems structurally, with no
+// exclusion list to maintain. base stays config.contentRoot for all
+// three (not each subroot) so the resulting relative paths ("pages/x.json")
+// line up with draftPaths below for the hasDraft/hasLive union logic.
+export function listContent(config, filters) {
+    const contentPaths = new Set([
+        ...listFilesRecursively(config.pagesRoot, config.contentRoot, '.json'),
+        ...listFilesRecursively(config.postsRoot, config.contentRoot, '.json'),
+        ...listFilesRecursively(config.menusRoot, config.contentRoot, '.json'),
+    ]);
+    const draftPaths = new Set(listFilesRecursively(config.draftsRoot, config.draftsRoot, '.json'));
+    const allPaths = new Set([...contentPaths, ...draftPaths]);
+    const entries = [];
+    for (const relativePath of allPaths) {
+        const hasDraft = draftPaths.has(relativePath);
+        const hasLive = contentPaths.has(relativePath);
+        // Prefer the live file's fields on conflict - the draft is a
+        // pending edit, not yet the source of truth for a content
+        // inventory view - but hasDraft still reports the draft's
+        // presence either way.
+        const summary = hasLive
+            ? readSummary(join(config.contentRoot, relativePath))
+            : readSummary(join(config.draftsRoot, relativePath));
+        if (!summary) {
+            continue;
+        }
+        const title = typeof summary.title === 'string' ? summary.title : '';
+        const entry = {
+            path: relativePath,
+            // Falls back to title, not '', for content written before "name"
+            // existed and not yet migrated (migrations aren't wired to run
+            // automatically) - the same default migrateV4ToV5 itself writes,
+            // just applied defensively at read time too.
+            name: typeof summary.name === 'string' ? summary.name : title,
+            title,
+            type: typeof summary.type === 'string' ? summary.type : '',
+            published: summary.published === true,
+            hasDraft,
+            url: computeContentUrl(relativePath),
+            changedAt: latestMtime([
+                ...(hasLive ? [join(config.contentRoot, relativePath)] : []),
+                ...(hasDraft ? [join(config.draftsRoot, relativePath)] : []),
+            ]),
+        };
+        if (filters.type !== undefined && entry.type !== filters.type) {
+            continue;
+        }
+        if (filters.prefix !== undefined && !entry.path.startsWith(filters.prefix)) {
+            continue;
+        }
+        if (filters.draftStatus === 'has-draft' && !entry.hasDraft) {
+            continue;
+        }
+        if (filters.draftStatus === 'no-draft' && entry.hasDraft) {
+            continue;
+        }
+        entries.push(entry);
+    }
+    entries.sort((a, b) => a.path.localeCompare(b.path));
+    return entries;
+}

package/dist/services/delete-content.d.ts

@@ -0,0 +1,12 @@
+import type { SiteConfig } from '../config.ts';
+import type { CommitAuthor } from './git.ts';
+import type { PreparedOperation } from './prepared-operation.ts';
+export type DeleteContentReason = 'page-not-found' | 'has-children' | 'redirect-cycle' | 'invalid-redirect-target' | 'write-failed' | 'commit-failed' | 'rollback-failed';
+export declare class DeleteContentError extends Error {
+    readonly reason: DeleteContentReason;
+    constructor(reason: DeleteContentReason, message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare function prepareDeleteContent(config: SiteConfig, relativePath: string, redirectTo: string | undefined): PreparedOperation;
+export declare function deleteContent(config: SiteConfig, relativePath: string, redirectTo: string | undefined, message: string, author: CommitAuthor): Promise<void>;

package/dist/services/delete-content.js

@@ -0,0 +1,174 @@
+import { existsSync, readFileSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { listFilesRecursively } from "./fs-walk.js";
+import { commitPaths } from "./git.js";
+import { sanitisePath } from "./path-safety.js";
+import { postPathToUrl } from "./post-urls.js";
+import { RedirectError, addRedirect, isValidRedirectTarget, loadRedirects, serialiseRedirects, } from "./redirects.js";
+import { pagePathToUrl } from "./urls.js";
+import { enqueue } from "./write-queue.js";
+const PAGES_PREFIX = 'pages/';
+const POSTS_PREFIX = 'posts/';
+// Widens the redirect-on-delete gate to posts alongside pages, without
+// touching the has-children subtree check below (PAGES_PREFIX-only,
+// unchanged - posts never have nested children by construction). A
+// tiny duplicated helper, not a shared "collection" abstraction,
+// matching this codebase's existing precedent (e.g. prepareSaveDraft/
+// prepareDiscardDraft mirror rather than share a base with publish.ts/
+// move.ts). Returns null for anything else (menus have no public URL
+// at all, so redirects are meaningless there).
+function urlForDeletedEntry(relativePath) {
+    if (relativePath.startsWith(PAGES_PREFIX)) {
+        return pagePathToUrl(relativePath.slice(PAGES_PREFIX.length));
+    }
+    if (relativePath.startsWith(POSTS_PREFIX)) {
+        return postPathToUrl(relativePath.slice(POSTS_PREFIX.length));
+    }
+    return null;
+}
+export class DeleteContentError extends Error {
+    reason;
+    constructor(reason, message, options) {
+        super(message, options);
+        this.name = 'DeleteContentError';
+        this.reason = reason;
+    }
+}
+// Validates and writes everything a delete needs, stopping short of
+// the commit itself - used both by the standalone deleteContentJob
+// (which commits immediately after) and by batch.ts (which accumulates
+// this alongside other operations and commits once for the whole
+// batch). A write-phase failure (including a client-triggered
+// redirect-cycle) is caught and rolled back here, inside prepare
+// itself, so prepare either fully succeeds or fully undoes itself
+// before throwing.
+export function prepareDeleteContent(config, relativePath, redirectTo) {
+    const livePath = sanitisePath(config.contentRoot, relativePath);
+    if (!existsSync(livePath)) {
+        throw new DeleteContentError('page-not-found', `No live page found at "${relativePath}"`);
+    }
+    // Subtree rejection: a deliberate scope decision (reject outright,
+    // not cascade) - an accidental single DELETE can't silently take a
+    // whole subtree with it. "Has children" means a real child page
+    // exists (checked via listFilesRecursively), never bare directory
+    // existence: a leftover *empty* sibling directory would otherwise
+    // make this page permanently undeletable, since no rmdir/cleanup
+    // endpoint exists anywhere in this API to ever clear it.
+    if (relativePath.startsWith(PAGES_PREFIX)) {
+        const dirRelative = relativePath.slice(PAGES_PREFIX.length).replace(/\.json$/, '');
+        const dirPath = sanitisePath(config.pagesRoot, dirRelative);
+        if (existsSync(dirPath) &&
+            statSync(dirPath).isDirectory() &&
+            listFilesRecursively(dirPath, dirPath, '.json').length > 0) {
+            throw new DeleteContentError('has-children', `"${relativePath}" has child pages; delete them first`);
+        }
+    }
+    // Never touches a draft at the same path: /v1/content and /v1/drafts
+    // are separate resources with their own dedicated DELETEs, and a
+    // draft-only page is already a legitimate, independently-listable
+    // state (Group D's listContent unions contentRoot/draftsRoot).
+    const original = readFileSync(livePath);
+    let redirectsBefore = null;
+    let redirectsChanged = false;
+    // Reverses the unlink and restores/removes redirects.json. Matches
+    // publish.ts's/move.ts's rollback() philosophy: attempt everything,
+    // report every failure.
+    function undoDeleteWrites() {
+        const restoreFailures = [];
+        try {
+            writeFileSync(livePath, original);
+        }
+        catch (restoreError) {
+            restoreFailures.push(restoreError);
+        }
+        if (redirectsChanged) {
+            try {
+                if (redirectsBefore === null) {
+                    rmSync(config.redirectsPath, { force: true });
+                }
+                else {
+                    writeFileSync(config.redirectsPath, redirectsBefore);
+                }
+            }
+            catch (restoreError) {
+                restoreFailures.push(restoreError);
+            }
+        }
+        return restoreFailures;
+    }
+    try {
+        unlinkSync(livePath);
+        // redirectTo is client-supplied, unlike publish.ts/move.ts's own
+        // automatic redirect bookkeeping - a client can trivially trigger a
+        // real cycle (e.g. redirectTo pointing back into an existing
+        // chain), so that's surfaced as its own reason, not left to fall
+        // into the generic write-failed/500 bucket an unlikely automatic-
+        // bookkeeping cycle would. Format is validated the same way as the
+        // dedicated manage-redirects.ts endpoints, internal-paths-only,
+        // so the two write paths never disagree on what's allowed into
+        // redirects.json.
+        const fromUrl = urlForDeletedEntry(relativePath);
+        if (redirectTo !== undefined && fromUrl !== null) {
+            if (!isValidRedirectTarget(redirectTo)) {
+                throw new DeleteContentError('invalid-redirect-target', `redirectTo "${redirectTo}" must be an internal path starting with "/"`);
+            }
+            redirectsBefore = existsSync(config.redirectsPath)
+                ? readFileSync(config.redirectsPath, 'utf-8')
+                : null;
+            let entries;
+            try {
+                entries = addRedirect(loadRedirects(config).entries, fromUrl, redirectTo).entries;
+            }
+            catch (error) {
+                if (error instanceof RedirectError) {
+                    throw new DeleteContentError('redirect-cycle', error.message, { cause: error });
+                }
+                throw error;
+            }
+            const serialised = serialiseRedirects(entries);
+            if (serialised !== (redirectsBefore ?? '')) {
+                writeFileSync(config.redirectsPath, serialised);
+                redirectsChanged = true;
+            }
+        }
+    }
+    catch (error) {
+        const failures = undoDeleteWrites();
+        if (failures.length > 0) {
+            throw new DeleteContentError('rollback-failed', 'Delete failed and rolling back afterwards also failed; the working tree may be inconsistent and needs manual inspection', { cause: error });
+        }
+        // A redirect-cycle is already a DeleteContentError with its own
+        // reason - preserve it rather than reclassifying it as write-failed.
+        if (error instanceof DeleteContentError) {
+            throw error;
+        }
+        // Always write-failed here, structurally: commitPaths hasn't been
+        // called yet, so this can never be a GitOperationError.
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new DeleteContentError('write-failed', `Delete failed: ${detail}`, { cause: error });
+    }
+    const paths = [livePath];
+    if (redirectsChanged) {
+        paths.push(config.redirectsPath);
+    }
+    return { paths, undo: undoDeleteWrites };
+}
+async function deleteContentJob(config, relativePath, redirectTo, message, author) {
+    const { paths, undo } = prepareDeleteContent(config, relativePath, redirectTo);
+    try {
+        commitPaths(config.siteRoot, paths, message, author);
+    }
+    catch (error) {
+        const failures = undo();
+        if (failures.length > 0) {
+            throw new DeleteContentError('rollback-failed', 'Delete failed and rolling back afterwards also failed; the working tree may be inconsistent and needs manual inspection', { cause: error });
+        }
+        // Always commit-failed here, structurally: prepare already
+        // succeeded, so anything caught in this try can only have come
+        // from commitPaths itself.
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new DeleteContentError('commit-failed', `Delete failed: ${detail}`, { cause: error });
+    }
+}
+export function deleteContent(config, relativePath, redirectTo, message, author) {
+    return enqueue(() => deleteContentJob(config, relativePath, redirectTo, message, author));
+}

package/dist/services/dev-tunnel.d.ts

@@ -0,0 +1,5 @@
+export interface DevTunnel {
+    url: string;
+    close: () => void;
+}
+export declare function startDevTunnel(port: number): Promise<DevTunnel>;

package/dist/services/dev-tunnel.js

@@ -0,0 +1,5 @@
+import localtunnel from 'localtunnel';
+export async function startDevTunnel(port) {
+    const tunnel = await localtunnel({ port });
+    return { url: tunnel.url, close: () => tunnel.close() };
+}

package/dist/services/drafts.d.ts

@@ -0,0 +1,15 @@
+import type { SiteConfig } from '../config.ts';
+import type { PreparedOperation } from './prepared-operation.ts';
+import type { ThemeSchemas, ValidationError } from './validation.ts';
+export type DraftReason = 'validation-failed' | 'conflict';
+export declare class DraftError extends Error {
+    readonly reason: DraftReason;
+    readonly errors: ValidationError[];
+    constructor(reason: DraftReason, message: string, errors?: ValidationError[]);
+}
+export declare function saveDraft(config: SiteConfig, themeSchemas: ThemeSchemas, relativePath: string, content: unknown, expectedEtag: string): Promise<string>;
+export declare function discardDraft(config: SiteConfig, relativePath: string): Promise<void>;
+export declare function prepareSaveDraft(config: SiteConfig, themeSchemas: ThemeSchemas, relativePath: string, content: unknown, expectedEtag: string): Promise<PreparedOperation & {
+    etag: string;
+}>;
+export declare function prepareDiscardDraft(config: SiteConfig, relativePath: string): Promise<PreparedOperation>;